rpc

type AccessList []AccessTuple

type AccessTuple struct {
	Address     eth.Address `json:"address"`
	StorageKeys []eth.Hash  `json:"storageKeys"`
}

type Block struct {
	Number           eth.Uint64         `json:"number"`
	Hash             eth.Hash           `json:"hash"`
	ParentHash       eth.Hash           `json:"parentHash"`
	Timestamp        eth.Timestamp      `json:"timestamp"`
	StateRoot        eth.Hash           `json:"stateRoot"`
	TransactionsRoot eth.Hash           `json:"transactionsRoot"`
	ReceiptsRoot     eth.Hash           `json:"receiptsRoot"`
	MixHash          eth.Hash           `json:"mixHash"`
	GasLimit         eth.Uint64         `json:"gasLimit"`
	GasUsed          eth.Uint64         `json:"gasUsed"`
	Difficulty       *eth.Uint256       `json:"difficulty"`
	TotalDifficulty  *eth.Uint256       `json:"totalDifficulty"`
	Miner            eth.Address        `json:"miner"`
	Nonce            eth.FixedUint64    `json:"nonce,omitempty"`
	LogsBloom        eth.Hex            `json:"logsBloom"`
	ExtraData        eth.Hex            `json:"extraData"`
	BaseFeePerGas    *eth.Uint256       `json:"baseFeePerGas,omitempty"`
	BlockSize        eth.Uint64         `json:"size,omitempty"`
	Transactions     *BlockTransactions `json:"transactions,omitempty"`
	UnclesSHA3       eth.Hash           `json:"sha3Uncles,omitempty"`
	Uncles           []eth.Hash         `json:"uncles,omitempty"`

	BlobGasUsed           *eth.Uint64  `json:"blobGasUsed,omitempty"`           // EIP-4844
	ExcessBlobGas         *eth.Uint64  `json:"excessBlobGas,omitempty"`         // EIP-4844
	ParentBeaconBlockRoot *eth.Hash    `json:"parentBeaconBlockRoot,omitempty"` // EIP-4844
	WithdrawalsHash       *eth.Hash    `json:"withdrawalsRoot,omitempty"`       // EIP-4895
	Withdrawals           []Withdrawal `json:"withdrawals,omitempty"`           // EIP-4895
	RequestsHash          *eth.Hash    `json:"requestsHash,omitempty"`          // EIP-7685
}

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

type BlockTransactions struct {
	Transactions []Transaction
	// contains filtered or unexported fields
}

type CallParams struct {
	// From the address the transaction is sent from (optional).
	From eth.Address `json:"from,omitempty"`
	// To the address the transaction is directed to (required).
	To eth.Address `json:"to,omitempty"`
	// GasLimit Integer of the gas provided for the transaction execution. eth_call consumes zero gas, but this parameter may be needed by some executions (optional).
	GasLimit uint64 `json:"gas,omitempty"`
	// GasPrice big integer of the gasPrice used for each paid gas (optional).
	GasPrice *big.Int `json:"gasPrice,omitempty"`
	// Value big integer of the value sent with this transaction (optional).
	Value *big.Int `json:"value,omitempty"`
	// Hash of the method signature and encoded parameters or any object that implements `MarshalJSONRPC` and serialize to a byte array, for details see Ethereum Contract ABI in the Solidity documentation (optional).
	Data interface{} `json:"data,omitempty"`
}

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

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

type ETHCallOption func(*ETHCall)

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

type ErrResponse struct {
	Code    ErrorCode   `json:"code"`
	Message string      `json:"message"`
	Data    interface{} `json:"data,omitempty"`
}

type ErrorCode int

type GetBlockOption interface {
	// contains filtered or unexported methods
}

type LogEntry struct {
	Address          eth.Address `json:"address"`
	Topics           []eth.Hash  `json:"topics"`
	Data             eth.Hex     `json:"data"`
	BlockNumber      eth.Uint64  `json:"blockNumber"`
	TransactionHash  eth.Hash    `json:"transactionHash"`
	TransactionIndex eth.Uint64  `json:"transactionIndex"`
	BlockHash        eth.Hash    `json:"blockHash"`
	LogIndex         eth.Uint64  `json:"logIndex"`
	Removed          bool        `json:"removed"`
}

type LogsParams struct {
	// FromBlock is either block number encoded as a hexadecimal or tagged value which is one of
	// "latest" (`rpc.LatestBlock`), "pending" (`rpc.PendingBlock`) or "earliest" tags (`rpc.EarliestBlock`) (optional).
	FromBlock *BlockRef `json:"fromBlock,omitempty"`

	// ToBlock is either block number encoded as a hexadecimal or tagged value which is one of
	// "latest" (`LatestBlock`), "pending" (`rpc.PendingBlock`) or "earliest" tags (`EarliestBlock`) (optional).
	ToBlock *BlockRef `json:"toBlock,omitempty"`

	// Address is the contract address or a list of addresses from which logs should originate (optional).
	Address eth.Address `json:"address,omitempty"`

	// Topics are order-dependent, each topic can also be an array of DATA with "or" options (optional).
	Topics *TopicFilter `json:"topics,omitempty"`

	// BlockHash is the block hash encoded as a hex string with prefix '0x'
	BlockHash eth.Bytes `json:"blockHash,omitempty"`
}

type Marshaler interface {
	MarshalJSON() ([]byte, error)
}

type MarshalerError struct {
	Type reflect.Type
	Err  error
	// contains filtered or unexported fields
}

type MarshalerRPC interface {
	MarshalJSONRPC() ([]byte, error)
}

type Option func(*Client)

type RPCRequest struct {
	Params []interface{} `json:"params"`
	Method string        `json:"method"`

	JSONRPC string  `json:"jsonrpc"`
	ID      eth.Int `json:"id"`
	// contains filtered or unexported fields
}

type RPCResponse struct {
	Content string
	ID      int
	Err     error
	// contains filtered or unexported fields
}

type RawMessage []byte

type ResponseDecoder func([]byte) ([]interface{}, error)

type SyncingResp struct {
	StartingBlockNum eth.Uint64 `json:"starting_block_num"`
	CurrentBlockNum  eth.Uint64 `json:"current_block_num"`
	HighestBlockNum  eth.Uint64 `json:"highest_block_num"`
}

type SyntaxError struct {
	Offset int64 // error occurred after reading Offset bytes
	// contains filtered or unexported fields
}

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

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

type Transaction struct {
	// Hash is the hash of the transaction.
	Hash eth.Hash `json:"hash"`

	Nonce eth.Uint64 `json:"nonce,omitempty"`

	// BlockHash is the hash of the block where this transaction was in, none when pending.
	BlockHash eth.Hash `json:"blockHash"`

	// BlockNumber is the block number where this transaction was in, none when pending.
	BlockNumber eth.Uint64 `json:"blockNumber"`

	// TransactionIndex is the transactions index position in the block, none when pending.
	TransactionIndex eth.Uint64 `json:"transactionIndex"`

	// From is the address of the sender.
	From eth.Address `json:"from"`

	// To is the address of the receiver, `null` when the transaction is a contract creation transaction.
	To *eth.Address `json:"to"`

	// Value is the ETH transfered value to the recipient/
	Value *eth.Uint256 `json:"value"`

	// GasPrice is the ETH value of the gas sender is willing to pay, it's the effective gas price when London fork is active and transaction type is 0x02 (DynamicFee).
	GasPrice *eth.Uint256 `json:"gasPrice"`

	// Gas is the the amount of gas sender is willing to allocate for this transaction, might not be fully consumed.
	Gas eth.Uint64 `json:"gas"`

	// Input data the transaction will receive for execution of EVM.
	Input eth.Hex `json:"input,omitempty"`

	// V is the ECDSA recovery id of the transaction's signature.
	V eth.Uint64 `json:"v,omitempty"`

	// R is the ECDSA signature R point of transaction's signature.
	R *eth.Uint256 `json:"r,omitempty"`

	// S is the ECDSA signature S point of transaction's signature.
	S *eth.Uint256 `json:"s,omitempty"`

	// AccessList is the defined access list tuples when the transaction is of AccessList type (0x01), none when transaction of other types.
	AccessList AccessList `json:"accessList,omitempty"`

	// ChainID is the identifier chain the transaction was executed in, none if London fork is **not** activated
	ChainID eth.Uint64 `json:"chainId,omitempty"`

	// MaxFeePerGas is the identifier chain the transaction was executed in, none if London fork is **not** activated
	MaxFeePerGas *eth.Uint256 `json:"maxFeePerGas,omitempty"`

	// MaxPriorityFeePerGas is the identifier chain the transaction was executed in, none if London fork is **not** activated
	MaxPriorityFeePerGas *eth.Uint256 `json:"maxPriorityFeePerGas,omitempty"`

	// Type is the transaction's type
	Type eth.TransactionType `json:"type"`
}

type TransactionReceipt struct {
	// TransactionHash is the hash of the transaction.
	TransactionHash eth.Hash `json:"transactionHash"`
	// TransactionIndex is the transactions index position in the block.
	TransactionIndex eth.Uint64 `json:"transactionIndex"`
	// BlockHash is the hash of the block where this transaction was in.
	BlockHash eth.Hash `json:"blockHash"`
	// BlockNumber is the block number where this transaction was in.
	BlockNumber eth.Uint64 `json:"blockNumber"`
	// From is the address of the sender.
	From eth.Address `json:"from"`
	// To is the address of the receiver, `null` when the transaction is a contract creation transaction.
	To *eth.Address `json:"to,omitempty"`
	// CumulativeGasUsed is the the total amount of gas used when this transaction was executed in the block.
	CumulativeGasUsed eth.Uint64 `json:"cumulativeGasUsed"`
	// EffectiveGasPrice is the sum of the base fee and tip paid per unit of gas.
	EffectiveGasPrice eth.Uint64 `json:"effectiveGasPrice"`
	// GasUsed is the the amount of gas used by this specific transaction alone.
	GasUsed eth.Uint64 `json:"gasUsed"`
	// ContractAddress is the the contract address created, if the transaction was a contract creation, otherwise - null.
	ContractAddress *eth.Address `json:"contractAddress,omitempty"`
	// Logs is the Array of log objects, which this transaction generated.
	Logs []*LogEntry `json:"logs"`
	// LogsBloom is the Bloom filter for light clients to quickly retrieve related logs.
	LogsBloom eth.Hex `json:"logsBloom"`
	// Type is the transaction type, 0x0 for legacy transactions, 0x1 for access list types, 0x2 for dynamic fees
	Type eth.Uint64 `json:"type"`

	// Root: 32 bytes of post-transaction stateroot (pre Byzantium)
	Root eth.Hash `json:"root"`
	// Status is either 1 (success) or 0 (failure) (post Byzantium)
	Status *eth.Uint64 `json:"status"`
}

type UnsupportedTypeError struct {
	Type reflect.Type
}

type UnsupportedValueError struct {
	Value reflect.Value
	Str   string
}

type Withdrawal struct {
	Index     eth.Uint64  `json:"index"`          // monotonically increasing identifier issued by consensus layer
	Validator eth.Uint64  `json:"validatorIndex"` // index of validator associated with withdrawal
	Address   eth.Address `json:"address"`        // target address for withdrawn ether
	Amount    eth.Uint64  `json:"amount"`         // value of withdrawal in Gwei
}