Trait reth_node_core::rpc::eth::helpers::Trace
pub trait Trace: LoadState {
// Required method
fn evm_config(&self) -> &impl ConfigureEvm;
// Provided methods
fn inspect<DB, I>(
&self,
db: DB,
env: EnvWithHandlerCfg,
inspector: I,
) -> Result<(ResultAndState, EnvWithHandlerCfg), Self::Error>
where DB: Database,
EthApiError: From<<DB as Database>::Error>,
I: GetInspector<DB> { ... }
fn inspect_and_return_db<DB, I>(
&self,
db: DB,
env: EnvWithHandlerCfg,
inspector: I,
) -> Result<(ResultAndState, EnvWithHandlerCfg, DB), Self::Error>
where DB: Database,
EthApiError: From<<DB as Database>::Error>,
I: GetInspector<DB> { ... }
fn trace_at<F, R>(
&self,
env: EnvWithHandlerCfg,
config: TracingInspectorConfig,
at: BlockId,
f: F,
) -> Result<R, Self::Error>
where Self: Call,
F: FnOnce(TracingInspector, ResultAndState) -> Result<R, Self::Error> { ... }
fn spawn_trace_at_with_state<F, R>(
&self,
env: EnvWithHandlerCfg,
config: TracingInspectorConfig,
at: BlockId,
f: F,
) -> impl Future<Output = Result<R, Self::Error>> + Send
where Self: LoadPendingBlock + Call,
F: FnOnce(TracingInspector, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
R: Send + 'static { ... }
fn spawn_trace_transaction_in_block<F, R>(
&self,
hash: FixedBytes<32>,
config: TracingInspectorConfig,
f: F,
) -> impl Future<Output = Result<Option<R>, Self::Error>> + Send
where Self: LoadPendingBlock + LoadTransaction + Call,
F: FnOnce(TransactionInfo, TracingInspector, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
R: Send + 'static { ... }
fn spawn_trace_transaction_in_block_with_inspector<Insp, F, R>(
&self,
hash: FixedBytes<32>,
inspector: Insp,
f: F,
) -> impl Future<Output = Result<Option<R>, Self::Error>> + Send
where Self: LoadPendingBlock + LoadTransaction + Call,
F: FnOnce(TransactionInfo, Insp, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static,
R: Send + 'static { ... }
fn trace_block_until<F, R>(
&self,
block_id: BlockId,
highest_index: Option<u64>,
config: TracingInspectorConfig,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
where Self: LoadBlock,
F: Fn(TransactionInfo, TracingInspector, ExecutionResult, &HashMap<Address, Account>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
R: Send + 'static { ... }
fn trace_block_until_with_inspector<Setup, Insp, F, R>(
&self,
block_id: BlockId,
highest_index: Option<u64>,
inspector_setup: Setup,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
where Self: LoadBlock,
F: Fn(TransactionInfo, Insp, ExecutionResult, &HashMap<Address, Account>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
Setup: FnMut() -> Insp + Send + 'static,
Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static,
R: Send + 'static { ... }
fn trace_block_with<F, R>(
&self,
block_id: BlockId,
config: TracingInspectorConfig,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
where Self: LoadBlock,
F: Fn(TransactionInfo, TracingInspector, ExecutionResult, &HashMap<Address, Account>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
R: Send + 'static { ... }
fn trace_block_inspector<Setup, Insp, F, R>(
&self,
block_id: BlockId,
insp_setup: Setup,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
where Self: LoadBlock,
F: Fn(TransactionInfo, Insp, ExecutionResult, &HashMap<Address, Account>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
Setup: FnMut() -> Insp + Send + 'static,
Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static,
R: Send + 'static { ... }
}
Expand description
Executes CPU heavy tasks.
Required Methods§
fn evm_config(&self) -> &impl ConfigureEvm
fn evm_config(&self) -> &impl ConfigureEvm
Returns a handle for reading evm config.
Data access in default (L1) trait method implementations.
Provided Methods§
fn inspect<DB, I>(
&self,
db: DB,
env: EnvWithHandlerCfg,
inspector: I,
) -> Result<(ResultAndState, EnvWithHandlerCfg), Self::Error>
fn inspect<DB, I>( &self, db: DB, env: EnvWithHandlerCfg, inspector: I, ) -> Result<(ResultAndState, EnvWithHandlerCfg), Self::Error>
Executes the EnvWithHandlerCfg
against the given Database without committing state
changes.
fn inspect_and_return_db<DB, I>(
&self,
db: DB,
env: EnvWithHandlerCfg,
inspector: I,
) -> Result<(ResultAndState, EnvWithHandlerCfg, DB), Self::Error>
fn inspect_and_return_db<DB, I>( &self, db: DB, env: EnvWithHandlerCfg, inspector: I, ) -> Result<(ResultAndState, EnvWithHandlerCfg, DB), Self::Error>
fn trace_at<F, R>(
&self,
env: EnvWithHandlerCfg,
config: TracingInspectorConfig,
at: BlockId,
f: F,
) -> Result<R, Self::Error>
fn trace_at<F, R>( &self, env: EnvWithHandlerCfg, config: TracingInspectorConfig, at: BlockId, f: F, ) -> Result<R, Self::Error>
Executes the transaction on top of the given BlockId
with a tracer configured by the
config.
The callback is then called with the [TracingInspector
] and the ResultAndState
after
the configured EnvWithHandlerCfg
was inspected.
Caution: this is blocking
fn spawn_trace_at_with_state<F, R>(
&self,
env: EnvWithHandlerCfg,
config: TracingInspectorConfig,
at: BlockId,
f: F,
) -> impl Future<Output = Result<R, Self::Error>> + Sendwhere
Self: LoadPendingBlock + Call,
F: FnOnce(TracingInspector, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
R: Send + 'static,
fn spawn_trace_at_with_state<F, R>(
&self,
env: EnvWithHandlerCfg,
config: TracingInspectorConfig,
at: BlockId,
f: F,
) -> impl Future<Output = Result<R, Self::Error>> + Sendwhere
Self: LoadPendingBlock + Call,
F: FnOnce(TracingInspector, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
R: Send + 'static,
Same as trace_at
but also provides the used database to the callback.
Executes the transaction on top of the given BlockId
with a tracer configured by the
config.
The callback is then called with the [TracingInspector
] and the ResultAndState
after
the configured EnvWithHandlerCfg
was inspected.
fn spawn_trace_transaction_in_block<F, R>(
&self,
hash: FixedBytes<32>,
config: TracingInspectorConfig,
f: F,
) -> impl Future<Output = Result<Option<R>, Self::Error>> + Sendwhere
Self: LoadPendingBlock + LoadTransaction + Call,
F: FnOnce(TransactionInfo, TracingInspector, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
R: Send + 'static,
fn spawn_trace_transaction_in_block<F, R>(
&self,
hash: FixedBytes<32>,
config: TracingInspectorConfig,
f: F,
) -> impl Future<Output = Result<Option<R>, Self::Error>> + Sendwhere
Self: LoadPendingBlock + LoadTransaction + Call,
F: FnOnce(TransactionInfo, TracingInspector, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
R: Send + 'static,
Retrieves the transaction if it exists and returns its trace.
Before the transaction is traced, all previous transaction in the block are applied to the
state by executing them first.
The callback f
is invoked with the ResultAndState
after the transaction was executed
and the database that points to the beginning of the transaction.
Note: Implementers should use a threadpool where blocking is allowed, such as
BlockingTaskPool
.
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>> + Sendwhere
Self: LoadPendingBlock + LoadTransaction + Call,
F: FnOnce(TransactionInfo, Insp, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static,
R: Send + 'static,
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>> + Sendwhere
Self: LoadPendingBlock + LoadTransaction + Call,
F: FnOnce(TransactionInfo, Insp, ResultAndState, CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static,
R: Send + 'static,
Retrieves the transaction if it exists and returns its trace.
Before the transaction is traced, all previous transaction in the block are applied to the
state by executing them first.
The callback f
is invoked with the ResultAndState
after the transaction was executed
and the database that points to the beginning of the transaction.
Note: Implementers should use a threadpool where blocking is allowed, such as
BlockingTaskPool
.
fn trace_block_until<F, R>(
&self,
block_id: BlockId,
highest_index: Option<u64>,
config: TracingInspectorConfig,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
fn trace_block_until<F, R>( &self, block_id: BlockId, highest_index: Option<u64>, config: TracingInspectorConfig, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
Executes all transactions of a block up to a given index.
If a highest_index
is given, this will only execute the first highest_index
transactions, in other words, it will stop executing transactions after the
highest_index
th transaction. If highest_index
is None
, all transactions
are executed.
fn trace_block_until_with_inspector<Setup, Insp, F, R>(
&self,
block_id: BlockId,
highest_index: Option<u64>,
inspector_setup: Setup,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Sendwhere
Self: LoadBlock,
F: Fn(TransactionInfo, Insp, ExecutionResult, &HashMap<Address, Account>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
Setup: FnMut() -> Insp + Send + 'static,
Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static,
R: Send + 'static,
fn trace_block_until_with_inspector<Setup, Insp, F, R>(
&self,
block_id: BlockId,
highest_index: Option<u64>,
inspector_setup: Setup,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Sendwhere
Self: LoadBlock,
F: Fn(TransactionInfo, Insp, ExecutionResult, &HashMap<Address, Account>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
Setup: FnMut() -> Insp + Send + 'static,
Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static,
R: Send + 'static,
Executes all transactions of a block.
If a highest_index
is given, this will only execute the first highest_index
transactions, in other words, it will stop executing transactions after the
highest_index
th transaction.
Note: This expect tx index to be 0-indexed, so the first transaction is at index 0.
This accepts a inspector_setup
closure that returns the inspector to be used for tracing
the transactions.
fn trace_block_with<F, R>(
&self,
block_id: BlockId,
config: TracingInspectorConfig,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
fn trace_block_with<F, R>( &self, block_id: BlockId, config: TracingInspectorConfig, f: F, ) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Send
Executes all transactions of a block and returns a list of callback results invoked for each transaction in the block.
This
- fetches all transactions of the block
- configures the EVM evn
- loops over all transactions and executes them
- calls the callback with the transaction info, the execution result, the changed state
after the transaction [
StateProviderDatabase
] and the database that points to the state right before the transaction.
fn trace_block_inspector<Setup, Insp, F, R>(
&self,
block_id: BlockId,
insp_setup: Setup,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Sendwhere
Self: LoadBlock,
F: Fn(TransactionInfo, Insp, ExecutionResult, &HashMap<Address, Account>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
Setup: FnMut() -> Insp + Send + 'static,
Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static,
R: Send + 'static,
fn trace_block_inspector<Setup, Insp, F, R>(
&self,
block_id: BlockId,
insp_setup: Setup,
f: F,
) -> impl Future<Output = Result<Option<Vec<R>>, Self::Error>> + Sendwhere
Self: LoadBlock,
F: Fn(TransactionInfo, Insp, ExecutionResult, &HashMap<Address, Account>, &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>) -> Result<R, Self::Error> + Send + 'static,
Setup: FnMut() -> Insp + Send + 'static,
Insp: for<'a, 'b> Inspector<StateCacheDbRefMutWrapper<'a, 'b>> + Send + 'static,
R: Send + 'static,
Executes all transactions of a block and returns a list of callback results invoked for each transaction in the block.
This
- fetches all transactions of the block
- configures the EVM evn
- loops over all transactions and executes them
- calls the callback with the transaction info, the execution result, the changed state
after the transaction
EvmState
and the database that points to the state right before the transaction, in other words the state the transaction was executed on:changed_state = tx(cached_state)
This accepts a inspector_setup
closure that returns the inspector to be used for tracing
a transaction. This is invoked for each transaction.