Struct fuel_vm::transactor::Transactor

pub struct Transactor<S, Tx> { /* private fields */ }

State machine to execute transactions and provide runtime entities on demand.

Builder pattern for Interpreter. Follows the recommended Non-consuming builder.

Based on https://doc.rust-lang.org/1.5.0/style/ownership/builders.html#non-consuming-builders-preferred

Implementations

impl<'a, S, Tx> Transactor<S, Tx>where
    Tx: ExecutableTransaction,

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

Transactor constructor

pub fn state_transition(&'a self) -> Option<StateTransitionRef<'a, Tx>>

State transition representation after the execution of a transaction.

Will be None if the last transaction resulted in a VM panic, or if no transaction was executed.

pub fn to_owned_state_transition(&self) -> Option<StateTransition<Tx>>

State transition representation after the execution of a transaction.

Will be None if the last transaction resulted in a VM panic, or if no transaction was executed.

pub const fn error(&self) -> Option<&InterpreterError>

Interpreter error representation after the execution of a transaction.

Follows the same criteria as Self::state_transition to return None.

Will be None if the last transaction resulted successful, or if no transaction was executed.

pub const fn is_success(&self) -> bool

Returns true if last transaction execution was successful

pub const fn is_error(&self) -> bool

Returns true if last transaction execution was erroneous

pub fn result(
    &'a self
) -> Result<StateTransitionRef<'a, Tx>, &'_ InterpreterError>

Result representation of the last executed transaction.

Will return None if no transaction was executed.

pub fn interpreter(self) -> Interpreter<S, Tx>

Convert this transaction into the underlying VM instance.

This isn’t a two-way operation since if you convert this instance into the raw VM, then you lose the transactor state.

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

Consensus parameters

pub const fn tx_offset(&self) -> usize

Tx memory offset

impl<'a, S> Transactor<S, Script>

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

Receipts after the execution of a transaction.

Follows the same criteria as Self::state_transition to return None.

pub fn backtrace(&self) -> Option<Backtrace>

Generate a backtrace when at least one receipt of ScriptResult was found.

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

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

Deploys Create checked transactions.

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

pub fn transact(&mut self, tx: Checked<Tx>) -> &mut Self

Execute a transaction, and return the new state of the transactor

Trait Implementations

impl<S, Tx> AsMut<S> for Transactor<S, Tx>where
    Tx: ExecutableTransaction,

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 Transactor<S, Tx>where
    Tx: ExecutableTransaction,

fn as_ref(&self) -> &S

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

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

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

Formats the value using the given formatter.

impl<S, Tx> Default for Transactor<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<'a> From<MemoryClient> for Transactor<MemoryStorage, Script>

fn from(client: MemoryClient) -> 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.