Struct EthApi

pub struct EthApi<Provider, 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, 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, ) -> EthApi<Provider, Pool, Network, EvmConfig>

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

where Tasks: TaskSpawner + Clone + 'static, Events: CanonStateSubscriptions,

Creates a new, shareable instance.

Trait Implementations

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

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 EthApi<Provider, Pool, Network, EvmConfig>: LoadState + SpawnBlocking, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Evm: ConfigureEvm<Header = Header>, EvmConfig: ConfigureEvm<Header = Header>,

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 + LoadPendingBlock + 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 TransactionSigned)>,

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>

fn clone(&self) -> EthApi<Provider, Pool, Network, EvmConfig>

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>

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

Formats the value using the given formatter.

impl<Provider, 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, ) -> &<EthApi<Provider, Pool, Network, EvmConfig> as Deref>::Target

Dereferences the value.

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

where EthApi<Provider, Pool, Network, EvmConfig>: Call,

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<N> EthApiBuilder<N> for EthApi<<N as FullNodeTypes>::Provider, <N as FullNodeComponents>::Pool, <N as FullNodeComponents>::Network, <N as FullNodeComponents>::Evm>

where N: FullNodeComponents,

fn build( ctx: &EthApiBuilderCtx<<N as RpcNodeCore>::Provider, <N as RpcNodeCore>::Pool, <N as RpcNodeCore>::Evm, <N as RpcNodeCore>::Network, TaskExecutor, <N as RpcNodeCore>::Provider>, ) -> EthApi<<N as FullNodeTypes>::Provider, <N as FullNodeComponents>::Pool, <N as FullNodeComponents>::Network, <N as FullNodeComponents>::Evm>

Builds the EthApi from the given context.

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

where EthApi<Provider, Pool, Network, EvmConfig>: RpcNodeCore, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider: ChainSpecProvider + BlockNumReader + StageCheckpointReader, <<EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider as ChainSpecProvider>::ChainSpec: EthereumHardforks, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Network: NetworkInfo,

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

Returns the block node is started on.

fn signers(&self) -> &RwLock<RawRwLock, Vec<Box<dyn EthSigner>>>

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 EthApi<Provider, Pool, Network, EvmConfig>: Send + Sync,

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, ) -> &<EthApi<Provider, Pool, Network, EvmConfig> as EthApiTypes>::TransactionCompat

Returns reference to transaction response builder.

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

where EthApi<Provider, Pool, Network, EvmConfig>: LoadBlock<Error = EthApiError>, <EthApi<Provider, Pool, Network, EvmConfig> as EthApiTypes>::NetworkTypes: Network<ReceiptResponse = TransactionReceipt>, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider: HeaderProvider,

async fn block_receipts( &self, block_id: BlockId, ) -> Result<Option<Vec<<<EthApi<Provider, Pool, Network, EvmConfig> as EthApiTypes>::NetworkTypes as Network>::ReceiptResponse>>, <EthApi<Provider, Pool, Network, EvmConfig> as EthApiTypes>::Error>

where EthApi<Provider, Pool, Network, EvmConfig>: LoadReceipt,

Helper function for eth_getBlockReceipts.

fn rpc_block_header( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<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, Arc<Vec<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<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 EthApi<Provider, Pool, Network, EvmConfig>: EstimateCall + LoadPendingBlock,

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

where Self: LoadBlock + FullEthApiTypes,

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

where Self: LoadBlock,

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 EthApi<Provider, Pool, Network, EvmConfig>: LoadFee,

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 EthApi<Provider, Pool, Network, EvmConfig>: LoadState + SpawnBlocking,

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<Account>, 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 EthApi<Provider, Pool, Network, EvmConfig>: LoadTransaction, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider: BlockReaderIdExt,

fn signers(&self) -> &RwLock<RawRwLock, Vec<Box<dyn EthSigner>>>

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<TransactionSigned>>, 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, 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, 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_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 send_transaction( &self, request: TransactionRequest, ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send

where Self: EthApiSpec + LoadBlock + LoadPendingBlock + 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<TransactionSigned, 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::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 EthApi<Provider, Pool, Network, EvmConfig>: LoadPendingBlock + SpawnBlocking, Provider: BlockReaderIdExt,

fn block_with_senders( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<Arc<SealedBlockWithSenders>>, 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 EthApi<Provider, Pool, Network, EvmConfig>: LoadBlock<Provider = Provider>, Provider: BlockReaderIdExt + EvmEnvProvider + ChainSpecProvider + StateProviderFactory, <Provider as ChainSpecProvider>::ChainSpec: EthChainSpec + EthereumHardforks,

fn gas_oracle( &self, ) -> &GasPriceOracle<<EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::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 EthApi<Provider, Pool, Network, EvmConfig>: SpawnBlocking + RpcNodeCore, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider: BlockReaderIdExt + EvmEnvProvider + ChainSpecProvider + StateProviderFactory, <<EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider as ChainSpecProvider>::ChainSpec: EthChainSpec + EthereumHardforks, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Pool: TransactionPool, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Evm: ConfigureEvm<Header = Header>,

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

Returns a handle to the pending block.

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

Configures the CfgEnvWithHandlerCfg and BlockEnv for the pending block

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

where Self: SpawnBlocking,

Returns the locally built pending block

fn assemble_receipt( &self, tx: &TransactionSignedEcRecovered, result: ExecutionResult, cumulative_gas_used: u64, ) -> Receipt

Assembles a Receipt for a transaction, based on its ExecutionResult.

fn receipts_root( &self, _block_env: &BlockEnv, execution_outcome: &ExecutionOutcome, block_number: u64, ) -> FixedBytes<32>

Calculates receipts root in block building.

fn build_block( &self, env: PendingBlockEnv, ) -> Result<(SealedBlockWithSenders, Vec<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 EthApi<Provider, Pool, Network, EvmConfig>: RpcNodeCoreExt, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider: TransactionsProvider<Transaction = TransactionSigned>,

async fn build_transaction_receipt( &self, tx: TransactionSigned, meta: TransactionMeta, receipt: Receipt, ) -> Result<<<EthApi<Provider, Pool, Network, EvmConfig> as EthApiTypes>::NetworkTypes as Network>::ReceiptResponse, <EthApi<Provider, Pool, Network, EvmConfig> as EthApiTypes>::Error>

Helper method for eth_getBlockReceipts and eth_getTransactionReceipt.

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

where EthApi<Provider, Pool, Network, EvmConfig>: RpcNodeCore, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider: StateProviderFactory + ChainSpecProvider, <<EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider as ChainSpecProvider>::ChainSpec: EthereumHardforks, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Pool: TransactionPool,

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<(CfgEnvWithHandlerCfg, BlockEnv, BlockId), Self::Error>> + Send

where Self: LoadPendingBlock + SpawnBlocking,

Returns the revm evm env for the requested BlockId

fn evm_env_for_raw_block( &self, header: &Header, ) -> impl Future<Output = Result<(CfgEnvWithHandlerCfg, BlockEnv), Self::Error>> + Send

where Self: LoadPendingBlock + SpawnBlocking,

Returns the revm evm env for the raw block header

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 EthApi<Provider, Pool, Network, EvmConfig>: SpawnBlocking + FullEthApiTypes + RpcNodeCore, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider: TransactionsProvider, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Pool: TransactionPool,

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, 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, Arc<SealedBlockWithSenders>)>, 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: Send + Sync + 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, ) -> &<EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Pool

Returns the transaction pool of the node.

fn evm_config( &self, ) -> &<EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Evm

Returns the node’s evm config.

fn network( &self, ) -> &<EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Network

Returns the handle to the network

fn payload_builder( &self, ) -> &<EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::PayloadBuilder

Returns the handle to the payload builder service.

fn provider( &self, ) -> &<EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Provider

Returns the provider of the node.

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

where EthApi<Provider, Pool, Network, EvmConfig>: RpcNodeCore,

fn cache(&self) -> &EthStateCache

Returns handle to RPC cache service.

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

where EthApi<Provider, Pool, Network, EvmConfig>: Clone + Send + Sync + 'static,

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 EthApi<Provider, Pool, Network, EvmConfig>: LoadState, <EthApi<Provider, Pool, Network, EvmConfig> as RpcNodeCore>::Evm: ConfigureEvm<Header = Header>,

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