Struct EthApi 

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

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>, EthRpcConverter<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<Provider: ChainSpecProvider<ChainSpec = ChainSpec>, Evm = EvmConfig>,

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();

impl<N, Rpc> EthApi<N, Rpc>

where N: RpcNodeCore, Rpc: RpcConvert, (): PendingEnvBuilder<N::Evm>,

pub fn new( components: N, eth_cache: EthStateCache<N::Primitives>, gas_oracle: GasPriceOracle<N::Provider>, gas_cap: impl Into<GasCap>, max_simulate_blocks: u64, eth_proof_window: u64, blocking_task_pool: BlockingTaskPool, fee_history_cache: FeeHistoryCache<ProviderHeader<N::Provider>>, proof_permits: usize, rpc_converter: Rpc, max_batch_size: usize, pending_block_kind: PendingBlockKind, raw_tx_forwarder: ForwardConfig, send_raw_transaction_sync_timeout: Duration, ) -> Self

Creates a new, shareable instance using the default tokio task spawner.

Trait Implementations

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

where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Network: RpcTypes<TransactionRequest: SignableTxRequest<ProviderTx<N::Provider>>>>,

fn with_dev_accounts(&self)

Generates 20 random developer accounts. Used in DEV mode.

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

where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, TxEnv = TxEnvFor<N::Evm>, Spec = SpecFor<N::Evm>>,

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 caller_gas_allowance( &self, db: impl Database>, _evm_env: &EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, tx_env: &<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::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 with_state_at_block<F, R>( &self, at: BlockId, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

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

Executes the closure with the state that corresponds to the given [BlockId].

fn transact<DB>( &self, db: DB, evm_env: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, tx_env: <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx, ) -> Result<ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, Self::Error>

where DB: Database<Error = ProviderError> + Debug,

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

fn transact_with_inspector<DB, I>( &self, db: DB, evm_env: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, tx_env: <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx, inspector: I, ) -> Result<ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, Self::Error>

where DB: Database<Error = ProviderError> + Debug, I: InspectorFor<Self::Evm, DB>,

Executes the [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<ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, Self::Error>> + Send

where Self: LoadPendingBlock,

Executes the call request at the given [BlockId].

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

where F: FnOnce(StateProviderTraitObjWrapper<'_>) -> 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(StateCacheDbRefMutWrapper<'_, '_>, EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::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, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Retrieves the transaction if it exists and executes it.

fn replay_transactions_until<'a, DB, I>( &self, db: &mut DB, evm_env: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, transactions: I, target_tx_hash: FixedBytes<32>, ) -> Result<usize, Self::Error>

where DB: Database<Error = ProviderError> + DatabaseCommit + Debug, I: IntoIterator<Item = Recovered<&'a <Self::Provider as TransactionsProvider>::Transaction>>,

Replays all the transactions until the target transaction is found.

fn create_txn_env( &self, evm_env: &EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, db: impl Database>, ) -> Result<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::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 [EvmEnv]’s settings.

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

where DB: Database + DatabaseCommit + OverrideBlockHashes, EthApiError: From<<DB as Database>::Error>,

Prepares the [EvmEnv] for execution of calls.

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

where N: RpcNodeCore, Rpc: RpcConvert,

fn clone(&self) -> Self

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

Formats the value using the given formatter.

impl<N: RpcNodeCore, Rpc: RpcConvert> Deref for EthApi<N, Rpc>

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

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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

where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, TxEnv = TxEnvFor<N::Evm>, Spec = SpecFor<N::Evm>>,

fn estimate_gas_with<S>( &self, evm_env: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, state: S, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> Result<Uint<256, 4>, Self::Error>

where S: StateProvider,

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, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

where Self: LoadPendingBlock,

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

fn map_out_of_gas_err<DB>( evm: &mut <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<DB, NoOpInspector>, tx_env: <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx, max_gas_limit: u64, ) -> Result<Uint<256, 4>, Self::Error>

where DB: Database<Error = ProviderError>, EthApiError: From<<DB as Database>::Error>,

Executes the requests again after an out of gas error to check if the error is gas related or not

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

where N: RpcNodeCore, Rpc: RpcConvert<Primitives = N::Primitives>,

type Transaction = <<N as RpcNodeCore>::Provider as TransactionsProvider>::Transaction

The transaction type signers are using.

type Rpc = <Rpc as RpcConvert>::Network

The RPC requests and responses.

fn starting_block(&self) -> U256

Returns the block node is started on.

fn signers(&self) -> &SignersForApi<Self>

Returns a handle to the signers owned by provider.

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 accounts(&self) -> Vec<Address>

Returns a list of addresses owned by provider.

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,

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 tx_resp_builder(&self) -> &Self::RpcConvert

Returns reference to transaction response builder.

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

where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::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>>, Arc<Vec<<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 N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, TxEnv = TxEnvFor<N::Evm>, Spec = SpecFor<N::Evm>>,

fn estimate_gas_at( &self, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, at: BlockId, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> 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

Simulate arbitrary number of 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: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, 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::Evm>, Rpc: RpcConvert<Primitives = N::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 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::Primitives>, Self: LoadPendingBlock,

fn max_proof_window(&self) -> u64

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

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 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_account( &self, address: Address, block_id: BlockId, ) -> impl Future<Output = Result<Option<TrieAccount>, Self::Error>> + Send

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> EthTransactions for EthApi<N, Rpc>

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

async fn send_raw_transaction(&self, tx: Bytes) -> Result<B256, Self::Error>

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

Returns the hash of the transaction.

fn signers(&self) -> &SignersForRpc<Self::Provider, Self::NetworkTypes>

Returns a handle for signing data.

fn send_raw_transaction_sync_timeout(&self) -> Duration

Returns the timeout duration for send_raw_transaction_sync RPC method.

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

where Self: LoadReceipt + 'static,

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 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 + 'static,

Returns the transaction receipt for the given hash.

fn load_transaction_and_receipt( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<(<Self::Provider as TransactionsProvider>::Transaction, TransactionMeta, <Self::Provider as ReceiptProvider>::Receipt)>, 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( &self, request: <Self::NetworkTypes as RpcTypes>::TransactionRequest, ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send

where Self: EthApiSpec + LoadBlock + EstimateCall,

Signs transaction with a matching signer, if any and submits the transaction to the pool. Returns the hash of the signed 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> LoadBlock for EthApi<N, Rpc>

where Self: LoadPendingBlock, N: RpcNodeCore, Rpc: RpcConvert<Primitives = N::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.

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

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

fn gas_oracle(&self) -> &GasPriceOracle<Self::Provider>

Returns a handle for reading gas price.

fn fee_history_cache(&self) -> &FeeHistoryCache<ProviderHeader<N::Provider>>

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 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::Evm>, Rpc: RpcConvert<Primitives = N::Primitives>,

fn pending_block(&self) -> &Mutex<Option<PendingBlock<Self::Primitives>>>

Returns a handle to the pending block.

fn pending_env_builder(&self) -> &dyn PendingEnvBuilder<Self::Evm>

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::Provider as BlockReader>::Block, <Self::Provider as ReceiptProvider>::Receipt, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, Self::Error>

Configures the [PendingBlockEnv] for the pending block

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>>, Self::Error>> + Send

where Self: SpawnBlocking,

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

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

where Self: SpawnBlocking,

Returns a mem-pool built pending block.

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>,

Returns the locally built pending block

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 pending block using the configured provider and pool.

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

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

fn build_transaction_receipt( &self, tx: <Self::Provider as TransactionsProvider>::Transaction, meta: TransactionMeta, receipt: <Self::Provider as ReceiptProvider>::Receipt, ) -> 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::Primitives>, Self: LoadPendingBlock,

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

where Self: SpawnBlocking,

Returns the state at the given [BlockId] enum.

fn latest_state(&self) -> Result<Box<dyn StateProvider>, 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>, Self::Error>> + Send

where Self: SpawnBlocking,

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

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

where Self: SpawnBlocking,

Returns the revm evm env for the requested [BlockId]

fn next_available_nonce( &self, address: Address, ) -> 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( &self, address: Address, block_id: Option<BlockId>, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send

where Self: SpawnBlocking,

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

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::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,

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

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) -> &Self::Pool

Returns the transaction pool of the node.

fn evm_config(&self) -> &Self::Evm

Returns the node’s evm config.

fn network(&self) -> &Self::Network

Returns the handle to the network

fn provider(&self) -> &Self::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::Primitives>

Returns handle to RPC cache service.

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

where N: RpcNodeCore, Rpc: RpcConvert,

fn io_task_spawner(&self) -> impl TaskSpawner

Returns a handle for spawning IO heavy blocking tasks.

fn tracing_task_pool(&self) -> &BlockingTaskPool

Returns a handle for spawning CPU heavy blocking tasks.

fn tracing_task_guard(&self) -> &BlockingTaskGuard

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

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

See also Semaphore::acquire_owned.

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

See also Semaphore::acquire_many_owned.

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 N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives>,

fn inspect<DB, I>( &self, db: DB, evm_env: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, tx_env: <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx, inspector: I, ) -> Result<ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, Self::Error>

where DB: Database<Error = ProviderError>, I: InspectorFor<Self::Evm, DB>,

Executes the [TxEnvFor] with [EvmEnvFor] against the given [Database] without committing state changes.

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

where Self: Call, R: Send + 'static, F: FnOnce(TracingInspector, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>) -> Result<R, Self::Error> + Send + 'static,

Executes the transaction on top of the given [BlockId] with a tracer configured by the config.

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

where Self: LoadPendingBlock + Call, F: FnOnce(TracingInspector, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Same as trace_at but also 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: LoadPendingBlock + LoadTransaction + Call, F: FnOnce(TransactionInfo, TracingInspector, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> 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: LoadPendingBlock + LoadTransaction + Call, F: FnOnce(TransactionInfo, Insp, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, Insp: for<'a, 'b> InspectorFor<Self::Evm, StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static, R: Send + 'static,

Retrieves the transaction if it exists and returns its trace.

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<'_, Recovered<&<Self::Provider as TransactionsProvider>::Transaction>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<StateCacheDbRefMutWrapper<'_, '_>, TracingInspector>>) -> 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<'_, Recovered<&<Self::Provider as TransactionsProvider>::Transaction>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<StateCacheDbRefMutWrapper<'_, '_>, Insp>>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: Clone + for<'a, 'b> InspectorFor<Self::Evm, StateCacheDbRefMutWrapper<'a, 'b>>, 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<'_, Recovered<&<Self::Provider as TransactionsProvider>::Transaction>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<StateCacheDbRefMutWrapper<'_, '_>, TracingInspector>>) -> 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<'_, Recovered<&<Self::Provider as TransactionsProvider>::Transaction>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<StateCacheDbRefMutWrapper<'_, '_>, Insp>>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: Clone + for<'a, 'b> InspectorFor<Self::Evm, StateCacheDbRefMutWrapper<'a, 'b>>, 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<DB>( &self, block: &RecoveredBlock<<Self::Provider as BlockReader>::Block>, db: &mut DB, evm_env: &EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec>, ) -> Result<(), Self::Error>

where DB: Send + Database + DatabaseCommit,

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