Struct MyEvm 

pub struct MyEvm<CTX, INSP> {
    pub ctx: CTX,
    pub inspector: INSP,
    pub instruction: EthInstructions<EthInterpreter, CTX>,
    pub precompiles: EthPrecompiles,
    pub frame_stack: FrameStack<MyFrame>,
}

MyEvm variant of the EVM.

Implements EvmTr manually as the stock implementation is only provided for Evm parameterized with EthFrame. Frame handling is delegated to the EthFrame wrapped inside MyFrame.

Fields

ctx: CTX

ContextTr of the EVM, it is used to fetch data from database.

inspector: INSP

Inspector of the EVM it is used to inspect the EVM. Its trait are defined in revm-inspector crate.

instruction: EthInstructions<EthInterpreter, CTX>

Instructions provider of the EVM it is used to execute instructions. InstructionProvider trait is defined in revm-handler crate.

precompiles: EthPrecompiles

Precompile provider of the EVM it is used to execute precompiles. PrecompileProvider trait is defined in revm-handler crate.

frame_stack: FrameStack<MyFrame>

The custom frame stack that is going to be executed.

Implementations

impl<CTX: ContextTr, INSP> MyEvm<CTX, INSP>

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

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

Trait Implementations

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

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

Formats the value using the given formatter.

impl<CTX: ContextTr, INSP> EvmTr for MyEvm<CTX, INSP>

fn frame_init( &mut self, frame_input: <Self::Frame as FrameTr>::FrameInit, ) -> Result<FrameInitResult<'_, Self::Frame>, ContextDbError<CTX>>

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

fn frame_run( &mut self, ) -> Result<FrameInitOrResult<Self::Frame>, ContextDbError<CTX>>

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

If frame has returned result it would mark it as finished.

fn frame_return_result( &mut self, result: <Self::Frame as FrameTr>::FrameResult, ) -> Result<Option<<Self::Frame as FrameTr>::FrameResult>, ContextDbError<Self::Context>>

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.

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 = EthPrecompiles

The type containing the available precompiled contracts

type Frame = MyFrame

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 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> ExecuteCommitEvm for MyEvm<CTX, INSP>

where CTX: ContextSetters<Db: DatabaseCommit, Journal: JournalTr<State = EvmState>>,

fn commit(&mut self, state: Self::State)

Commit the state.

fn commit_inner(&mut self)

Finalize the state and commit it to the database.

fn transact_commit( &mut self, tx: Self::Tx, ) -> Result<Self::ExecutionResult, Self::Error>

Transact the transaction and commit to the state.

fn transact_many_commit( &mut self, txs: impl Iterator<Item = Self::Tx>, ) -> Result<Vec<Self::ExecutionResult>, TransactionIndexedError<Self::Error>>

Transact multiple transactions and commit to the state.

fn replay_commit(&mut self) -> Result<Self::ExecutionResult, Self::Error>

Replay the transaction and commit to the state.

impl<CTX, INSP> ExecuteEvm for MyEvm<CTX, INSP>

where CTX: ContextSetters<Journal: JournalTr<State = EvmState>>,

type State = HashMap<Address, Account, FbBuildHasher<20>>

Output state type representing changes after execution.

type ExecutionResult = ExecutionResult

Output of transaction execution.

type Error = EVMError<<<CTX as ContextTr>::Db as Database>::Error>

Error type

type Tx = <CTX as ContextTr>::Tx

Transaction type.

type Block = <CTX as ContextTr>::Block

Block type.

fn set_block(&mut self, block: Self::Block)

Set the block.

fn transact_one( &mut self, tx: Self::Tx, ) -> Result<Self::ExecutionResult, Self::Error>

Execute transaction and store state inside journal. Returns output of transaction execution.

fn finalize(&mut self) -> Self::State

Finalize execution, clearing the journal and returning the accumulated state changes.

fn replay( &mut self, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Execute previous transaction and finalize it.

fn transact( &mut self, tx: Self::Tx, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Transact the given transaction and finalize in a single operation.

fn transact_many( &mut self, txs: impl Iterator<Item = Self::Tx>, ) -> Result<Vec<Self::ExecutionResult>, TransactionIndexedError<Self::Error>>

Execute multiple transactions without finalizing the state.

fn transact_many_finalize( &mut self, txs: impl Iterator<Item = Self::Tx>, ) -> Result<ExecResultAndState<Vec<Self::ExecutionResult>, Self::State>, TransactionIndexedError<Self::Error>>

Execute multiple transactions and finalize the state in a single operation.

impl<CTX, INSP> InspectCommitEvm for MyEvm<CTX, INSP>

where CTX: ContextSetters<Db: DatabaseCommit, Journal: JournalTr<State = EvmState> + JournalExt>, INSP: Inspector<CTX, EthInterpreter>,

fn inspect_tx_commit( &mut self, tx: Self::Tx, ) -> Result<Self::ExecutionResult, Self::Error>

Inspect the EVM with the current inspector and previous transaction by replaying, similar to InspectEvm::inspect_tx and commit the state diff to the database.

fn inspect_commit( &mut self, tx: Self::Tx, inspector: Self::Inspector, ) -> Result<Self::ExecutionResult, Self::Error>

Inspect the EVM with the given transaction and inspector similar to InspectEvm::inspect and commit the state diff to the database.

impl<CTX, INSP> InspectEvm for MyEvm<CTX, INSP>

where CTX: ContextSetters<Journal: JournalTr<State = EvmState> + JournalExt>, INSP: Inspector<CTX, EthInterpreter>,

type Inspector = INSP

The inspector type used for inspecting EVM execution.

fn set_inspector(&mut self, inspector: Self::Inspector)

Set the inspector for the EVM.

fn inspect_one_tx( &mut self, tx: Self::Tx, ) -> Result<Self::ExecutionResult, Self::Error>

Inspect the EVM with the given transaction.

fn inspect_tx( &mut self, tx: Self::Tx, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Inspect the EVM and finalize the state.

fn inspect( &mut self, tx: Self::Tx, inspector: Self::Inspector, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Inspect the EVM with the given inspector and transaction, and finalize the state.

fn inspect_one( &mut self, tx: Self::Tx, inspector: Self::Inspector, ) -> Result<Self::ExecutionResult, Self::Error>

Inspect the EVM with the given inspector and transaction.

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

where CTX: ContextSetters<Journal: JournalExt> + ContextTr, 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.