OpEthApi

op_reth::rpc::eth

Struct OpEthApi 

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

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, Rpc> OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>,

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

Returns the SequencerClient if one is set.

§

impl<N, Rpc> OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert,

pub fn new( eth_api: EthApiInner<N, Rpc>, sequencer_client: Option<SequencerClient>, min_suggested_priority_fee: Uint<256, 4>, flashblocks: Option<FlashblocksListeners<<N as RpcNodeCore>::Primitives>>, ) -> OpEthApi<N, Rpc>

Creates a new OpEthApi.

pub fn eth_api(&self) -> &EthApiInner<N, Rpc>

Returns a reference to the EthApiNodeBackend.

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

Returns the configured sequencer client, if any.

pub fn pending_block_rx( &self, ) -> Option<Receiver<Option<PendingFlashBlock<<N as RpcNodeCore>::Primitives>>>>

Returns a cloned pending block receiver, if any.

pub fn subscribe_received_flashblocks( &self, ) -> Option<Receiver<Arc<FlashBlock>>>

Returns a new subscription to received flashblocks.

pub fn subscribe_flashblock_sequence( &self, ) -> Option<Receiver<FlashBlockCompleteSequence>>

Returns a new subscription to flashblock sequences.

pub const fn builder() -> OpEthApiBuilder<Rpc>

Build a OpEthApi using OpEthApiBuilder.

pub async fn pending_flashblock( &self, ) -> Result<Option<PendingBlock<<N as RpcNodeCore>::Primitives>>, Report>
where OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>,

Returns a PendingBlock that is built out of flashblocks.

If flashblocks receiver is not set, then it always returns None.

It may wait up to 50ms for a fresh flashblock if one is currently being built.

Trait Implementations§

§

impl<N, Rpc> Call for OpEthApi<N, Rpc>
where OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError, Evm = <N as RpcNodeCore>::Evm>, N: RpcNodeCore,

§

fn call_gas_limit(&self) -> u64

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

fn max_simulate_blocks(&self) -> u64

Returns the maximum number of blocks accepted for eth_simulateV1.
§

fn evm_memory_limit(&self) -> u64

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

fn caller_gas_allowance( &self, db: impl Database>, _evm_env: &EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::BlockEnv>, tx_env: &<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx, ) -> Result<u64, Self::Error>
where <impl Database as Database>::Error: Into<EthApiError>,

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

fn with_state_at_block<F, R>( &self, at: BlockId, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send
where R: Send + 'static, F: FnOnce(Self, StateProviderTraitObjWrapper<'_>) -> Result<R, Self::Error> + Send + 'static,

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

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

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

fn transact_with_inspector<DB, I>( &self, db: DB, evm_env: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::BlockEnv>, tx_env: <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx, inspector: I, ) -> Result<ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, Self::Error>
where DB: Database<Error = ProviderError> + Debug, I: InspectorFor<Self::Evm, DB>,

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

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

Executes the call request at the given [BlockId].
§

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

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

fn spawn_with_call_at<F, R>( &self, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, at: BlockId, overrides: EvmOverrides, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send
where Self: LoadPendingBlock, F: FnOnce(StateCacheDbRefMutWrapper<'_, '_>, EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::BlockEnv>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

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

fn spawn_replay_transaction<F, R>( &self, hash: FixedBytes<32>, f: F, ) -> impl Future<Output = Result<Option<R>, Self::Error>> + Send
where Self: LoadBlock + LoadTransaction, F: FnOnce(TransactionInfo, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, State<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Retrieves the transaction if it exists and executes it. Read more
§

fn replay_transactions_until<'a, DB, I>( &self, db: &mut DB, evm_env: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::BlockEnv>, transactions: I, target_tx_hash: FixedBytes<32>, ) -> Result<usize, Self::Error>
where DB: Database<Error = ProviderError> + DatabaseCommit + Debug, I: IntoIterator<Item = Recovered<&'a <Self::Provider as TransactionsProvider>::Transaction>>,

Replays all the transactions until the target transaction is found. Read more
§

fn create_txn_env( &self, evm_env: &EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::BlockEnv>, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, db: impl Database>, ) -> Result<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx, Self::Error>
where <impl Database as Database>::Error: Into<EthApiError>,

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

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

Prepares the [reth_evm::EvmEnv] for execution of calls. Read more
§

impl<N, Rpc> Clone for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert,

§

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

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
§

impl<N, Rpc> Debug for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert,

§

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

Formats the value using the given formatter. Read more
§

impl<N, Rpc> EstimateCall for OpEthApi<N, Rpc>
where OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError, Evm = <N as RpcNodeCore>::Evm>, N: RpcNodeCore,

§

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

Estimates the gas usage of the request with the state. Read more
§

fn estimate_gas_at( &self, request: <<Self::RpcConvert as RpcConvert>::Network as RpcTypes>::TransactionRequest, at: BlockId, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> impl Future<Output = Result<Uint<256, 4>, Self::Error>> + Send
where Self: LoadPendingBlock,

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

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

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

impl<N, Rpc> EthApiSpec for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>,

§

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

Returns the block node is started on.
§

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

Returns the current ethereum protocol version.
§

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

Returns the chain id
§

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

Returns provider chain info
§

fn is_syncing(&self) -> bool

Returns true if the network is undergoing sync.
§

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

Returns the [SyncStatus] of the network
§

impl<N, Rpc> EthApiTypes for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>,

§

type Error = OpEthApiError

Extension of FromEthApiError, with network specific errors.
§

type NetworkTypes = <Rpc as RpcConvert>::Network

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

type RpcConvert = Rpc

Conversion methods for transaction RPC type.
§

fn tx_resp_builder(&self) -> &<OpEthApi<N, Rpc> as EthApiTypes>::RpcConvert

Returns reference to transaction response builder.
§

impl<N, Rpc> EthBlocks for OpEthApi<N, Rpc>
where N: RpcNodeCore, OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError>,

§

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

Returns the block header for the given block id.
§

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

Returns the populated rpc block object for the given block id. Read more
§

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. Read more
§

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

Helper function for eth_getBlockReceipts. Read more
§

fn load_block_and_receipts( &self, block_id: BlockId, ) -> impl Future<Output = Result<Option<(Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>, Arc<Vec<<Self::Provider as ReceiptProvider>::Receipt>>)>, Self::Error>> + Send
where Self: LoadReceipt, Self::Pool: TransactionPool, <Self::Pool as TransactionPool>::Transaction: PoolTransaction<Consensus = <Self::Provider as TransactionsProvider>::Transaction>,

Helper method that loads a block and all its receipts.
§

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

Returns uncle headers of given block. Read more
§

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

Returns uncle block at given index in given block. Read more
§

impl<N, Rpc> EthCall for OpEthApi<N, Rpc>
where OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError, Evm = <N as RpcNodeCore>::Evm>, N: RpcNodeCore,

§

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

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

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

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

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

Executes the call request (eth_call) and returns the output
§

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

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

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

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

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

Creates [AccessListResult] for the RpcTxReq at the given [BlockId].
§

impl<N, Rpc> EthFees for OpEthApi<N, Rpc>
where N: RpcNodeCore, OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError>,

§

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. Read more
§

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. Read more
§

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

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

impl<N, Rpc> EthState for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>, OpEthApi<N, Rpc>: LoadPendingBlock,

§

fn max_proof_window(&self) -> u64

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

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

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

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

Returns code of given account, at given blocknumber.
§

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

Returns balance of given account, at given blocknumber.
§

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

Returns values stored of given account, at given blocknumber.
§

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

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

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

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

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

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

impl<N, Rpc> EthTransactions for OpEthApi<N, Rpc>
where N: RpcNodeCore, OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError>,

§

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

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

Returns the hash of the transaction.

§

fn send_raw_transaction_sync( &self, tx: Bytes, ) -> impl Future<Output = Result<<<OpEthApi<N, Rpc> as EthApiTypes>::NetworkTypes as RpcTypes>::Receipt, <OpEthApi<N, Rpc> as EthApiTypes>::Error>> + Send
where OpEthApi<N, Rpc>: LoadReceipt + 'static,

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

And awaits the receipt, checking both canonical blocks and flashblocks for faster confirmation.

§

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

Returns the transaction receipt for the given hash.

With flashblocks, we should also lookup the pending block for the transaction because this is considered confirmed/mined.

§

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

Returns a handle for signing data. Read more
§

fn send_raw_transaction_sync_timeout(&self) -> Duration

Returns the timeout duration for send_raw_transaction_sync RPC method.
§

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

Returns a list of addresses owned by provider.
§

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. Read more
§

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. Read more
§

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. Read more
§

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

Helper method that loads a transaction and its receipt.
§

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

Get transaction by [BlockId] and index of transaction within that block. Read more
§

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

Find a transaction by sender’s address and nonce.
§

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

Get transaction, as raw bytes, by [BlockId] and index of transaction within that block. Read more
§

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

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

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

Fills the defaults on a given unsigned transaction.
§

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

Signs a transaction, with configured signers.
§

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

Signs given message. Returns the signature.
§

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

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

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

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

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

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

impl<N, Rpc> LoadBlock for OpEthApi<N, Rpc>
where N: RpcNodeCore, OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError>,

§

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

Returns the block object for the given block id.
§

impl<N, Rpc> LoadFee for OpEthApi<N, Rpc>
where N: RpcNodeCore, OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError>,

§

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

Returns a handle for reading gas price. Read more
§

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

Returns a handle for reading fee history data from memory. Read more
§

async fn suggested_priority_fee( &self, ) -> Result<Uint<256, 4>, <OpEthApi<N, Rpc> as EthApiTypes>::Error>

Returns a suggestion for the priority fee (the tip)
§

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. Read more
§

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. Read more
§

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.
§

impl<N, Rpc> LoadPendingBlock for OpEthApi<N, Rpc>
where N: RpcNodeCore, OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>,

§

async fn local_pending_block( &self, ) -> Result<Option<BlockAndReceipts<<OpEthApi<N, Rpc> as RpcNodeCore>::Primitives>>, <OpEthApi<N, Rpc> as EthApiTypes>::Error>

Returns the locally built pending block

§

async fn local_pending_state( &self, ) -> Result<Option<Box<dyn StateProvider>>, <OpEthApi<N, Rpc> as EthApiTypes>::Error>
where OpEthApi<N, Rpc>: SpawnBlocking,

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

§

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

Returns a handle to the pending block. Read more
§

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

Returns a [PendingEnvBuilder] for the pending block.
§

fn pending_block_kind(&self) -> PendingBlockKind

Returns the pending block kind
§

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

Configures the PendingBlockEnv for the pending block Read more
§

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

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

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

Returns a mem-pool built pending block.
§

fn build_block( &self, parent: &SealedHeader<<Self::Provider as HeaderProvider>::Header>, ) -> Result<ExecutedBlock<Self::Primitives>, Self::Error>
where Self::Pool: TransactionPool, <Self::Pool as TransactionPool>::Transaction: PoolTransaction<Consensus = <Self::Provider as TransactionsProvider>::Transaction>, EthApiError: From<ProviderError>,

Builds a pending block using the configured provider and pool. Read more
§

impl<N, Rpc> LoadReceipt for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError>,

§

fn build_transaction_receipt( &self, tx: <Self::Provider as TransactionsProvider>::Transaction, meta: TransactionMeta, receipt: <Self::Provider as ReceiptProvider>::Receipt, ) -> impl Future<Output = Result<<Self::NetworkTypes as RpcTypes>::Receipt, Self::Error>> + Send

Helper method for eth_getBlockReceipts and eth_getTransactionReceipt.
§

impl<N, Rpc> LoadState for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>, OpEthApi<N, Rpc>: LoadPendingBlock,

§

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

Returns the state at the given block number
§

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

Returns the state at the given [BlockId] enum. Read more
§

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

Returns the latest state
§

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

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

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

Returns the revm evm env for the requested [BlockId] Read more
§

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. Read more
§

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

Returns code of given account, at the given identifier.
§

impl<N, Rpc> LoadTransaction for OpEthApi<N, Rpc>
where N: RpcNodeCore, OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = OpEthApiError>,

§

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. Read more
§

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]. Read more
§

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

Fetches the transaction and the transaction’s block
§

impl<N, Rpc> RpcNodeCore for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>,

§

type Primitives = <N as RpcNodeCore>::Primitives

Blockchain data primitives.
§

type Provider = <N as RpcNodeCore>::Provider

The provider type used to interact with the node.
§

type Pool = <N as RpcNodeCore>::Pool

The transaction pool of the node.
§

type Evm = <N as RpcNodeCore>::Evm

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

type Network = <N as RpcNodeCore>::Network

Network API.
§

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

Returns the transaction pool of the node.
§

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

Returns the node’s evm config.
§

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

Returns the handle to the network
§

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

Returns the provider of the node.
§

impl<N, Rpc> RpcNodeCoreExt for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>,

§

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

Returns handle to RPC cache service.
§

impl<N, Rpc> SpawnBlocking for OpEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>,

§

fn io_task_spawner(&self) -> impl TaskSpawner

Returns a handle for spawning IO heavy blocking tasks. Read more
§

fn tracing_task_pool(&self) -> &BlockingTaskPool

Returns a handle for spawning CPU heavy blocking tasks. Read more
§

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. Read more
§

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

Executes the future on a new blocking task. Read more
§

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. Read more
§

impl<N, Rpc> Trace for OpEthApi<N, Rpc>
where N: RpcNodeCore, OpEthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives>,

§

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

Executes the TxEnvFor with [reth_evm::EvmEnv] against the given [Database] without committing state changes.
§

fn trace_at<F, R>( &self, evm_env: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::BlockEnv>, tx_env: <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx, config: TracingInspectorConfig, at: BlockId, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send
where Self: Call, R: Send + 'static, F: FnOnce(TracingInspector, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>) -> Result<R, Self::Error> + Send + 'static,

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

fn spawn_trace_at_with_state<F, R>( &self, evm_env: EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::BlockEnv>, tx_env: <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Tx, config: TracingInspectorConfig, at: BlockId, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send
where Self: LoadPendingBlock + Call, F: FnOnce(TracingInspector, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, State<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Same as trace_at but also provides the used database to the callback. Read more
§

fn spawn_trace_transaction_in_block<F, R>( &self, hash: FixedBytes<32>, config: TracingInspectorConfig, f: F, ) -> impl Future<Output = Result<Option<R>, Self::Error>> + Send
where Self: LoadPendingBlock + LoadTransaction + Call, F: FnOnce(TransactionInfo, TracingInspector, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, State<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Retrieves the transaction if it exists and returns its trace. Read more
§

fn spawn_trace_transaction_in_block_with_inspector<Insp, F, R>( &self, hash: FixedBytes<32>, inspector: Insp, f: F, ) -> impl Future<Output = Result<Option<R>, Self::Error>> + Send
where Self: LoadPendingBlock + LoadTransaction + Call, F: FnOnce(TransactionInfo, Insp, ExecResultAndState<ExecutionResult<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::HaltReason>>, State<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static, Insp: for<'a, 'b> InspectorFor<Self::Evm, StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static, R: Send + 'static,

Retrieves the transaction if it exists and returns its trace. Read more
§

fn trace_block_until<F, R>( &self, block_id: BlockId, block: Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, highest_index: Option<u64>, config: TracingInspectorConfig, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
where Self: LoadBlock, F: Fn(TransactionInfo, TracingCtx<'_, Recovered<&<Self::Provider as TransactionsProvider>::Transaction>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<StateCacheDbRefMutWrapper<'_, '_>, TracingInspector>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

Executes all transactions of a block up to a given index. Read more
§

fn trace_block_until_with_inspector<Setup, Insp, F, R>( &self, block_id: BlockId, block: Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, highest_index: Option<u64>, inspector_setup: Setup, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
where Self: LoadBlock, F: Fn(TransactionInfo, TracingCtx<'_, Recovered<&<Self::Provider as TransactionsProvider>::Transaction>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<StateCacheDbRefMutWrapper<'_, '_>, Insp>>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: Clone + for<'a, 'b> InspectorFor<Self::Evm, StateCacheDbRefMutWrapper<'a, 'b>>, R: Send + 'static,

Executes all transactions of a block. Read more
§

fn trace_block_with<F, R>( &self, block_id: BlockId, block: Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, config: TracingInspectorConfig, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
where Self: LoadBlock, F: Fn(TransactionInfo, TracingCtx<'_, Recovered<&<Self::Provider as TransactionsProvider>::Transaction>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<StateCacheDbRefMutWrapper<'_, '_>, TracingInspector>>) -> Result<R, Self::Error> + Send + 'static, R: Send + 'static,

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

fn trace_block_inspector<Setup, Insp, F, R>( &self, block_id: BlockId, block: Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>, insp_setup: Setup, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
where Self: LoadBlock, F: Fn(TransactionInfo, TracingCtx<'_, Recovered<&<Self::Provider as TransactionsProvider>::Transaction>, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<StateCacheDbRefMutWrapper<'_, '_>, Insp>>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: Clone + for<'a, 'b> InspectorFor<Self::Evm, StateCacheDbRefMutWrapper<'a, 'b>>, R: Send + 'static,

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

fn apply_pre_execution_changes<DB>( &self, block: &RecoveredBlock<<Self::Provider as BlockReader>::Block>, db: &mut DB, evm_env: &EvmEnv<<<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::Spec, <<<Self::Evm as ConfigureEvm>::BlockExecutorFactory as BlockExecutorFactory>::EvmFactory as EvmFactory>::BlockEnv>, ) -> Result<(), Self::Error>
where DB: Send + Database + DatabaseCommit,

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

Auto Trait Implementations§

§

impl<N, Rpc> Freeze for OpEthApi<N, Rpc>

§

impl<N, Rpc> !RefUnwindSafe for OpEthApi<N, Rpc>

§

impl<N, Rpc> Send for OpEthApi<N, Rpc>

§

impl<N, Rpc> Sync for OpEthApi<N, Rpc>

§

impl<N, Rpc> Unpin for OpEthApi<N, Rpc>

§

impl<N, Rpc> !UnwindSafe for OpEthApi<N, Rpc>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit #126799)
Performs copy-assignment from self to dest. Read more
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> DynClone for T
where T: Clone,

Source§

fn __clone_box(&self, _: Private) -> *mut ()

§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<TxEnv, T> FromRecoveredTx<&T> for TxEnv
where TxEnv: FromRecoveredTx<T>,

§

fn from_recovered_tx(tx: &&T, sender: Address) -> TxEnv

Builds a [TxEnv] from a transaction and a sender address.
§

impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnv
where TxEnv: FromTxWithEncoded<T>,

§

fn from_encoded_tx(tx: &&T, sender: Address, encoded: Bytes) -> TxEnv

Builds a [TxEnv] from a transaction, its sender, and encoded transaction bytes.
§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> IntoRequest<T> for T

§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

impl<L> LayerExt<L> for L

§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in [Layered].
§

impl<T> Paint for T
where T: ?Sized,

§

fn fg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the foreground set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like red() and green(), which have the same functionality but are pithier.

§Example

Set foreground color to white using fg():

use yansi::{Paint, Color};

painted.fg(Color::White);

Set foreground color to white using white().

use yansi::Paint;

painted.white();
§

fn primary(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Primary].

§Example
println!("{}", value.primary());
§

fn fixed(&self, color: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Fixed].

§Example
println!("{}", value.fixed(color));
§

fn rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Rgb].

§Example
println!("{}", value.rgb(r, g, b));
§

fn black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Black].

§Example
println!("{}", value.black());
§

fn red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Red].

§Example
println!("{}", value.red());
§

fn green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Green].

§Example
println!("{}", value.green());
§

fn yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Yellow].

§Example
println!("{}", value.yellow());
§

fn blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Blue].

§Example
println!("{}", value.blue());
§

fn magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Magenta].

§Example
println!("{}", value.magenta());
§

fn cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Cyan].

§Example
println!("{}", value.cyan());
§

fn white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: White].

§Example
println!("{}", value.white());
§

fn bright_black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlack].

§Example
println!("{}", value.bright_black());
§

fn bright_red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightRed].

§Example
println!("{}", value.bright_red());
§

fn bright_green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightGreen].

§Example
println!("{}", value.bright_green());
§

fn bright_yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightYellow].

§Example
println!("{}", value.bright_yellow());
§

fn bright_blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlue].

§Example
println!("{}", value.bright_blue());
§

fn bright_magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightMagenta].

§Example
println!("{}", value.bright_magenta());
§

fn bright_cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightCyan].

§Example
println!("{}", value.bright_cyan());
§

fn bright_white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightWhite].

§Example
println!("{}", value.bright_white());
§

fn bg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the background set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like on_red() and on_green(), which have the same functionality but are pithier.

§Example

Set background color to red using fg():

use yansi::{Paint, Color};

painted.bg(Color::Red);

Set background color to red using on_red().

use yansi::Paint;

painted.on_red();
§

fn on_primary(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Primary].

§Example
println!("{}", value.on_primary());
§

fn on_fixed(&self, color: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Fixed].

§Example
println!("{}", value.on_fixed(color));
§

fn on_rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Rgb].

§Example
println!("{}", value.on_rgb(r, g, b));
§

fn on_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Black].

§Example
println!("{}", value.on_black());
§

fn on_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Red].

§Example
println!("{}", value.on_red());
§

fn on_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Green].

§Example
println!("{}", value.on_green());
§

fn on_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Yellow].

§Example
println!("{}", value.on_yellow());
§

fn on_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Blue].

§Example
println!("{}", value.on_blue());
§

fn on_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Magenta].

§Example
println!("{}", value.on_magenta());
§

fn on_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Cyan].

§Example
println!("{}", value.on_cyan());
§

fn on_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: White].

§Example
println!("{}", value.on_white());
§

fn on_bright_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlack].

§Example
println!("{}", value.on_bright_black());
§

fn on_bright_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightRed].

§Example
println!("{}", value.on_bright_red());
§

fn on_bright_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightGreen].

§Example
println!("{}", value.on_bright_green());
§

fn on_bright_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightYellow].

§Example
println!("{}", value.on_bright_yellow());
§

fn on_bright_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlue].

§Example
println!("{}", value.on_bright_blue());
§

fn on_bright_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightMagenta].

§Example
println!("{}", value.on_bright_magenta());
§

fn on_bright_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightCyan].

§Example
println!("{}", value.on_bright_cyan());
§

fn on_bright_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightWhite].

§Example
println!("{}", value.on_bright_white());
§

fn attr(&self, value: Attribute) -> Painted<&T>

Enables the styling [Attribute] value.

This method should be used rarely. Instead, prefer to use attribute-specific builder methods like bold() and underline(), which have the same functionality but are pithier.

§Example

Make text bold using attr():

use yansi::{Paint, Attribute};

painted.attr(Attribute::Bold);

Make text bold using using bold().

use yansi::Paint;

painted.bold();
§

fn bold(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Bold].

§Example
println!("{}", value.bold());
§

fn dim(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Dim].

§Example
println!("{}", value.dim());
§

fn italic(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Italic].

§Example
println!("{}", value.italic());
§

fn underline(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Underline].

§Example
println!("{}", value.underline());

Returns self with the attr() set to [Attribute :: Blink].

§Example
println!("{}", value.blink());

Returns self with the attr() set to [Attribute :: RapidBlink].

§Example
println!("{}", value.rapid_blink());
§

fn invert(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Invert].

§Example
println!("{}", value.invert());
§

fn conceal(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Conceal].

§Example
println!("{}", value.conceal());
§

fn strike(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Strike].

§Example
println!("{}", value.strike());
§

fn quirk(&self, value: Quirk) -> Painted<&T>

Enables the yansi [Quirk] value.

This method should be used rarely. Instead, prefer to use quirk-specific builder methods like mask() and wrap(), which have the same functionality but are pithier.

§Example

Enable wrapping using .quirk():

use yansi::{Paint, Quirk};

painted.quirk(Quirk::Wrap);

Enable wrapping using wrap().

use yansi::Paint;

painted.wrap();
§

fn mask(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Mask].

§Example
println!("{}", value.mask());
§

fn wrap(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Wrap].

§Example
println!("{}", value.wrap());
§

fn linger(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Linger].

§Example
println!("{}", value.linger());
§

fn clear(&self) -> Painted<&T>

👎Deprecated since 1.0.1: renamed to resetting() due to conflicts with Vec::clear(). The clear() method will be removed in a future release.

Returns self with the quirk() set to [Quirk :: Clear].

§Example
println!("{}", value.clear());
§

fn resetting(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Resetting].

§Example
println!("{}", value.resetting());
§

fn bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Bright].

§Example
println!("{}", value.bright());
§

fn on_bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: OnBright].

§Example
println!("{}", value.on_bright());
§

fn whenever(&self, value: Condition) -> Painted<&T>

Conditionally enable styling based on whether the [Condition] value applies. Replaces any previous condition.

See the crate level docs for more details.

§Example

Enable styling painted only when both stdout and stderr are TTYs:

use yansi::{Paint, Condition};

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
§

fn new(self) -> Painted<Self>
where Self: Sized,

Create a new [Painted] with a default [Style]. Read more
§

fn paint<S>(&self, style: S) -> Painted<&Self>
where S: Into<Style>,

Apply a style wholesale to self. Any previous style is replaced. Read more
§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> ServiceExt for T

§

fn propagate_header(self, header: HeaderName) -> PropagateHeader<Self>
where Self: Sized,

Propagate a header from the request to the response. Read more
§

fn add_extension<T>(self, value: T) -> AddExtension<Self, T>
where Self: Sized,

Add some shareable value to request extensions. Read more
§

fn map_request_body<F>(self, f: F) -> MapRequestBody<Self, F>
where Self: Sized,

Apply a transformation to the request body. Read more
§

fn map_response_body<F>(self, f: F) -> MapResponseBody<Self, F>
where Self: Sized,

Apply a transformation to the response body. Read more
§

fn compression(self) -> Compression<Self>
where Self: Sized,

Compresses response bodies. Read more
§

fn decompression(self) -> Decompression<Self>
where Self: Sized,

Decompress response bodies. Read more
§

fn trace_for_http(self) -> Trace<Self, SharedClassifier<ServerErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using HTTP status codes. Read more
§

fn trace_for_grpc(self) -> Trace<Self, SharedClassifier<GrpcErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using gRPC headers. Read more
§

fn follow_redirects(self) -> FollowRedirect<Self>
where Self: Sized,

Follow redirect resposes using the Standard policy. Read more
§

fn sensitive_headers( self, headers: impl IntoIterator<Item = HeaderName>, ) -> SetSensitiveRequestHeaders<SetSensitiveResponseHeaders<Self>>
where Self: Sized,

Mark headers as sensitive on both requests and responses. Read more
§

fn sensitive_request_headers( self, headers: impl IntoIterator<Item = HeaderName>, ) -> SetSensitiveRequestHeaders<Self>
where Self: Sized,

Mark headers as sensitive on requests. Read more
§

fn sensitive_response_headers( self, headers: impl IntoIterator<Item = HeaderName>, ) -> SetSensitiveResponseHeaders<Self>
where Self: Sized,

Mark headers as sensitive on responses. Read more
§

fn override_request_header<M>( self, header_name: HeaderName, make: M, ) -> SetRequestHeader<Self, M>
where Self: Sized,

Insert a header into the request. Read more
§

fn append_request_header<M>( self, header_name: HeaderName, make: M, ) -> SetRequestHeader<Self, M>
where Self: Sized,

Append a header into the request. Read more
§

fn insert_request_header_if_not_present<M>( self, header_name: HeaderName, make: M, ) -> SetRequestHeader<Self, M>
where Self: Sized,

Insert a header into the request, if the header is not already present. Read more
§

fn override_response_header<M>( self, header_name: HeaderName, make: M, ) -> SetResponseHeader<Self, M>
where Self: Sized,

Insert a header into the response. Read more
§

fn append_response_header<M>( self, header_name: HeaderName, make: M, ) -> SetResponseHeader<Self, M>
where Self: Sized,

Append a header into the response. Read more
§

fn insert_response_header_if_not_present<M>( self, header_name: HeaderName, make: M, ) -> SetResponseHeader<Self, M>
where Self: Sized,

Insert a header into the response, if the header is not already present. Read more
§

fn set_request_id<M>( self, header_name: HeaderName, make_request_id: M, ) -> SetRequestId<Self, M>
where Self: Sized, M: MakeRequestId,

Add request id header and extension. Read more
§

fn set_x_request_id<M>(self, make_request_id: M) -> SetRequestId<Self, M>
where Self: Sized, M: MakeRequestId,

Add request id header and extension, using x-request-id as the header name. Read more
§

fn propagate_request_id( self, header_name: HeaderName, ) -> PropagateRequestId<Self>
where Self: Sized,

Propgate request ids from requests to responses. Read more
§

fn propagate_x_request_id(self) -> PropagateRequestId<Self>
where Self: Sized,

Propgate request ids from requests to responses, using x-request-id as the header name. Read more
§

fn catch_panic(self) -> CatchPanic<Self, DefaultResponseForPanic>
where Self: Sized,

Catch panics and convert them into 500 Internal Server responses. Read more
§

fn request_body_limit(self, limit: usize) -> RequestBodyLimit<Self>
where Self: Sized,

Intercept requests with over-sized payloads and convert them into 413 Payload Too Large responses. Read more
§

fn trim_trailing_slash(self) -> NormalizePath<Self>
where Self: Sized,

Remove trailing slashes from paths. Read more
§

fn append_trailing_slash(self) -> NormalizePath<Self>
where Self: Sized,

Append trailing slash to paths. Read more
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<T> TryClone for T
where T: Clone,

§

fn try_clone(&self) -> Result<T, Error>

Clones self, possibly returning an error.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
§

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> FullEthApi for T
where T: FullEthApiTypes + EthApiSpec + EthTransactions + EthBlocks + EthState + EthCall + EthFees + Trace + LoadReceipt,

§

impl<T> FullEthApiServer for T
where T: EthApiServer<<<T as EthApiTypes>::NetworkTypes as RpcTypes>::TransactionRequest, <<T as EthApiTypes>::NetworkTypes as RpcTypes>::TransactionResponse, Block<<<T as EthApiTypes>::NetworkTypes as RpcTypes>::TransactionResponse, <<T as EthApiTypes>::NetworkTypes as RpcTypes>::Header>, <<T as EthApiTypes>::NetworkTypes as RpcTypes>::Receipt, <<T as EthApiTypes>::NetworkTypes as RpcTypes>::Header, <<T as RpcNodeCore>::Primitives as NodePrimitives>::SignedTx> + FullEthApi + Clone,

§

impl<T> MaybeDebug for T
where T: Debug,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> TraceExt for T
where T: LoadTransaction + LoadBlock + Trace + Call,

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