Struct TransferInspector 

pub struct TransferInspector {
    pub transfers: Vec<TokenTransfer>,
    pub logs: Vec<Log>,
}

Inspector that captures ERC20 Transfer events during EVM execution.

Attach to a simulation and the Inspector::log hook records every emitted log; logs matching the ERC20 Transfer layout are additionally decoded into TokenTransfers. Reconstruct net balance changes afterward with balance_deltas or balance_deltas_for_tokens, and reuse the inspector across calls via clear.

Fields

transfers: Vec<TokenTransfer>

Token transfers decoded from captured logs.

logs: Vec<Log>

Every log emitted during execution, retained for debugging/analysis.

Implementations

impl TransferInspector

pub fn new() -> Self

Create an empty inspector with no captured transfers or logs.

use evm_fork_cache::inspector::TransferInspector;

let inspector = TransferInspector::new();
assert!(inspector.transfers.is_empty());
assert!(inspector.logs.is_empty());

pub fn balance_deltas(&self, owner: Address) -> HashMap<Address, I256>

Compute balance deltas for a specific owner from captured transfers

Returns a map of token address -> signed balance change Positive values indicate tokens received, negative indicates tokens sent

pub fn balance_deltas_for_tokens( &self, owner: Address, tokens: impl IntoIterator<Item = Address>, ) -> HashMap<Address, I256>

Like balance_deltas, but restricted to the given set of token addresses.

Tokens in tokens with no transfers touching owner are simply absent from the result; tokens not in tokens are excluded even if owner transacted in them.

let mut inspector = TransferInspector::new();
let token_a = Address::repeat_byte(0xAA);
let token_b = Address::repeat_byte(0xBB);
let owner = Address::repeat_byte(0x11);
let other = Address::repeat_byte(0x22);
inspector.transfers.push(TokenTransfer { token: token_a, from: owner, to: other, value: U256::from(100u64) });
inspector.transfers.push(TokenTransfer { token: token_b, from: other, to: owner, value: U256::from(50u64) });

let deltas = inspector.balance_deltas_for_tokens(owner, [token_a]);
assert_eq!(deltas.len(), 1);
assert_eq!(deltas.get(&token_a), Some(&(-I256::from_raw(U256::from(100u64)))));
assert!(!deltas.contains_key(&token_b));

pub fn clear(&mut self)

Drop all captured transfers and logs so the inspector can be reused across simulations.

pub fn parse_transfer(log: &Log) -> Option<TokenTransfer>

Parse a Transfer event from log topics and data

Trait Implementations

impl Clone for TransferInspector

fn clone(&self) -> TransferInspector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransferInspector

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

Formats the value using the given formatter.

impl Default for TransferInspector

fn default() -> TransferInspector

Returns the “default value” for a type.

impl<CTX, INTR> Inspector<CTX, INTR> for TransferInspector

where INTR: InterpreterTypes,

Captures every emitted log via the Inspector::log hook.

Each log is pushed to logs; logs whose first topic matches the ERC20 Transfer signature and that carry the standard ERC20 layout are additionally decoded into transfers. Logs that do not match (wrong signature, fewer than three topics, or fewer than 32 data bytes) are retained in logs but produce no transfer.

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

Records log and, if it parses as an ERC20 Transfer, the decoded transfer.

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_full( &mut self, interpreter: &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: Uint<256, 4>, )

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