Trait Evm

pub trait Evm {
    type DB;
    type Tx: IntoTxEnv<Self::Tx>;
    type Error: EvmError;
    type HaltReason: HaltReasonTr + Send + Sync + 'static;
    type Spec: Debug + Copy + Send + Sync + 'static;

    // Required methods
    fn block(&self) -> &BlockEnv;
    fn transact_raw(
        &mut self,
        tx: Self::Tx,
    ) -> Result<ResultAndState<Self::HaltReason>, Self::Error>;
    fn transact_system_call(
        &mut self,
        caller: Address,
        contract: Address,
        data: Bytes,
    ) -> Result<ResultAndState<Self::HaltReason>, Self::Error>;
    fn db_mut(&mut self) -> &mut Self::DB;
    fn finish(self) -> (Self::DB, EvmEnv<Self::Spec>)
       where Self: Sized;

    // Provided methods
    fn transact(
        &mut self,
        tx: impl IntoTxEnv<Self::Tx>,
    ) -> Result<ResultAndState<Self::HaltReason>, Self::Error> { ... }
    fn transact_commit(
        &mut self,
        tx: impl IntoTxEnv<Self::Tx>,
    ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>
       where Self::DB: DatabaseCommit { ... }
    fn into_db(self) -> Self::DB
       where Self: Sized { ... }
    fn into_env(self) -> EvmEnv<Self::Spec>
       where Self: Sized { ... }
}

Available on crate feature evm only.

An instance of an ethereum virtual machine.

An EVM is commonly initialized with the corresponding block context and state and it’s only purpose is to execute transactions.

Executing a transaction will return the outcome of the transaction.

Required Associated Types

type DB

Database type held by the EVM.

type Tx: IntoTxEnv<Self::Tx>

The transaction object that the EVM will execute.

Implementations are expected to rely on a single entrypoint for transaction execution such as [revm::context::TxEnv]. The actual set of valid inputs is not limited by allowing to provide any IntoTxEnv implementation for Evm::transact method.

type Error: EvmError

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

type HaltReason: HaltReasonTr + Send + Sync + 'static

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: Debug + Copy + Send + Sync + 'static

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

Required Methods

fn block(&self) -> &BlockEnv

Reference to [BlockEnv].

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

Executes a transaction and returns the outcome.

fn transact_system_call( &mut self, caller: Address, contract: Address, data: Bytes, ) -> Result<ResultAndState<Self::HaltReason>, Self::Error>

Executes a system call.

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

Returns a mutable reference to the underlying database.

fn finish(self) -> (Self::DB, EvmEnv<Self::Spec>)

where Self: Sized,

Consumes the EVM and returns the inner EvmEnv.

Provided Methods

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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

type Tx = TxEnv

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

type HaltReason = HaltReason

type Spec = SpecId