Struct OpEthApi

pub struct OpEthApi<N>
where
    N: OpNodeCore,
{ /* private fields */ }

Available on crate feature optimism only.

OP-Reth Eth API implementation.

This type provides the functionality for handling eth_ related requests.

This wraps a default Eth implementation, and provides additional functionality where the optimism spec deviates from the default (ethereum) spec, e.g. transaction forwarding to the sequencer, receipts, additional RPC fields for transaction receipts.

This type implements the FullEthApi by implemented all the Eth helper traits and prerequisite traits.

Implementations

impl<N> OpEthApi<N>

where N: OpNodeCore,

pub fn raw_tx_forwarder(&self) -> Option<SequencerClient>

Returns the SequencerClient if one is set.

impl<N> OpEthApi<N>

where N: OpNodeCore, <N as RpcNodeCore>::Provider: BlockReaderIdExt + ChainSpecProvider + CanonStateSubscriptions<Primitives = EthPrimitives> + Clone + 'static,

pub fn eth_api( &self, ) -> &EthApiInner<<N as RpcNodeCore>::Provider, <N as RpcNodeCore>::Pool, <N as RpcNodeCore>::Network, <N as RpcNodeCore>::Evm>

Returns a reference to the EthApiNodeBackend.

pub fn sequencer_client(&self) -> Option<&SequencerClient>

Returns the configured sequencer client, if any.

pub const fn builder() -> OpEthApiBuilder

Build a OpEthApi using OpEthApiBuilder.

Trait Implementations

impl<N> AddDevSigners for OpEthApi<N>

where N: OpNodeCore,

fn with_dev_accounts(&self)

Generates 20 random developer accounts. Used in DEV mode.

impl<N> Call for OpEthApi<N>

where OpEthApi<N>: LoadState + SpawnBlocking, <OpEthApi<N> as RpcNodeCore>::Evm: ConfigureEvm<Header = <<OpEthApi<N> as RpcNodeCore>::Provider as HeaderProvider>::Header>, <OpEthApi<N> as EthApiTypes>::Error: From<OpEthApiError>, N: OpNodeCore,

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 create_txn_env( &self, block_env: &BlockEnv, request: TransactionRequest, ) -> Result<TxEnv, <OpEthApi<N> as EthApiTypes>::Error>

Configures a new [TxEnv] for the [TransactionRequest]

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 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<N> Clone for OpEthApi<N>

where N: Clone + OpNodeCore,

fn clone(&self) -> OpEthApi<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> Debug for OpEthApi<N>

where N: OpNodeCore,

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

Formats the value using the given formatter.

impl<N> EstimateCall for OpEthApi<N>

where OpEthApi<N>: Call, <OpEthApi<N> as EthApiTypes>::Error: From<OpEthApiError>, N: OpNodeCore,

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> EthApiSpec for OpEthApi<N>

where N: OpNodeCore, <N as RpcNodeCore>::Provider: ChainSpecProvider + BlockNumReader + StageCheckpointReader, <<N as RpcNodeCore>::Provider as ChainSpecProvider>::ChainSpec: EthereumHardforks, <N as RpcNodeCore>::Network: NetworkInfo,

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

The transaction type signers are using.

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

Returns the block node is started on.

fn signers( &self, ) -> &RwLock<RawRwLock, Vec<Box<dyn EthSigner<<<OpEthApi<N> as RpcNodeCore>::Provider as TransactionsProvider>::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<N> EthApiTypes for OpEthApi<N>

where OpEthApi<N>: Send + Sync, N: OpNodeCore,

type Error = OpEthApiError

Extension of FromEthApiError, with network specific errors.

type NetworkTypes = Optimism

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

type TransactionCompat = OpEthApi<N>

Conversion methods for transaction RPC type.

fn tx_resp_builder(&self) -> &<OpEthApi<N> as EthApiTypes>::TransactionCompat

Returns reference to transaction response builder.

impl<N> EthBlocks for OpEthApi<N>

where <OpEthApi<N> as RpcNodeCore>::Provider: BlockReader<Receipt = Receipt, Transaction = TransactionSigned>, <OpEthApi<N> as EthApiTypes>::NetworkTypes: Network<ReceiptResponse = OpTransactionReceipt>, N: OpNodeCore, <N as RpcNodeCore>::Provider: ChainSpecProvider<ChainSpec = OpChainSpec> + HeaderProvider, OpEthApi<N>: LoadBlock<Error = OpEthApiError>,

async fn block_receipts( &self, block_id: BlockId, ) -> Result<Option<Vec<<<OpEthApi<N> as EthApiTypes>::NetworkTypes as Network>::ReceiptResponse>>, <OpEthApi<N> as EthApiTypes>::Error>

where OpEthApi<N>: 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<N> EthCall for OpEthApi<N>

where OpEthApi<N>: EstimateCall + LoadBlock + FullEthApiTypes, N: OpNodeCore,

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<N> EthFees for OpEthApi<N>

where OpEthApi<N>: LoadFee, N: OpNodeCore,

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<N> EthState for OpEthApi<N>

where OpEthApi<N>: LoadState + SpawnBlocking, N: OpNodeCore,

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<N> EthTransactions for OpEthApi<N>

where OpEthApi<N>: LoadTransaction, <OpEthApi<N> as RpcNodeCore>::Provider: BlockReaderIdExt, N: OpNodeCore, <N as RpcNodeCore>::Provider: BlockReader<Transaction = <<OpEthApi<N> as RpcNodeCore>::Provider as TransactionsProvider>::Transaction>,

async fn send_raw_transaction( &self, tx: Bytes, ) -> Result<FixedBytes<32>, <OpEthApi<N> as EthApiTypes>::Error>

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

Returns the hash of the transaction.

fn signers( &self, ) -> &RwLock<RawRwLock, Vec<Box<dyn EthSigner<<<OpEthApi<N> as RpcNodeCore>::Provider as TransactionsProvider>::Transaction>>>>

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<N> LoadBlock for OpEthApi<N>

where OpEthApi<N>: LoadPendingBlock + SpawnBlocking, N: OpNodeCore,

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<N> LoadFee for OpEthApi<N>

where OpEthApi<N>: LoadBlock<Provider = <N as RpcNodeCore>::Provider>, N: OpNodeCore, <N as RpcNodeCore>::Provider: BlockReaderIdExt + EvmEnvProvider + ChainSpecProvider + StateProviderFactory, <<N as RpcNodeCore>::Provider as ChainSpecProvider>::ChainSpec: EthChainSpec + EthereumHardforks,

fn gas_oracle(&self) -> &GasPriceOracle<<OpEthApi<N> 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<N> LoadPendingBlock for OpEthApi<N>

where OpEthApi<N>: EthApiTypes + SpawnBlocking, <OpEthApi<N> as EthApiTypes>::NetworkTypes: Network<HeaderResponse = Header<<<OpEthApi<N> as RpcNodeCore>::Provider as HeaderProvider>::Header>>, <N as RpcNodeCore>::Provider: EvmEnvProvider + ChainSpecProvider + StateProviderFactory + BlockReaderIdExt<Transaction = TransactionSigned, Block = Block, Receipt = Receipt, Header = Header>, <<N as RpcNodeCore>::Provider as ChainSpecProvider>::ChainSpec: EthChainSpec + EthereumHardforks, <N as RpcNodeCore>::Pool: TransactionPool, <<N as RpcNodeCore>::Pool as TransactionPool>::Transaction: PoolTransaction<Consensus = <<N as RpcNodeCore>::Provider as TransactionsProvider>::Transaction>, N: RpcNodeCore, <N as RpcNodeCore>::Evm: ConfigureEvm<Header = Header, Transaction = TransactionSigned>,

async fn local_pending_block( &self, ) -> Result<Option<(SealedBlockWithSenders, Vec<Receipt>)>, <OpEthApi<N> as EthApiTypes>::Error>

Returns the locally built pending block

fn pending_block( &self, ) -> &Mutex<Option<PendingBlock<<<OpEthApi<N> as RpcNodeCore>::Provider as BlockReader>::Block, <<OpEthApi<N> as RpcNodeCore>::Provider as ReceiptProvider>::Receipt>>>

Returns a handle to the pending block.

fn assemble_block( &self, block_env: &BlockEnv, parent_hash: FixedBytes<32>, state_root: FixedBytes<32>, transactions: Vec<<<OpEthApi<N> as RpcNodeCore>::Provider as TransactionsProvider>::Transaction>, receipts: &[<<OpEthApi<N> as RpcNodeCore>::Provider as ReceiptProvider>::Receipt], ) -> <<OpEthApi<N> as RpcNodeCore>::Provider as BlockReader>::Block

Assembles a pending block.

fn assemble_receipt( &self, tx: &<<OpEthApi<N> as RpcNodeCore>::Provider as TransactionsProvider>::Transaction, result: ExecutionResult, cumulative_gas_used: u64, ) -> <<OpEthApi<N> as RpcNodeCore>::Provider as ReceiptProvider>::Receipt

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 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<N> LoadReceipt for OpEthApi<N>

where N: FullNodeComponents, <N as FullNodeTypes>::Types: NodeTypes<ChainSpec = OpChainSpec>, <OpEthApi<N> as RpcNodeCore>::Provider: TransactionsProvider<Transaction = TransactionSigned> + ReceiptProvider<Receipt = Receipt>, OpEthApi<N>: Send + Sync,

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

Helper method for eth_getBlockReceipts and eth_getTransactionReceipt.

impl<N> LoadState for OpEthApi<N>

where N: OpNodeCore, <N as RpcNodeCore>::Provider: StateProviderFactory + ChainSpecProvider, <<N as RpcNodeCore>::Provider as ChainSpecProvider>::ChainSpec: EthereumHardforks, <N 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<(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<N> LoadTransaction for OpEthApi<N>

where OpEthApi<N>: SpawnBlocking + FullEthApiTypes + RpcNodeCoreExt, N: OpNodeCore, <N as RpcNodeCore>::Provider: TransactionsProvider, <N as RpcNodeCore>::Pool: TransactionPool, <OpEthApi<N> 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<<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<N> RpcNodeCore for OpEthApi<N>

where N: OpNodeCore,

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.

type PayloadBuilder = ()

Builds new blocks.

fn pool(&self) -> &<OpEthApi<N> as RpcNodeCore>::Pool

Returns the transaction pool of the node.

fn evm_config(&self) -> &<OpEthApi<N> as RpcNodeCore>::Evm

Returns the node’s evm config.

fn network(&self) -> &<OpEthApi<N> as RpcNodeCore>::Network

Returns the handle to the network

fn payload_builder(&self) -> &<OpEthApi<N> as RpcNodeCore>::PayloadBuilder

Returns the handle to the payload builder service.

fn provider(&self) -> &<OpEthApi<N> as RpcNodeCore>::Provider

Returns the provider of the node.

impl<N> RpcNodeCoreExt for OpEthApi<N>

where N: OpNodeCore,

fn cache( &self, ) -> &EthStateCache<<<N as RpcNodeCore>::Provider as BlockReader>::Block, <<N as RpcNodeCore>::Provider as ReceiptProvider>::Receipt>

Returns handle to RPC cache service.

impl<N> SpawnBlocking for OpEthApi<N>

where OpEthApi<N>: Send + Sync + Clone + 'static, N: OpNodeCore,

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<N> Trace for OpEthApi<N>

where <OpEthApi<N> as RpcNodeCore>::Provider: BlockReader, OpEthApi<N>: LoadState + RpcNodeCore, <OpEthApi<N> as RpcNodeCore>::Evm: ConfigureEvm<Header = <<OpEthApi<N> as RpcNodeCore>::Provider as HeaderProvider>::Header, Transaction = <<OpEthApi<N> as RpcNodeCore>::Provider as TransactionsProvider>::Transaction>, N: OpNodeCore,

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.

impl<N> TransactionCompat for OpEthApi<N>

where N: FullNodeComponents, <N as FullNodeTypes>::Provider: ReceiptProvider<Receipt = Receipt>,

type Transaction = Transaction

RPC transaction response type.

type Error = OpEthApiError

RPC transaction error type.

fn fill( &self, tx: RecoveredTx, tx_info: TransactionInfo, ) -> Result<<OpEthApi<N> as TransactionCompat>::Transaction, <OpEthApi<N> as TransactionCompat>::Error>

Create a new rpc transaction result for a pending signed transaction, setting block environment related fields to None.

fn build_simulate_v1_transaction( &self, request: TransactionRequest, ) -> Result<TransactionSigned, <OpEthApi<N> as TransactionCompat>::Error>

Builds a fake transaction from a transaction request for inclusion into block built in eth_simulateV1.

fn otterscan_api_truncate_input( tx: &mut <OpEthApi<N> as TransactionCompat>::Transaction, )

Truncates the input of a transaction to only the first 4 bytes.

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