Type Alias MainnetEvm

pub type MainnetEvm<CTX, INSP = ()> = Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles>;

Aliased Type

pub struct MainnetEvm<CTX, INSP = ()> {
    pub ctx: CTX,
    pub inspector: INSP,
    pub instruction: EthInstructions<EthInterpreter, CTX>,
    pub precompiles: EthPrecompiles,
}

Fields

ctx: CTX

context_interface::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.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.

Implementations

impl<CTX, I, P> Evm<CTX, (), I, P>

pub fn new(ctx: CTX, instruction: I, precompiles: P) -> Evm<CTX, (), I, P>

Create a new EVM instance with a given context, instruction set, and precompile provider.

Inspector will be set to ().

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

pub fn new_with_inspector( ctx: CTX, inspector: INSP, instruction: I, precompiles: P, ) -> Evm<CTX, INSP, I, P>

Create a new EVM instance with a given context, inspector, instruction set, and precompile provider.

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

pub fn with_inspector<OINSP>(self, inspector: OINSP) -> Evm<CTX, OINSP, I, P>

Consumed self and returns new Evm type with given Inspector.

pub fn with_precompiles<OP>(self, precompiles: OP) -> Evm<CTX, INSP, I, OP>

Consumes self and returns new Evm type with given Precompiles.

pub fn into_inspector(self) -> INSP

Consumes self and returns inner Inspector.

Trait Implementations

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

where CTX: Clone, INSP: Clone, I: Clone, P: Clone,

fn clone(&self) -> Evm<CTX, INSP, I, P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

where CTX: Debug, INSP: Debug, I: Debug, P: Debug,

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

Formats the value using the given formatter.

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

type Target = CTX

The resulting type after dereferencing.

fn deref(&self) -> &<Evm<CTX, INSP, I, P> as Deref>::Target

Dereferences the value.

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

fn deref_mut(&mut self) -> &mut <Evm<CTX, INSP, I, P> as Deref>::Target

Mutably dereferences the value.

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

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

type Instructions = I

The instruction set type that implements InstructionProvider to define available operations

type Precompiles = P

The type containing the available precompiled contracts

fn run_interpreter( &mut self, interpreter: &mut Interpreter<<<Evm<CTX, INSP, I, P> as EvmTr>::Instructions as InstructionProvider>::InterpreterTypes>, ) -> <<<Evm<CTX, INSP, I, P> as EvmTr>::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 <Evm<CTX, INSP, I, P> as EvmTr>::Context

Returns a mutable reference to the execution context

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

Returns an immutable reference to the execution context

fn ctx_instructions( &mut self, ) -> (&mut <Evm<CTX, INSP, I, P> as EvmTr>::Context, &mut <Evm<CTX, INSP, I, P> as EvmTr>::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 <Evm<CTX, INSP, I, P> as EvmTr>::Context, &mut <Evm<CTX, INSP, I, P> as EvmTr>::Precompiles)

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

impl<CTX, INSP, INST, PRECOMPILES> ExecuteCommitEvm for Evm<CTX, INSP, INST, PRECOMPILES>

where CTX: ContextTr + ContextSetters, <CTX as ContextTr>::Journal: JournalTr<FinalOutput = JournalOutput>, <CTX as ContextTr>::Db: DatabaseCommit, INST: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>, PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,

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

Commit output of transaction execution.

fn replay_commit( &mut self, ) -> <Evm<CTX, INSP, INST, PRECOMPILES> as ExecuteCommitEvm>::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, INST, PRECOMPILES> ExecuteEvm for Evm<CTX, INSP, INST, PRECOMPILES>

where CTX: ContextTr + ContextSetters, <CTX as ContextTr>::Journal: JournalTr<FinalOutput = JournalOutput>, INST: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>, PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,

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 replay( &mut self, ) -> <Evm<CTX, INSP, INST, PRECOMPILES> as ExecuteEvm>::Output

Transact the transaction that is set in the context.

fn set_tx(&mut self, tx: <Evm<CTX, INSP, INST, PRECOMPILES> as ExecuteEvm>::Tx)

Set the transaction.

fn set_block( &mut self, block: <Evm<CTX, INSP, INST, PRECOMPILES> as ExecuteEvm>::Block, )

Set the block.

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

Transact the given transaction.

impl<CTX, INSP, INST, PRECOMPILES> InspectCommitEvm for Evm<CTX, INSP, INST, PRECOMPILES>

where CTX: ContextSetters + ContextTr, <CTX as ContextTr>::Journal: JournalTr<FinalOutput = JournalOutput> + JournalExt, <CTX as ContextTr>::Db: DatabaseCommit, INSP: Inspector<CTX>, INST: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>, PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,

fn inspect_replay_commit( &mut self, ) -> <Evm<CTX, INSP, INST, PRECOMPILES> as ExecuteCommitEvm>::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, INST, PRECOMPILES> InspectEvm for Evm<CTX, INSP, INST, PRECOMPILES>

where CTX: ContextSetters + ContextTr, <CTX as ContextTr>::Journal: JournalTr<FinalOutput = JournalOutput> + JournalExt, INSP: Inspector<CTX>, INST: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>, PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,

type Inspector = INSP

fn set_inspector( &mut self, inspector: <Evm<CTX, INSP, INST, PRECOMPILES> as InspectEvm>::Inspector, )

Set the inspector for the EVM.

fn inspect_replay( &mut self, ) -> <Evm<CTX, INSP, INST, PRECOMPILES> as ExecuteEvm>::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, I, P> InspectorEvmTr for Evm<CTX, INSP, I, P>

where CTX: ContextTr + ContextSetters, <CTX as ContextTr>::Journal: JournalExt, I: InstructionProvider<Context = CTX>, <I as InstructionProvider>::InterpreterTypes: InterpreterTypes<Output = InterpreterAction>, P: PrecompileProvider<CTX>, INSP: Inspector<CTX, <I as InstructionProvider>::InterpreterTypes>,

type Inspector = INSP

fn inspector( &mut self, ) -> &mut <Evm<CTX, INSP, I, P> as InspectorEvmTr>::Inspector

Returns a mutable reference to the inspector.

fn ctx_inspector( &mut self, ) -> (&mut <Evm<CTX, INSP, I, P> as EvmTr>::Context, &mut <Evm<CTX, INSP, I, P> as InspectorEvmTr>::Inspector)

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

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

Runs the inspector on the interpreter.

impl<CTX, INSP, INST, PRECOMPILES> SystemCallCommitEvm for Evm<CTX, INSP, INST, PRECOMPILES>

where CTX: ContextTr + ContextSetters, <CTX as ContextTr>::Journal: JournalTr<FinalOutput = JournalOutput>, <CTX as ContextTr>::Db: DatabaseCommit, <CTX as ContextTr>::Tx: SystemCallTx, INST: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>, PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,

fn transact_system_call_commit( &mut self, system_contract_address: Address, data: Bytes, ) -> <Evm<CTX, INSP, INST, PRECOMPILES> as ExecuteCommitEvm>::CommitOutput

Transact the system call and commit to the state.

impl<CTX, INSP, INST, PRECOMPILES> SystemCallEvm for Evm<CTX, INSP, INST, PRECOMPILES>

where CTX: ContextTr + ContextSetters, <CTX as ContextTr>::Journal: JournalTr<FinalOutput = JournalOutput>, <CTX as ContextTr>::Tx: SystemCallTx, INST: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>, PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,

fn transact_system_call( &mut self, system_contract_address: Address, data: Bytes, ) -> <Evm<CTX, INSP, INST, PRECOMPILES> as ExecuteEvm>::Output

System call is a special transaction call that is used to call a system contract.