Struct OpEvm 

pub struct OpEvm<DB, I, P = OpPrecompiles>
where
    DB: Database,
{ /* private fields */ }

OP EVM implementation.

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

Implementations

impl<DB, I, P> OpEvm<DB, I, P>

where DB: Database,

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

Provides a reference to the EVM context.

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

Provides a mutable reference to the EVM context.

impl<DB, I, P> OpEvm<DB, I, P>

where DB: Database,

pub const fn new( evm: OpEvm<Context<BlockEnv, OpTransaction<TxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>, I, EthInstructions<EthInterpreter, Context<BlockEnv, OpTransaction<TxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>>, P>, inspect: bool, ) -> OpEvm<DB, I, P>

Creates a new OP EVM instance.

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

Methods from Deref<Target = Context<BlockEnv, OpTransaction<TxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>>

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.

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

where F: FnOnce(&mut LOCAL),

Modifies the local context.

Trait Implementations

impl<DB, I, P> Deref for OpEvm<DB, I, P>

where DB: Database,

type Target = Context<BlockEnv, OpTransaction<TxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>

The resulting type after dereferencing.

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

Dereferences the value.

impl<DB, I, P> DerefMut for OpEvm<DB, I, P>

where DB: Database,

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

Mutably dereferences the value.

impl<DB, I, P> Evm for OpEvm<DB, I, P>

where DB: Database, I: Inspector<Context<BlockEnv, OpTransaction<TxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>>, P: PrecompileProvider<Context<BlockEnv, OpTransaction<TxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>, Output = InterpreterResult>,

type DB = DB

Database type held by the EVM.

type Tx = OpTransaction<TxEnv>

The transaction object that the EVM will execute.

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

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

type HaltReason = OpHaltReason

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

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

type Precompiles = P

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: <OpEvm<DB, I, P> as Evm>::Tx, ) -> Result<ExecResultAndState<ExecutionResult<<OpEvm<DB, I, P> as Evm>::HaltReason>>, <OpEvm<DB, I, P> as Evm>::Error>

Executes a transaction and returns the outcome.

fn transact_system_call( &mut self, caller: Address, contract: Address, data: Bytes, ) -> Result<ExecResultAndState<ExecutionResult<<OpEvm<DB, I, P> as Evm>::HaltReason>>, <OpEvm<DB, I, P> as Evm>::Error>

Executes a system call.

fn finish( self, ) -> (<OpEvm<DB, I, P> as Evm>::DB, EvmEnv<<OpEvm<DB, I, P> 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 components( &self, ) -> (&<OpEvm<DB, I, P> as Evm>::DB, &<OpEvm<DB, I, P> as Evm>::Inspector, &<OpEvm<DB, I, P> as Evm>::Precompiles)

Provides immutable references to the database, inspector and precompiles.

fn components_mut( &mut self, ) -> (&mut <OpEvm<DB, I, P> as Evm>::DB, &mut <OpEvm<DB, I, P> as Evm>::Inspector, &mut <OpEvm<DB, I, P> as Evm>::Precompiles)

Provides mutable references to the database, inspector and precompiles.

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

Same as [Evm::transact_raw], but takes any type implementing [IntoTxEnv].

fn db(&self) -> &Self::DB

Returns an immutable reference to the underlying database.

fn db_mut(&mut self) -> &mut Self::DB

Returns a mutable reference to the underlying database.

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.

fn precompiles(&self) -> &Self::Precompiles

Getter of precompiles.

fn precompiles_mut(&mut self) -> &mut Self::Precompiles

Mutable getter of precompiles.

fn inspector(&self) -> &Self::Inspector

Getter of inspector.

fn inspector_mut(&mut self) -> &mut Self::Inspector

Mutable getter of 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.