Trait EvmTr

pub trait EvmTr {
    type Context: ContextTr;
    type Instructions: InstructionProvider;
    type Precompiles: PrecompileProvider<Self::Context>;

    // Required methods
    fn run_interpreter(
        &mut self,
        interpreter: &mut Interpreter<<Self::Instructions as InstructionProvider>::InterpreterTypes>,
    ) -> <<Self::Instructions as InstructionProvider>::InterpreterTypes as InterpreterTypes>::Output;
    fn ctx(&mut self) -> &mut Self::Context;
    fn ctx_ref(&self) -> &Self::Context;
    fn ctx_instructions(
        &mut self,
    ) -> (&mut Self::Context, &mut Self::Instructions);
    fn ctx_precompiles(
        &mut self,
    ) -> (&mut Self::Context, &mut Self::Precompiles);
}

A trait that integrates context, instruction set, and precompiles to create an EVM struct.

In addition to execution capabilities, this trait provides getter methods for its component fields.

Required Associated Types

type Context: ContextTr

The context type that implements ContextTr to provide access to execution state

type Instructions: InstructionProvider

The instruction set type that implements InstructionProvider to define available operations

type Precompiles: PrecompileProvider<Self::Context>

The type containing the available precompiled contracts

Required Methods

fn run_interpreter( &mut self, interpreter: &mut Interpreter<<Self::Instructions as InstructionProvider>::InterpreterTypes>, ) -> <<Self::Instructions as InstructionProvider>::InterpreterTypes as InterpreterTypes>::Output

Executes the interpreter loop for the given interpreter instance. Returns either a completion status or the next interpreter action to take.

fn ctx(&mut self) -> &mut Self::Context

Returns a mutable reference to the execution context

fn ctx_ref(&self) -> &Self::Context

Returns an immutable reference to the execution context

fn ctx_instructions(&mut self) -> (&mut Self::Context, &mut Self::Instructions)

Returns mutable references to both the context and instruction set. This enables atomic access to both components when needed.

fn ctx_precompiles(&mut self) -> (&mut Self::Context, &mut Self::Precompiles)

Returns mutable references to both the context and precompiles. This enables atomic access to both components when needed.

Implementations on Foreign Types

impl<'a, T> EvmTr for &'a mut T

where T: 'a + EvmTr + ?Sized,

type Context = <T as EvmTr>::Context

type Instructions = <T as EvmTr>::Instructions

type Precompiles = <T as EvmTr>::Precompiles

fn run_interpreter( &mut self, interpreter: &mut Interpreter<<<&'a mut T as EvmTr>::Instructions as InstructionProvider>::InterpreterTypes>, ) -> <<<&'a mut T as EvmTr>::Instructions as InstructionProvider>::InterpreterTypes as InterpreterTypes>::Output

fn ctx(&mut self) -> &mut <&'a mut T as EvmTr>::Context

fn ctx_ref(&self) -> &<&'a mut T as EvmTr>::Context

fn ctx_instructions( &mut self, ) -> (&mut <&'a mut T as EvmTr>::Context, &mut <&'a mut T as EvmTr>::Instructions)

fn ctx_precompiles( &mut self, ) -> (&mut <&'a mut T as EvmTr>::Context, &mut <&'a mut T as EvmTr>::Precompiles)

impl<CTX, INSP, I, P> EvmTr for OpEvm<CTX, INSP, I, P>

where CTX: ContextTr, I: InstructionProvider<Context = CTX>, <I as InstructionProvider>::InterpreterTypes: InterpreterTypes<Output = InterpreterAction>, P: PrecompileProvider<CTX>,

type Context = CTX

type Instructions = I

type Precompiles = P

fn run_interpreter( &mut self, interpreter: &mut Interpreter<<<OpEvm<CTX, INSP, I, P> as EvmTr>::Instructions as InstructionProvider>::InterpreterTypes>, ) -> <<<OpEvm<CTX, INSP, I, P> as EvmTr>::Instructions as InstructionProvider>::InterpreterTypes as InterpreterTypes>::Output

fn ctx(&mut self) -> &mut <OpEvm<CTX, INSP, I, P> as EvmTr>::Context

fn ctx_ref(&self) -> &<OpEvm<CTX, INSP, I, P> as EvmTr>::Context

fn ctx_instructions( &mut self, ) -> (&mut <OpEvm<CTX, INSP, I, P> as EvmTr>::Context, &mut <OpEvm<CTX, INSP, I, P> as EvmTr>::Instructions)

fn ctx_precompiles( &mut self, ) -> (&mut <OpEvm<CTX, INSP, I, P> as EvmTr>::Context, &mut <OpEvm<CTX, INSP, I, P> as EvmTr>::Precompiles)

impl<T> EvmTr for Box<T>

where T: EvmTr + ?Sized,

type Context = <T as EvmTr>::Context

type Instructions = <T as EvmTr>::Instructions

type Precompiles = <T as EvmTr>::Precompiles

fn run_interpreter( &mut self, interpreter: &mut Interpreter<<<Box<T> as EvmTr>::Instructions as InstructionProvider>::InterpreterTypes>, ) -> <<<Box<T> as EvmTr>::Instructions as InstructionProvider>::InterpreterTypes as InterpreterTypes>::Output

fn ctx(&mut self) -> &mut <Box<T> as EvmTr>::Context

fn ctx_ref(&self) -> &<Box<T> as EvmTr>::Context

fn ctx_instructions( &mut self, ) -> (&mut <Box<T> as EvmTr>::Context, &mut <Box<T> as EvmTr>::Instructions)

fn ctx_precompiles( &mut self, ) -> (&mut <Box<T> as EvmTr>::Context, &mut <Box<T> as EvmTr>::Precompiles)

Implementors

impl<CTX, INSP, I, P> EvmTr for Evm<CTX, INSP, I, P>

where CTX: ContextTr, I: InstructionProvider<Context = CTX>, <I as InstructionProvider>::InterpreterTypes: InterpreterTypes<Output = InterpreterAction>, P: PrecompileProvider<CTX>,

type Context = CTX

type Instructions = I

type Precompiles = P