Struct EthEvm

pub struct EthEvm<DB, I, PRECOMPILE = EthPrecompiles>
where
    DB: Database,
{ /* private fields */ }

Ethereum EVM implementation.

This is a wrapper type around the revm ethereum evm with optional [Inspector] (tracing) support. [Inspector] support is configurable at runtime because it’s part of the underlying [RevmEvm] type.

Implementations

impl<DB, I, PRECOMPILE> EthEvm<DB, I, PRECOMPILE>

where DB: Database,

pub const fn new( evm: Evm<Context<BlockEnv, TxEnv, CfgEnv, DB>, I, EthInstructions<EthInterpreter, Context<BlockEnv, TxEnv, CfgEnv, DB>>, PRECOMPILE>, inspect: bool, ) -> EthEvm<DB, I, PRECOMPILE>

Creates a new Ethereum EVM instance.

The inspect argument determines whether the configured [Inspector] of the given [RevmEvm] should be invoked on [Evm::transact].

pub fn into_inner( self, ) -> Evm<Context<BlockEnv, TxEnv, CfgEnv, DB>, I, EthInstructions<EthInterpreter, Context<BlockEnv, TxEnv, CfgEnv, DB>>, PRECOMPILE>

Consumes self and return the inner EVM instance.

pub const fn ctx(&self) -> &Context<BlockEnv, TxEnv, CfgEnv, DB>

Provides a reference to the EVM context.

pub fn ctx_mut(&mut self) -> &mut Context<BlockEnv, TxEnv, CfgEnv, DB>

Provides a mutable reference to the EVM context.

Methods from Deref<Target = Context<BlockEnv, TxEnv, CfgEnv, DB>>

pub fn modify_block<F>(&mut self, f: F)

where F: FnOnce(&mut BLOCK),

Modifies the context block.

pub fn modify_tx<F>(&mut self, f: F)

where F: FnOnce(&mut TX),

Modifies the context transaction.

pub fn modify_cfg<F>(&mut self, f: F)

where F: FnOnce(&mut CFG),

Modifies the context configuration.

pub fn modify_chain<F>(&mut self, f: F)

where F: FnOnce(&mut CHAIN),

Modifies the context chain.

pub fn modify_db<F>(&mut self, f: F)

where F: FnOnce(&mut DB),

Modifies the context database.

pub fn modify_journal<F>(&mut self, f: F)

where F: FnOnce(&mut JOURNAL),

Modifies the context journal.

Trait Implementations

impl<DB, I, PRECOMPILE> Deref for EthEvm<DB, I, PRECOMPILE>

where DB: Database,

type Target = Context<BlockEnv, TxEnv, CfgEnv, DB>

The resulting type after dereferencing.

fn deref(&self) -> &<EthEvm<DB, I, PRECOMPILE> as Deref>::Target

Dereferences the value.

impl<DB, I, PRECOMPILE> DerefMut for EthEvm<DB, I, PRECOMPILE>

where DB: Database,

fn deref_mut(&mut self) -> &mut <EthEvm<DB, I, PRECOMPILE> as Deref>::Target

Mutably dereferences the value.

impl<DB, I, PRECOMPILE> Evm for EthEvm<DB, I, PRECOMPILE>

where DB: Database, I: Inspector<Context<BlockEnv, TxEnv, CfgEnv, DB>>, PRECOMPILE: PrecompileProvider<Context<BlockEnv, TxEnv, CfgEnv, DB>, Output = InterpreterResult>,

type DB = DB

Database type held by the EVM.

type Tx = TxEnv

The transaction object that the EVM will execute.

type Error = EVMError<<DB as Database>::Error>

Error type returned by EVM. Contains either errors related to invalid transactions or internal irrecoverable execution errors.

type HaltReason = HaltReason

Halt reason. Enum over all possible reasons for halting the execution. When execution halts, it means that transaction is valid, however, it’s execution was interrupted (e.g because of running out of gas or overflowing stack).

type Spec = SpecId

Identifier of the EVM specification. EVM is expected to use this identifier to determine which features are enabled.

type Precompiles = PRECOMPILE

Precompiles used by the EVM.

type Inspector = I

Evm inspector.

fn block(&self) -> &BlockEnv

Reference to [BlockEnv].

fn chain_id(&self) -> u64

Returns the chain ID of the environment.

fn transact_raw( &mut self, tx: <EthEvm<DB, I, PRECOMPILE> as Evm>::Tx, ) -> Result<ResultAndState, <EthEvm<DB, I, PRECOMPILE> as Evm>::Error>

Executes a transaction and returns the outcome.

fn transact_system_call( &mut self, caller: Address, contract: Address, data: Bytes, ) -> Result<ResultAndState, <EthEvm<DB, I, PRECOMPILE> as Evm>::Error>

Executes a system call.

fn db_mut(&mut self) -> &mut <EthEvm<DB, I, PRECOMPILE> as Evm>::DB

Returns a mutable reference to the underlying database.

fn finish( self, ) -> (<EthEvm<DB, I, PRECOMPILE> as Evm>::DB, EvmEnv<<EthEvm<DB, I, PRECOMPILE> as Evm>::Spec>)

Consumes the EVM and returns the inner [EvmEnv].

fn set_inspector_enabled(&mut self, enabled: bool)

Determines whether additional transactions should be inspected or not.

fn precompiles(&self) -> &<EthEvm<DB, I, PRECOMPILE> as Evm>::Precompiles

Getter of precompiles.

fn precompiles_mut( &mut self, ) -> &mut <EthEvm<DB, I, PRECOMPILE> as Evm>::Precompiles

Mutable getter of precompiles.

fn inspector(&self) -> &<EthEvm<DB, I, PRECOMPILE> as Evm>::Inspector

Getter of inspector.

fn inspector_mut( &mut self, ) -> &mut <EthEvm<DB, I, PRECOMPILE> as Evm>::Inspector

Mutable getter of inspector.

fn transact( &mut self, tx: impl IntoTxEnv<Self::Tx>, ) -> Result<ResultAndState<Self::HaltReason>, Self::Error>

Same as [Evm::transact_raw], but takes a [IntoTxEnv] implementation, thus allowing to support transacting with an external type.

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

where Self::DB: DatabaseCommit,

Executes a transaction and commits the state changes to the underlying database.

fn into_db(self) -> Self::DB

where Self: Sized,

Consumes the EVM and returns the inner database.

fn into_env(self) -> EvmEnv<Self::Spec>

where Self: Sized,

Consumes the EVM and returns the inner [EvmEnv].

fn enable_inspector(&mut self)

Enables the configured inspector.

fn disable_inspector(&mut self)

Disables the configured inspector.

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.