Struct fuel_vm::interpreter::Interpreter

pub struct Interpreter<S, Tx = ()> { /* private fields */ }

VM interpreter.

The internal state of the VM isn’t expose because the intended usage is to either inspect the resulting receipts after a transaction execution, or the resulting mutated transaction.

These can be obtained with the help of a crate::transactor::Transactor or a client implementation.

Implementations

impl<S, Tx> Interpreter<S, Tx>where
    Tx: Default,

pub fn with_storage(storage: S, params: ConsensusParameters) -> Self

Create a new interpreter instance out of a storage implementation.

If the provided storage implements crate::storage::InterpreterStorage, the returned interpreter will provide full functionality.

pub fn with_params(&mut self, params: ConsensusParameters) -> &mut Self

Set the consensus parameters for the interpreter

impl<S, Tx> Interpreter<S, Tx>where
    S: Clone,
    Tx: ExecutableTransaction,

pub fn build(&mut self) -> Self

Build the interpreter

impl<Tx> Interpreter<(), Tx>where
    Tx: ExecutableTransaction,

pub fn without_storage() -> Self

Create a new interpreter without a storage backend.

It will have restricted capabilities.

impl<Tx> Interpreter<MemoryStorage, Tx>where
    Tx: ExecutableTransaction,

pub fn with_memory_storage() -> Self

Create a new storage with a provided in-memory storage.

It will have full capabilities.

impl<S, Tx> Interpreter<S, Tx>where
    S: InterpreterStorage,
    Tx: ExecutableTransaction,

pub fn execute(&mut self) -> Result<ExecuteState, InterpreterError>

Execute the current instruction pair located in $m[$pc].

pub fn instruction(
    &mut self,
    instruction: Instruction
) -> Result<ExecuteState, InterpreterError>

Execute a provided instruction

impl<T> Interpreter<PredicateStorage, T>

pub fn check_predicates<Tx>(
    checked: Checked<Tx>,
    params: ConsensusParameters
) -> boolwhere
    Tx: ExecutableTransaction,
    <Tx as IntoChecked>::Metadata: CheckedMetadata,

Initialize the VM with the provided transaction and check all predicates defined in the inputs.

The storage provider is not used since contract opcodes are not allowed for predicates. This way, its possible, for the sake of simplicity, it is possible to use unit as storage provider.

Debug

This is not a valid entrypoint for debug calls. It will only return a bool, and not the VM state required to trace the execution steps.

impl<S, Tx> Interpreter<S, Tx>where
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
    <Tx as IntoChecked>::Metadata: CheckedMetadata,

pub fn transact_owned(
    storage: S,
    tx: Checked<Tx>,
    params: ConsensusParameters
) -> Result<StateTransition<Tx>, InterpreterError>

Allocate internally a new instance of Interpreter with the provided storage, initialize it with the provided transaction and return the result of th execution in form of StateTransition

pub fn transact(
    &mut self,
    tx: Checked<Tx>
) -> Result<StateTransitionRef<'_, Tx>, InterpreterError>

Initialize a pre-allocated instance of Interpreter with the provided transaction and execute it. The result will be bound to the lifetime of the interpreter and will avoid unnecessary copy with the data that can be referenced from the interpreter instance itself.

impl<S, Tx> Interpreter<S, Tx>where
    S: InterpreterStorage,

pub fn deploy(&mut self, tx: Checked<Create>) -> Result<Create, InterpreterError>

Deploys Create transaction without initialization VM and without invalidation of the last state of execution of the Script transaction.

Returns Create transaction with all modifications after execution.

impl<S, Tx> Interpreter<S, Tx>where
    S: InterpreterStorage,
    Tx: ExecutableTransaction,

pub fn prepare_call(
    &mut self,
    ra: RegisterId,
    rb: RegisterId,
    rc: RegisterId,
    rd: RegisterId
) -> Result<(), RuntimeError>

Prepare a call instruction for execution

impl<S, Tx> Interpreter<S, Tx>where
    Tx: ExecutableTransaction,
    <Tx as IntoChecked>::Metadata: CheckedMetadata,

pub fn init_predicate(&mut self, checked: Checked<Tx>) -> bool

Initialize the VM for a predicate context

impl<S, Tx> Interpreter<S, Tx>where
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
    <Tx as IntoChecked>::Metadata: CheckedMetadata,

pub fn init_script(
    &mut self,
    checked: Checked<Tx>
) -> Result<(), InterpreterError>

Initialize the VM with a given transaction, backed by a storage provider that allows execution of contract opcodes.

For predicate verification, check Self::init_predicate

impl<S, Tx> Interpreter<S, Tx>

pub fn memory(&self) -> &[u8]

Returns the current state of the VM memory

pub const fn registers(&self) -> &[Word]

Returns the current state of the registers

pub const fn debugger(&self) -> &Debugger

Debug handler

pub fn transaction(&self) -> &Tx

The current transaction.

pub fn initial_balances(&self) -> &InitialBalances

The initial balances.

pub const fn params(&self) -> &ConsensusParameters

Consensus parameters

pub fn receipts(&self) -> &[Receipt]

Receipts generated by a transaction execution.

Trait Implementations

impl<S, Tx> AsMut<S> for Interpreter<S, Tx>

fn as_mut(&mut self) -> &mut S

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S, Tx> AsRef<Interpreter<S, Tx>> for Transactor<S, Tx>where
    Tx: ExecutableTransaction,

fn as_ref(&self) -> &Interpreter<S, Tx>

Converts this type into a shared reference of the (usually inferred) input type.

impl<S, Tx> AsRef<S> for Interpreter<S, Tx>

fn as_ref(&self) -> &S

Converts this type into a shared reference of the (usually inferred) input type.

impl<S: Clone, Tx: Clone> Clone for Interpreter<S, Tx>

fn clone(&self) -> Interpreter<S, Tx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, Tx: Debug> Debug for Interpreter<S, Tx>

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

Formats the value using the given formatter.

impl<S, Tx> Default for Interpreter<S, Tx>where
    S: Default,
    Tx: ExecutableTransaction,

fn default() -> Self

Returns the “default value” for a type.

impl<S, Tx> From<Interpreter<S, Tx>> for Transactor<S, Tx>where
    Tx: ExecutableTransaction,

fn from(interpreter: Interpreter<S, Tx>) -> Self

Converts to this type from the input type.

impl<S, Tx> From<Transactor<S, Tx>> for Interpreter<S, Tx>where
    Tx: ExecutableTransaction,

fn from(transactor: Transactor<S, Tx>) -> Self

Converts to this type from the input type.