Struct DebugRecorder 

pub struct DebugRecorder {
    sink: DebugStepSink,
    table: Option<StepTable>,
    first_step: usize,
    frames: Vec<RecordedFrame>,
    open: Vec<OpenFrame>,
    pending: Option<PendingStep>,
    converter: StepConverter,
}

Records every opcode step of the debugged calls into a [StepTable], with the steps that each call and creation spans.

The steps are the ones TracingInspector records in debug mode, converted as the SolDB frontend converts them, but without the per-step CallTraceStep and its full stack copy. The inspector stack calls this recorder next to the tracer, so its frames are the tracer’s nodes in the same order.

Fields

sink: DebugStepSink

table: Option<StepTable>

The sink’s table while this recorder appends to it.

first_step: usize

The first step this recorder appended.

frames: Vec<RecordedFrame>

The steps of each call trace node, by node index.

open: Vec<OpenFrame>

The frames that run now, innermost last.

pending: Option<PendingStep>

The step that started and did not end yet.

converter: StepConverter

Converts the return data and storage of the steps.

Implementations

impl DebugRecorder

pub fn new(sink: DebugStepSink) -> Self

A recorder that appends to sink.

pub fn finish(&mut self) -> DebugRecording

The steps this recorder appended, by call trace node.

fn table(&mut self) -> &mut StepTable

The table to append to, taken from the sink on first use.

fn enter(&mut self, depth: usize)

Opens a frame at journal depth depth, as the tracer opens a node.

fn exit(&mut self)

Closes the innermost frame.

fn start_step<CTX: ContextTr<Journal: JournalExt>>( &mut self, interp: &Interpreter, context: &CTX, )

Starts a step.

fn end_step<CTX: ContextTr<Journal: JournalExt>>( &mut self, interp: &mut Interpreter, context: &CTX, )

Ends the pending step after its instruction ran.

pub fn end_step_not_run(&mut self, interp: &Interpreter)

Ends the pending step if an inspector halted the frame before its instruction ran.

fn append( &mut self, step: PendingStep, kept: &[U256], status: Option<InstructionResult>, gas_cost: u64, loaded: Option<U256>, had_value: Option<U256>, )

Appends step, whose stack is kept and its inputs.

loaded is the value an SLOAD or TLOAD pushed, if the frame went on, and had_value the value an SSTORE overwrote, if the journal recorded it.

Trait Implementations

impl Clone for DebugRecorder

A clone records the next call into the same sink, from an empty state.

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DebugRecorder

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

Formats the value using the given formatter.

impl Default for DebugRecorder

fn default() -> Self

Returns the “default value” for a type.

impl Drop for DebugRecorder

Gives the table back to the sink.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<CTX: ContextTr<Journal: JournalExt>> Inspector<CTX> for DebugRecorder

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

Called on each step of the interpreter.

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

Called after step when the instruction has been executed.

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 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 frame_start(&mut self, context: &mut CTX, frame_input: &mut FI) -> Option<FR>

Called before call/create dispatch. Called with a mutable reference to the frame input, allowing mutations of the input before the variant-specific hooks (call/create) are called.

fn frame_end( &mut self, context: &mut CTX, frame_input: &FI, frame_result: &mut FR, )

Called after call_end()/create_end() variant-specific hooks complete.

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: 1256 bytes