Struct EthApi

pub struct EthApi<Provider: BlockReader, Pool, Network, EvmConfig> {
    pub tx_resp_builder: EthTxBuilder,
    /* 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).

Fields

tx_resp_builder: EthTxBuilder

Transaction RPC response builder.

Implementations

impl<Provider, Pool, Network, EvmConfig> EthApi<Provider, Pool, Network, EvmConfig>

where Provider: BlockReaderIdExt,

pub fn new( provider: Provider, pool: Pool, network: Network, eth_cache: EthStateCache<Provider::Block, Provider::Receipt>, gas_oracle: GasPriceOracle<Provider>, gas_cap: impl Into<GasCap>, max_simulate_blocks: u64, eth_proof_window: u64, blocking_task_pool: BlockingTaskPool, fee_history_cache: FeeHistoryCache, evm_config: EvmConfig, proof_permits: usize, ) -> Self

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

impl<Provider, Pool, EvmConfig, Network> EthApi<Provider, Pool, Network, EvmConfig>

where Provider: ChainSpecProvider + BlockReaderIdExt + Clone + 'static, Pool: Clone, EvmConfig: Clone, Network: Clone,

pub fn with_spawner<Tasks, Events>( ctx: &EthApiBuilderCtx<Provider, Pool, EvmConfig, Network, Tasks, Events>, ) -> Self

where Tasks: TaskSpawner + Clone + 'static, Events: CanonStateSubscriptions<Primitives: NodePrimitives<Block = ProviderBlock<Provider>, Receipt = ProviderReceipt<Provider>>>,

Creates a new, shareable instance.

Trait Implementations

impl<Provider, Pool, Network, EvmConfig> AddDevSigners for EthApi<Provider, Pool, Network, EvmConfig>

where Provider: BlockReader,

fn with_dev_accounts(&self)

Generates 20 random developer accounts. Used in DEV mode.

impl<Provider, Pool, Network, EvmConfig> Call for EthApi<Provider, Pool, Network, EvmConfig>

where Self: LoadState<Evm: ConfigureEvm<Header = ProviderHeader<Self::Provider>>> + SpawnBlocking, EvmConfig: ConfigureEvm<Header = Header>, Provider: BlockReader,

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 with_state_at_block<F, R>(&self, at: BlockId, f: F) -> Result<R, Self::Error>

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

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

fn transact<DB>( &self, db: DB, env: EnvWithHandlerCfg, ) -> Result<(ResultAndState, EnvWithHandlerCfg), Self::Error>

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

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

fn transact_with_inspector<DB>( &self, db: DB, env: EnvWithHandlerCfg, inspector: impl GetInspector<DB>, ) -> Result<(ResultAndState, EnvWithHandlerCfg), Self::Error>

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

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

fn transact_call_at( &self, request: TransactionRequest, at: BlockId, overrides: EvmOverrides, ) -> impl Future<Output = Result<(ResultAndState, EnvWithHandlerCfg), 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: TransactionRequest, at: BlockId, overrides: EvmOverrides, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

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

Prepares the state and env for the given [TransactionRequest] 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, ResultAndState, 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, cfg: CfgEnvWithHandlerCfg, block_env: BlockEnv, transactions: I, target_tx_hash: FixedBytes<32>, ) -> Result<usize, Self::Error>

where DB: Database + DatabaseCommit, EthApiError: From<<DB as Database>::Error>, I: IntoIterator<Item = (&'a Address, &'a <Self::Evm as ConfigureEvmEnv>::Transaction)>, <Self::Evm as ConfigureEvmEnv>::Transaction: SignedTransaction,

Replays all the transactions until the target transaction is found.

fn create_txn_env( &self, block_env: &BlockEnv, request: TransactionRequest, ) -> Result<TxEnv, Self::Error>

Configures a new [TxEnv] for the [TransactionRequest]

fn build_call_evm_env( &self, cfg: CfgEnvWithHandlerCfg, block: BlockEnv, request: TransactionRequest, ) -> Result<EnvWithHandlerCfg, Self::Error>

Creates a new [EnvWithHandlerCfg] to be used for executing the [TransactionRequest] in eth_call.

fn prepare_call_env<DB>( &self, cfg: CfgEnvWithHandlerCfg, block: BlockEnv, request: TransactionRequest, db: &mut CacheDB<DB>, overrides: EvmOverrides, ) -> Result<EnvWithHandlerCfg, Self::Error>

where DB: DatabaseRef, EthApiError: From<<DB as DatabaseRef>::Error>,

Prepares the [EnvWithHandlerCfg] for execution of calls.

impl<Provider, Pool, Network, EvmConfig> Clone for EthApi<Provider, Pool, Network, EvmConfig>

where Provider: BlockReader,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Provider, Pool, Network, EvmConfig> Debug for EthApi<Provider, Pool, Network, EvmConfig>

where Provider: BlockReader,

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

Formats the value using the given formatter.

impl<Provider: BlockReader, Pool, Network, EvmConfig> Deref for EthApi<Provider, Pool, Network, EvmConfig>

type Target = Arc<EthApiInner<Provider, Pool, Network, EvmConfig>>

The resulting type after dereferencing.

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

Dereferences the value.

impl<Provider, Pool, Network, EvmConfig> EstimateCall for EthApi<Provider, Pool, Network, EvmConfig>

where Self: Call, Provider: BlockReader,

fn estimate_gas_with<S>( &self, cfg: CfgEnvWithHandlerCfg, block: BlockEnv, request: 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: 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>( &self, env_gas_limit: Uint<256, 4>, env: EnvWithHandlerCfg, db: &mut DB, ) -> Self::Error

where DB: Database, 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<Provider, Pool, Network, EvmConfig> EthApiSpec for EthApi<Provider, Pool, Network, EvmConfig>

where Self: RpcNodeCore<Provider: ChainSpecProvider<ChainSpec: EthereumHardforks> + BlockNumReader + StageCheckpointReader, Network: NetworkInfo>, Provider: BlockReader,

type Transaction = <Provider as TransactionsProvider>::Transaction

The transaction type signers are using.

fn starting_block(&self) -> U256

Returns the block node is started on.

fn signers(&self) -> &RwLock<Vec<Box<dyn EthSigner<Self::Transaction>>>>

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<Provider, Pool, Network, EvmConfig> EthApiTypes for EthApi<Provider, Pool, Network, EvmConfig>

where Self: Send + Sync, Provider: BlockReader,

type Error = EthApiError

Extension of FromEthApiError, with network specific errors.

type NetworkTypes = Ethereum

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

type TransactionCompat = EthTxBuilder

Conversion methods for transaction RPC type.

fn tx_resp_builder(&self) -> &Self::TransactionCompat

Returns reference to transaction response builder.

impl<Provider, Pool, Network, EvmConfig> EthBlocks for EthApi<Provider, Pool, Network, EvmConfig>

where Self: LoadBlock<Error = EthApiError, NetworkTypes: Network<ReceiptResponse = TransactionReceipt>, Provider: BlockReader<Transaction = TransactionSigned, Receipt = Receipt>>, Provider: BlockReader,

async fn block_receipts( &self, block_id: BlockId, ) -> Result<Option<Vec<RpcReceipt<Self::NetworkTypes>>>, Self::Error>

where Self: LoadReceipt,

Helper function for eth_getBlockReceipts.

fn rpc_block_header( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<Header<<Self::Provider as HeaderProvider>::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 Network>::TransactionResponse, <Self::NetworkTypes as Network>::HeaderResponse>>, 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 load_block_and_receipts( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<(SealedBlock<<<Self::Provider as BlockReader>::Block as Block>::Header, <<Self::Provider as BlockReader>::Block as Block>::Body>, Arc<Vec<<Self::Provider as ReceiptProvider>::Receipt>>)>, Self::Error>> + Send

where Self: LoadReceipt,

Helper method that loads a bock and all its receipts.

fn ommers( &self, block_id: BlockId, ) -> Result<Option<Vec<<Self::Provider as HeaderProvider>::Header>>, Self::Error>

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 Network>::TransactionResponse, <Self::NetworkTypes as Network>::HeaderResponse>>, Self::Error>> + Send

Returns uncle block at given index in given block.

impl<Provider, Pool, Network, EvmConfig> EthCall for EthApi<Provider, Pool, Network, EvmConfig>

where Self: EstimateCall + LoadPendingBlock + FullEthApiTypes, Provider: BlockReader,

fn estimate_gas_at( &self, request: 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, block: Option<BlockId>, ) -> impl Future<Output = Result<Vec<SimulatedBlock<Block<<Self::NetworkTypes as Network>::TransactionResponse, <Self::NetworkTypes as Network>::HeaderResponse>>>, 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: 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, bundle: Bundle, state_context: Option<StateContext>, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> impl Future<Output = Result<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: TransactionRequest, block_number: Option<BlockId>, ) -> impl Future<Output = Result<AccessListResult, Self::Error>> + Send

where Self: Trace,

Creates [AccessListResult] for the [TransactionRequest] at the given [BlockId], or latest block.

fn create_access_list_with( &self, cfg: CfgEnvWithHandlerCfg, block: BlockEnv, at: BlockId, request: TransactionRequest, ) -> Result<AccessListResult, Self::Error>

where Self: Trace,

Creates [AccessListResult] for the [TransactionRequest] at the given [BlockId].

impl<Provider, Pool, Network, EvmConfig> EthFees for EthApi<Provider, Pool, Network, EvmConfig>

where Self: LoadFee, Provider: BlockReader,

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, requested_percentile: f64, ) -> u128

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

impl<Provider, Pool, Network, EvmConfig> EthState for EthApi<Provider, Pool, Network, EvmConfig>

where Self: LoadState + SpawnBlocking, Provider: BlockReader,

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.

impl<Provider, Pool, Network, EvmConfig> EthTransactions for EthApi<Provider, Pool, Network, EvmConfig>

where Self: LoadTransaction<Provider: BlockReaderIdExt>, Provider: BlockReader<Transaction = ProviderTx<Self::Provider>>,

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, ) -> &RwLock<Vec<Box<dyn EthSigner<ProviderTx<Self::Provider>>>>>

Returns a handle for signing data.

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 Network>::ReceiptResponse>, 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 Network>::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 Network>::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: 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: 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: 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::Error>

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

impl<Provider, Pool, Network, EvmConfig> LoadBlock for EthApi<Provider, Pool, Network, EvmConfig>

where Self: LoadPendingBlock + SpawnBlocking + RpcNodeCoreExt, Provider: BlockReader,

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

Returns the block object for the given block id.

impl<Provider, Pool, Network, EvmConfig> LoadFee for EthApi<Provider, Pool, Network, EvmConfig>

where Self: LoadBlock<Provider = Provider>, Provider: BlockReaderIdExt + EvmEnvProvider + ChainSpecProvider<ChainSpec: EthChainSpec + EthereumHardforks> + StateProviderFactory,

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

Returns a handle for reading gas price.

fn fee_history_cache(&self) -> &FeeHistoryCache

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<Provider, Pool, Network, EvmConfig> LoadPendingBlock for EthApi<Provider, Pool, Network, EvmConfig>

where Self: SpawnBlocking<NetworkTypes: Network<HeaderResponse = Header>> + RpcNodeCore<Provider: BlockReaderIdExt<Transaction = TransactionSigned, Block = Block, Receipt = Receipt, Header = Header> + EvmEnvProvider + ChainSpecProvider<ChainSpec: EthChainSpec + EthereumHardforks> + StateProviderFactory, Pool: TransactionPool<Transaction: PoolTransaction<Consensus = ProviderTx<Self::Provider>>>, Evm: ConfigureEvm<Header = Header, Transaction = ProviderTx<Self::Provider>>>, Provider: BlockReader<Block = Block, Receipt = Receipt>,

fn pending_block( &self, ) -> &Mutex<Option<PendingBlock<ProviderBlock<Self::Provider>, ProviderReceipt<Self::Provider>>>>

Returns a handle to the pending block.

fn assemble_block( &self, block_env: &BlockEnv, parent_hash: B256, state_root: B256, transactions: Vec<ProviderTx<Self::Provider>>, receipts: &[ProviderReceipt<Self::Provider>], ) -> ProviderBlock<Self::Provider>

Assembles a pending block.

fn assemble_receipt( &self, tx: &ProviderTx<Self::Provider>, result: ExecutionResult, cumulative_gas_used: u64, ) -> ProviderReceipt<Self::Provider>

Assembles a receipt for a transaction, based on its [ExecutionResult].

fn pending_block_env_and_cfg( &self, ) -> Result<PendingBlockEnv<<Self::Provider as BlockReader>::Block, <Self::Provider as ReceiptProvider>::Receipt>, Self::Error>

Configures the [CfgEnvWithHandlerCfg] and [BlockEnv] for the pending block

fn local_pending_block( &self, ) -> impl Future<Output = Result<Option<(SealedBlockWithSenders<<Self::Provider as BlockReader>::Block>, Vec<<Self::Provider as ReceiptProvider>::Receipt>)>, Self::Error>> + Send

where Self: SpawnBlocking,

Returns the locally built pending block

fn assemble_block_and_receipts( &self, block_env: &BlockEnv, parent_hash: FixedBytes<32>, state_root: FixedBytes<32>, transactions: Vec<<Self::Provider as TransactionsProvider>::Transaction>, results: Vec<ExecutionResult>, ) -> (<Self::Provider as BlockReader>::Block, Vec<<Self::Provider as ReceiptProvider>::Receipt>)

Helper to invoke both [Self::assemble_block] and [Self::assemble_receipt].

fn build_block( &self, cfg: CfgEnvWithHandlerCfg, block_env: BlockEnv, parent_hash: FixedBytes<32>, ) -> Result<(SealedBlockWithSenders<<Self::Provider as BlockReader>::Block>, Vec<<Self::Provider as ReceiptProvider>::Receipt>), Self::Error>

where EthApiError: From<ProviderError>,

Builds a pending block using the configured provider and pool.

impl<Provider, Pool, Network, EvmConfig> LoadReceipt for EthApi<Provider, Pool, Network, EvmConfig>

where Self: RpcNodeCoreExt<Provider: TransactionsProvider<Transaction = TransactionSigned> + ReceiptProvider<Receipt = Receipt>>, Provider: BlockReader,

async fn build_transaction_receipt( &self, tx: TransactionSigned, meta: TransactionMeta, receipt: Receipt, ) -> Result<RpcReceipt<Self::NetworkTypes>, Self::Error>

Helper method for eth_getBlockReceipts and eth_getTransactionReceipt.

impl<Provider, Pool, Network, EvmConfig> LoadState for EthApi<Provider, Pool, Network, EvmConfig>

where Self: RpcNodeCoreExt<Provider: BlockReader + StateProviderFactory + ChainSpecProvider<ChainSpec: EthereumHardforks>, Pool: TransactionPool>, Provider: BlockReader,

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, ) -> Result<Box<dyn StateProvider>, Self::Error>

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>, ) -> Result<Box<dyn StateProvider>, Self::Error>

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

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

where Self: LoadPendingBlock + 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<Provider, Pool, Network, EvmConfig> LoadTransaction for EthApi<Provider, Pool, Network, EvmConfig>

where Self: SpawnBlocking + FullEthApiTypes + RpcNodeCoreExt<Provider: TransactionsProvider, Pool: TransactionPool>, Provider: BlockReader,

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<SealedBlockWithSenders<<Self::Provider as BlockReader>::Block>>)>, Self::Error>> + Send

Fetches the transaction and the transaction’s block

impl<Provider, Pool, Network, EvmConfig> RpcNodeCore for EthApi<Provider, Pool, Network, EvmConfig>

where Provider: BlockReader + Clone + Unpin, Pool: Send + Sync + Clone + Unpin, Network: Send + Sync + Clone, EvmConfig: Send + Sync + Clone + Unpin,

type Provider = Provider

The provider type used to interact with the node.

type Pool = Pool

The transaction pool of the node.

type Evm = EvmConfig

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

type Network = Network

Network API.

type PayloadBuilder = ()

Builds new blocks.

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 payload_builder(&self) -> &Self::PayloadBuilder

Returns the handle to the payload builder service.

fn provider(&self) -> &Self::Provider

Returns the provider of the node.

impl<Provider, Pool, Network, EvmConfig> RpcNodeCoreExt for EthApi<Provider, Pool, Network, EvmConfig>

where Provider: BlockReader + Clone + Unpin, Pool: Send + Sync + Clone + Unpin, Network: Send + Sync + Clone, EvmConfig: Send + Sync + Clone + Unpin,

fn cache( &self, ) -> &EthStateCache<ProviderBlock<Provider>, ProviderReceipt<Provider>>

Returns handle to RPC cache service.

impl<Provider, Pool, Network, EvmConfig> SpawnBlocking for EthApi<Provider, Pool, Network, EvmConfig>

where Self: Clone + Send + Sync + 'static, Provider: BlockReader,

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_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<Provider, Pool, Network, EvmConfig> Trace for EthApi<Provider, Pool, Network, EvmConfig>

where Self: LoadState<Provider: BlockReader, Evm: ConfigureEvm<Header = ProviderHeader<Self::Provider>, Transaction = ProviderTx<Self::Provider>>>, Provider: BlockReader,

fn inspect<DB, I>( &self, db: DB, env: EnvWithHandlerCfg, inspector: I, ) -> Result<(ResultAndState, EnvWithHandlerCfg), Self::Error>

where DB: Database, EthApiError: From<<DB as Database>::Error>, I: GetInspector<DB>,

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

fn inspect_and_return_db<DB, I>( &self, db: DB, env: EnvWithHandlerCfg, inspector: I, ) -> Result<(ResultAndState, EnvWithHandlerCfg, DB), Self::Error>

where DB: Database, EthApiError: From<<DB as Database>::Error>, I: GetInspector<DB>,

Same as inspect but also returns the database again.

fn trace_at<F, R>( &self, env: EnvWithHandlerCfg, config: TracingInspectorConfig, at: BlockId, f: F, ) -> Result<R, Self::Error>

where Self: Call, F: FnOnce(TracingInspector, ResultAndState) -> Result<R, Self::Error>,

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, env: EnvWithHandlerCfg, config: TracingInspectorConfig, at: BlockId, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send

where Self: LoadPendingBlock + Call, F: FnOnce(TracingInspector, ResultAndState, 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, ResultAndState, 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, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, Insp: for<'a, 'b> Inspector<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<SealedBlockWithSenders<<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, TracingInspector, ExecutionResult, &HashMap<Address, Account, RandomState>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> 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<SealedBlockWithSenders<<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, Insp, ExecutionResult, &HashMap<Address, Account, RandomState>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static, R: Send + 'static,

Executes all transactions of a block.

fn trace_block_with<F, R>( &self, block_id: BlockId, block: Option<Arc<SealedBlockWithSenders<<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, TracingInspector, ExecutionResult, &HashMap<Address, Account, RandomState>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> 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<SealedBlockWithSenders<<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, Insp, ExecutionResult, &HashMap<Address, Account, RandomState>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + 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 apply_pre_execution_changes<DB>( &self, block: &SealedBlockWithSenders<<Self::Provider as BlockReader>::Block>, db: &mut DB, cfg: &CfgEnvWithHandlerCfg, block_env: &BlockEnv, ) -> Result<(), Self::Error>

where DB: Send + Database + DatabaseCommit, <DB as Database>::Error: Display,

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