Struct InspectorStack 

pub struct InspectorStack<A, B>(pub A, pub B);

Runs two Inspectors over the same execution.

Every Inspector hook is fanned out to both inner inspectors (.0 first, then .1) so each captures its own result independently in a single pass. The canonical use is pairing a CallTracer with a TransferInspector to obtain both a call-frame trace and the ERC-20 transfers from one simulation:

let mut overlay = EvmOverlay::new(snapshot, None);
let (_result, stack) = overlay.call_raw_with_inspector(
    from,
    to,
    Bytes::new(),
    &TxConfig::default(),
    InspectorStack(CallTracer::new(), TransferInspector::new()),
    false,
)?;
let InspectorStack(tracer, transfer) = stack;
let _trace = tracer.into_trace();
let _transfers = transfer.transfers;

For the call/create hooks — which return Option<…Outcome> to optionally override the result — the first inspector that returns Some wins and the second’s hook is not called, mirroring revm’s own composition of inspector tuples. The observe-only inspectors here (CallTracer, TransferInspector) always return None, so both always observe.

Tuple Fields

0: A

1: B

Trait Implementations

impl<A: Clone, B: Clone> Clone for InspectorStack<A, B>

fn clone(&self) -> InspectorStack<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for InspectorStack<A, B>

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

Formats the value using the given formatter.

impl<A: Default, B: Default> Default for InspectorStack<A, B>

fn default() -> InspectorStack<A, B>

Returns the “default value” for a type.

impl<A, B, CTX, INTR> Inspector<CTX, INTR> for InspectorStack<A, B>

where INTR: InterpreterTypes, A: Inspector<CTX, INTR>, B: Inspector<CTX, INTR>,

fn initialize_interp( &mut self, interp: &mut Interpreter<INTR>, context: &mut CTX, )

Called before the interpreter is initialized.

fn step(&mut self, interp: &mut Interpreter<INTR>, context: &mut CTX)

Called on each step of the interpreter.

fn step_end(&mut self, interp: &mut Interpreter<INTR>, context: &mut CTX)

Called after step when the instruction has been executed.

fn log(&mut self, context: &mut CTX, log: Log)

Called when a log is emitted, called on every new log. If there is a needs for Interpreter context, use Inspector::log_full instead.

fn log_full( &mut self, interp: &mut Interpreter<INTR>, context: &mut CTX, log: Log, )

Called when a log is emitted with the interpreter context.

fn call( &mut self, context: &mut CTX, inputs: &mut CallInputs, ) -> Option<CallOutcome>

Called whenever a call to a contract is about to start.

fn call_end( &mut self, context: &mut CTX, inputs: &CallInputs, outcome: &mut CallOutcome, )

Called when a call to a contract has concluded.

fn create( &mut self, context: &mut CTX, inputs: &mut CreateInputs, ) -> Option<CreateOutcome>

Called when a contract is about to be created.

fn create_end( &mut self, context: &mut CTX, inputs: &CreateInputs, outcome: &mut CreateOutcome, )

Called when a contract has been created.

fn selfdestruct(&mut self, contract: Address, target: Address, value: U256)

Called when a contract has been self-destructed with funds transferred to target.