Struct fuel_vm :: interpreter :: Interpreter Copy item path

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

pub fn with_storage( memory: M, storage: S, interpreter_params: InterpreterParams, ) -> 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.

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

pub fn with_storage_and_ecal( memory: M, storage: S, interpreter_params: InterpreterParams, ecal_state: Ecal, ) -> 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.

impl<M, S, Tx, Ecal> Interpreter<M, Record<S>, Tx, Ecal>
where S: InterpreterStorage, Tx: ExecutableTransaction,

pub fn remove_recording(self) -> Interpreter<M, S, Tx, Ecal>

Remove the [Recording] wrapper from the storage. Recording storage changes has an overhead so it’s useful to be able to remove it once the diff is generated.

pub fn storage_diff(&self) -> Diff<Deltas>

Get the diff of changes to this VMs storage.

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where M: Memory, S: InterpreterStorage, Tx: ExecutableTransaction,

pub fn add_recording(self) -> Interpreter<M, Record<S>, Tx, Ecal>

Add a [Recording] wrapper around the storage to record any changes this VM makes to it’s storage. Recording storage changes has an overhead so should be used in production.

pub fn reset_vm_state(&mut self, diff: &Diff<InitialVmState>)
where Tx: Clone + 'static,

Change this VMs internal state to match the initial state from this diff.

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where M: Memory,

pub fn diff(&self, other: &Self) -> Diff<Deltas>
where Tx: PartialEq + Clone + Debug + 'static,

The diff function generates a diff of VM state, represented by the Diff struct, between two VMs internal states.

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where M: Memory, S: InterpreterStorage, Tx: ExecutableTransaction, Ecal: EcalHandler,

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

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

pub fn instruction<R: Into<RawInstruction> + Copy>( &mut self, raw: R, ) -> Result<ExecuteState, InterpreterError<S::DataError>>

Execute a provided instruction

impl<Tx> Interpreter<&mut MemoryInstance, PredicateStorage, Tx>
where Tx: ExecutableTransaction,

pub fn check_predicates( checked: &Checked<Tx>, params: &CheckPredicateParams, memory: impl Memory, ) -> Result<PredicatesChecked, PredicateVerificationFailed>
where <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.

pub async fn check_predicates_async<E>( checked: &Checked<Tx>, params: &CheckPredicateParams, pool: &impl VmMemoryPool, ) -> Result<PredicatesChecked, PredicateVerificationFailed>
where Tx: Send + 'static, <Tx as IntoChecked>::Metadata: CheckedMetadata, E: ParallelExecutor,

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

The storage provider is not used since contract opcodes are not allowed for predicates.

pub fn estimate_predicates( transaction: &mut Tx, params: &CheckPredicateParams, memory: impl Memory, ) -> Result<PredicatesChecked, PredicateVerificationFailed>

Initialize the VM with the provided transaction, check all predicates defined in the inputs and set the predicate_gas_used to be the actual gas consumed during execution for each predicate.

The storage provider is not used since contract opcodes are not allowed for predicates.

pub async fn estimate_predicates_async<E>( transaction: &mut Tx, params: &CheckPredicateParams, pool: &impl VmMemoryPool, ) -> Result<PredicatesChecked, PredicateVerificationFailed>
where Tx: Send + 'static, E: ParallelExecutor,

Initialize the VM with the provided transaction, check all predicates defined in the inputs and set the predicate_gas_used to be the actual gas consumed during execution for each predicate in parallel.

The storage provider is not used since contract opcodes are not allowed for predicates.

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where M: Memory, S: InterpreterStorage, Tx: ExecutableTransaction, <Tx as IntoChecked>::Metadata: CheckedMetadata, Ecal: EcalHandler,

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

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<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where S: InterpreterStorage,

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

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<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where S: InterpreterStorage,

pub fn upgrade( &mut self, tx: Ready<Upgrade>, ) -> Result<Upgrade, InterpreterError<S::DataError>>

Executes Upgrade transaction without initialization VM and without invalidation of the last state of execution of the Script transaction.

Returns Upgrade transaction with all modifications after execution.

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

pub fn upload( &mut self, tx: Ready<Upload>, ) -> Result<Upload, InterpreterError<S::DataError>>

Executes Upload transaction without initialization VM and without invalidation of the last state of execution of the Script transaction.

Returns Upload transaction with all modifications after execution.

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where M: Memory, S: InterpreterStorage, Tx: ExecutableTransaction, Ecal: EcalHandler,

pub fn resume(&mut self) -> Result<ProgramState, InterpreterError<S::DataError>>

Continue the execution from a previously interrupted program flow.

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where M: Memory, S: InterpreterStorage, Tx: ExecutableTransaction,

pub fn prepare_call( &mut self, ra: RegId, rb: RegId, rc: RegId, rd: RegId, ) -> IoResult<(), S::DataError>

Prepare a call instruction for execution

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>

pub fn remaining_gas(&self) -> Word

Global remaining gas amount

pub fn gas_charge(&mut self, gas: Word) -> SimpleResult<()>

Do a gas charge with the given amount, panicing when running out of gas.

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where M: Memory, Tx: ExecutableTransaction, S: InterpreterStorage,

pub fn init_predicate( &mut self, context: Context, tx: Tx, gas_limit: Word, ) -> Result<(), InterpreterError<S::DataError>>

Initialize the VM for a predicate context

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where M: Memory, S: InterpreterStorage, <S as InterpreterStorage>::DataError: From<S::DataError>, Tx: ExecutableTransaction, <Tx as IntoChecked>::Metadata: CheckedMetadata,

pub fn init_script( &mut self, ready_tx: Ready<Tx>, ) -> Result<(), InterpreterError<S::DataError>>

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

For predicate estimation and verification, check Self::init_predicate

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where M: Memory,

pub fn allocate(&mut self, amount: Word) -> SimpleResult<()>

Expand heap by amount bytes.

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where Tx: ExecutableTransaction,

pub const fn single_stepping(&self) -> bool

Get single-stepping mode

pub fn set_single_stepping(&mut self, single_stepping: bool)

Set single-stepping mode

pub fn clear_breakpoints(&mut self)

Clear all set breakpoints.

pub fn set_breakpoint(&mut self, breakpoint: Breakpoint)

Set a new breakpoint for the provided location.

pub fn overwrite_breakpoints(&mut self, breakpoints: &[Breakpoint])

Overwrite all breakpoints with a new set of breakpoints.

pub fn remove_breakpoint(&mut self, breakpoint: &Breakpoint)

Remove a previously set breakpoint.

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where Ecal: EcalHandler,

pub fn ecal_state(&self) -> &Ecal

Read access to the ECAL state

pub fn ecal_state_mut(&mut self) -> &mut Ecal

Write access to the ECAL state

impl<M: Memory, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>

pub fn memory(&self) -> &MemoryInstance

Returns the current state of the VM memory

impl<M: AsMut<MemoryInstance>, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>

pub fn memory_mut(&mut self) -> &mut MemoryInstance

Returns mutable access to the vm memory

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>

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

Returns the current state of the registers

pub fn registers_mut(&mut self) -> &mut [Word]

Returns mutable access to 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 fn max_inputs(&self) -> u16

Get max_inputs value

pub fn gas_price(&self) -> Word

Gas price for current block

pub fn gas_costs(&self) -> &GasCosts

Gas costs for opcodes

pub fn fee_params(&self) -> &FeeParameters

Get the Fee Parameters

pub fn base_asset_id(&self) -> &AssetId

Get the base Asset ID

pub fn contract_max_size(&self) -> u64

Get contract_max_size value

pub fn tx_offset(&self) -> usize

Get tx_offset value

pub fn max_message_data_length(&self) -> u64

Get max_message_data_length value

pub fn chain_id(&self) -> ChainId

Get the chain id

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

Receipts generated by a transaction execution.

pub fn compute_receipts_root(&self) -> Bytes32

Compute current receipts root

Trait Implementations§

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

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

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

impl<M, S, Tx, Ecal> AsRef<Interpreter<M, S, Tx, Ecal>> for Transactor<M, S, Tx, Ecal>
where Tx: ExecutableTransaction, S: InterpreterStorage, Ecal: EcalHandler,

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

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

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

fn as_ref(&self) -> &S

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

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

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

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

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

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

Formats the value using the given formatter. Read more

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<M, S, Tx, Ecal> PartialEq for Interpreter<M, S, Tx, Ecal>
where M: Memory, Tx: PartialEq,

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

Does not compare storage, debugger or profiler

1.0.0 · source§

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.

Auto Trait Implementations§

impl<M, S, Tx, Ecal> Freeze for Interpreter<M, S, Tx, Ecal>
where M: Freeze, Tx: Freeze, S: Freeze, Ecal: Freeze,

impl<M, S, Tx, Ecal> RefUnwindSafe for Interpreter<M, S, Tx, Ecal>
where M: RefUnwindSafe, Tx: RefUnwindSafe, S: RefUnwindSafe, Ecal: RefUnwindSafe,

impl<M, S, Tx, Ecal> Send for Interpreter<M, S, Tx, Ecal>
where M: Send, Tx: Send, S: Send, Ecal: Send,

impl<M, S, Tx, Ecal> Sync for Interpreter<M, S, Tx, Ecal>
where M: Sync, Tx: Sync, S: Sync, Ecal: Sync,

impl<M, S, Tx, Ecal> Unpin for Interpreter<M, S, Tx, Ecal>
where M: Unpin, Tx: Unpin, S: Unpin, Ecal: Unpin,

impl<M, S, Tx, Ecal> UnwindSafe for Interpreter<M, S, Tx, Ecal>
where M: UnwindSafe, Tx: UnwindSafe, S: UnwindSafe, Ecal: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> AnyDebug for T
where T: Any + Debug,

fn as_any_ref(&self) -> &(dyn Any + 'static)

Returns a reference to the underlying type as Any.

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> Conv for T

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.

impl<T> Same for T

type Output = T

Should always be Self

impl<T> StorageAsMut for T

fn storage<Type>(&mut self) -> StorageMut<'_, Self, Type>
where Type: Mappable,

fn storage_as_mut<Type>(&mut self) -> StorageMut<'_, Self, Type>
where Type: Mappable,

impl<T> StorageAsRef for T

fn storage<Type>(&self) -> StorageRef<'_, Self, Type>
where Type: Mappable,

fn storage_as_ref<Type>(&self) -> StorageRef<'_, Self, Type>
where Type: Mappable,

impl<T> Tap for T

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more

fn tap_borrow(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

Immutable access to the Borrow of a value. Read more

fn tap_borrow_mut(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut, B: ?Sized,

Mutable access to the BorrowMut of a value. Read more

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.

fn tap_borrow_dbg(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.

fn tap_borrow_mut_dbg(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> TryConv for T

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V