ArbEthApi

arb_rpc::api

Struct ArbEthApi 

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

Arbitrum Eth API wrapping the standard reth EthApiInner.

This wrapper overrides gas estimation to add L1 posting costs.

Implementations§

Source§

impl<N: RpcNodeCore, Rpc: RpcConvert> ArbEthApi<N, Rpc>

Source

pub fn new(inner: EthApiInner<N, Rpc>) -> Self

Create a new ArbEthApi wrapping the given inner.

Trait Implementations§

Source§

impl<N, Rpc> Call for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, Evm = N::Evm>,

Source§

fn call_gas_limit(&self) -> u64

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

fn max_simulate_blocks(&self) -> u64

Returns the maximum number of blocks accepted for eth_simulateV1.
Source§

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, Box<dyn StateProvider + Send>) -> 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 = EvmDatabaseError<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 = EvmDatabaseError<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]. Read more
§

fn spawn_with_state_at_block<F, R>( &self, at: impl Into<BlockId>, f: F, ) -> impl Future<Output = Result<R, Self::Error>> + Send
where F: FnOnce(Self, State<StateProviderDatabase<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(&mut State<StateProviderDatabase<StateProviderTraitObjWrapper>>, 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 = EvmDatabaseError<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
Source§

impl<N: RpcNodeCore, Rpc: RpcConvert> Clone for ArbEthApi<N, Rpc>

Source§

fn clone(&self) -> Self

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

impl<N: RpcNodeCore, Rpc: RpcConvert> Debug for ArbEthApi<N, Rpc>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<N, Rpc> EstimateCall for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, Evm = N::Evm>,

§

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

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 = EvmDatabaseError<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
Source§

impl<N, Rpc> EthApiSpec for ArbEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,

Source§

fn starting_block(&self) -> U256

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

impl<N, Rpc> EthApiTypes for ArbEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Error = EthApiError>,

Source§

type Error = EthApiError

Extension of [FromEthApiError], with network specific errors.
Source§

type NetworkTypes = <Rpc as RpcConvert>::Network

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

type RpcConvert = Rpc

Conversion methods for transaction RPC type.
Source§

fn converter(&self) -> &Self::RpcConvert

Returns reference to transaction response builder.
Source§

impl<N, Rpc> EthBlocks for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,

§

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

Returns the block header for the given block id.
§

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

Returns the populated rpc block object for the given block id. 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
Source§

impl<N, Rpc> EthCall for ArbEthApi<N, Rpc>
where N: RpcNodeCore<Provider: StateProviderFactory + BlockReaderIdExt + Clone, Primitives = ArbPrimitives>, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, Evm = N::Evm>, RpcTxReq<<Rpc as RpcConvert>::Network>: AsRef<TransactionRequest> + AsMut<TransactionRequest> + Clone + Default + From<TransactionRequest>,

Source§

fn estimate_gas_at( &self, request: RpcTxReq<<Self::RpcConvert as RpcConvert>::Network>, at: BlockId, state_override: Option<StateOverride>, ) -> impl Future<Output = Result<U256, Self::Error>> + Send

Override gas estimation to add L1 posting costs.

Also intercepts estimateRetryableTicket calls to the NodeInterface (0xc8): client calls eth_estimateGas({to:0xc8, data: estimateRetryableTicket(...)}) and expects back the gas for the retryable submission. We parse the ABI args, build an equivalent transaction request targeting the retry_to with retry_value + retry_data, run the standard estimation on that, and add the submit-retryable overhead.

Source§

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

Intercept eth_call to the NodeInterface (0xc8) virtual contract for methods that need chain history or nested EVM calls. Methods that can be resolved at the precompile layer (with zero / empty fallbacks) are delegated to the default EVM path.

§

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_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].
Source§

impl<N, Rpc> EthFees for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,

Source§

fn gas_price(&self) -> impl Future<Output = Result<U256, Self::Error>> + Send
where Self: LoadBlock,

eth_gasPrice returns just the latest base fee — there is no priority-fee market on this chain.

Source§

fn suggested_priority_fee( &self, ) -> impl Future<Output = Result<U256, Self::Error>> + Send
where Self: 'static,

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

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

impl<N, Rpc> EthState for ArbEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>, Self: LoadPendingBlock,

Source§

fn max_proof_window(&self) -> u64

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

fn ensure_within_proof_window( &self, block_id: BlockId, ) -> Result<(), Self::Error>
where Self: EthApiSpec,

Validates that the given block is within the configured proof window. Read more
§

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 storage_values( &self, requests: HashMap<Address, Vec<JsonStorageKey>>, block_id: Option<BlockId>, ) -> impl Future<Output = Result<HashMap<Address, Vec<FixedBytes<32>>>, Self::Error>> + Send

Returns values from multiple storage positions across multiple addresses. Read more
§

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
where Self: EthApiSpec,

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

impl<N, Rpc> EthTransactions for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,

Source§

fn signers( &self, ) -> &RwLock<Vec<Box<dyn EthSigner<<Self::Provider as TransactionsProvider>::Transaction, RpcTxReq<Self::NetworkTypes>>>>>

Returns a handle for signing data. Read more
Source§

fn send_raw_transaction_sync_timeout(&self) -> Duration

Returns the timeout duration for send_raw_transaction_sync RPC method.
Source§

async fn send_transaction( &self, origin: TransactionOrigin, tx: WithEncoded<Recovered<PoolPooledTx<Self::Pool>>>, ) -> Result<B256, Self::Error>

Submits the transaction to the pool with the given [TransactionOrigin].
§

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

Returns a list of addresses owned by provider.
§

fn send_raw_transaction( &self, tx: Bytes, ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send

Decodes and recovers the transaction and submits it to the pool. Read more
§

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

Decodes and recovers the transaction and submits it to the pool. Read more
§

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 transaction_receipt( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::Receipt>, Self::Error>> + Send
where Self: LoadReceipt + 'static,

Returns the transaction receipt for the given hash. Read more
§

fn load_transaction_and_receipt( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<(Recovered<<Self::Provider as TransactionsProvider>::Transaction>, TransactionMeta, <Self::Provider as ReceiptProvider>::Receipt, Option<Arc<Vec<<Self::Provider as ReceiptProvider>::Receipt>>>)>, Self::Error>> + Send
where Self: 'static,

Helper method that loads a transaction and its receipt. Read more
§

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_request( &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<FillTransaction<<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.
Source§

impl<N, Rpc> GetBlockAccessList for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, Evm = N::Evm>,

Source§

async fn get_block_access_list( &self, _block_id: BlockId, ) -> Result<Option<BlockAccessList>, Self::Error>

eth_getBlockAccessList* is unsupported on Arbitrum for now.

reth’s default implementation reconstructs the access list by replaying the block over a State whose BAL recorder is fed only through DatabaseCommit::commit. The Arbitrum executor applies mints, burns, nonce bumps, and fee distribution by writing state.cache.accounts directly, so those balance changes bypass the recorder and the default would return an access list silently missing them for every block. Return an explicit error instead of incomplete data until the executor feeds the BAL builder.

Source§

impl<N, Rpc> LoadBlock for ArbEthApi<N, Rpc>
where Self: LoadPendingBlock, N: RpcNodeCore, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,

§

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

Returns the block object for the given block id.
Source§

impl<N, Rpc> LoadFee for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,

Source§

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

Returns a handle for reading gas price. Read more
Source§

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

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

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

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)
Source§

impl<N, Rpc> LoadPendingBlock for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,

Source§

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

Returns a handle to the pending block. Read more
Source§

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

Returns a [PendingEnvBuilder] for the pending block.
Source§

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 local_pending_state( &self, ) -> impl Future<Output = Result<Option<Box<dyn StateProvider + Send>>, Self::Error>> + Send
where Self: SpawnBlocking,

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

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

Returns a mem-pool built pending block.
§

fn build_pool_pending_block( &self, parent: SealedHeader<<Self::Provider as HeaderProvider>::Header>, 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>, ) -> impl Future<Output = Result<Option<PendingBlock<Self::Primitives>>, Self::Error>> + Send
where Self: SpawnBlocking,

Builds or returns a cached pending block from the transaction pool. Read more
§

fn local_pending_block( &self, ) -> impl Future<Output = Result<Option<BlockAndReceipts<Self::Primitives>>, Self::Error>> + Send
where Self: SpawnBlocking, Self::Pool: TransactionPool, <Self::Pool as TransactionPool>::Transaction: PoolTransaction<Consensus = <Self::Provider as TransactionsProvider>::Transaction>,

Returns the locally built pending block
§

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

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

impl<N, Rpc> LoadReceipt for ArbEthApi<N, Rpc>
where N: RpcNodeCore<Primitives = ArbPrimitives>, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>, Self::Error: FromEthApiError,

Source§

fn build_transaction_receipt( &self, tx: Recovered<ProviderTx<Self::Provider>>, meta: TransactionMeta, receipt: ProviderReceipt<Self::Provider>, all_receipts: Option<Arc<Vec<ProviderReceipt<Self::Provider>>>>, ) -> impl Future<Output = Result<RpcReceipt<Self::NetworkTypes>, Self::Error>> + Send

Override to use convert_receipts_with_block so every single-tx receipt fetch (e.g. eth_getTransactionReceipt) includes the Arbitrum l1BlockNumber field sourced from the block’s mix_hash.

Reth’s default impl uses convert_receipts (no-block path), which our ArbReceiptConverter populates with l1_block_number = None. That breaks Arbitrum spec (bridges, indexers, explorers all expect l1BlockNumber on every receipt).

Source§

impl<N, Rpc> LoadState for ArbEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Primitives = N::Primitives>, Self: LoadPendingBlock,

§

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

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

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

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

fn evm_env_for_header( &self, header: &SealedHeader<<Self::Primitives as NodePrimitives>::BlockHeader>, ) -> 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::Error>

Returns the revm evm env for the given sealed header.
§

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

impl<N, Rpc> LoadTransaction for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,

§

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

Returns the transaction by hash. 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
Source§

impl<N, Rpc> RpcNodeCore for ArbEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert,

Source§

type Primitives = <N as RpcNodeCore>::Primitives

Blockchain data primitives.
Source§

type Provider = <N as RpcNodeCore>::Provider

The provider type used to interact with the node.
Source§

type Pool = <N as RpcNodeCore>::Pool

The transaction pool of the node.
Source§

type Evm = <N as RpcNodeCore>::Evm

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

type Network = <N as RpcNodeCore>::Network

Network API.
Source§

fn pool(&self) -> &Self::Pool

Returns the transaction pool of the node.
Source§

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

Returns the node’s evm config.
Source§

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

Returns the handle to the network
Source§

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

Returns the provider of the node.
Source§

impl<N, Rpc> RpcNodeCoreExt for ArbEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert,

Source§

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

Returns handle to RPC cache service.
Source§

impl<N, Rpc> SpawnBlocking for ArbEthApi<N, Rpc>
where N: RpcNodeCore, Rpc: RpcConvert<Error = EthApiError>,

Source§

fn io_task_spawner(&self) -> &Runtime

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

fn tracing_task_pool(&self) -> &BlockingTaskPool

Returns a handle for spawning CPU heavy blocking tasks, such as tracing requests. Read more
Source§

fn tracing_task_guard(&self) -> &BlockingTaskGuard

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

fn blocking_io_task_guard(&self) -> &Arc<Semaphore>

Returns handle to semaphore for blocking IO tasks. Read more
§

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

Acquires a permit from the tracing task semaphore. Read more
§

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

Acquires multiple permits from the tracing task semaphore. Read more
§

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

Acquires a permit from the blocking IO request semaphore. Read more
§

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

Acquires multiple permits from the blocking IO request semaphore. Read more
§

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

Acquires permits from the blocking IO request semaphore based on a calculated weight. Read more
§

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

impl<N, Rpc> Trace for ArbEthApi<N, Rpc>
where N: RpcNodeCore, EthApiError: FromEvmError<N::Evm>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, Evm = N::Evm>,

§

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 = EvmDatabaseError<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 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 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: LoadTransaction, 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: LoadTransaction, 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> InspectorFor<Self::Evm, &'a mut State<StateProviderDatabase<StateProviderTraitObjWrapper>>> + 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<&mut State<StateProviderDatabase<StateProviderTraitObjWrapper>>, 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<&mut State<StateProviderDatabase<StateProviderTraitObjWrapper>>, Insp>>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: Clone + for<'a> InspectorFor<Self::Evm, &'a mut State<StateProviderDatabase<StateProviderTraitObjWrapper>>>, 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<&mut State<StateProviderDatabase<StateProviderTraitObjWrapper>>, 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<&mut State<StateProviderDatabase<StateProviderTraitObjWrapper>>, Insp>>) -> Result<R, Self::Error> + Send + 'static, Setup: FnMut() -> Insp + Send + 'static, Insp: Clone + for<'a> InspectorFor<Self::Evm, &'a mut State<StateProviderDatabase<StateProviderTraitObjWrapper>>>, 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( &self, block: &RecoveredBlock<<Self::Provider as BlockReader>::Block>, db: &mut State<StateProviderDatabase<StateProviderTraitObjWrapper>>, ) -> Result<(), Self::Error>

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

Auto Trait Implementations§

§

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

§

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

§

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

§

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

§

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

§

impl<N, Rpc> !UnwindSafe for ArbEthApi<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
§

impl<T> ArchivePointee for T

§

type ArchivedMetadata = ()

The archived version of the pointer metadata for this type.
§

fn pointer_metadata( _: &<T as ArchivePointee>::ArchivedMetadata, ) -> <T as Pointee>::Metadata

Converts some archived metadata to the pointer metadata for itself.
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)
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
§

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

§

fn debug_bytes(self) -> Vec<u8> ⓘ

§

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

§

fn debug_color(&self, color: &str) -> String

§

fn debug_blue(&self) -> String

§

fn debug_dim(&self) -> String

§

fn debug_clear(&self) -> String

§

fn debug_grey(&self) -> String

§

fn debug_mint(&self) -> String

§

fn debug_pink(&self) -> String

§

fn debug_red(&self) -> String

§

fn debug_white(&self) -> String

§

fn debug_yellow(&self) -> String

§

fn debug_orange(&self) -> String

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> LayoutRaw for T

§

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

Returns the layout of the type.
§

impl<T, N1, N2> Niching<NichedOption<T, N1>> for N2
where T: SharedNiching<N1, N2>, N1: Niching<T>, N2: Niching<T>,

§

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

Returns whether the given value has been niched. Read more
§

fn resolve_niched(out: Place<NichedOption<T, N1>>)

Writes data to out indicating that a T is niched.
§

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> Pointee for T

§

type Metadata = ()

The metadata type for pointers and references to this type.
§

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<T> Upcastable for T
where T: Any + Send + Sync + 'static,

§

fn upcast_any_ref(&self) -> &(dyn Any + 'static)

upcast ref
§

fn upcast_any_mut(&mut self) -> &mut (dyn Any + 'static)

upcast mut ref
§

fn upcast_any_box(self: Box<T>) -> Box<dyn Any>

upcast boxed dyn
§

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

§

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> MaybeSend for T
where T: Send,

§

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