Struct HashStorageProbe 

pub struct HashStorageProbe { /* private fields */ }

A revm::Inspector that records KECCAK256 preimages and every SLOAD (slot + loaded value), so accesses can reconstruct the mapping layout of hashed reads and slots_returning can find the slot that drove a getter’s return value (hashed or plain).

Attach it through EvmCache::call_raw_with_inspector or EvmOverlay::call_raw_with_inspector, and it composes with other inspectors via InspectorStack so discovery can piggyback on a simulation you are already running.

use evm_fork_cache::mapping_probe::HashStorageProbe;
let probe = HashStorageProbe::new();
assert!(probe.accesses(&[]).is_empty()); // nothing executed yet

Implementations

impl HashStorageProbe

pub fn new() -> Self

Create an empty probe.

pub fn preimage_count(&self) -> usize

Number of distinct KECCAK256 preimages observed.

pub fn hashed_read_count(&self) -> usize

Number of hash-derived SLOADs observed (a subset of all reads).

pub fn slots_returning(&self, value: U256) -> Vec<B256>

Storage slots whose loaded value equalled value, deduplicated in observation order.

This is the building block for mocking a getter’s return: the slot a view call read that equals what it returned is (almost always) the slot that drives the return. Includes plain (non-hashed) slots, so it covers totalSupply-style variables as well as mapping entries.

pub fn accesses(&self, known: &[B256]) -> Vec<HashSlotAccess>

Resolve every hash-derived SLOAD into a HashSlotAccess.

known are words (e.g. addresses via Address::into_word) the caller wants matched as mapping keys; pass &[] to rely purely on the significant-byte magnitude heuristic. Results are in observation order.

Disambiguation

• 64-byte preimage X ‖ Y — a mapping entry. If one half is itself a recorded hash it is the parent location (nested mapping) and the other is the key; recurse. Otherwise the key is the half matching a known word, else the half with more significant bytes (a 20-byte address dwarfs a small slot index); the remaining half is the base slot.
• 32-byte preimage — Solady-style addr ‖ seed (detected when the high 20 bytes match a known address) or a keccak(slot) array pointer.

Trait Implementations

impl Clone for HashStorageProbe

fn clone(&self) -> HashStorageProbe

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HashStorageProbe

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

Formats the value using the given formatter.

impl Default for HashStorageProbe

fn default() -> HashStorageProbe

Returns the “default value” for a type.

impl<CTX, INTR: InterpreterTypes> Inspector<CTX, INTR> for HashStorageProbe

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

Called on each step of the interpreter.

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

Called after step when the instruction has been executed.

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

Called before the interpreter is initialized.

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