Struct essential_check::state_read_vm::Vm

pub struct Vm {
    pub pc: usize,
    pub stack: Stack,
    pub temp_memory: Memory,
    pub repeat: Repeat,
    pub state_slots_mut: StateSlotsMut,
}

The operation execution state of the State Read VM.

Fields

pc: usize

The program counter, i.e. index of the current operation within the program.

stack: Stack

The stack machine.

temp_memory: Memory

The memory for temporary storage of words.

repeat: Repeat

The repeat stack.

state_slots_mut: StateSlotsMut

The state slots that will be written to by this program.

Implementations

impl Vm

pub async fn exec_ops<'a, S>( &mut self, ops: &[StateRead], access: Access<'a>, state_read: &S, op_gas_cost: &impl OpGasCost, gas_limit: GasLimit, ) -> Result<u64, StateReadError<<S as StateRead>::Error>>

where S: StateRead,

Execute the given operations from the current state of the VM.

Upon reaching a Halt operation or reaching the end of the operation sequence, returns the gas spent and the Vm will be left in the resulting state.

This is a wrapper around Vm::exec that expects operation access in the form of a &[Op].

If memory bloat is a concern, consider using the Vm::exec_bytecode or Vm::exec_bytecode_iter methods which allow for providing a more compact representation of the operations in the form of mapped bytecode.

pub async fn exec_bytecode<'a, S, B>( &mut self, bytecode_mapped: &BytecodeMapped<StateRead, B>, access: Access<'a>, state_read: &S, op_gas_cost: &impl OpGasCost, gas_limit: GasLimit, ) -> Result<u64, StateReadError<<S as StateRead>::Error>>

where S: StateRead, B: Deref<Target = [u8]>,

Execute the given mapped bytecode from the current state of the VM.

Upon reaching a Halt operation or reaching the end of the operation sequence, returns the gas spent and the Vm will be left in the resulting state.

This is a wrapper around Vm::exec that expects operation access in the form of &BytecodeMapped.

This can be a more memory efficient alternative to Vm::exec_ops due to the compact representation of operations in the form of bytecode and indices.

pub async fn exec_bytecode_iter<'a, S, I>( &mut self, bytecode_iter: I, access: Access<'a>, state_read: &S, op_gas_cost: &impl OpGasCost, gas_limit: GasLimit, ) -> Result<u64, StateReadError<<S as StateRead>::Error>>

where S: StateRead, I: IntoIterator<Item = u8>, <I as IntoIterator>::IntoIter: Unpin,

Execute the given bytecode from the current state of the VM.

Upon reaching a Halt operation or reaching the end of the operation sequence, returns the gas spent and the Vm will be left in the resulting state.

The given bytecode will be mapped lazily during execution. This can be more efficient than pre-mapping the bytecode and using Vm::exec_bytecode in the case that execution may fail early.

However, successful execution still requires building the full BytecodeMapped instance internally. So if bytecode has already been mapped, Vm::exec_bytecode should be preferred.

pub async fn exec<'a, S, OA>( &mut self, access: Access<'a>, state_read: &S, op_access: OA, op_gas_cost: &impl OpGasCost, gas_limit: GasLimit, ) -> Result<u64, StateReadError<<S as StateRead>::Error>>

where S: StateRead, OA: OpAccess<Op = StateRead> + Unpin, <OA as OpAccess>::Error: Into<OpError<<S as StateRead>::Error>>,

Execute over the given operation access from the current state of the VM.

Upon reaching a Halt operation or reaching the end of the operation sequence, returns the gas spent and the Vm will be left in the resulting state.

The type requirements for the op_access argument can make this finicky to use directly. You may prefer one of the convenience methods:

• Vm::exec_ops
• Vm::exec_bytecode
• Vm::exec_bytecode_iter

pub fn into_state_slots(self) -> Vec<Vec<i64>>

Consumes the Vm and returns the read state slots.

The returned slots correspond directly with the current memory content.

Trait Implementations

impl Debug for Vm

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

Formats the value using the given formatter.

impl Default for Vm

fn default() -> Vm

Returns the “default value” for a type.

impl<'a, S> From<StepOpAsyncFuture<'a, S>> for &'a mut Vm

where S: StateRead,

fn from(future: StepOpAsyncFuture<'a, S>) -> &'a mut Vm

Converts to this type from the input type.

impl PartialEq for Vm

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Vm