Struct Transactor

pub struct Transactor<M, S, Tx, Ecal = NotSupportedEcal>
where
    S: InterpreterStorage,
{ /* 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<M, S, Tx, Ecal> Transactor<M, S, Tx, Ecal>

where S: InterpreterStorage, Tx: ExecutableTransaction, Ecal: EcalHandler + Default,

pub fn new(memory: M, storage: S, interpreter_params: InterpreterParams) -> Self

Transactor constructor

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

where S: InterpreterStorage, Tx: ExecutableTransaction, Ecal: EcalHandler,

pub fn state_transition(&self) -> Option<StateTransitionRef<'_, 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<S::DataError>>

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_reverted(&self) -> bool

Returns true if last transaction execution was erroneous

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

Result representation of the last executed transaction.

Will return None if no transaction was executed.

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

Gets the interpreter.

pub fn gas_costs(&self) -> &GasCosts

Gas costs of opcodes

pub fn fee_params(&self) -> &FeeParameters

Fee parameters

pub fn tx_offset(&self) -> usize

Tx memory offset

impl<M, S, Ecal> Transactor<M, S, Script, Ecal>

where M: Memory, S: InterpreterStorage,

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<M, S, Tx, Ecal> Transactor<M, S, Tx, Ecal>

where S: InterpreterStorage,

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

Deploys Create checked transactions.

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

Deployt a Ready transaction directly instead of letting Transactor construct

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

Executes Upgrade checked transactions.

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

Executes a Ready transaction directly instead of letting Transactor construct

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

Executes Upload checked transactions.

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

Executes a Ready transaction directly instead of letting Transactor construct

pub fn blob( &mut self, checked: Checked<Blob>, ) -> Result<Blob, InterpreterError<S::DataError>>

Executes Blob checked transactions.

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

Executes a Ready transaction directly instead of letting Transactor construct

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

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

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

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

pub fn transact_ready_tx(&mut self, ready_tx: Ready<Tx>) -> &mut Self

Transact a Ready transaction directly instead of letting Transactor construct

Trait Implementations

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

where Tx: ExecutableTransaction, S: InterpreterStorage,

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 Transactor<M, S, Tx, Ecal>

where Tx: ExecutableTransaction, S: InterpreterStorage,

fn as_ref(&self) -> &S

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

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

where S: InterpreterStorage + Debug, S::DataError: Debug,

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

Formats the value using the given formatter.

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.