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.

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

Returns a mutable reference to the execution context

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_multi_commit( &mut self, txs: impl Iterator<Item = Self::Tx>, ) -> Result<Vec<Self::ExecutionResult>, 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>

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( &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<ResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Execute previous transaction and finalize it.

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

Transact the given transaction and finalize in a single operation.

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

Execute multiple transactions without finalizing the state.

fn transact_multi_finalize( &mut self, txs: impl Iterator<Item = Self::Tx>, ) -> Result<ResultAndState<Vec<Self::ExecutionResult>, Self::State>, 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

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

Set the inspector for the EVM.

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

Inspect the EVM with the given transaction.

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

Inspect the EVM and finalize the state.

fn inspect( &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

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.