Struct TraceStep 

pub struct TraceStep {
    pub pc: u64,
    pub op: Word,
    pub gas: u64,
    pub gas_cost: u64,
    pub depth: u64,
    pub stack: Vec<Word>,
    pub memory: Option<Bytes>,
    pub storage: Option<BTreeMap<String, String>>,
    pub error: Option<String>,
    pub snapshot: StepSnapshot,
}

One recorded EVM step, as a backend builds it.

A TransactionTrace holds its steps in a StepTable, which takes them with StepTable::push and gives each back as a StepView or, when ownership is needed, with StepView::to_trace_step.

The machine state lives in snapshot, once. The flat stack, memory, and storage fields are the layout older trace files and web clients read: every constructor in this workspace leaves them empty, serialization fills them from the snapshot so the wire format is unchanged, and deserialization moves whatever they hold into the snapshot. Read a step through TraceStep::snapshot_ref, which handles both shapes; never through the flat fields.

Consecutive steps share their memory and storage when nothing changed between them (see StepSnapshot), which is what keeps a trace of hundreds of thousands of steps resident: memory changes on a handful of opcodes and storage on SSTORE alone.

Fields

pc: u64

op: Word

The mnemonic, shared with every other step running the same opcode: there are a couple of hundred of them and hundreds of thousands of steps.

gas: u64

gas_cost: u64

The cost as the tracer reports it: for a call, its own cost plus the gas it forwards to the callee; for a creation, the same under REVM but without the forwarded gas under geth.

depth: u64

stack: Vec<Word>

Legacy layout; empty unless a caller filled it by hand. See the type docs.

memory: Option<Bytes>

Legacy layout; None unless a caller filled it by hand. See the type docs.

storage: Option<BTreeMap<String, String>>

Legacy layout; None unless a caller filled it by hand. See the type docs.

error: Option<String>

snapshot: StepSnapshot

Implementations

impl TraceStep

pub fn new( pc: u64, op: Word, gas: u64, gas_cost: u64, depth: u64, error: Option<String>, snapshot: StepSnapshot, ) -> Self

A step whose state lives in snapshot, the way every backend builds one.

pub fn snapshot_ref(&self) -> StepSnapshotRef<'_>

Borrows the machine state this step captured, without copying it.

Whichever shape the step is in, its snapshot or the legacy flat fields, this returns a view of it.

Prefer this over TraceStep::normalized_snapshot anywhere that walks a trace. Traces routinely run to hundreds of thousands of steps and each one’s memory can be tens of kilobytes, so copying per step — or, as variable decoding does, per variable per step — dominates the cost of reading a trace.

pub fn normalized_snapshot(&self) -> StepSnapshot

Copies the machine state this step captured into an owned StepSnapshot.

Use this only when ownership is genuinely required; TraceStep::snapshot_ref is the same view without the copy.

Trait Implementations

impl Clone for TraceStep

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 TraceStep

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TraceStep

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Eq for TraceStep

impl Extend<TraceStep> for StepTable

fn extend<I: IntoIterator<Item = TraceStep>>(&mut self, steps: I)

Panics

As StepTable::push.

fn extend_one(&mut self, item: T)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<TraceStep> for StepTable

fn from_iter<I: IntoIterator<Item = TraceStep>>(steps: I) -> Self

Panics

As StepTable::push.

impl PartialEq for TraceStep

fn eq(&self, other: &Self) -> bool

Two steps are equal when they record the same thing, whichever shape holds it.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for TraceStep

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Writes the step in the wire format every client reads: the flat fields and the snapshot, both from the one copy of the state.