Struct CustomEvm 

pub struct CustomEvm<CTX, INSP>(pub Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, CustomPrecompileProvider, EthFrame<EthInterpreter>>);

Custom EVM variant with journal-accessing precompiles.

This EVM extends the standard behavior by using a custom precompile provider that includes journal access functionality. It follows the same pattern as MyEvm but uses CustomPrecompileProvider instead of EthPrecompiles.

Tuple Fields

0: Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, CustomPrecompileProvider, EthFrame<EthInterpreter>>

Implementations

impl<CTX, INSP> CustomEvm<CTX, INSP>

where CTX: ContextTr<Cfg: Cfg<Spec = SpecId>>,

pub fn new(ctx: CTX, inspector: INSP) -> Self

Creates a new instance of CustomEvm with the provided context and inspector.

Arguments

• ctx - The execution context that manages state, environment, and journaling
• inspector - The inspector for debugging and tracing execution

Returns

A new CustomEvm instance configured with:

• The provided context and inspector
• Mainnet instruction set
• Custom precompiles with journal access
• A fresh frame stack for execution

Trait Implementations

impl<CTX: Debug, INSP: Debug> Debug for CustomEvm<CTX, INSP>

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

Formats the value using the given formatter.

impl<CTX, INSP> EvmTr for CustomEvm<CTX, INSP>

where CTX: ContextTr<Cfg: Cfg<Spec = SpecId>>,

type Context = CTX

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

type Instructions = EthInstructions<EthInterpreter, CTX>

The instruction set type that implements InstructionProvider to define available operations

type Precompiles = CustomPrecompileProvider

The type containing the available precompiled contracts

type Frame = EthFrame

The type containing the frame

fn all( &self, ) -> (&Self::Context, &Self::Instructions, &Self::Precompiles, &FrameStack<Self::Frame>)

Returns a tuple of references to the context, the frame and the instructions.

fn all_mut( &mut self, ) -> (&mut Self::Context, &mut Self::Instructions, &mut Self::Precompiles, &mut FrameStack<Self::Frame>)

Returns a tuple of mutable references to the context, the frame and the instructions.

fn frame_init( &mut self, frame_input: <Self::Frame as FrameTr>::FrameInit, ) -> Result<ItemOrResult<&mut Self::Frame, <Self::Frame as FrameTr>::FrameResult>, ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>>

Initializes the frame for the given frame input. Frame is pushed to the frame stack.

fn frame_run( &mut self, ) -> Result<FrameInitOrResult<Self::Frame>, ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>>

Run the frame from the top of the stack. Returns the frame init or result.

fn frame_return_result( &mut self, frame_result: <Self::Frame as FrameTr>::FrameResult, ) -> Result<Option<<Self::Frame as FrameTr>::FrameResult>, ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>>

Returns the result of the frame to the caller. Frame is popped from the frame stack. Consumes the frame result or returns it if there is more frames to run.

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

Returns a mutable reference to the execution context

fn ctx_mut(&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.

fn frame_stack(&mut self) -> &mut FrameStack<Self::Frame>

Returns a mutable reference to the frame stack.

impl<CTX, INSP> InspectorEvmTr for CustomEvm<CTX, INSP>

where CTX: ContextSetters<Cfg: Cfg<Spec = SpecId>, Journal: JournalExt>, INSP: Inspector<CTX, EthInterpreter>,

type Inspector = INSP

The inspector type used for EVM execution inspection.

fn all_inspector( &self, ) -> (&Self::Context, &Self::Instructions, &Self::Precompiles, &FrameStack<Self::Frame>, &Self::Inspector)

Returns a tuple of mutable references to the context, the inspector, the frame and the instructions.

fn all_mut_inspector( &mut self, ) -> (&mut Self::Context, &mut Self::Instructions, &mut Self::Precompiles, &mut FrameStack<Self::Frame>, &mut Self::Inspector)

Returns a tuple of mutable references to the context, the inspector, the frame and the instructions.

fn inspector(&mut self) -> &mut Self::Inspector

Returns a mutable reference to the inspector.

fn ctx_inspector(&mut self) -> (&mut Self::Context, &mut Self::Inspector)

Returns a tuple of mutable references to the context and the inspector.

fn ctx_inspector_frame( &mut self, ) -> (&mut Self::Context, &mut Self::Inspector, &mut Self::Frame)

Returns a tuple of mutable references to the context, the inspector and the frame.

fn ctx_inspector_frame_instructions( &mut self, ) -> (&mut Self::Context, &mut Self::Inspector, &mut Self::Frame, &mut Self::Instructions)

Returns a tuple of mutable references to the context, the inspector, the frame and the instructions.

fn inspect_frame_init( &mut self, frame_init: <Self::Frame as FrameTr>::FrameInit, ) -> Result<ItemOrResult<&mut Self::Frame, <Self::Frame as FrameTr>::FrameResult>, ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>>

Initializes the frame for the given frame input. Frame is pushed to the frame stack.

fn inspect_frame_run( &mut self, ) -> Result<ItemOrResult<<Self::Frame as FrameTr>::FrameInit, <Self::Frame as FrameTr>::FrameResult>, ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>>

Run the frame from the top of the stack. Returns the frame init or result.