Struct Invoker

pub struct Invoker<'config, 'resolver, R> { /* private fields */ }

Standard invoker.

The generic parameters are as follows:

• S: The runtime state, usually RuntimeState but can be customized.
• H: Backend type.
• R: Code resolver type, also handle precompiles. Usually EtableResolver but can be customized.
• Tr: Trap type, usually crate::interpreter::Opcode but can be customized.

Implementations

impl<'config, 'resolver, R> Invoker<'config, 'resolver, R>

pub const fn new(resolver: &'resolver R) -> Self

Create a new standard invoker with the given config and resolver.

Trait Implementations

impl<'config, 'resolver, H, R> Invoker<H> for Invoker<'config, 'resolver, R>

where R::State: InvokerState + AsRef<RuntimeState> + AsMut<RuntimeState> + AsRef<Config>, <R::State as InvokerState>::TransactArgs: AsRef<TransactArgs<'config>>, H: RuntimeEnvironment + RuntimeBackend + TransactionalBackend, R: Resolver<H>, <R::Interpreter as Interpreter<H>>::Trap: TrapConsume<CallCreateTrap>, R::Interpreter: FeedbackInterpreter<H, CallFeedback> + FeedbackInterpreter<H, CreateFeedback>,

type State = <R as Resolver<H>>::State

State type.

type Interpreter = <R as Resolver<H>>::Interpreter

Interpreter type.

type Interrupt = <<<R as Resolver<H>>::Interpreter as Interpreter<H>>::Trap as TrapConsume<CallCreateTrap>>::Rest

Possible interrupt type that may be returned by the call stack.

type TransactArgs = <<<R as Resolver<H>>::Interpreter as Interpreter<H>>::State as InvokerState>::TransactArgs

Type for transaction arguments.

type TransactValue = TransactValue

The returned value of the transaction.

type TransactInvoke = TransactInvoke<'config>

The invoke of a top-layer transaction call stack. When finalizing a transaction, this invoke is used to figure out the finalization routine.

type SubstackInvoke = SubstackInvoke

The invoke of a sub-layer call stack. When exiting a call stack, this invoke is used to figure out the exit routine.

fn new_transact( &self, args: Self::TransactArgs, handler: &mut H, ) -> Result<(Self::TransactInvoke, InvokerControl<Self::Interpreter, Self::State>), ExitError>

Create a new transaction with the given transaction arguments.

fn finalize_transact( &self, invoke: &Self::TransactInvoke, exit: InvokerExit<Self::State>, handler: &mut H, ) -> Result<Self::TransactValue, ExitError>

Finalize a transaction.

fn enter_substack( &self, trap: <R::Interpreter as Interpreter<H>>::Trap, machine: &mut Self::Interpreter, handler: &mut H, depth: usize, ) -> Capture<Result<(Self::SubstackInvoke, InvokerControl<Self::Interpreter, Self::State>), ExitError>, Self::Interrupt>

Enter a sub-layer call stack.

fn exit_substack( &self, trap_data: Self::SubstackInvoke, exit: InvokerExit<Self::State>, parent: &mut Self::Interpreter, handler: &mut H, ) -> Result<(), ExitError>

Exit a sub-layer call stack.