Struct fuel_vm::interpreter::Interpreter

source · [−]

pub struct Interpreter<S> { /* private fields */ }

Expand description

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

source

impl<S> Interpreter<S>

source

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.

source

impl Interpreter<()>

source

pub fn without_storage() -> Self

Create a new interpreter without a storage backend.

It will have restricted capabilities.

source

impl Interpreter<MemoryStorage>

source

pub fn with_memory_storage() -> Self

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

It will have full capabilities.

source

impl<S> Interpreter<S>

source

pub fn execute<F>(
 &mut self,
 instruction_executor: F
) -> Result<ExecuteState, InterpreterError> where
 F: Fn(&mut Self, Instruction) -> Result<ExecuteState, RuntimeError>,

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

source

pub fn instruction<F>(
 &mut self,
 instruction_executor: F,
 instruction: Instruction
) -> Result<ExecuteState, InterpreterError> where
 F: FnOnce(&mut Self, Instruction) -> Result<ExecuteState, RuntimeError>,

Execute a provided instruction

source

impl<S> Interpreter<S> where
S: Default + Clone,

source

pub fn check_predicates(tx: Transaction, params: ConsensusParameters) -> bool

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.

source

pub fn check_predicate(&mut self, tx: Transaction, idx: usize) -> bool

Initialize the VM with the provided transaction and check the input predicate indexed by idx. If the input isn’t of type Input::CoinPredicate, the function will return false.

For additional information, check Self::check_predicates

source

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

source

pub fn transact_owned(
 storage: S,
 tx: Transaction,
 params: ConsensusParameters
) -> Result<StateTransition, 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

source

pub fn transact(
&mut self,
tx: Transaction
) -> Result<StateTransitionRef<'_>, 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.

source