Struct EthApi 

pub struct EthApi<N, Rpc>
where
    N: RpcNodeCore,
    Rpc: RpcConvert,
{ /* private fields */ }

Available on crate feature rpc only.

Eth API implementation.

This type provides the functionality for handling eth_ related requests. These are implemented two-fold: Core functionality is implemented as EthApiSpec trait. Additionally, the required server implementations (e.g. EthApiServer) are implemented separately in submodules. The rpc handler implementation can then delegate to the main impls. This way EthApi is not limited to jsonrpsee and can be used standalone or in other network handlers (for example ipc).

Trait requirements

While this type requires various unrestricted generic components, trait bounds are enforced when additional traits are implemented for this type.

Implementations

impl EthApi<RpcNodeCoreAdapter<NoopProvider, NoopTransactionPool, NoopNetwork, EthEvmConfig>, RpcConverter<Ethereum, EthEvmConfig, EthReceiptConverter<ChainSpec>>>

pub fn builder<Provider, Pool, Network, EvmConfig, ChainSpec>( provider: Provider, pool: Pool, network: Network, evm_config: EvmConfig, ) -> EthApiBuilder<RpcNodeCoreAdapter<Provider, Pool, Network, EvmConfig>, RpcConverter<Ethereum, EvmConfig, EthReceiptConverter<ChainSpec>>>

where RpcNodeCoreAdapter<Provider, Pool, Network, EvmConfig>: RpcNodeCore<Evm = EvmConfig>, <RpcNodeCoreAdapter<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider: ChainSpecProvider<ChainSpec = ChainSpec>,

Convenience fn to obtain a new EthApiBuilder instance with mandatory components.

Creating an EthApi requires a few mandatory components:

• provider: The type responsible for fetching requested data from disk.
• transaction pool: To interact with the pool, submitting new transactions (e.g. eth_sendRawTransactions).
• network: required to handle requests related to network state (e.g. eth_syncing).
• evm config: Knows how create a new EVM instance to transact,estimate,call,trace.

Create an instance with noop ethereum implementations

use alloy_network::Ethereum;
use reth_evm_ethereum::EthEvmConfig;
use reth_network_api::noop::NoopNetwork;
use reth_provider::noop::NoopProvider;
use reth_rpc::EthApi;
use reth_transaction_pool::noop::NoopTransactionPool;
let eth_api = EthApi::builder(
    NoopProvider::default(),
    NoopTransactionPool::default(),
    NoopNetwork::default(),
    EthEvmConfig::mainnet(),
)
.build();

Trait Implementations

impl<N, Rpc> Call for EthApi<N, Rpc>

where EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError, Evm = <N as RpcNodeCore>::Evm>, N: RpcNodeCore,

fn call_gas_limit(&self) -> u64

Returns default gas limit to use for eth_call and tracing RPC methods.

fn max_simulate_blocks(&self) -> u64

Returns the maximum number of blocks accepted for eth_simulateV1.

fn compute_state_root_for_eth_simulate(&self) -> bool

Returns whether eth_simulateV1 should compute state roots.

fn evm_memory_limit(&self) -> u64

Returns the maximum memory the EVM can allocate per RPC request.

fn simulate_call_nonce( &self, _request: &<<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, _db: &mut dyn DynDatabase, ) -> Result<Option<u64>, EthApiError>

Returns the nonce for an eth_simulateV1 call that has none.

fn caller_gas_allowance( &self, db: impl Database>, _evm_env: &<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, tx_env: &Recovered<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes as EvmTypesHost>::Tx>, ) -> Result<u64, Self::Error>

where <impl Database as Database>::Error: Into<EthApiError>,

Returns the max gas limit that the caller can afford given a transaction environment.

fn transact<DB>( &self, db: DB, evm_env: <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, tx_env: Recovered<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes as EvmTypesHost>::Tx>, ) -> Result<TxResultWithState<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>, Self::Error>

where DB: Database + Debug,

Executes the TxEnv against the given Database without committing state changes.

fn transact_with_inspector<DB, I>( &self, db: DB, evm_env: <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, tx_env: Recovered<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes as EvmTypesHost>::Tx>, inspector: I, ) -> Result<(I, TxResultWithState<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>), Self::Error>

where DB: Database + Debug, I: Inspector<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes> + 'static,

Executes the reth_evm::EvmEnv against the given Database without committing state changes.

fn transact_call_at( &self, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, at: BlockId, overrides: EvmOverrides, ) -> impl Future<Output = Result<TxResultWithState<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>, Self::Error>> + Send

where Self: LoadPendingBlock,

Executes the call request at the given BlockId.

fn spawn_with_state_at_block<F, R>( &self, at: impl Into<BlockId>, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

where F: FnOnce(Self, CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Executes the closure with the state that corresponds to the given BlockId on a new task

fn spawn_with_call_at<F, R>( &self, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, at: BlockId, overrides: EvmOverrides, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

where Self: LoadPendingBlock, F: FnOnce(&mut CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>, <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, Recovered<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes as EvmTypesHost>::Tx>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Prepares the state and env for the given RpcTxReq at the given BlockId and executes the closure on a new task returning the result of the closure.

fn spawn_replay_transaction<F, R>( &self, hash: FixedBytes<32>, f: F, ) -> impl Future<Output = Result<Option<R>, Self::Error>> + Send

where Self: LoadBlock + LoadTransaction, F: FnOnce(TransactionInfo, TxResultWithState<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>, CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Retrieves the transaction if it exists and executes it.

fn replay_transactions_until_with_executor<'a, Txs>( &self, executor: &mut <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::Executor<'_>, transactions: Txs, target_tx_index: usize, ) -> Result<(), Self::Error>

where Txs: IntoIterator<Item = Recovered<&'a <Self::Provider as TransactionsProvider>::Transaction>>,

Replays all transactions before the target transaction index through the given executor.

fn block_executor<'a>( &'a self, block: &'a RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>, db: &'a mut CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>, evm_env: <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, ) -> Result<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::Executor<'a>, Self::Error>

Creates a block executor for block on db with the given EVM environment.

fn create_txn_env( &self, evm_env: &<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, db: impl Database>, ) -> Result<Recovered<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes as EvmTypesHost>::Tx>, Self::Error>

where <impl Database as Database>::Error: Into<EthApiError>,

All TxEnv fields are derived from the given RpcTxReq, if fields are None, they fall back to the reth_evm::EvmEnv’s settings.

fn prepare_call_env<DB>( &self, evm_env: <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, db: &mut CacheDB<DB>, overrides: EvmOverrides, ) -> Result<(<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, Recovered<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes as EvmTypesHost>::Tx>), Self::Error>

where DB: DynDatabase,

Prepares the reth_evm::EvmEnv for execution of calls.

impl<N, Rpc> Clone for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert,

fn clone(&self) -> EthApi<N, Rpc>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<N, Rpc> Debug for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert,

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

Formats the value using the given formatter.

impl<N, Rpc> Deref for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert,

type Target = Arc<EthApiInner<N, Rpc>>

The resulting type after dereferencing.

fn deref(&self) -> &<EthApi<N, Rpc> as Deref>::Target

Dereferences the value.

impl<N, Rpc> EstimateCall for EthApi<N, Rpc>

where EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError, Evm = <N as RpcNodeCore>::Evm>, N: RpcNodeCore,

fn estimate_gas_with<S>( &self, evm_env: <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, state: S, overrides: EvmOverrides, ) -> Result<Uint<256, 4>, Self::Error>

where S: EvmStateProvider,

Estimates the gas usage of the request with the state.

fn estimate_gas_at( &self, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, at: BlockId, overrides: EvmOverrides, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

where Self: LoadPendingBlock,

Estimate gas needed for execution of the request at the BlockId.

impl<N, Rpc> EthApiSpec for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn starting_block(&self) -> Uint<256, 4>

Returns the block node is started on.

fn protocol_version( &self, ) -> impl Future<Output = Result<Uint<64, 1>, RethError>> + Send

Returns the current ethereum protocol version.

fn chain_id(&self) -> Uint<64, 1>

Returns the chain id

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

Returns provider chain info

fn capabilities(&self) -> Result<EthCapabilities, RethError>

where Self: EthState,

Returns effective routing capabilities for this node.

fn is_syncing(&self) -> bool

Returns true if the network is undergoing sync.

fn sync_status(&self) -> Result<SyncStatus, RethError>

Returns the SyncStatus of the network

impl<N, Rpc> EthApiTypes for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert<Error = EthApiError>,

type Error = EthApiError

Extension of FromEthApiError, with network specific errors.

type NetworkTypes = <Rpc as RpcConvert>::Network

Blockchain primitive types, specific to network, e.g. block and transaction.

type RpcConvert = Rpc

Conversion methods for transaction RPC type.

fn eth_api_settings(&self) -> &EthApiSettings

Returns the settings shared by the eth RPC helpers.

fn converter(&self) -> &<EthApi<N, Rpc> as EthApiTypes>::RpcConvert

Returns reference to transaction response builder.

impl<N, Rpc> EthBlocks for EthApi<N, Rpc>

where N: RpcNodeCore, EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn rpc_block_header( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::Header>, Self::Error>> + Send

where Self: FullEthApiTypes,

Returns the block header for the given block id.

fn rpc_block( &self, block_id: BlockId, full: bool, ) -> impl Future<Output = Result<Option<Block<<Self::NetworkTypes as RpcTypes>::TransactionResponse, <Self::NetworkTypes as RpcTypes>::Header>>, Self::Error>> + Send

where Self: FullEthApiTypes,

Returns the populated rpc block object for the given block id.

fn block_transaction_count( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<usize>, Self::Error>> + Send

Returns the number transactions in the given block.

fn block_receipts( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<Vec<<Self::NetworkTypes as RpcTypes>::Receipt>>, Self::Error>> + Send

where Self: LoadReceipt,

Helper function for eth_getBlockReceipts.

fn load_block_and_receipts( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<(Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>, SharedReceipts<<Self::Provider as ReceiptProvider>::Receipt>)>, Self::Error>> + Send

where Self: LoadReceipt, Self::Pool: TransactionPool, <Self::Pool as TransactionPool>::Transaction: PoolTransaction<Consensus = <Self::Provider as TransactionsProvider>::Transaction>,

Helper method that loads a block and all its receipts.

fn ommers( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<Vec<<Self::Provider as HeaderProvider>::Header>>, Self::Error>> + Send

Returns uncle headers of given block.

fn ommer_by_block_and_index( &self, block_id: BlockId, index: Index, ) -> impl Future<Output = Result<Option<Block<<Self::NetworkTypes as RpcTypes>::TransactionResponse, <Self::NetworkTypes as RpcTypes>::Header>>, Self::Error>> + Send

Returns uncle block at given index in given block.

impl<N, Rpc> EthCall for EthApi<N, Rpc>

where EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError, Evm = <N as RpcNodeCore>::Evm>, N: RpcNodeCore,

fn estimate_gas_at( &self, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, at: BlockId, overrides: EvmOverrides, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

Estimate gas needed for execution of the request at the BlockId.

fn simulate_v1( &self, payload: SimulatePayload<<<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest>, block: Option<BlockId>, ) -> impl Future<Output = Result<Vec<SimulatedBlock<Block<<Self::NetworkTypes as RpcTypes>::TransactionResponse, <Self::NetworkTypes as RpcTypes>::Header>>>, Self::Error>> + Send

eth_simulateV1 executes an arbitrary number of transactions on top of the requested state. The transactions are packed into individual blocks. Overrides can be provided.

fn call( &self, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, block_number: Option<BlockId>, overrides: EvmOverrides, ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send

Executes the call request (eth_call) and returns the output

fn call_many( &self, bundles: Vec<Bundle<<<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest>>, state_context: Option<StateContext>, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> impl Future<Output = Result<Vec<Vec<EthCallResponse>>, Self::Error>> + Send

where Self: Trace,

Simulate transactions at an arbitrary blockchain index, with the optionality of state overrides.

fn create_access_list_at( &self, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, block_number: Option<BlockId>, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> impl Future<Output = Result<AccessListResult, Self::Error>> + Send

where Self: Trace,

Creates AccessListResult for the RpcTxReq at the given BlockId, or latest block.

fn create_access_list_with( &self, evm_env: <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, at: BlockId, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> impl Future<Output = Result<AccessListResult, Self::Error>> + Send

where Self: Trace,

Creates AccessListResult for the RpcTxReq at the given BlockId.

impl<N, Rpc> EthFees for EthApi<N, Rpc>

where N: RpcNodeCore, EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn gas_price( &self, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

where Self: LoadBlock,

Returns a suggestion for a gas price for legacy transactions.

fn blob_base_fee( &self, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

where Self: LoadBlock,

Returns a suggestion for a base fee for blob transactions.

fn base_fee( &self, ) -> impl Future<Output = Result<Option<Uint<256, 4>>, Self::Error>> + Send

where Self: LoadBlock,

Returns the base fee for the next block, or None before London activation.

fn suggested_priority_fee( &self, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

where Self: 'static,

Returns a suggestion for the priority fee (the tip)

fn fee_history( &self, block_count: u64, newest_block: BlockNumberOrTag, reward_percentiles: Option<Vec<f64>>, ) -> impl Future<Output = Result<FeeHistory, Self::Error>> + Send

Reports the fee history, for the given amount of blocks, up until the given newest block.

fn approximate_percentile( &self, entry: &FeeHistoryEntry<<Self::Provider as HeaderProvider>::Header>, requested_percentile: f64, ) -> u128

Approximates reward at a given percentile for a specific block Based on the configured resolution

impl<N, Rpc> EthState for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>, EthApi<N, Rpc>: LoadPendingBlock,

fn max_proof_window(&self) -> u64

Returns the maximum number of blocks into the past for generating state proofs.

fn ensure_within_proof_window( &self, block_id: BlockId, ) -> Result<(), Self::Error>

where Self: EthApiSpec,

Validates that the given block is within the configured proof window.

fn transaction_count( &self, address: Address, block_id: Option<BlockId>, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

Returns the number of transactions sent from an address at the given block identifier.

fn get_code( &self, address: Address, block_id: Option<BlockId>, ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send

Returns code of given account, at given blocknumber.

fn balance( &self, address: Address, block_id: Option<BlockId>, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

Returns balance of given account, at given blocknumber.

fn storage_at( &self, address: Address, index: JsonStorageKey, block_id: Option<BlockId>, ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send

Returns values stored of given account, at given blocknumber.

fn storage_values( &self, requests: HashMap<Address, Vec<JsonStorageKey>>, block_id: Option<BlockId>, ) -> impl Future<Output = Result<HashMap<Address, Vec<FixedBytes<32>>>, Self::Error>> + Send

Returns values from multiple storage positions across multiple addresses.

fn get_proof( &self, address: Address, keys: Vec<JsonStorageKey>, block_id: Option<BlockId>, ) -> Result<impl Future<Output = Result<EIP1186AccountProofResponse, Self::Error>> + Send, Self::Error>

where Self: EthApiSpec,

Returns values stored of given account, with Merkle-proof, at given blocknumber.

fn get_multi_proof( &self, targets: Vec<(Address, Vec<FixedBytes<32>>)>, block_id: Option<BlockId>, ) -> Result<impl Future<Output = Result<Vec<EIP1186AccountProofResponse>, Self::Error>> + Send, Self::Error>

where Self: EthApiSpec,

Returns account and storage proofs for multiple targets at the given block number.

fn get_account( &self, address: Address, block_id: BlockId, ) -> impl Future<Output = Result<Option<TrieAccount>, Self::Error>> + Send

where Self: EthApiSpec,

Returns the account at the given address for the provided block identifier.

fn get_account_info( &self, address: Address, block_id: BlockId, ) -> impl Future<Output = Result<AccountInfo, Self::Error>> + Send

Retrieves the account’s balance, nonce, and code for a given address.

impl<N, Rpc> EthSubscriptions for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn log_stream( &self, filter: Filter, ) -> impl Stream<Item = <Self::NetworkTypes as RpcTypes>::Log> + Send + Unpin

Returns a stream that yields matching logs from canonical chain updates.

fn header_stream( &self, ) -> impl Stream<Item = <Self::NetworkTypes as RpcTypes>::Header> + Send + Unpin

Returns a stream that yields new block headers from canonical chain updates.

fn transaction_receipts_stream( &self, filter: TransactionReceiptsParams, ) -> impl Stream<Item = Vec<<Self::NetworkTypes as RpcTypes>::Receipt>> + Send + Unpin

Returns a stream that yields matching transaction receipts from canonical chain updates.

impl<N, Rpc> EthTransactions for EthApi<N, Rpc>

where N: RpcNodeCore, EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn signers( &self, ) -> &RwLock<RawRwLock, Vec<Box<dyn EthSigner<<<EthApi<N, Rpc> as RpcNodeCore>::Provider as TransactionsProvider>::Transaction, <<EthApi<N, Rpc> as EthApiTypes>::NetworkTypes as RpcTypes>::TransactionRequest>>>>

Returns a handle for signing data.

async fn send_pool_transaction( &self, origin: TransactionOrigin, tx: WithEncoded<<<EthApi<N, Rpc> as RpcNodeCore>::Pool as TransactionPool>::Transaction>, ) -> Result<FixedBytes<32>, <EthApi<N, Rpc> as EthApiTypes>::Error>

Submits the pool transaction to the pool with the given TransactionOrigin.

fn accounts(&self) -> Vec<Address>

Returns a list of addresses owned by provider.

fn send_raw_transaction_sync_timeout(&self) -> Duration

Returns the timeout duration for send_raw_transaction_sync RPC method.

fn send_raw_transaction( &self, tx: Bytes, ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send

Decodes and recovers the transaction and submits it to the pool.

fn recover_raw_pool_transaction( &self, tx: &[u8], ) -> Result<<Self::Pool as TransactionPool>::Transaction, Self::Error>

Decodes and recovers a raw pool transaction, sharing sender recovery when configured.

fn send_transaction( &self, origin: TransactionOrigin, tx: WithEncoded<Recovered<<<Self::Pool as TransactionPool>::Transaction as PoolTransaction>::Pooled>>, ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send

Submits the transaction to the pool with the given TransactionOrigin.

fn send_raw_transaction_sync( &self, tx: Bytes, timeout_ms: Option<u64>, ) -> impl Future<Output = Result<<Self::NetworkTypes as RpcTypes>::Receipt, Self::Error>> + Send

where Self: LoadReceipt,

Decodes and recovers the transaction and submits it to the pool.

fn transaction_by_hash( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>>, Self::Error>> + Send

Returns the transaction by hash.

fn pending_transactions( &self, ) -> Result<Vec<<Self::NetworkTypes as RpcTypes>::TransactionResponse>, Self::Error>

Returns all transactions from the local pending pool.

fn transactions_by_block( &self, block: FixedBytes<32>, ) -> impl Future<Output = Result<Option<Vec<<Self::Provider as TransactionsProvider>::Transaction>>, Self::Error>> + Send

Get all transactions in the block with the given hash.

fn raw_transaction_by_hash( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + Send

Returns the EIP-2718 encoded transaction by hash.

fn historical_transaction_by_hash_at( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<(TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>, FixedBytes<32>)>, Self::Error>> + Send

Returns the historical transaction and the block it was mined in

fn transaction_receipt( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::Receipt>, Self::Error>> + Send

where Self: LoadReceipt,

Returns the transaction receipt for the given hash.

fn load_transaction_and_receipt( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<(Recovered<<Self::Provider as TransactionsProvider>::Transaction>, TransactionMeta, <Self::Provider as ReceiptProvider>::Receipt, Option<Arc<Vec<<Self::Provider as ReceiptProvider>::Receipt>>>, Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>)>, Self::Error>> + Send

where Self: 'static,

Helper method that loads a transaction and its receipt.

fn transaction_by_block_and_tx_index( &self, block_id: BlockId, index: usize, ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::TransactionResponse>, Self::Error>> + Send

where Self: LoadBlock,

Get transaction by BlockId and index of transaction within that block.

fn get_transaction_by_sender_and_nonce( &self, sender: Address, nonce: u64, include_pending: bool, ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::TransactionResponse>, Self::Error>> + Send

where Self: LoadBlock + LoadState,

Find a transaction by sender’s address and nonce.

fn raw_transaction_by_block_and_tx_index( &self, block_id: BlockId, index: usize, ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + Send

where Self: LoadBlock,

Get transaction, as raw bytes, by BlockId and index of transaction within that block.

fn send_transaction_request( &self, request: <Self::NetworkTypes as RpcTypes>::TransactionRequest, ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send

where Self: EthApiSpec + EstimateCall + LoadFee,

Signs transaction with a matching signer, if any and submits the transaction to the pool. Returns the hash of the signed transaction.

fn fill_transaction( &self, request: <Self::NetworkTypes as RpcTypes>::TransactionRequest, ) -> impl Future<Output = Result<FillTransaction<<Self::Primitives as NodePrimitives>::SignedTx>, Self::Error>> + Send

where Self: EthApiSpec + EstimateCall + LoadFee,

Fills the defaults on a given unsigned transaction.

fn sign_request( &self, from: &Address, txn: <Self::NetworkTypes as RpcTypes>::TransactionRequest, ) -> impl Future<Output = Result<<Self::Provider as TransactionsProvider>::Transaction, Self::Error>> + Send

Signs a transaction, with configured signers.

fn sign( &self, account: Address, message: Bytes, ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send

Signs given message. Returns the signature.

fn sign_transaction( &self, request: <Self::NetworkTypes as RpcTypes>::TransactionRequest, ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send

Signs a transaction request using the given account in request Returns the EIP-2718 encoded signed transaction.

fn sign_typed_data( &self, data: &TypedData, account: Address, ) -> Result<Bytes, Self::Error>

Encodes and signs the typed data according EIP-712. Payload must implement Eip712 trait.

fn find_signer( &self, account: &Address, ) -> Result<Box<dyn EthSigner<<Self::Provider as TransactionsProvider>::Transaction, <Self::NetworkTypes as RpcTypes>::TransactionRequest>>, Self::Error>

Returns the signer for the given account, if found in configured signers.

impl<N, Rpc> GetBlockAccessList for EthApi<N, Rpc>

where EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError, Evm = <N as RpcNodeCore>::Evm>, N: RpcNodeCore, EthApi<N, Rpc>: Trace,

fn get_block_access_list( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<Vec<AccountChanges>>, Self::Error>> + Send

Retrieves the block access list for a block identified by its hash.

fn get_raw_block_access_list( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + Send

Retrieves the raw RLP-encoded block access list for a block.

impl<N, Rpc> LoadBlock for EthApi<N, Rpc>

where EthApi<N, Rpc>: LoadPendingBlock, N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn recovered_block( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, Self::Error>> + Send

Returns the block object for the given block id.

fn recovered_block_and_maybe_bal( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<(Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>, Option<Arc<DecodedBal<Arc<Bal>>>>)>, Self::Error>> + Send

Returns the block for the given block id, together with the block’s cached block access list, if any.

impl<N, Rpc> LoadFee for EthApi<N, Rpc>

where N: RpcNodeCore, EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn gas_oracle( &self, ) -> &GasPriceOracle<<EthApi<N, Rpc> as RpcNodeCore>::Provider>

Returns a handle for reading gas price.

fn fee_history_cache( &self, ) -> &FeeHistoryCache<<<N as RpcNodeCore>::Provider as HeaderProvider>::Header>

Returns a handle for reading fee history data from memory.

fn legacy_gas_price( &self, gas_price: Option<Uint<256, 4>>, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

Returns the gas price if it is set, otherwise fetches a suggested gas price for legacy transactions.

fn eip1559_fees( &self, base_fee: Option<Uint<256, 4>>, max_priority_fee_per_gas: Option<Uint<256, 4>>, ) -> impl Future<Output = Result<(Uint<256, 4>, Uint<256, 4>), Self::Error>> + Send

Returns the EIP-1559 fees if they are set, otherwise fetches a suggested gas price for EIP-1559 transactions.

fn eip4844_blob_fee( &self, blob_fee: Option<Uint<256, 4>>, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

Returns the EIP-4844 blob fee if it is set, otherwise fetches a blob fee.

fn gas_price( &self, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

Returns a suggestion for a gas price for legacy transactions.

fn blob_base_fee( &self, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

Returns a suggestion for a base fee for blob transactions.

fn base_fee( &self, ) -> impl Future<Output = Result<Option<Uint<256, 4>>, Self::Error>> + Send

Returns the base fee for the next block, or None before London activation.

fn suggested_priority_fee( &self, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

where Self: 'static,

Returns a suggestion for the priority fee (the tip)

impl<N, Rpc> LoadPendingBlock for EthApi<N, Rpc>

where N: RpcNodeCore, EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn pending_block( &self, ) -> &Mutex<Option<PendingBlock<<EthApi<N, Rpc> as RpcNodeCore>::Primitives>>>

Returns a handle to the pending block.

fn pending_env_builder( &self, ) -> &(dyn PendingEnvBuilder<<EthApi<N, Rpc> as RpcNodeCore>::Evm> + 'static)

Returns a PendingEnvBuilder for the pending block.

fn pending_block_kind(&self) -> PendingBlockKind

Returns the pending block kind.

fn pending_block_env_and_cfg( &self, ) -> Result<PendingBlockEnv<Self::Evm>, Self::Error>

Returns the pending block environment and its origin.

fn next_env_attributes( &self, parent: &SealedHeader<<Self::Provider as HeaderProvider>::Header>, ) -> Result<<Self::Evm as ConfigureEvm>::NextBlockEnvCtx, Self::Error>

Returns ConfigureEvm::NextBlockEnvCtx for building a local pending block.

fn local_pending_state( &self, ) -> impl Future<Output = Result<Option<Box<dyn StateProvider + Send>>, Self::Error>> + Send

where Self: SpawnBlocking,

Returns a StateProviderBox on a mem-pool built pending block overlaying latest.

fn local_pending_block_or_state( &self, ) -> impl Future<Output = Result<Option<PendingStateSource<Self::Primitives>>, Self::Error>> + Send

where Self: SpawnBlocking,

Selects the local pending source for state RPCs.

fn pool_pending_block( &self, ) -> impl Future<Output = Result<Option<PendingBlock<Self::Primitives>>, Self::Error>> + Send

where Self: SpawnBlocking,

Returns a cached or newly built pending block from the transaction pool.

fn build_pool_pending_block( &self, parent: SealedHeader<<Self::Provider as HeaderProvider>::Header>, evm_env: <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, ) -> impl Future<Output = Result<Option<PendingBlock<Self::Primitives>>, Self::Error>> + Send

where Self: SpawnBlocking,

Returns a cached or newly built pending block for the given parent and environment.

fn local_pending_block( &self, ) -> impl Future<Output = Result<Option<BlockAndReceipts<Self::Primitives>>, Self::Error>> + Send

where Self: SpawnBlocking, Self::Pool: TransactionPool, <Self::Pool as TransactionPool>::Transaction: PoolTransaction<Consensus = <Self::Provider as TransactionsProvider>::Transaction>,

When enabled, returns the provider’s pending block or builds one from the pool.

fn build_block( &self, parent: &SealedHeader<<Self::Provider as HeaderProvider>::Header>, ) -> Result<ExecutedBlock<Self::Primitives>, Self::Error>

where Self::Pool: TransactionPool, <Self::Pool as TransactionPool>::Transaction: PoolTransaction<Consensus = <Self::Provider as TransactionsProvider>::Transaction>, EthApiError: From<ProviderError>,

Builds a locally derived pending block using the configured provider and pool.

impl<N, Rpc> LoadReceipt for EthApi<N, Rpc>

where N: RpcNodeCore, EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn build_transaction_receipt( &self, tx: Recovered<<Self::Provider as TransactionsProvider>::Transaction>, meta: TransactionMeta, receipt: <Self::Provider as ReceiptProvider>::Receipt, all_receipts: Option<Arc<Vec<<Self::Provider as ReceiptProvider>::Receipt>>>, block: Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, ) -> impl Future<Output = Result<<Self::NetworkTypes as RpcTypes>::Receipt, Self::Error>> + Send

Helper method for eth_getBlockReceipts and eth_getTransactionReceipt.

impl<N, Rpc> LoadState for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>, EthApi<N, Rpc>: LoadPendingBlock,

fn transaction_count( &self, address: Address, block_id: Option<BlockId>, ) -> impl Future<Output = Result<Uint<256, 4>, <EthApi<N, Rpc> as EthApiTypes>::Error>> + Send

where EthApi<N, Rpc>: SpawnBlocking,

Reads the nonce from the provider’s state instead of a locally built pending block.

A local pending block only applies pool transactions on top of the latest state, and the pool lookup for the pending tag already accounts for the sender’s transactions, so building the block and its state overlay only to read one nonce is redundant.

fn state_at_hash( &self, block_hash: FixedBytes<32>, ) -> Result<Box<dyn StateProvider + Send>, Self::Error>

Returns the state at the given block number

fn state_at_block_id( &self, at: BlockId, ) -> impl Future<Output = Result<Box<dyn StateProvider + Send>, Self::Error>> + Send

where Self: SpawnBlocking,

Returns the state at the given BlockId, preferring locally built state for pending.

fn latest_state(&self) -> Result<Box<dyn StateProvider + Send>, Self::Error>

Returns the latest state

fn state_at_block_id_or_latest( &self, block_id: Option<BlockId>, ) -> impl Future<Output = Result<Box<dyn StateProvider + Send>, Self::Error>> + Send

where Self: SpawnBlocking,

Returns the state at the given BlockId enum or the latest.

fn spawn_blocking_io_with_state<F, R>( &self, at: BlockId, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

where Self: SpawnBlocking, F: FnOnce(Self, Box<dyn StateProvider + Send>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Executes f with the state at the given BlockId on a blocking IO task.

fn evm_env_for_header( &self, header: &SealedHeader<<Self::Primitives as NodePrimitives>::BlockHeader>, ) -> Result<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, Self::Error>

Returns the EVM environment for the given sealed header.

fn evm_env_at( &self, at: BlockId, ) -> impl Future<Output = Result<(<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, BlockId), Self::Error>> + Send

where Self: SpawnBlocking,

Returns the EVM environment for the requested BlockId

fn evm_env_and_recovered_block_at( &self, at: BlockId, ) -> impl Future<Output = Result<(Arc<RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>>, <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, BlockId), Self::Error>> + Send

where Self: LoadBlock,

Returns the recovered block, EVM environment, and state block id for the requested BlockId.

fn next_available_nonce_for( &self, request: &<Self::NetworkTypes as RpcTypes>::TransactionRequest, ) -> impl Future<Output = Result<u64, Self::Error>> + Send

where Self: SpawnBlocking,

Returns the next available nonce without gaps for the given address Next available nonce is either the on chain nonce of the account or the highest consecutive nonce in the pool + 1

fn transaction_count_with_state( &self, address: Address, at: BlockId, state: &Box<dyn StateProvider + Send>, ) -> Result<Uint<256, 4>, Self::Error>

Returns the number of transactions sent from an address, given the state at at.

fn get_code( &self, address: Address, block_id: Option<BlockId>, ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send

where Self: SpawnBlocking,

Returns code of given account, at the given identifier.

impl<N, Rpc> LoadTransaction for EthApi<N, Rpc>

where N: RpcNodeCore, EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,

fn recover_raw_transaction<T>( &self, tx: &[u8], ) -> Result<Recovered<T>, EthApiError>

where T: SignedTransaction,

Decodes and recovers a raw transaction, sharing sender recovery when configured.

fn recover_raw_transactions<T>( &self, txs: impl IntoIterator<Item = impl AsRef<[u8]>>, ) -> Result<Vec<Recovered<T>>, EthApiError>

where T: SignedTransaction,

Decodes and recovers raw transactions in order, stopping at the first error.

fn recover_mined_transaction<T>( &self, tx: T, ) -> Result<Recovered<T>, EthApiError>

where T: SignedTransaction,

Recovers the sender of a mined transaction, reusing a cached sender when configured.

fn transaction_by_hash( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>>, Self::Error>> + Send

Returns the transaction by hash.

fn transaction_by_hash_at( &self, transaction_hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<(TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>, BlockId)>, Self::Error>> + Send

Returns the transaction by including its corresponding BlockId.

fn transaction_and_block( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<(TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>, Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>)>, Self::Error>> + Send

Fetches the transaction and the transaction’s block

fn transaction_and_block_and_maybe_bal( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<(TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>, Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>, Option<Arc<DecodedBal<Arc<Bal>>>>)>, Self::Error>> + Send

Fetches the transaction and the transaction’s block, together with the block’s cached block access list, if any.

impl<N, Rpc> RpcNodeCore for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert,

type Primitives = <N as RpcNodeCore>::Primitives

Blockchain data primitives.

type Provider = <N as RpcNodeCore>::Provider

The provider type used to interact with the node.

type Pool = <N as RpcNodeCore>::Pool

The transaction pool of the node.

type Evm = <N as RpcNodeCore>::Evm

The node’s EVM configuration, defining settings for the Ethereum Virtual Machine.

type Network = <N as RpcNodeCore>::Network

Network API.

fn pool(&self) -> &<EthApi<N, Rpc> as RpcNodeCore>::Pool

Returns the transaction pool of the node.

fn evm_config(&self) -> &<EthApi<N, Rpc> as RpcNodeCore>::Evm

Returns the node’s evm config.

fn network(&self) -> &<EthApi<N, Rpc> as RpcNodeCore>::Network

Returns the handle to the network

fn provider(&self) -> &<EthApi<N, Rpc> as RpcNodeCore>::Provider

Returns the provider of the node.

impl<N, Rpc> RpcNodeCoreExt for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert,

fn cache(&self) -> &EthStateCache<<N as RpcNodeCore>::Primitives>

Returns handle to RPC cache service.

impl<N, Rpc> SpawnBlocking for EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert<Error = EthApiError>,

fn io_task_spawner(&self) -> &Runtime

Returns a handle for spawning IO heavy blocking tasks.

fn tracing_task_pool(&self) -> &BlockingTaskPool

Returns a handle for spawning CPU heavy blocking tasks, such as tracing requests.

fn tracing_task_guard(&self) -> &BlockingTaskGuard

Returns handle to semaphore for pool of CPU heavy blocking tasks.

fn blocking_io_task_guard(&self) -> &Arc<Semaphore>

Returns handle to semaphore for blocking IO tasks.

fn acquire_owned_tracing( &self, ) -> impl Future<Output = Result<OwnedSemaphorePermit, AcquireError>> + Send

Acquires a permit from the tracing task semaphore.

fn acquire_many_owned_tracing( &self, n: u32, ) -> impl Future<Output = Result<OwnedSemaphorePermit, AcquireError>> + Send

Acquires multiple permits from the tracing task semaphore.

fn acquire_owned_blocking_io( &self, ) -> impl Future<Output = Result<OwnedSemaphorePermit, AcquireError>> + Send

Acquires a permit from the blocking IO request semaphore.

fn acquire_many_owned_blocking_io( &self, n: u32, ) -> impl Future<Output = Result<OwnedSemaphorePermit, AcquireError>> + Send

Acquires multiple permits from the blocking IO request semaphore.

fn acquire_weighted_blocking_io( &self, weight: u32, ) -> impl Future<Output = Result<OwnedSemaphorePermit, AcquireError>> + Send

Acquires permits from the blocking IO request semaphore based on a calculated weight.

fn spawn_blocking_io<F, R>( &self, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

where F: FnOnce(Self) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Executes the future on a new blocking task.

fn spawn_blocking_io_fut<F, R, Fut>( &self, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

where Fut: Future<Output = Result<R, Self::Error>> + Send + 'static, F: FnOnce(Self) -> Fut + Send + 'static, R: Send + 'static,

Executes the future on a new blocking task.

fn spawn_tracing<F, R>( &self, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

where F: FnOnce(Self) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Executes a blocking task on the tracing pool.

impl<N, Rpc> Trace for EthApi<N, Rpc>

where EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError, Evm = <N as RpcNodeCore>::Evm>, N: RpcNodeCore, EthApi<N, Rpc>: Call,

fn inspect<DB, I>( &self, db: DB, evm_env: <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, tx_env: &Recovered<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes as EvmTypesHost>::Tx>, inspector: I, ) -> Result<(I, TxResultWithState<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>), Self::Error>

where DB: Database, I: Inspector<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes> + 'static,

Executes a transaction with the provided inspector without committing state changes.

fn spawn_trace_at_with_state<F, R>( &self, evm_env: <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv, tx_env: Recovered<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes as EvmTypesHost>::Tx>, config: TracingInspectorConfig, at: BlockId, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

where F: FnOnce(TracingInspector, TxResultWithState<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>, CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Executes the transaction on top of the given BlockId with a tracer configured by the config and provides the used database to the callback.

fn spawn_trace_transaction_in_block<F, R>( &self, hash: FixedBytes<32>, config: TracingInspectorConfig, f: F, ) -> impl Future<Output = Result<Option<R>, Self::Error>> + Send

where Self: LoadTransaction, F: FnOnce(TransactionInfo, TracingInspector, TxResultWithState<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>, CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Retrieves the transaction if it exists and returns its trace.

fn spawn_trace_transaction_in_block_with_inspector<Insp, F, R>( &self, hash: FixedBytes<32>, inspector: Insp, f: F, ) -> impl Future<Output = Result<Option<R>, Self::Error>> + Send

where Self: LoadTransaction, F: FnOnce(TransactionInfo, Insp, TxResultWithState<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>, CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>) -> Result<R, Self::Error> + Send + 'static, Insp: Inspector<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes> + Send + 'static, R: Send + 'static,

Retrieves the transaction if it exists and returns its trace.

fn replay_block_until( &self, db: &mut CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>, block: &RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>, target_tx_index: usize, bal: Option<&DecodedBal<Arc<Bal>>>, ) -> Result<(), Self::Error>

Positions the state of db right before the transaction at the target index.

fn inspect_transaction_in_block<I>( &self, block: &RecoveredBlock<<Self::Primitives as NodePrimitives>::Block>, db: &mut CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>, inspector: I, target_tx_index: usize, bal: Option<&DecodedBal<Arc<Bal>>>, ) -> Result<(I, TxResultWithState<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>, <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmEnv), Self::Error>

where I: Inspector<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes> + 'static,

Executes the block’s transaction at the target index with the configured inspector on the state right before the transaction.

fn trace_block_until<F, R>( &self, block_id: BlockId, block: Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, highest_index: Option<u64>, config: TracingInspectorConfig, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send

where Self: LoadBlock, F: Fn(TransactionInfo, TracingCtx<'_, TracingInspector, <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Executes all transactions of a block up to a given index.

fn trace_block_until_with_inspector<Setup, Insp, F, R>( &self, block_id: BlockId, block: Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, highest_index: Option<u64>, inspector_setup: Setup, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send

where Self: LoadBlock, F: Fn(TransactionInfo, TracingCtx<'_, Insp, <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: Inspector<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes> + 'static, R: Send + 'static,

Executes all transactions of a block.

fn trace_block_with<F, R>( &self, block_id: BlockId, block: Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, config: TracingInspectorConfig, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send

where Self: LoadBlock, F: Fn(TransactionInfo, TracingCtx<'_, TracingInspector, <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Executes all transactions of a block and returns a list of callback results invoked for each transaction in the block.

fn trace_block_inspector<Setup, Insp, F, R>( &self, block_id: BlockId, block: Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, insp_setup: Setup, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send

where Self: LoadBlock, F: Fn(TransactionInfo, TracingCtx<'_, Insp, <<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: Inspector<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmTypes> + 'static, R: Send + 'static,

Executes all transactions of a block and returns a list of callback results invoked for each transaction in the block.

fn apply_pre_execution_changes( &self, block: &RecoveredBlock<<Self::Provider as BlockReader>::Block>, db: &mut CacheDB<Db<StateProviderDatabase<EvmStateProviderAdapter<Box<dyn StateProvider + Send>>>>>, ) -> Result<BundleState, Self::Error>

Applies chain-specific state transitions required before executing a block.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes