amazechain

type CallMsg struct {
	From      types.Address  // the sender of the 'transaction'
	To        *types.Address // the destination contract (nil for contract creation)
	Gas       uint64         // if 0, the call executes with near-infinite gas
	GasPrice  *uint256.Int   // wei <-> gas exchange ratio
	GasFeeCap *uint256.Int   // EIP-1559 fee cap per gas.
	GasTipCap *uint256.Int   // EIP-1559 tip per gas.
	Value     *uint256.Int   // amount of wei sent along with the call
	Data      []byte         // input data, usually an ABI-encoded contract method invocation

}

type ChainReader interface {
	BlockByHash(ctx context.Context, hash types.Hash) (*block.Block, error)
	BlockByNumber(ctx context.Context, number uint256.Int) (*block.Block, error)
	HeaderByHash(ctx context.Context, hash types.Hash) (*block.Header, error)
	HeaderByNumber(ctx context.Context, number uint256.Int) (*block.Header, error)
	TransactionCount(ctx context.Context, blockHash types.Hash) (uint, error)
	TransactionInBlock(ctx context.Context, blockHash types.Hash, index uint) (*transaction.Transaction, error)

	// This method subscribes to notifications about changes of the head block of
	// the canonical chain.
	SubscribeNewHead(ctx context.Context, ch chan<- *block.Header) (Subscription, error)
}

type ChainStateReader interface {
	BalanceAt(ctx context.Context, account types.Address, blockNumber *big.Int) (*big.Int, error)
	StorageAt(ctx context.Context, account types.Address, key types.Hash, blockNumber *big.Int) ([]byte, error)
	CodeAt(ctx context.Context, account types.Address, blockNumber uint256.Int) ([]byte, error)
	NonceAt(ctx context.Context, account types.Address, blockNumber uint256.Int) (uint64, error)
}

type ChainSyncReader interface {
	SyncProgress(ctx context.Context) (*SyncProgress, error)
}

type ContractCaller interface {
	CallContract(ctx context.Context, call CallMsg, blockNumber uint256.Int) ([]byte, error)
}

type FeeHistory struct {
	OldestBlock  uint256.Int     // block corresponding to first response value
	Reward       [][]uint256.Int // list every txs priority fee per block
	BaseFee      []uint256.Int   // list of each block's base fee
	GasUsedRatio []float64       // ratio of gas used out of the total available limit
}

type FilterQuery struct {
	BlockHash *types.Hash     // used by eth_getLogs, return logs only from block with this hash
	FromBlock *uint256.Int    // beginning of the queried range, nil means genesis block
	ToBlock   *uint256.Int    // end of the range, nil means latest block
	Addresses []types.Address // restricts matches to events created by specific contracts

	// The Topic list restricts matches to particular event topics. Each event has a list
	// of topics. Topics matches a prefix of that list. An empty element slice matches any
	// topic. Non-empty elements represent an alternative that matches any of the
	// contained topics.
	//
	// Examples:
	// {} or nil          matches any topic list
	// {{A}}              matches topic A in first position
	// {{}, {B}}          matches any topic in first position AND B in second position
	// {{A}, {B}}         matches topic A in first position AND B in second position
	// {{A, B}, {C, D}}   matches topic (A OR B) in first position AND (C OR D) in second position
	Topics [][]types.Hash
}

type GasEstimator interface {
	EstimateGas(ctx context.Context, call CallMsg) (uint64, error)
}

type GasPricer interface {
	SuggestGasPrice(ctx context.Context) (uint256.Int, error)
}

type LogFilterer interface {
	FilterLogs(ctx context.Context, q FilterQuery) ([]block.Log, error)
	SubscribeFilterLogs(ctx context.Context, q FilterQuery, ch chan<- block.Log) (Subscription, error)
}

type PendingContractCaller interface {
	PendingCallContract(ctx context.Context, call CallMsg) ([]byte, error)
}

type PendingStateEventer interface {
	SubscribePendingTransactions(ctx context.Context, ch chan<- *transaction.Transaction) (Subscription, error)
}

type PendingStateReader interface {
	PendingBalanceAt(ctx context.Context, account types.Address) (uint256.Int, error)
	PendingStorageAt(ctx context.Context, account types.Address, key types.Hash) ([]byte, error)
	PendingCodeAt(ctx context.Context, account types.Address) ([]byte, error)
	PendingNonceAt(ctx context.Context, account types.Address) (uint64, error)
	PendingTransactionCount(ctx context.Context) (uint, error)
}

type Subscription interface {
	// Unsubscribe cancels the sending of events to the data channel
	// and closes the error channel.
	Unsubscribe()
	// Err returns the subscription error channel. The error channel receives
	// a value if there is an issue with the subscription (e.g. the network connection
	// delivering the events has been closed). Only one value will ever be sent.
	// The error channel is closed by Unsubscribe.
	Err() <-chan error
}

type SyncProgress struct {
	StartingBlock uint64 // Block number where sync began
	CurrentBlock  uint64 // Current block number where sync is at
	HighestBlock  uint64 // Highest alleged block number in the chain

	// "fast sync" fields. These used to be sent by geth, but are no longer used
	// since version v1.10.
	PulledStates uint64 // Number of state trie entries already downloaded
	KnownStates  uint64 // Total number of state trie entries known about

	// "snap sync" fields.
	SyncedAccounts      uint64 // Number of accounts downloaded
	SyncedAccountBytes  uint64 // Number of account trie bytes persisted to disk
	SyncedBytecodes     uint64 // Number of bytecodes downloaded
	SyncedBytecodeBytes uint64 // Number of bytecode bytes downloaded
	SyncedStorage       uint64 // Number of storage slots downloaded
	SyncedStorageBytes  uint64 // Number of storage trie bytes persisted to disk

	HealedTrienodes     uint64 // Number of state trie nodes downloaded
	HealedTrienodeBytes uint64 // Number of state trie bytes persisted to disk
	HealedBytecodes     uint64 // Number of bytecodes downloaded
	HealedBytecodeBytes uint64 // Number of bytecodes persisted to disk

	HealingTrienodes uint64 // Number of state trie nodes pending
	HealingBytecode  uint64 // Number of bytecodes pending
}

type TransactionReader interface {
	// TransactionByHash checks the pool of pending transactions in addition to the
	// blockchain. The isPending return value indicates whether the transaction has been
	// mined yet. Note that the transaction may not be part of the canonical chain even if
	// it's not pending.
	TransactionByHash(ctx context.Context, txHash types.Hash) (tx *transaction.Transaction, isPending bool, err error)
	// TransactionReceipt returns the receipt of a mined transaction. Note that the
	// transaction may not be included in the current canonical chain even if a receipt
	// exists.
	TransactionReceipt(ctx context.Context, txHash types.Hash) (*block.Receipt, error)
}

type TransactionSender interface {
	SendTransaction(ctx context.Context, tx *transaction.Transaction) error
}