Struct MyEvm

pub struct MyEvm<CTX, INSP>(pub Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles>);

MyEvm variant of the EVM.

Tuple Fields

0: Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles>

Implementations

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

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

Trait Implementations

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

where CTX: ContextTr,

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

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 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_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.

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

where CTX: ContextSetters<Db: DatabaseCommit, Journal: JournalTr<FinalOutput = JournalOutput>>,

type CommitOutput = Result<ExecutionResult, EVMError<<<CTX as ContextTr>::Db as Database>::Error>>

Commit output of transaction execution.

fn replay_commit(&mut self) -> Self::CommitOutput

Transact the transaction and commit to the state.

fn transact_commit(&mut self, tx: Self::Tx) -> Self::CommitOutput

Transact the transaction and commit to the state.

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

where CTX: ContextSetters<Journal: JournalTr<FinalOutput = JournalOutput>>,

type Output = Result<ResultAndState, EVMError<<<CTX as ContextTr>::Db as Database>::Error>>

Output of transaction execution.

type Tx = <CTX as ContextTr>::Tx

Transaction type.

type Block = <CTX as ContextTr>::Block

Block type.

fn set_tx(&mut self, tx: Self::Tx)

Set the transaction.

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

Set the block.

fn replay(&mut self) -> Self::Output

Transact the transaction that is set in the context.

fn transact(&mut self, tx: Self::Tx) -> Self::Output

Transact the given transaction.

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

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

fn inspect_replay_commit(&mut self) -> Self::CommitOutput

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

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

Inspects commit with the given inspector and previous transaction, similar to InspectEvm::inspect_replay_with_inspector and commit the state diff to the database.

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

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

fn inspect_commit( &mut self, tx: Self::Tx, inspector: Self::Inspector, ) -> Self::CommitOutput

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<FinalOutput = JournalOutput> + JournalExt>, INSP: Inspector<CTX, EthInterpreter>,

type Inspector = INSP

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

Set the inspector for the EVM.

fn inspect_replay(&mut self) -> Self::Output

Inspect the EVM with the current inspector and previous transaction.

fn inspect(&mut self, tx: Self::Tx, inspector: Self::Inspector) -> Self::Output

Inspect the EVM with the given inspector and transaction.

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

Inspect the EVM with the current inspector and previous transaction by replaying it.

fn inspect_with_tx(&mut self, tx: Self::Tx) -> Self::Output

Inspect the EVM with the given transaction.

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

where CTX: ContextSetters<Journal: JournalExt> + ContextTr, INSP: Inspector<CTX, EthInterpreter>,

type Inspector = INSP

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 run_inspect_interpreter( &mut self, interpreter: &mut Interpreter<<Self::Instructions as InstructionProvider>::InterpreterTypes>, ) -> <<Self::Instructions as InstructionProvider>::InterpreterTypes as InterpreterTypes>::Output

Runs the inspector on the interpreter.