rpc

type Activation struct {
	Generic
	Pkh    mavryk.Address  `json:"pkh"`
	Secret mavryk.HexBytes `json:"secret"`
}

type BakingRight struct {
	Delegate      mavryk.Address `json:"delegate"`
	Level         int64          `json:"level"`
	Priority      int            `json:"priority"` // until v011
	Round         int            `json:"round"`    // v012+
	EstimatedTime time.Time      `json:"estimated_time"`
}

type BalanceUpdate struct {
	Kind     string `json:"kind"`          // contract, freezer, accumulator, commitment, minted, burned
	Origin   string `json:"origin"`        // block, migration, subsidy
	Category string `json:"category"`      // optional, used on mint, burn, freezer
	Change   int64  `json:"change,string"` // amount, <0 =

	// related debtor or creditor
	Contract  mavryk.Address `json:"contract"`  // contract only
	Delegate  mavryk.Address `json:"delegate"`  // freezer and burn only
	Committer mavryk.Address `json:"committer"` // committer only

	// Ithaca only
	IsParticipationBurn bool `json:"participation"` // burn only
	IsRevelationBurn    bool `json:"revelation"`    // burn only

	// legacy freezer cycle
	Level_ int64 `json:"level"` // wrongly called level, it's cycle
	Cycle_ int64 `json:"cycle"` // v4 fix, also used in Atlas for unstake

	// smart rollup
	BondId struct {
		SmartRollup mavryk.Address `json:"smart_rollup"`
	} `json:"bond_id"`

	// Atlas staking
	Staker struct {
		Contract mavryk.Address `json:"contract"` // tz1/2/3 accounts (only stake, unstake)
		Delegate mavryk.Address `json:"delegate"` // baker
		Baker    mavryk.Address `json:"baker"`    // baker
	} `json:"staker"`
	DelayedOp mavryk.OpHash `json:"delayed_operation_hash"`
}

type BalanceUpdates []BalanceUpdate

type Ballot struct {
	Generic
	Source   mavryk.Address      `json:"source"`
	Period   int                 `json:"period"`
	Ballot   mavryk.BallotVote   `json:"ballot"` // yay, nay, pass
	Proposal mavryk.ProtocolHash `json:"proposal"`
}

type BallotInfo struct {
	Delegate mavryk.Address    `json:"pkh"`
	Ballot   mavryk.BallotVote `json:"ballot"`
}

type BallotList []BallotInfo

type BallotSummary struct {
	Yay  Int64orString `json:"yay"`
	Nay  Int64orString `json:"nay"`
	Pass Int64orString `json:"pass"`
}

type BigmapInfo struct {
	KeyType    micheline.Prim `json:"key_type"`
	ValueType  micheline.Prim `json:"value_type"`
	TotalBytes int64          `json:"total_bytes,string"`
}

type Block struct {
	Protocol   mavryk.ProtocolHash `json:"protocol"`
	ChainId    mavryk.ChainIdHash  `json:"chain_id"`
	Hash       mavryk.BlockHash    `json:"hash"`
	Header     BlockHeader         `json:"header"`
	Metadata   BlockMetadata       `json:"metadata"`
	Operations [][]*Operation      `json:"operations"`
}

type BlockAlias string

type BlockContent struct {
	Command    string              `json:"command"`
	Protocol   mavryk.ProtocolHash `json:"hash"`
	Fitness    []mavryk.HexBytes   `json:"fitness"`
	Parameters *GenesisData        `json:"protocol_parameters"`
}

type BlockHeader struct {
	Level                     int64                 `json:"level"`
	Proto                     int                   `json:"proto"`
	Predecessor               mavryk.BlockHash      `json:"predecessor"`
	Timestamp                 time.Time             `json:"timestamp"`
	ValidationPass            int                   `json:"validation_pass"`
	OperationsHash            mavryk.OpListListHash `json:"operations_hash"`
	Fitness                   []mavryk.HexBytes     `json:"fitness"`
	Context                   mavryk.ContextHash    `json:"context"`
	PayloadHash               mavryk.PayloadHash    `json:"payload_hash"`
	PayloadRound              int                   `json:"payload_round"`
	Priority                  int                   `json:"priority"`
	ProofOfWorkNonce          mavryk.HexBytes       `json:"proof_of_work_nonce"`
	SeedNonceHash             *mavryk.NonceHash     `json:"seed_nonce_hash"`
	Signature                 mavryk.Signature      `json:"signature"`
	Content                   *BlockContent         `json:"content,omitempty"`
	LiquidityBakingEscapeVote bool                  `json:"liquidity_baking_escape_vote"`
	LiquidityBakingToggleVote mavryk.FeatureVote    `json:"liquidity_baking_toggle_vote"`
	AdaptiveIssuanceVote      mavryk.FeatureVote    `json:"adaptive_issuance_vote"`

	// only present when header is fetched explicitly
	Hash     mavryk.BlockHash    `json:"hash"`
	Protocol mavryk.ProtocolHash `json:"protocol"`
	ChainId  mavryk.ChainIdHash  `json:"chain_id"`
}

type BlockHeaderLogEntry struct {
	Hash           mavryk.BlockHash      `json:"hash"`
	Level          int64                 `json:"level"`
	Proto          int                   `json:"proto"`
	Predecessor    mavryk.BlockHash      `json:"predecessor"`
	Timestamp      time.Time             `json:"timestamp"`
	ValidationPass int                   `json:"validation_pass"`
	OperationsHash mavryk.OpListListHash `json:"operations_hash"`
	Fitness        []mavryk.HexBytes     `json:"fitness"`
	Context        mavryk.ContextHash    `json:"context"`
	ProtocolData   mavryk.HexBytes       `json:"protocol_data"`
}

type BlockHeaderMonitor struct {
	// contains filtered or unexported fields
}

type BlockID interface {
	fmt.Stringer
	Int64() int64
}

type BlockLevel int64

type BlockMetadata struct {
	Protocol               mavryk.ProtocolHash    `json:"protocol"`
	NextProtocol           mavryk.ProtocolHash    `json:"next_protocol"`
	MaxOperationsTTL       int                    `json:"max_operations_ttl"`
	MaxOperationDataLength int                    `json:"max_operation_data_length"`
	MaxBlockHeaderLength   int                    `json:"max_block_header_length"`
	MaxOperationListLength []*OperationListLength `json:"max_operation_list_length"`
	Baker                  mavryk.Address         `json:"baker"`
	Proposer               mavryk.Address         `json:"proposer"`
	NonceHash              mavryk.NonceHash       `json:"nonce_hash"`
	ConsumedGas            int64                  `json:"consumed_gas,string"`
	Deactivated            []mavryk.Address       `json:"deactivated"`
	BalanceUpdates         BalanceUpdates         `json:"balance_updates"`

	// <v008
	Level            *LevelInfo               `json:"level"`
	VotingPeriodKind *mavryk.VotingPeriodKind `json:"voting_period_kind"`

	// v008+
	LevelInfo        *LevelInfo        `json:"level_info"`
	VotingPeriodInfo *VotingPeriodInfo `json:"voting_period_info"`

	// v010+
	ImplicitOperationsResults []ImplicitResult `json:"implicit_operations_results"`
	LiquidityBakingEscapeEma  int64            `json:"liquidity_baking_escape_ema"`

	// v015+
	ProposerConsensusKey mavryk.Address `json:"proposer_consensus_key"`
	BakerConsensusKey    mavryk.Address `json:"baker_consensus_key"`
}

type BlockOffset struct {
	Base   BlockID
	Offset int64
}

type BootstrapMonitor struct {
	// contains filtered or unexported fields
}

type BootstrappedBlock struct {
	Block     mavryk.BlockHash `json:"block"`
	Timestamp time.Time        `json:"timestamp"`
}

type CallOptions struct {
	Confirmations     int64          // number of confirmations to wait after broadcast
	MaxFee            int64          // max acceptable fee, optional (default = 0)
	TTL               int64          // max lifetime for operations in blocks
	IgnoreLimits      bool           // ignore simulated limits and use user-defined limits from op
	ExtraGasMargin    int64          // safety margin in case simulation underestimates future usage
	SimulationBlockID BlockID        // custom block id to simulate operation (default is head, use to select a past block)
	SimulationOffset  int64          // custom block offset for future block simulations
	Signer            signer.Signer  // optional signer interface to use for signing the transaction
	Sender            mavryk.Address // optional address to sign for (use when signer manages multiple addresses)
	Observer          *Observer      // optional custom block observer for waiting on confirmations
}

type Client struct {

	// Base URL for API requests.
	BaseURL *url.URL
	// Base URL for IPFS requests.
	IpfsURL *url.URL
	// User agent name for client.
	UserAgent string
	// Optional API key for protected endpoints
	ApiKey string
	// The chain the client will query.
	ChainId mavryk.ChainIdHash
	// The current chain configuration.
	Params *mavryk.Params
	// An active event observer to watch for operation inclusion
	BlockObserver *Observer
	// An active event observer to watch for operation posting to the mempool
	MempoolObserver *Observer
	// A default signer used for transaction sending
	Signer signer.Signer
	// MetadataMode defines the metadata reconstruction mode used for fetching
	// block and operation receipts. Set this mode to `always` if an RPC node prunes
	// metadata (i.e. you see metadata too large in certain operations)
	MetadataMode MetadataMode
	// Close connections. This may help with EOF errors from unexpected
	// connection close by Tezos RPC.
	CloseConns bool
	// Log is the logger implementation used by this client
	Log log.Logger
	// contains filtered or unexported fields
}

type CommitInfo struct {
	CommitHash string `json:"commit_hash"`
	CommitDate string `json:"commit_date"`
}

type ConnVersion struct {
	Name  string `json:"name"`
	Major uint16 `json:"major"`
	Minor uint16 `json:"minor"`
}

type ConstantRegistration struct {
	Manager
	Value micheline.Prim `json:"value,omitempty"`
}

type Constants struct {
	PreservedCycles              int64    `json:"preserved_cycles"`
	BlocksPerCycle               int64    `json:"blocks_per_cycle"`
	BlocksPerRollSnapshot        int64    `json:"blocks_per_roll_snapshot"`
	TimeBetweenBlocks            []string `json:"time_between_blocks"`
	HardGasLimitPerOperation     int64    `json:"hard_gas_limit_per_operation,string"`
	HardGasLimitPerBlock         int64    `json:"hard_gas_limit_per_block,string"`
	MichelsonMaximumTypeSize     int      `json:"michelson_maximum_type_size"`
	OriginationSize              int64    `json:"origination_size"`
	OriginationBurn              int64    `json:"origination_burn,string"`
	CostPerByte                  int64    `json:"cost_per_byte,string"`
	HardStorageLimitPerOperation int64    `json:"hard_storage_limit_per_operation,string"`
	MaxOperationDataLength       int      `json:"max_operation_data_length"`

	// New in v10
	MinimalBlockDelay int `json:"minimal_block_delay,string"`

	// New in v12
	MaxOperationsTimeToLive int64 `json:"max_operations_time_to_live"`
	BlocksPerStakeSnapshot  int64 `json:"blocks_per_stake_snapshot"`
}

type ContractInfo struct {
	Balance        int64          `json:"balance,string"`
	Delegate       mavryk.Address `json:"delegate"`
	Counter        int64          `json:"counter,string"`
	Manager        string         `json:"manager"`
	FrozenDeposits struct {
		InitialAmount int64 `json:"initial_amount,string"`
		ActualAmount  int64 `json:"actual_amount,string"`
	} `json:"frozen_deposits"`
	FrozenDepositsPseudotokens int64 `json:"frozen_deposits_pseudotokens,string"`
	MissedAttestations         struct {
		RemainingSlots int64 `json:"remaining_slots"`
		MissedLevels   int64 `json:"missed_levels"`
	} `json:"missed_attestations"`
	StakingParameters struct {
	} `json:"staking_parameters"`
	UnstakeRequests struct {
		Delegate mavryk.Address `json:"delegate"`
		Requests []struct {
			Cycle           int64 `json:"cycle"`
			RequestedAmount int64 `json:"requested_amount,string"`
		} `json:"requests"`
	} `json:"unstake_requests"`
	UnstakedFrozenDeposits []UnstakedDeposit `json:"unstaked_frozen_deposits"`
}

type Contracts []mavryk.Address

type CycleBalance struct {
	Cycle   int64 `json:"cycle"`
	Deposit int64 `json:"deposit,string"`
	Fees    int64 `json:"fees,string"`
	Rewards int64 `json:"rewards,string"`
}

type CycleKey struct {
	Cycle int64          `json:"cycle"`
	Pkh   mavryk.Address `json:"pkh"`
}

type DalAttestation struct {
	Generic
	Attestor    mavryk.Address `json:"attestor"`
	Attestation mavryk.Z       `json:"attestation"`
	Level       int64          `json:"level"`
}

type DalPublishSlotHeader struct {
	Manager
	SlotHeader struct {
		Level      int64           `json:"level"`
		Index      byte            `json:"index"`
		Commitment string          `json:"commitment"`
		Proof      mavryk.HexBytes `json:"commitment_proof"`
	} `json:"slot_header"`
}

type Delegate struct {
	// extra info
	Delegate mavryk.Address `json:"-"`
	Height   int64          `json:"-"`
	Block    string         `json:"-"`

	// tezos data
	Deactivated          bool             `json:"deactivated"`
	Balance              int64            `json:"balance,string"`
	DelegatedContracts   []mavryk.Address `json:"delegated_contracts"`
	FrozenBalance        int64            `json:"frozen_balance,string"`
	FrozenBalanceByCycle []CycleBalance   `json:"frozen_balance_by_cycle"`
	GracePeriod          int64            `json:"grace_period"`
	StakingBalance       int64            `json:"staking_balance,string"`
	DelegatedBalance     int64            `json:"delegated_balance,string"`
	VotingPower          Int64orString    `json:"voting_power"`

	// v012+
	FullBalance           int64 `json:"full_balance,string"`
	FrozenDeposits        int64 `json:"frozen_deposits,string"`
	CurrentFrozenDeposits int64 `json:"current_frozen_deposits,string"`
	FrozenDepositsLimit   int64 `json:"frozen_deposits_limit,string"`

	// v015+
	ActiveConsensusKey   mavryk.Address `json:"active_consensus_key"`
	PendingConsensusKeys []CycleKey     `json:"pending_consensus_keys"`
}

type DelegateList []mavryk.Address

type Delegation struct {
	Manager
	Delegate mavryk.Address `json:"delegate,omitempty"`
}

type DoubleBaking struct {
	Generic
	BH1 BlockHeader `json:"bh1"`
	BH2 BlockHeader `json:"bh2"`
}

type DoubleEndorsement struct {
	Generic
	OP1 InlinedEndorsement `json:"op1"`
	OP2 InlinedEndorsement `json:"op2"`
}

type DrainDelegate struct {
	Generic
	ConsensusKey mavryk.Address `json:"consensus_key"`
	Delegate     mavryk.Address `json:"delegate"`
	Destination  mavryk.Address `json:"destination"`
}

type Endorsement struct {
	Generic
	Level       int64               `json:"level"`                 // <= v008, v012+
	Endorsement *InlinedEndorsement `json:"endorsement,omitempty"` // v009+
	Slot        int                 `json:"slot"`                  // v009+
	Round       int                 `json:"round"`                 // v012+
	PayloadHash mavryk.PayloadHash  `json:"block_payload_hash"`    // v012+
}

type EndorsingRight struct {
	Delegate       mavryk.Address `json:"delegate"`
	Level          int64          `json:"level"`
	EstimatedTime  time.Time      `json:"estimated_time"`
	Slots          []int          `json:"slots,omitempty"` // until v011
	FirstSlot      int            `json:"first_slot"`      // v012+
	EndorsingPower int            `json:"endorsing_power"` // v012+
}

type Error interface {
	error
	ErrorID() string
	ErrorKind() string
}

type Errors []Error

type FrozenDeposit struct {
	Cycle   int64 `json:"cycle"`
	Deposit int64 `json:"deposit,string"`
}

type GameStatus struct {
	Status string          `json:"status,omitempty"`
	Kind   string          `json:"kind,omitempty"`
	Reason string          `json:"reason,omitempty"`
	Player *mavryk.Address `json:"player,omitempty"`
}

type Generic struct {
	OpKind   mavryk.OpType     `json:"kind"`
	Metadata OperationMetadata `json:"metadata"`
}

type GenericError struct {
	ID   string         `json:"id"`
	Kind string         `json:"kind"`
	With micheline.Prim `json:"with"`
}

type GenesisData struct {
	Accounts    []*X0
	Contracts   []*X1
	Commitments []*X2
}

type HTTPError interface {
	error
	HTTPStatus
}

type HTTPStatus interface {
	Request() string // e.g. GET /...
	Status() string  // e.g. "200 OK"
	StatusCode() int // e.g. 200
	Body() []byte
}

type IDTimestamp struct {
	ID        string
	Timestamp time.Time
}

type ImplicitResult struct {
	Kind                mavryk.OpType     `json:"kind"`
	BalanceUpdates      BalanceUpdates    `json:"balance_updates"`
	ConsumedGas         int64             `json:"consumed_gas,string"`
	ConsumedMilliGas    int64             `json:"consumed_milligas,string"`
	Storage             *micheline.Prim   `json:"storage,omitempty"`
	StorageSize         int64             `json:"storage_size,string"`
	OriginatedContracts []mavryk.Address  `json:"originated_contracts,omitempty"`
	PaidStorageSizeDiff int64             `json:"paid_storage_size_diff,string"`
	Script              *micheline.Script `json:"script,omitempty"`
}

type IncreasePaidStorage struct {
	Manager
	Destination mavryk.Address `json:"destination"`
	Amount      int64          `json:"amount,string"`
}

type InlinedEndorsement struct {
	Branch     mavryk.BlockHash `json:"branch"`     // the double block
	Operations Endorsement      `json:"operations"` // only level and kind are set
	Signature  mavryk.Signature `json:"signature"`
}

type Int64orString int64

type InternalResult struct {
	Kind          mavryk.OpType         `json:"kind"`
	Source        mavryk.Address        `json:"source"`
	Nonce         int64                 `json:"nonce"`
	Result        OperationResult       `json:"result"`
	Destination   *mavryk.Address       `json:"destination,omitempty"` // transaction
	Delegate      *mavryk.Address       `json:"delegate,omitempty"`    // delegation
	Parameters    *micheline.Parameters `json:"parameters,omitempty"`  // transaction
	Amount        int64                 `json:"amount,string"`         // transaction
	Balance       int64                 `json:"balance,string"`        // origination
	Script        *micheline.Script     `json:"script,omitempty"`      // origination
	Type          micheline.Prim        `json:"type"`                  // event
	Payload       micheline.Prim        `json:"payload"`               // event
	Tag           string                `json:"tag"`                   // event
	TicketUpdates []TicketUpdate        `json:"ticket_receipt"`        // v015
}

type InvalidBlock struct {
	Block mavryk.BlockHash `json:"block"`
	Level int64            `json:"level"`
	Error Errors           `json:"error"`
}

type IssuanceParameters struct {
	Cycle           int64 `json:"cycle"`
	BakingReward    int64 `json:"baking_reward_fixed_portion,string"`
	BakingBonus     int64 `json:"baking_reward_bonus_per_slot,string"`
	AttestingReward int64 `json:"attesting_reward_per_slot,string"`
	LBSubsidy       int64 `json:"liquidity_baking_subsidy,string"`
	SeedNonceTip    int64 `json:"seed_nonce_revelation_tip,string"`
	VdfTip          int64 `json:"vdf_revelation_tip,string"`
}

type LevelInfo struct {
	Level              int64 `json:"level"`
	LevelPosition      int64 `json:"level_position"`
	Cycle              int64 `json:"cycle"`
	CyclePosition      int64 `json:"cycle_position"`
	ExpectedCommitment bool  `json:"expected_commitment"`

	// <v008
	VotingPeriod         int64 `json:"voting_period"`
	VotingPeriodPosition int64 `json:"voting_period_position"`
}

type Manager struct {
	Generic
	Source       mavryk.Address `json:"source"`
	Fee          int64          `json:"fee,string"`
	Counter      int64          `json:"counter,string"`
	GasLimit     int64          `json:"gas_limit,string"`
	StorageLimit int64          `json:"storage_limit,string"`
}

type Mempool struct {
	Applied       []*Operation `json:"applied"`
	Refused       []*Operation `json:"refused"`
	Outdated      []*Operation `json:"outdated"` // v012+
	BranchRefused []*Operation `json:"branch_refused"`
	BranchDelayed []*Operation `json:"branch_delayed"`
	Unprocessed   []*Operation `json:"unprocessed"`
}

type MempoolMonitor struct {
	// contains filtered or unexported fields
}

type MetadataMode string

type Monitor interface {
	New() interface{}
	Send(ctx context.Context, val interface{})
	Err(error)
	Closed() <-chan struct{}
	Close()
}

type NetworkAddress struct {
	Addr string `json:"addr"`
	Port uint16 `json:"port"`
}

type NetworkConnection struct {
	Incoming         bool            `json:"incoming"`
	PeerID           string          `json:"peer_id"`
	IDPoint          NetworkAddress  `json:"id_point"`
	RemoteSocketPort uint16          `json:"remote_socket_port"`
	Versions         []*ConnVersion  `json:"versions"`
	Private          bool            `json:"private"`
	LocalMetadata    NetworkMetadata `json:"local_metadata"`
	RemoteMetadata   NetworkMetadata `json:"remote_metadata"`
}

type NetworkConnectionTimestamp struct {
	NetworkAddress
	Timestamp time.Time
}

type NetworkMetadata struct {
	DisableMempool bool `json:"disable_mempool"`
	PrivateNode    bool `json:"private_node"`
}

type NetworkPeer struct {
	PeerID                    string                      `json:"-"`
	Score                     int64                       `json:"score"`
	Trusted                   bool                        `json:"trusted"`
	ConnMetadata              *NetworkMetadata            `json:"conn_metadata"`
	State                     string                      `json:"state"`
	ReachableAt               *NetworkAddress             `json:"reachable_at"`
	Stat                      NetworkStats                `json:"stat"`
	LastEstablishedConnection *NetworkConnectionTimestamp `json:"last_established_connection"`
	LastSeen                  *NetworkConnectionTimestamp `json:"last_seen"`
	LastFailedConnection      *NetworkConnectionTimestamp `json:"last_failed_connection"`
	LastRejectedConnection    *NetworkConnectionTimestamp `json:"last_rejected_connection"`
	LastDisconnection         *NetworkConnectionTimestamp `json:"last_disconnection"`
	LastMiss                  *NetworkConnectionTimestamp `json:"last_miss"`
}

type NetworkPeerLogEntry struct {
	NetworkAddress
	Kind      string    `json:"kind"`
	Timestamp time.Time `json:"timestamp"`
}

type NetworkPeerMonitor struct {
	// contains filtered or unexported fields
}

type NetworkPoint struct {
	Address                   string            `json:"-"`
	Trusted                   bool              `json:"trusted"`
	GreylistedUntil           time.Time         `json:"greylisted_until"`
	State                     NetworkPointState `json:"state"`
	P2PPeerID                 string            `json:"p2p_peer_id"`
	LastFailedConnection      time.Time         `json:"last_failed_connection"`
	LastRejectedConnection    *IDTimestamp      `json:"last_rejected_connection"`
	LastEstablishedConnection *IDTimestamp      `json:"last_established_connection"`
	LastDisconnection         *IDTimestamp      `json:"last_disconnection"`
	LastSeen                  *IDTimestamp      `json:"last_seen"`
	LastMiss                  time.Time         `json:"last_miss"`
}

type NetworkPointLogEntry struct {
	Kind      NetworkPointState `json:"kind"`
	Timestamp time.Time         `json:"timestamp"`
}

type NetworkPointMonitor struct {
	// contains filtered or unexported fields
}

type NetworkPointState struct {
	EventKind string `json:"event_kind"`
	P2PPeerID string `json:"p2p_peer_id"`
}

type NetworkStats struct {
	TotalBytesSent int64 `json:"total_sent,string"`
	TotalBytesRecv int64 `json:"total_recv,string"`
	CurrentInflow  int64 `json:"current_inflow"`
	CurrentOutflow int64 `json:"current_outflow"`
}

type NetworkVersion struct {
	ChainName            string `json:"chain_name"`
	DistributedDbVersion int    `json:"distributed_db_version"`
	P2pVersion           int    `json:"p2p_version"`
}

type NodeVersion struct {
	Major int `json:"major"`
	Minor int `json:"minor"`
}

type Observer struct {
	// contains filtered or unexported fields
}

type ObserverCallback func(*BlockHeaderLogEntry, int64, int, int, bool) bool

type Operation struct {
	Protocol  mavryk.ProtocolHash `json:"protocol"`
	ChainID   mavryk.ChainIdHash  `json:"chain_id"`
	Hash      mavryk.OpHash       `json:"hash"`
	Branch    mavryk.BlockHash    `json:"branch"`
	Contents  OperationList       `json:"contents"`
	Signature mavryk.Signature    `json:"signature"`
	Errors    []OperationError    `json:"error,omitempty"`    // mempool only
	Metadata  string              `json:"metadata,omitempty"` // contains `too large` when stripped, this is BAD!!
}

type OperationError struct {
	GenericError
	Contract *mavryk.Address `json:"contract,omitempty"`
	Raw      json.RawMessage `json:"-"`
}

type OperationList []TypedOperation

type OperationListLength struct {
	MaxSize int `json:"max_size"`
	MaxOp   int `json:"max_op"`
}

type OperationMetadata struct {
	BalanceUpdates BalanceUpdates  `json:"balance_updates"` // fee-related
	Result         OperationResult `json:"operation_result"`

	// transaction only
	InternalResults []*InternalResult `json:"internal_operation_results,omitempty"`

	// endorsement only
	Delegate            mavryk.Address `json:"delegate"`
	Slots               []int          `json:"slots,omitempty"`
	EndorsementPower    int            `json:"endorsement_power,omitempty"`    // v12+
	PreendorsementPower int            `json:"preendorsement_power,omitempty"` // v12+

	// some rollup ops only, FIXME: is this correct here or is this field in result?
	Level int64 `json:"level"`

	// v18 slashing ops may block a baker
	ForbiddenDelegate mavryk.Address `json:"forbidden_delegate"` // v18+
}

type OperationResult struct {
	Status               mavryk.OpStatus  `json:"status"`
	BalanceUpdates       BalanceUpdates   `json:"balance_updates"`
	ConsumedGas          int64            `json:"consumed_gas,string"`      // deprecated in v015
	ConsumedMilliGas     int64            `json:"consumed_milligas,string"` // v007+
	Errors               []OperationError `json:"errors,omitempty"`
	Allocated            bool             `json:"allocated_destination_contract"` // tx only
	Storage              *micheline.Prim  `json:"storage,omitempty"`              // tx, orig
	OriginatedContracts  []mavryk.Address `json:"originated_contracts"`           // orig only
	StorageSize          int64            `json:"storage_size,string"`            // tx, orig, const
	PaidStorageSizeDiff  int64            `json:"paid_storage_size_diff,string"`  // tx, orig
	BigmapDiff           json.RawMessage  `json:"big_map_diff,omitempty"`         // tx, orig, <v013
	LazyStorageDiff      json.RawMessage  `json:"lazy_storage_diff,omitempty"`    // v008+ tx, orig
	GlobalAddress        mavryk.ExprHash  `json:"global_address"`                 // const
	TicketUpdatesCorrect []TicketUpdate   `json:"ticket_updates"`                 // v015
	TicketReceipts       []TicketUpdate   `json:"ticket_receipt"`                 // v015, name on internal

	// v013 tx rollup
	TxRollupResult

	// v016 smart rollup
	SmartRollupResult
}

type Origination struct {
	Manager
	ManagerPubkey  mavryk.Address    `json:"manager_pubkey"` // proto v1 & >= v4
	ManagerPubkey2 mavryk.Address    `json:"managerPubkey"`  // proto v2, v3
	Balance        int64             `json:"balance,string"`
	Spendable      *bool             `json:"spendable"`   // true when missing before v5 Babylon
	Delegatable    *bool             `json:"delegatable"` // true when missing before v5 Babylon
	Delegate       *mavryk.Address   `json:"delegate"`
	Script         *micheline.Script `json:"script"`
}

type PendingOperation Operation

type Proposal struct {
	Proposal mavryk.ProtocolHash `json:"proposal"`
	Upvotes  int64               `json:"upvotes,string"`
}

type ProposalList []Proposal

type Proposals struct {
	Generic
	Source    mavryk.Address        `json:"source"`
	Period    int                   `json:"period"`
	Proposals []mavryk.ProtocolHash `json:"proposals"`
}

type RPCError interface {
	Error
	HTTPStatus
	Errors() []Error // returns all errors as a slice
}

type Receipt struct {
	Block  mavryk.BlockHash
	Height int64
	List   int
	Pos    int
	Op     *Operation
}

type Result struct {
	// contains filtered or unexported fields
}

type Reveal struct {
	Manager
	PublicKey mavryk.Key `json:"public_key"`
}

type RollSnapshotInfo struct {
	LastRoll     []string `json:"last_roll"`
	Nonces       []string `json:"nonces"`
	RandomSeed   string   `json:"random_seed"`
	RollSnapshot int      `json:"roll_snapshot"`
}

type RpcClient interface {
	Init(ctx context.Context) error
	UseIpfsUrl(uri string) error
	Client() *http.Client
	Listen()
	Close()
	ResolveChainConfig(ctx context.Context) error
	Get(ctx context.Context, urlpath string, result interface{}) error
	GetAsync(ctx context.Context, urlpath string, mon Monitor) error
	Put(ctx context.Context, urlpath string, body, result interface{}) error
	Post(ctx context.Context, urlpath string, body, result interface{}) error
	NewRequest(ctx context.Context, method, urlStr string, body interface{}) (*http.Request, error)
	Do(req *http.Request, v interface{}) error
	DoAsync(req *http.Request, mon Monitor) error
	GetBlock(ctx context.Context, id BlockID) (*Block, error)
	GetBlockHeight(ctx context.Context, height int64) (*Block, error)
	GetTips(ctx context.Context, depth int, head mavryk.BlockHash) ([][]mavryk.BlockHash, error)
	GetHeadBlock(ctx context.Context) (*Block, error)
	GetGenesisBlock(ctx context.Context) (*Block, error)
	GetTipHeader(ctx context.Context) (*BlockHeader, error)
	GetBlockHeader(ctx context.Context, id BlockID) (*BlockHeader, error)
	GetBlockMetadata(ctx context.Context, id BlockID) (*BlockMetadata, error)
	GetBlockHash(ctx context.Context, id BlockID) (hash mavryk.BlockHash, err error)
	GetBlockPredHashes(ctx context.Context, hash mavryk.BlockHash, count int) ([]mavryk.BlockHash, error)
	GetInvalidBlocks(ctx context.Context) ([]*InvalidBlock, error)
	GetInvalidBlock(ctx context.Context, blockID mavryk.BlockHash) (*InvalidBlock, error)
	GetChainId(ctx context.Context) (mavryk.ChainIdHash, error)
	GetStatus(ctx context.Context) (Status, error)
	GetVersionInfo(ctx context.Context) (VersionInfo, error)
	GetConstants(ctx context.Context, id BlockID) (con Constants, err error)
	GetCustomConstants(ctx context.Context, id BlockID, resp any) error
	GetParams(ctx context.Context, id BlockID) (*mavryk.Params, error)
	GetContract(ctx context.Context, addr mavryk.Address, id BlockID) (*ContractInfo, error)
	GetContractBalance(ctx context.Context, addr mavryk.Address, id BlockID) (mavryk.Z, error)
	GetManagerKey(ctx context.Context, addr mavryk.Address, id BlockID) (mavryk.Key, error)
	GetContractExt(ctx context.Context, addr mavryk.Address, id BlockID) (*ContractInfo, error)
	ListContracts(ctx context.Context, id BlockID) (Contracts, error)
	GetContractScript(ctx context.Context, addr mavryk.Address) (*micheline.Script, error)
	GetNormalizedScript(ctx context.Context, addr mavryk.Address, mode UnparsingMode) (*micheline.Script, error)
	GetContractStorage(ctx context.Context, addr mavryk.Address, id BlockID) (micheline.Prim, error)
	GetContractStorageNormalized(ctx context.Context, addr mavryk.Address, id BlockID, mode UnparsingMode) (micheline.Prim, error)
	GetContractEntrypoints(ctx context.Context, addr mavryk.Address) (map[string]micheline.Type, error)
	ListBigmapKeys(ctx context.Context, bigmap int64, id BlockID) ([]mavryk.ExprHash, error)
	ListActiveBigmapKeys(ctx context.Context, bigmap int64) ([]mavryk.ExprHash, error)
	GetBigmapValue(ctx context.Context, bigmap int64, hash mavryk.ExprHash, id BlockID) (micheline.Prim, error)
	GetActiveBigmapValue(ctx context.Context, bigmap int64, hash mavryk.ExprHash) (micheline.Prim, error)
	ListBigmapValues(ctx context.Context, bigmap int64, id BlockID) ([]micheline.Prim, error)
	ListActiveBigmapValues(ctx context.Context, bigmap int64, id BlockID) ([]micheline.Prim, error)
	GetActiveBigmapInfo(ctx context.Context, bigmap int64) (*BigmapInfo, error)
	GetBigmapInfo(ctx context.Context, bigmap int64, id BlockID) (*BigmapInfo, error)
	ListActiveDelegates(ctx context.Context, id BlockID) (DelegateList, error)
	GetDelegate(ctx context.Context, addr mavryk.Address, id BlockID) (*Delegate, error)
	GetDelegateBalance(ctx context.Context, addr mavryk.Address, id BlockID) (int64, error)
	GetMempool(ctx context.Context) (*Mempool, error)
	MonitorBootstrapped(ctx context.Context, monitor *BootstrapMonitor) error
	MonitorBlockHeader(ctx context.Context, monitor *BlockHeaderMonitor) error
	MonitorMempool(ctx context.Context, monitor *MempoolMonitor) error
	MonitorNetworkPointLog(ctx context.Context, address string, monitor *NetworkPointMonitor) error
	MonitorNetworkPeerLog(ctx context.Context, peerID string, monitor *NetworkPeerMonitor) error
	GetNetworkStats(ctx context.Context) (*NetworkStats, error)
	GetNetworkConnections(ctx context.Context) ([]*NetworkConnection, error)
	GetNetworkPeers(ctx context.Context, filter string) ([]*NetworkPeer, error)
	GetNetworkPeer(ctx context.Context, peerID string) (*NetworkPeer, error)
	BanNetworkPeer(ctx context.Context, peerID string) error
	TrustNetworkPeer(ctx context.Context, peerID string) error
	GetNetworkPeerBanned(ctx context.Context, peerID string) (bool, error)
	GetNetworkPeerLog(ctx context.Context, peerID string) ([]*NetworkPeerLogEntry, error)
	GetNetworkPoints(ctx context.Context, filter string) ([]*NetworkPoint, error)
	GetNetworkPoint(ctx context.Context, address string) (*NetworkPoint, error)
	ConnectToNetworkPoint(ctx context.Context, address string, timeout time.Duration) error
	BanNetworkPoint(ctx context.Context, address string) error
	TrustNetworkPoint(ctx context.Context, address string) error
	GetNetworkPointBanned(ctx context.Context, address string) (bool, error)
	GetNetworkPointLog(ctx context.Context, address string) ([]*NetworkPointLogEntry, error)
	GetBlockOperationHash(ctx context.Context, id BlockID, l, n int) (mavryk.OpHash, error)
	GetBlockOperationHashes(ctx context.Context, id BlockID) ([][]mavryk.OpHash, error)
	GetBlockOperationListHashes(ctx context.Context, id BlockID, l int) ([]mavryk.OpHash, error)
	GetBlockOperation(ctx context.Context, id BlockID, l, n int) (*Operation, error)
	GetBlockOperationList(ctx context.Context, id BlockID, l int) ([]Operation, error)
	GetBlockOperations(ctx context.Context, id BlockID) ([][]Operation, error)
	BroadcastOperation(ctx context.Context, body []byte) (hash mavryk.OpHash, err error)
	RunOperation(ctx context.Context, id BlockID, body, resp interface{}) error
	ForgeOperation(ctx context.Context, id BlockID, body, resp interface{}) error
	ListBakingRights(ctx context.Context, id BlockID, max int) ([]BakingRight, error)
	ListBakingRightsCycle(ctx context.Context, id BlockID, cycle int64, max int) ([]BakingRight, error)
	ListEndorsingRights(ctx context.Context, id BlockID) ([]EndorsingRight, error)
	ListEndorsingRightsCycle(ctx context.Context, id BlockID, cycle int64) ([]EndorsingRight, error)
	GetRollSnapshotInfoCycle(ctx context.Context, id BlockID, cycle int64) (*RollSnapshotInfo, error)
	GetStakingSnapshotInfoCycle(ctx context.Context, id BlockID, cycle int64) (*StakingSnapshotInfo, error)
	GetSnapshotIndexCycle(ctx context.Context, id BlockID, cycle int64) (*SnapshotIndex, error)
	ListSnapshotRollOwners(ctx context.Context, id BlockID, cycle, index int64) (*SnapshotOwners, error)
	Complete(ctx context.Context, o *codec.Op, key mavryk.Key) error
	Simulate(ctx context.Context, o *codec.Op, opts *CallOptions) (*Receipt, error)
	Validate(ctx context.Context, o *codec.Op) error
	Broadcast(ctx context.Context, o *codec.Op) (mavryk.OpHash, error)
	Send(ctx context.Context, op *codec.Op, opts *CallOptions) (*Receipt, error)
	RunCode(ctx context.Context, id BlockID, body, resp interface{}) error
	RunCallback(ctx context.Context, id BlockID, body, resp interface{}) error
	RunView(ctx context.Context, id BlockID, body, resp interface{}) error
	TraceCode(ctx context.Context, id BlockID, body, resp interface{}) error
	ListVoters(ctx context.Context, id BlockID) (VoterList, error)
	GetVoteQuorum(ctx context.Context, id BlockID) (int, error)
	GetVoteProposal(ctx context.Context, id BlockID) (mavryk.ProtocolHash, error)
	ListBallots(ctx context.Context, id BlockID) (BallotList, error)
	GetVoteResult(ctx context.Context, id BlockID) (BallotSummary, error)
	ListProposals(ctx context.Context, id BlockID) (ProposalList, error)
}

type RunCodeRequest struct {
	ChainId    mavryk.ChainIdHash `json:"chain_id"`
	Script     micheline.Code     `json:"script"`
	Storage    micheline.Prim     `json:"storage"`
	Input      micheline.Prim     `json:"input"`
	Amount     mavryk.N           `json:"amount"`
	Balance    mavryk.N           `json:"balance"`
	Source     *mavryk.Address    `json:"source,omitempty"`
	Payer      *mavryk.Address    `json:"payer,omitempty"`
	Gas        *mavryk.N          `json:"gas,omitempty"`
	Entrypoint string             `json:"entrypoint,omitempty"`
}

type RunCodeResponse struct {
	Operations      []Operation            `json:"operations"`
	Storage         micheline.Prim         `json:"storage"`
	BigmapDiff      micheline.BigmapEvents `json:"big_map_diff,omitempty"`
	LazyStorageDiff micheline.LazyEvents   `json:"lazy_storage_diff,omitempty"`
}

type RunOperationRequest struct {
	Operation *codec.Op          `json:"operation"`
	ChainId   mavryk.ChainIdHash `json:"chain_id"`
	Latency   int64              `json:"latency,omitempty"`
}

type RunViewRequest struct {
	Contract     mavryk.Address     `json:"contract"`
	Entrypoint   string             `json:"entrypoint,omitempty"`
	View         string             `json:"view,omitempty"`
	Input        micheline.Prim     `json:"input"`
	ChainId      mavryk.ChainIdHash `json:"chain_id"`
	Source       mavryk.Address     `json:"source"`
	Payer        mavryk.Address     `json:"payer"`
	Gas          mavryk.N           `json:"gas"`
	Mode         string             `json:"unparsing_mode"`          // "Readable" | "Optimized"
	UnlimitedGas bool               `json:"unlimited_gas,omitempty"` // view
	Now          string             `json:"now,omitempty"`           // view
}

type RunViewResponse struct {
	Data micheline.Prim `json:"data"`
}

type SeedNonce struct {
	Generic
	Level int64           `json:"level"`
	Nonce mavryk.HexBytes `json:"nonce"`
}

type SetDepositsLimit struct {
	Manager
	Limit    int64             `json:"limit,string"`
	Metadata OperationMetadata `json:"metadata"`
}

type SmartRollupAddMessages struct {
	Manager
	Messages []mavryk.HexBytes `json:"message"`
}

type SmartRollupCement struct {
	Manager
	Rollup     mavryk.Address                `json:"rollup"`
	Commitment *mavryk.SmartRollupCommitHash `json:"commitment,omitempty"` // deprecated in v17
}

type SmartRollupCommitment struct {
	CompressedState mavryk.SmartRollupStateHash  `json:"compressed_state"`
	InboxLevel      int64                        `json:"inbox_level"`
	Predecessor     mavryk.SmartRollupCommitHash `json:"predecessor"`
	NumberOfTicks   mavryk.Z                     `json:"number_of_ticks"`
}

type SmartRollupExecuteOutboxMessage struct {
	Manager
	Rollup             mavryk.Address               `json:"rollup"`
	CementedCommitment mavryk.SmartRollupCommitHash `json:"cemented_commitment"`
	OutputProof        mavryk.HexBytes              `json:"output_proof"`
}

type SmartRollupInputProof struct {
	Kind    string          `json:"input_proof_kind"`
	Level   int64           `json:"level"`
	Counter mavryk.Z        `json:"message_counter"`
	Proof   mavryk.HexBytes `json:"serialized_proof"`
}

type SmartRollupOriginate struct {
	Manager
	PvmKind          mavryk.PvmKind  `json:"pvm_kind"`
	Kernel           mavryk.HexBytes `json:"kernel"`
	OriginationProof mavryk.HexBytes `json:"origination_proof"`
	ParametersTy     micheline.Prim  `json:"parameters_ty"`
}

type SmartRollupProof struct {
	PvmStep    mavryk.HexBytes        `json:"pvm_step,omitempty"`
	InputProof *SmartRollupInputProof `json:"input_proof,omitempty"`
}

type SmartRollupPublish struct {
	Manager
	Rollup     mavryk.Address        `json:"rollup"`
	Commitment SmartRollupCommitment `json:"commitment"`
}

type SmartRollupRecoverBond struct {
	Manager
	Rollup mavryk.Address `json:"rollup"`
	Staker mavryk.Address `json:"staker"`
}

type SmartRollupRefutation struct {
	Kind         string                        `json:"refutation_kind"`
	PlayerHash   *mavryk.SmartRollupCommitHash `json:"player_commitment_hash,omitempty"`
	OpponentHash *mavryk.SmartRollupCommitHash `json:"opponent_commitment_hash,omitempty"`
	Choice       *mavryk.Z                     `json:"choice,omitempty"`
	Step         *SmartRollupRefuteStep        `json:"step,omitempty"`
}

type SmartRollupRefute struct {
	Manager
	Rollup     mavryk.Address        `json:"rollup"`
	Opponent   mavryk.Address        `json:"opponent"`
	Refutation SmartRollupRefutation `json:"refutation"`
}

type SmartRollupRefuteStep struct {
	Ticks []SmartRollupTick
	Proof *SmartRollupProof
}

type SmartRollupResult struct {
	Address          *mavryk.Address               `json:"address,omitempty"`            // v016, smart_rollup_originate
	Size             *mavryk.Z                     `json:"size,omitempty"`               // v016, smart_rollup_originate
	InboxLevel       int64                         `json:"inbox_level,omitempty"`        // v016, smart_rollup_cement
	StakedHash       *mavryk.SmartRollupCommitHash `json:"staked_hash,omitempty"`        // v016, smart_rollup_publish
	PublishedAtLevel int64                         `json:"published_at_level,omitempty"` // v016, smart_rollup_publish
	GameStatus       *GameStatus                   `json:"game_status,omitempty"`        // v016, smart_rollup_refute, smart_rollup_timeout
	Commitment       *mavryk.SmartRollupCommitHash `json:"commitment_hash,omitempty"`    // v017, smart_rollup_cement
}

type SmartRollupTick struct {
	State mavryk.SmartRollupStateHash `json:"state"`
	Tick  mavryk.Z                    `json:"tick"`
}

type SmartRollupTimeout struct {
	Manager
	Rollup  mavryk.Address `json:"rollup"`
	Stakers struct {
		Alice mavryk.Address `json:"alice"`
		Bob   mavryk.Address `json:"bob"`
	} `json:"stakers"`
}

type SnapshotIndex struct {
	Cycle int64 // the requested cycle that contains rights from the snapshot
	Base  int64 // the cycle where the snapshot happened
	Index int   // the index inside base where snapshot happened
}

type SnapshotOwners struct {
	Cycle int64          `json:"cycle"`
	Index int64          `json:"index"`
	Rolls []SnapshotRoll `json:"rolls"`
}

type SnapshotRoll struct {
	RollId   int64
	OwnerKey mavryk.Key
}

type StakeInfo struct {
	ActiveStake int64          `json:"active_stake,string"`
	Baker       mavryk.Address `json:"baker"`
}

type StakingParameters struct {
	Cycle int64 `json:"cycle"`
	Limit int64 `json:"limit_of_staking_over_baking_millionth"`
	Edge  int64 `json:"edge_of_baking_over_staking_billionth"`
}

type StakingSnapshotInfo struct {
	Nonces           []string    `json:"nonces"`
	RandomSeed       string      `json:"random_seed"`
	BakerStake       []StakeInfo `json:"selected_stake_distribution,omitempty"`
	TotalActiveStake int64       `json:"total_active_stake,string"`
}

type Status struct {
	Bootstrapped bool   `json:"bootstrapped"`
	SyncState    string `json:"sync_state"`
}

type Ticket struct {
	Ticketer mavryk.Address `json:"ticketer"`
	Content  micheline.Prim `json:"content"`
	Type     micheline.Prim `json:"content_type"`
}

type TicketBalanceUpdate struct {
	Account mavryk.Address `json:"account"`
	Amount  mavryk.Z       `json:"amount"`
}

type TicketUpdate struct {
	Ticket  Ticket                `json:"ticket_token"`
	Updates []TicketBalanceUpdate `json:"updates"`
}

type Transaction struct {
	Manager
	Destination mavryk.Address        `json:"destination"`
	Amount      int64                 `json:"amount,string"`
	Parameters  *micheline.Parameters `json:"parameters,omitempty"`
}

type TransferTicket struct {
	Manager
	Destination mavryk.Address `json:"destination"`
	Entrypoint  string         `json:"entrypoint"`
	Type        micheline.Prim `json:"ticket_ty"`
	Contents    micheline.Prim `json:"ticket_contents"`
	Ticketer    mavryk.Address `json:"ticket_ticketer"`
	Amount      mavryk.Z       `json:"ticket_amount"`
}

type TxRollup struct {
	// common
	Manager

	// rollup address (used by most ops)
	Rollup mavryk.Address `json:"rollup"`

	// tx_rollup_submit_batch
	Batch TxRollupBatch `json:"-"`

	// tx_rollup_rejection
	Reject TxRollupRejection `json:"-"`

	// tx_rollup_dispatch_tickets
	Dispatch TxRollupDispatch `json:"-"`

	// tx_rollup_commit
	Commit TxRollupCommit `json:"commitment"`
}