Struct RevertDiagnostic

pub struct RevertDiagnostic {
    pub non_contract_call: Option<(Address, CallScheme, usize)>,
    pub non_contract_size_check: Option<(Address, usize)>,
    pub is_extcodesize_step: bool,
}

An inspector that tracks call context to enhances revert diagnostics. Useful for understanding reverts that are not linked to custom errors or revert strings.

Supported diagnostics:

1. Non-void call to non-contract address: the soldity compiler adds some validation to the return data of the call, so despite the call succeeds, as doesn’t return data, the validation causes a revert.

   Identified when: a call with non-empty calldata is made to an address without bytecode, followed by an empty revert at the same depth.

2. Void call to non-contract address: in this case the solidity compiler adds some checks before doing the call, so it never takes place.

   Identified when: extcodesize for the target address returns 0 + empty revert at the same depth.

Fields

non_contract_call: Option<(Address, CallScheme, usize)>

Tracks calls with calldata that target an address without executable code.

non_contract_size_check: Option<(Address, usize)>

Tracks EXTCODESIZE checks that target an address without executable code.

is_extcodesize_step: bool

Whether the step opcode is EXTCODESIZE or not.

Implementations

impl RevertDiagnostic

fn code_target_address(&self, inputs: &mut CallInputs) -> Address

Returns the effective target address whose code would be executed. For delegate calls, this is the bytecode_address. Otherwise, it’s the target_address.

fn reason(&self) -> Option<DetailedRevertReason>

Derives the revert reason based on the cached data. Should only be called after a revert.

fn broadcast_diagnostic(&self, interp: &mut Interpreter)

Injects the revert diagnostic into the debug traces. Should only be called after a revert.

fn handle_revert<CTX, D>(&mut self, interp: &mut Interpreter, ctx: &mut CTX)

where D: Database<Error = DatabaseError>, CTX: ContextTr<Db = D>, CTX::Journal: JournalExt,

When a REVERT opcode with zero data size occurs:

• if non_contract_call was set at the current depth, broadcast_diagnostic is called. Otherwise, it is cleared.
• if non_contract_size_check was set at the current depth, broadcast_diagnostic is called. Otherwise, it is cleared.

fn handle_extcodesize<CTX, D>( &mut self, interp: &mut Interpreter, ctx: &mut CTX, )

where D: Database<Error = DatabaseError>, CTX: ContextTr<Db = D>, CTX::Journal: JournalExt,

When an EXTCODESIZE opcode occurs:

• Optimistically caches the target address and current depth in non_contract_size_check, pending later validation.

fn handle_extcodesize_output(&mut self, interp: &mut Interpreter)

Tracks EXTCODESIZE output. If the bytecode size is NOT 0, clears the cache.

Trait Implementations

impl Clone for RevertDiagnostic

fn clone(&self) -> RevertDiagnostic

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RevertDiagnostic

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

Formats the value using the given formatter.

impl Default for RevertDiagnostic

fn default() -> RevertDiagnostic

Returns the “default value” for a type.

impl<CTX, D> Inspector<CTX> for RevertDiagnostic

where D: Database<Error = DatabaseError>, CTX: ContextTr<Db = D>, CTX::Journal: JournalExt,

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

Tracks the first call with non-zero calldata that targets a non-contract address. Excludes precompiles and test addresses.

fn step(&mut self, interp: &mut Interpreter, ctx: &mut CTX)

Handles REVERT and EXTCODESIZE opcodes for diagnostics.

fn step_end(&mut self, interp: &mut Interpreter, _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, interp: &mut Interpreter<INTR>, context: &mut CTX, log: Log)

Called when a log is emitted.

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 eofcreate( &mut self, context: &mut CTX, inputs: &mut EOFCreateInputs, ) -> Option<CreateOutcome>

Called when EOF creating is called.

fn eofcreate_end( &mut self, context: &mut CTX, inputs: &EOFCreateInputs, outcome: &mut CreateOutcome, )

Called when eof creating has ended.

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.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 80 bytes