Struct RpcBlockchainStateProvider 

pub struct RpcBlockchainStateProvider<P, Node, N = AnyNetwork>
where
    Node: NodeTypes,
{ /* private fields */ }

RPC-based state provider implementation that fetches blockchain state via remote RPC calls.

This is the state provider counterpart to RpcBlockchainProvider, handling state queries at specific block heights via RPC instead of local database access.

Implementations

impl<P: Clone, Node: NodeTypes, N> RpcBlockchainStateProvider<P, Node, N>

pub fn new( provider: P, block_id: BlockId, _primitives: PhantomData<Node>, ) -> Self

Creates a new state provider for the given block

pub fn with_chain_spec( provider: P, block_id: BlockId, chain_spec: Arc<Node::ChainSpec>, ) -> Self

Creates a new state provider with a cached chain spec

pub const fn with_compute_state_root(self, is_enable: bool) -> Self

Helper function to enable state root calculation

If enabled, the node will compute the state root and updates. When disabled, it will return zero for state root and no updates.

pub const fn with_reth_rpc_support(self, is_enable: bool) -> Self

Sets whether to use Reth-specific RPC methods for better performance

If enabled, the node will use Reth’s RPC methods (debug_codeByHash and eth_getAccountInfo) to speed up account information retrieval. When disabled, it will use multiple standard RPC calls to get account information.

Trait Implementations

impl<P, Node, N> AccountReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn basic_account( &self, address: &Address, ) -> Result<Option<Account>, ProviderError>

Get basic account information.

impl<P, Node, N> BlockBodyIndicesProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn block_body_indices( &self, _num: u64, ) -> Result<Option<StoredBlockBodyIndices>, ProviderError>

Returns the block body indices with matching number from database.

fn block_body_indices_range( &self, _range: RangeInclusive<u64>, ) -> Result<Vec<StoredBlockBodyIndices>, ProviderError>

Returns the block body indices within the requested range matching number from storage.

impl<P, Node, N> BlockHashReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn block_hash(&self, number: u64) -> Result<Option<B256>, ProviderError>

Get the hash of the block with the given number. Returns None if no block with this number exists.

fn canonical_hashes_range( &self, _start: BlockNumber, _end: BlockNumber, ) -> Result<Vec<B256>, ProviderError>

Get headers in range of block hashes or numbers

fn convert_block_hash( &self, hash_or_number: HashOrNumber, ) -> Result<Option<FixedBytes<32>>, ProviderError>

Get the hash of the block with the given number. Returns None if no block with this number exists.

impl<P, Node, N> BlockIdReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn block_number_for_id( &self, _block_id: BlockId, ) -> Result<Option<BlockNumber>, ProviderError>

Get the number of the block by matching the given id.

fn pending_block_num_hash(&self) -> Result<Option<BlockNumHash>, ProviderError>

Get the current pending block number and hash.

fn safe_block_num_hash(&self) -> Result<Option<BlockNumHash>, ProviderError>

Get the current safe block number and hash.

fn finalized_block_num_hash( &self, ) -> Result<Option<BlockNumHash>, ProviderError>

Get the current finalized block number and hash.

fn convert_block_number( &self, num: BlockNumberOrTag, ) -> Result<Option<u64>, ProviderError>

Converts the BlockNumberOrTag variants to a block number.

fn block_hash_for_id( &self, block_id: BlockId, ) -> Result<Option<FixedBytes<32>>, ProviderError>

Get the hash of the block by matching the given id.

fn safe_block_number(&self) -> Result<Option<u64>, ProviderError>

Get the safe block number.

fn finalized_block_number(&self) -> Result<Option<u64>, ProviderError>

Get the finalized block number.

fn safe_block_hash(&self) -> Result<Option<FixedBytes<32>>, ProviderError>

Get the safe block hash.

fn finalized_block_hash(&self) -> Result<Option<FixedBytes<32>>, ProviderError>

Get the finalized block hash.

impl<P, Node, N> BlockNumReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn chain_info(&self) -> Result<ChainInfo, ProviderError>

Returns the current info for the chain.

fn best_block_number(&self) -> Result<BlockNumber, ProviderError>

Returns the best block number in the chain.

fn last_block_number(&self) -> Result<BlockNumber, ProviderError>

Returns the last block number associated with the last canonical header in the database.

fn block_number(&self, hash: B256) -> Result<Option<BlockNumber>, ProviderError>

Gets the BlockNumber for the given hash. Returns None if no block with this hash exists.

fn earliest_block_number(&self) -> Result<u64, ProviderError>

Returns earliest block number to keep track of the expired block range.

fn convert_hash_or_number( &self, id: HashOrNumber, ) -> Result<Option<u64>, ProviderError>

Gets the block number for the given BlockHashOrNumber. Returns None if no block with this hash exists. If the BlockHashOrNumber is a Number, it is returned as is.

fn convert_number( &self, id: HashOrNumber, ) -> Result<Option<FixedBytes<32>>, ProviderError>

Gets the block hash for the given BlockHashOrNumber. Returns None if no block with this number exists. If the BlockHashOrNumber is a Hash, it is returned as is.

impl<P, Node, N> BlockReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

type Block = <<Node as NodeTypes>::Primitives as NodePrimitives>::Block

The block type this provider reads.

fn find_block_by_hash( &self, _hash: B256, _source: BlockSource, ) -> Result<Option<Self::Block>, ProviderError>

Tries to find in the given block source.

fn block( &self, _id: BlockHashOrNumber, ) -> Result<Option<Self::Block>, ProviderError>

Returns the block with given id from the database.

fn pending_block( &self, ) -> Result<Option<RecoveredBlock<Self::Block>>, ProviderError>

Returns the pending block if available

fn pending_block_and_receipts( &self, ) -> Result<Option<(RecoveredBlock<Self::Block>, Vec<Self::Receipt>)>, ProviderError>

Returns the pending block and receipts if available.

fn recovered_block( &self, _id: BlockHashOrNumber, _transaction_kind: TransactionVariant, ) -> Result<Option<RecoveredBlock<Self::Block>>, ProviderError>

Returns the block with senders with matching number or hash from database.

fn sealed_block_with_senders( &self, _id: BlockHashOrNumber, _transaction_kind: TransactionVariant, ) -> Result<Option<RecoveredBlock<BlockTy<Node>>>, ProviderError>

Returns the sealed block with senders with matching number or hash from database.

fn block_range( &self, _range: RangeInclusive<BlockNumber>, ) -> Result<Vec<Self::Block>, ProviderError>

Returns all blocks in the given inclusive range.

fn block_with_senders_range( &self, _range: RangeInclusive<BlockNumber>, ) -> Result<Vec<RecoveredBlock<BlockTy<Node>>>, ProviderError>

Returns a range of blocks from the database, along with the senders of each transaction in the blocks.

fn recovered_block_range( &self, _range: RangeInclusive<BlockNumber>, ) -> Result<Vec<RecoveredBlock<Self::Block>>, ProviderError>

Returns a range of sealed blocks from the database, along with the senders of each transaction in the blocks.

fn block_by_hash( &self, hash: FixedBytes<32>, ) -> Result<Option<Self::Block>, ProviderError>

Returns the block with matching hash from the database.

fn block_by_number( &self, num: u64, ) -> Result<Option<Self::Block>, ProviderError>

Returns the block with matching number from database.

impl<P, Node, N> BytecodeReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn bytecode_by_hash( &self, code_hash: &B256, ) -> Result<Option<Bytecode>, ProviderError>

Get account code by its hash

impl<P, Node, N> ChainSpecProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Send + Sync + Debug, N: Send + Sync, Node: NodeTypes, Node::ChainSpec: Default,

type ChainSpec = <Node as NodeTypes>::ChainSpec

The chain spec type.

fn chain_spec(&self) -> Arc<Self::ChainSpec>

Get an Arc to the chainspec.

impl<P, Node, N> ChainStateBlockReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn last_finalized_block_number( &self, ) -> Result<Option<BlockNumber>, ProviderError>

Returns the last finalized block number.

fn last_safe_block_number(&self) -> Result<Option<BlockNumber>, ProviderError>

Returns the last safe block number.

impl<P, Node, N> ChainStateBlockWriter for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn save_finalized_block_number( &self, _block_number: BlockNumber, ) -> Result<(), ProviderError>

Saves the given finalized block number in the DB.

fn save_safe_block_number( &self, _block_number: BlockNumber, ) -> Result<(), ProviderError>

Saves the given safe block number in the DB.

impl<P, Node, N> ChangeSetReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn account_block_changeset( &self, _block_number: BlockNumber, ) -> Result<Vec<AccountBeforeTx>, ProviderError>

Iterate over account changesets and return the account state from before this block.

impl<P, Node, N> DBProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

type Tx = TxMock

Underlying database transaction held by the provider.

fn tx_ref(&self) -> &Self::Tx

Returns a reference to the underlying transaction.

fn tx_mut(&mut self) -> &mut Self::Tx

Returns a mutable reference to the underlying transaction.

fn into_tx(self) -> Self::Tx

Consumes the provider and returns the underlying transaction.

fn prune_modes_ref(&self) -> &PruneModes

Returns a reference to prune modes.

fn disable_long_read_transaction_safety(self) -> Self

Disables long-lived read transaction safety guarantees for leaks prevention and observability improvements.

fn commit(self) -> Result<bool, ProviderError>

Commit database transaction

fn table<T>( &self, ) -> Result<Vec<(<T as Table>::Key, <T as Table>::Value)>, DatabaseError>

where T: Table, <T as Table>::Key: Default + Ord,

Return full table as Vec

fn get<T>( &self, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<Vec<(<T as Table>::Key, <T as Table>::Value)>, DatabaseError>

where T: Table,

Return a list of entries from the table, based on the given range.

fn cursor_read_collect<T>( &self, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<Vec<<T as Table>::Value>, ProviderError>

where T: Table<Key = u64>,

Iterates over read only values in the given table and collects them into a vector.

fn cursor_collect<T>( &self, cursor: &mut impl DbCursorRO<T>, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<Vec<<T as Table>::Value>, ProviderError>

where T: Table<Key = u64>,

Iterates over read only values in the given table and collects them into a vector.

fn cursor_collect_with_capacity<T>( &self, cursor: &mut impl DbCursorRO<T>, range: impl RangeBounds<<T as Table>::Key>, capacity: usize, ) -> Result<Vec<<T as Table>::Value>, ProviderError>

where T: Table<Key = u64>,

Iterates over read only values in the given table and collects them into a vector with capacity.

fn remove<T>( &self, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<usize, DatabaseError>

where T: Table, Self::Tx: DbTxMut,

Remove list of entries from the table. Returns the number of entries removed.

fn take<T>( &self, range: impl RangeBounds<<T as Table>::Key>, ) -> Result<Vec<(<T as Table>::Key, <T as Table>::Value)>, DatabaseError>

where T: Table, Self::Tx: DbTxMut,

Return a list of entries from the table, and remove them, based on the given range.

impl<P: Debug, Node: NodeTypes, N> Debug for RpcBlockchainStateProvider<P, Node, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P, Node, N> HashedPostStateProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn hashed_post_state(&self, _bundle_state: &BundleState) -> HashedPostState

Returns the HashedPostState of the provided [BundleState].

impl<P, Node, N> HeaderProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

type Header = <<Node as NodeTypes>::Primitives as NodePrimitives>::BlockHeader

The header type this provider supports.

fn header( &self, _block_hash: &BlockHash, ) -> Result<Option<Self::Header>, ProviderError>

Get header by block hash

fn header_by_number( &self, _num: BlockNumber, ) -> Result<Option<Self::Header>, ProviderError>

Get header by block number

fn header_td(&self, _hash: &BlockHash) -> Result<Option<U256>, ProviderError>

Get total difficulty by block hash.

fn header_td_by_number( &self, _number: BlockNumber, ) -> Result<Option<U256>, ProviderError>

Get total difficulty by block number.

fn headers_range( &self, _range: impl RangeBounds<BlockNumber>, ) -> Result<Vec<Self::Header>, ProviderError>

Get headers in range of block numbers

fn sealed_header( &self, _number: BlockNumber, ) -> Result<Option<SealedHeader<HeaderTy<Node>>>, ProviderError>

Get a single sealed header by block number.

fn sealed_headers_range( &self, _range: impl RangeBounds<BlockNumber>, ) -> Result<Vec<SealedHeader<HeaderTy<Node>>>, ProviderError>

Get headers in range of block numbers.

fn sealed_headers_while( &self, _range: impl RangeBounds<BlockNumber>, _predicate: impl FnMut(&SealedHeader<HeaderTy<Node>>) -> bool, ) -> Result<Vec<SealedHeader<HeaderTy<Node>>>, ProviderError>

Get sealed headers while predicate returns true or the range is exhausted.

fn is_known(&self, block_hash: &FixedBytes<32>) -> Result<bool, ProviderError>

Check if block is known

fn sealed_header_by_hash( &self, block_hash: FixedBytes<32>, ) -> Result<Option<SealedHeader<Self::Header>>, ProviderError>

Retrieves the header sealed by the given block hash.

fn header_by_hash_or_number( &self, hash_or_num: HashOrNumber, ) -> Result<Option<Self::Header>, ProviderError>

Get header by block number or hash

impl<P, Node, N> NodePrimitivesProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Send + Sync + Debug, N: Send + Sync, Node: NodeTypes,

type Primitives = <Node as NodeTypes>::Primitives

The node primitive types.

impl<P, Node, N> PruneCheckpointReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn get_prune_checkpoint( &self, _segment: PruneSegment, ) -> Result<Option<PruneCheckpoint>, ProviderError>

Fetch the prune checkpoint for the given segment.

fn get_prune_checkpoints( &self, ) -> Result<Vec<(PruneSegment, PruneCheckpoint)>, ProviderError>

Fetch all the prune checkpoints.

impl<P, Node, N> ReceiptProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

type Receipt = <<Node as NodeTypes>::Primitives as NodePrimitives>::Receipt

The receipt type.

fn receipt(&self, _id: TxNumber) -> Result<Option<Self::Receipt>, ProviderError>

Get receipt by transaction number

fn receipt_by_hash( &self, _hash: B256, ) -> Result<Option<Self::Receipt>, ProviderError>

Get receipt by transaction hash.

fn receipts_by_block( &self, _block: BlockHashOrNumber, ) -> Result<Option<Vec<Self::Receipt>>, ProviderError>

Get receipts by block num or hash.

fn receipts_by_tx_range( &self, _range: impl RangeBounds<TxNumber>, ) -> Result<Vec<Self::Receipt>, ProviderError>

Get receipts by tx range.

fn receipts_by_block_range( &self, _range: RangeInclusive<BlockNumber>, ) -> Result<Vec<Vec<Self::Receipt>>, ProviderError>

Get receipts by block range.

impl<P, Node, N> StageCheckpointReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn get_stage_checkpoint( &self, _id: StageId, ) -> Result<Option<StageCheckpoint>, ProviderError>

Fetch the checkpoint for the given stage.

fn get_stage_checkpoint_progress( &self, _id: StageId, ) -> Result<Option<Vec<u8>>, ProviderError>

Get stage checkpoint progress.

fn get_all_checkpoints( &self, ) -> Result<Vec<(String, StageCheckpoint)>, ProviderError>

Reads all stage checkpoints and returns a list with the name of the stage and the checkpoint data.

impl<P, Node, N> StateProofProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn proof( &self, _input: TrieInput, _address: Address, _slots: &[B256], ) -> Result<AccountProof, ProviderError>

Get account and storage proofs of target keys in the HashedPostState on top of the current state.

fn multiproof( &self, _input: TrieInput, _targets: MultiProofTargets, ) -> Result<MultiProof, ProviderError>

Generate [MultiProof] for target hashed account and corresponding hashed storage slot keys.

fn witness( &self, _input: TrieInput, _target: HashedPostState, ) -> Result<Vec<Bytes>, ProviderError>

Get trie witness for provided state.

impl<P, Node, N> StateProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn storage( &self, address: Address, storage_key: StorageKey, ) -> Result<Option<U256>, ProviderError>

Get storage of given account.

fn account_code( &self, addr: &Address, ) -> Result<Option<Bytecode>, ProviderError>

Get account code by its address.

fn account_balance(&self, addr: &Address) -> Result<Option<U256>, ProviderError>

Get account balance by its address.

fn account_nonce(&self, addr: &Address) -> Result<Option<u64>, ProviderError>

Get account nonce by its address.

impl<P, Node, N> StateProviderFactory for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static + Send + Sync, Node: NodeTypes + 'static, Node::ChainSpec: Send + Sync, N: Network, Self: Clone + 'static,

fn latest(&self) -> Result<StateProviderBox, ProviderError>

Storage provider for latest block.

fn state_by_block_id( &self, block_id: BlockId, ) -> Result<StateProviderBox, ProviderError>

Returns a [StateProvider] indexed by the given [BlockId].

fn state_by_block_number_or_tag( &self, number_or_tag: BlockNumberOrTag, ) -> Result<StateProviderBox, ProviderError>

Returns a [StateProvider] indexed by the given block number or tag.

fn history_by_block_number( &self, block_number: BlockNumber, ) -> Result<StateProviderBox, ProviderError>

Returns a historical [StateProvider] indexed by the given historic block number.

fn history_by_block_hash( &self, block_hash: BlockHash, ) -> Result<StateProviderBox, ProviderError>

Returns a historical [StateProvider] indexed by the given block hash.

fn state_by_block_hash( &self, block_hash: BlockHash, ) -> Result<StateProviderBox, ProviderError>

Returns any [StateProvider] with matching block hash.

fn pending(&self) -> Result<StateProviderBox, ProviderError>

Storage provider for pending state.

fn pending_state_by_hash( &self, _block_hash: B256, ) -> Result<Option<StateProviderBox>, ProviderError>

Storage provider for pending state for the given block hash.

impl<P, Node, N> StateReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

type Receipt = <<Node as NodeTypes>::Primitives as NodePrimitives>::Receipt

Receipt type in [ExecutionOutcome].

fn get_state( &self, _block: BlockNumber, ) -> Result<Option<ExecutionOutcome<Self::Receipt>>, ProviderError>

Get the [ExecutionOutcome] for the given block

impl<P, Node, N> StateRootProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn state_root( &self, hashed_state: HashedPostState, ) -> Result<B256, ProviderError>

Returns the state root of the BundleState on top of the current state.

fn state_root_from_nodes( &self, _input: TrieInput, ) -> Result<B256, ProviderError>

Returns the state root of the HashedPostState on top of the current state but reuses the intermediate nodes to speed up the computation. It’s up to the caller to construct the prefix sets and inform the provider of the trie paths that have changes.

fn state_root_with_updates( &self, hashed_state: HashedPostState, ) -> Result<(B256, TrieUpdates), ProviderError>

Returns the state root of the HashedPostState on top of the current state with trie updates to be committed to the database.

fn state_root_from_nodes_with_updates( &self, _input: TrieInput, ) -> Result<(B256, TrieUpdates), ProviderError>

Returns state root and trie updates. See [StateRootProvider::state_root_from_nodes] for more info.

impl<P, Node, N> StatsReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn count_entries<T: Table>(&self) -> Result<usize, ProviderError>

Fetch the number of entries in the corresponding [Table]. Depending on the provider, it may route to different data sources other than [Table].

impl<P, Node, N> StorageReader for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn plain_state_storages( &self, addresses_with_keys: impl IntoIterator<Item = (Address, impl IntoIterator<Item = StorageKey>)>, ) -> Result<Vec<(Address, Vec<StorageEntry>)>, ProviderError>

Get plainstate storages for addresses and storage keys.

fn changed_storages_with_range( &self, _range: RangeInclusive<BlockNumber>, ) -> Result<BTreeMap<Address, BTreeSet<StorageKey>>, ProviderError>

Iterate over storage changesets and return all storage slots that were changed.

fn changed_storages_and_blocks_with_range( &self, _range: RangeInclusive<BlockNumber>, ) -> Result<BTreeMap<(Address, StorageKey), Vec<u64>>, ProviderError>

Iterate over storage changesets and return all storage slots that were changed alongside each specific set of blocks.

impl<P, Node, N> StorageRootProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

fn storage_root( &self, _address: Address, _hashed_storage: HashedStorage, ) -> Result<B256, ProviderError>

Returns the storage root of the HashedStorage for target address on top of the current state.

fn storage_proof( &self, _address: Address, _slot: B256, _hashed_storage: HashedStorage, ) -> Result<StorageProof, ProviderError>

Returns the storage proof of the HashedStorage for target slot on top of the current state.

fn storage_multiproof( &self, _address: Address, _slots: &[B256], _hashed_storage: HashedStorage, ) -> Result<StorageMultiProof, ProviderError>

Returns the storage multiproof for target slots.

impl<P, Node, N> TransactionsProvider for RpcBlockchainStateProvider<P, Node, N>

where P: Provider<N> + Clone + 'static, N: Network, Node: NodeTypes,

type Transaction = <<Node as NodeTypes>::Primitives as NodePrimitives>::SignedTx

The transaction type this provider reads.

fn transaction_id( &self, _tx_hash: B256, ) -> Result<Option<TxNumber>, ProviderError>

Get internal transaction identifier by transaction hash.

fn transaction_by_id( &self, _id: TxNumber, ) -> Result<Option<Self::Transaction>, ProviderError>

Get transaction by id, computes hash every time so more expensive.

fn transaction_by_id_unhashed( &self, _id: TxNumber, ) -> Result<Option<Self::Transaction>, ProviderError>

Get transaction by id without computing the hash.

fn transaction_by_hash( &self, _hash: B256, ) -> Result<Option<Self::Transaction>, ProviderError>

Get transaction by transaction hash.

fn transaction_by_hash_with_meta( &self, _hash: B256, ) -> Result<Option<(Self::Transaction, TransactionMeta)>, ProviderError>

Get transaction by transaction hash and additional metadata of the block the transaction was mined in

fn transaction_block( &self, _id: TxNumber, ) -> Result<Option<BlockNumber>, ProviderError>

Get transaction block number

fn transactions_by_block( &self, _block: BlockHashOrNumber, ) -> Result<Option<Vec<Self::Transaction>>, ProviderError>

Get transactions by block id.

fn transactions_by_block_range( &self, _range: impl RangeBounds<BlockNumber>, ) -> Result<Vec<Vec<Self::Transaction>>, ProviderError>

Get transactions by block range.

fn transactions_by_tx_range( &self, _range: impl RangeBounds<TxNumber>, ) -> Result<Vec<Self::Transaction>, ProviderError>

Get transactions by tx range.

fn senders_by_tx_range( &self, _range: impl RangeBounds<TxNumber>, ) -> Result<Vec<Address>, ProviderError>

Get Senders from a tx range.

fn transaction_sender( &self, _id: TxNumber, ) -> Result<Option<Address>, ProviderError>

Get transaction sender.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.