Struct StepTable 

pub struct StepTable { /* private fields */ }

The steps of a trace, in columns. See the module docs.

Implementations

impl StepTable

pub fn new() -> Self

pub fn with_capacity(steps: usize) -> Self

An empty table that holds steps steps without allocating its columns again.

pub fn try_from_steps( steps: impl IntoIterator<Item = TraceStep>, ) -> Result<Self, StepError>

A table of steps, in order.

Errors

As StepTable::try_push.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn get(&self, index: usize) -> Option<StepView<'_>>

pub fn step(&self, index: usize) -> StepView<'_>

The step at index.

Panics

When index is not below StepTable::len, as indexing a slice does.

pub fn first(&self) -> Option<StepView<'_>>

pub fn last(&self) -> Option<StepView<'_>>

pub fn iter(&self) -> Steps<'_>

pub fn push(&mut self, step: TraceStep)

Appends a step built the way every backend builds one, sharing what did not change since the step before: its stack words, memory, storage and return data.

Panics

When a stack word is not hex. A producer reading words from untrusted input, a node or a file, appends with StepTable::try_push instead.

pub fn try_push(&mut self, step: TraceStep) -> Result<(), StepError>

StepTable::push for a step whose stack words may not be hex.

Errors

Returns a StepError when a stack word is not hex. Nothing is appended then.

pub fn append( &mut self, record: StepRecord, stack: impl IntoIterator<Item = EvmWord>, )

Appends a step whose whole stack is stack, bottom first. The words the previous step’s stack starts with are kept rather than stored again.

pub fn append_kept( &mut self, record: StepRecord, kept: usize, words: impl IntoIterator<Item = EvmWord>, )

Appends a step whose stack is the bottom kept words of the previous step’s with words on top, for a producer that knows how much of the stack an instruction left alone and so never copies the rest.

Panics

When kept is more than the previous step’s stack holds.

pub fn start_memory_frame(&mut self)

Starts recording the memory of a new frame, empty, as a call or a creation starts one: the steps appended from now on have it, as written with StepTable::write_memory.

pub fn end_memory_frame(&mut self)

Stops recording the innermost frame’s memory, as its call returns; the steps appended from now on have its caller’s again.

pub fn write_memory( &mut self, offset: u64, data: &[u8], size: u64, ) -> Result<(), MemoryWriteError>

Records that the step appended last wrote data at offset of its frame’s memory, which is size bytes long afterwards; a write without data records memory growing. The steps appended after it see the write: a step’s memory is the memory it starts with.

Errors

Returns a MemoryWriteError when the write ends past size or size is smaller than the memory was. Nothing is recorded then.

pub fn storage_diffs( &self, ) -> impl DoubleEndedIterator<Item = (usize, &BTreeMap<String, StorageChange>)>

The steps that changed storage, with the slots they changed, in order.

pub fn transient_storage( &self, ) -> impl DoubleEndedIterator<Item = (usize, &BTreeMap<String, String>)>

The steps that read or wrote transient storage, with the slots, in order.

pub fn truncate(&mut self, len: usize)

Drops the steps from len on. What was recorded of their memory stays, unused.

pub fn to_steps(&self) -> Vec<TraceStep>

Every step as a TraceStep of its own.

Trait Implementations

impl Clone for StepTable

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 StepTable

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

Formats the value using the given formatter.

impl Default for StepTable

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StepTable

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

Reads steps as written by any version, appending each as it is read so that a file’s steps are never all resident as TraceSteps.

impl Eq for StepTable

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 From<Vec<TraceStep>> for StepTable

fn from(steps: Vec<TraceStep>) -> Self

Panics

As StepTable::push.

impl FromIterator<TraceStep> for StepTable

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

Panics

As StepTable::push.

impl<'a> IntoIterator for &'a StepTable

type Item = StepView<'a>

The type of the elements being iterated over.

type IntoIter = Steps<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for StepTable

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for StepTable

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

Serialize this value into the given Serde serializer.