Trait Evm 

pub trait Evm {
    type EvmTypes: EvmTypes<Tx = Self::Transaction>;
    type Transaction;

    // Required methods
    fn transact(
        &mut self,
        transaction: &Recovered<Self::Transaction>,
    ) -> Result<TxResultWithState<Self::EvmTypes>, BlockExecutionError>;
    fn transact_commit(
        &mut self,
        transaction: &Recovered<Self::Transaction>,
    ) -> Result<TxResultExt<<Self::EvmTypes as EvmTypesHost>::TxResultExt>, BlockExecutionError>;
    fn transact_result(
        &mut self,
        transaction: &Recovered<Self::Transaction>,
    ) -> Result<TxResultExt<<Self::EvmTypes as EvmTypesHost>::TxResultExt>, BlockExecutionError>;
    fn transact_with_inspector<I>(
        &mut self,
        transaction: &Recovered<Self::Transaction>,
        inspector: I,
    ) -> Result<(I, TxResultWithState<Self::EvmTypes>), BlockExecutionError>
       where I: Inspector<Self::EvmTypes> + 'static;
    fn set_inspector<I>(&mut self, inspector: I)
       where I: Inspector<Self::EvmTypes> + 'static;
    unsafe fn with_inspector<I, R>(
        &mut self,
        f: impl FnOnce(&mut I) -> R,
    ) -> Option<R>
       where I: Inspector<Self::EvmTypes> + 'static;
    fn take_inspector(
        &mut self,
    ) -> Option<Box<dyn Inspector<Self::EvmTypes> + '_>>;
    fn state_db_mut(&mut self) -> &mut dyn DynDatabase;
    fn commit_state(&mut self, state: &PendingState);
    fn take_state_cache(&mut self) -> Cache;
    fn precompile_ids(&self) -> Vec<(Address, PrecompileId)>;
    fn has_precompile(&self, address: &Address) -> bool;
    fn account_info(
        &mut self,
        address: &Address,
    ) -> Result<Option<AccountInfo>, BlockExecutionError>;
    fn move_precompiles(
        &mut self,
        moves: impl IntoIterator<Item = (Address, Address)>,
    ) -> Result<(), MovePrecompileError>;
    fn transact_and_discard<R>(
        &mut self,
        transaction: &Recovered<Self::Transaction>,
        observe: impl FnOnce(&ExecutedTx<'_, '_, Self::EvmTypes>) -> R,
    ) -> Result<R, BlockExecutionError>;
}

Available on crate feature evm only.

A configured EVM instance.

Required Associated Types

type EvmTypes: EvmTypes<Tx = Self::Transaction>

Runtime EVM type family.

type Transaction

Transaction environment consumed by this EVM.

Required Methods

fn transact( &mut self, transaction: &Recovered<Self::Transaction>, ) -> Result<TxResultWithState<Self::EvmTypes>, BlockExecutionError>

Executes a transaction without committing its state changes.

fn transact_commit( &mut self, transaction: &Recovered<Self::Transaction>, ) -> Result<TxResultExt<<Self::EvmTypes as EvmTypesHost>::TxResultExt>, BlockExecutionError>

Executes and accepts writes in the EVM’s block-scoped state without detaching them.

fn transact_result( &mut self, transaction: &Recovered<Self::Transaction>, ) -> Result<TxResultExt<<Self::EvmTypes as EvmTypesHost>::TxResultExt>, BlockExecutionError>

Executes a transaction and discards writes without materializing detached state.

fn transact_with_inspector<I>( &mut self, transaction: &Recovered<Self::Transaction>, inspector: I, ) -> Result<(I, TxResultWithState<Self::EvmTypes>), BlockExecutionError>

where I: Inspector<Self::EvmTypes> + 'static,

Executes a transaction with an inspector without committing its state changes.

fn set_inspector<I>(&mut self, inspector: I)

where I: Inspector<Self::EvmTypes> + 'static,

Sets the inspector used by subsequent transactions.

unsafe fn with_inspector<I, R>( &mut self, f: impl FnOnce(&mut I) -> R, ) -> Option<R>

where I: Inspector<Self::EvmTypes> + 'static,

Runs f on the inspector set by Self::set_inspector if it has type I.

Safety

I must have no lifetime parameters. The type check cannot tell an inspector that borrows data from an I that borrows 'static data, so f could then keep a 'static reference to borrowed data.

fn take_inspector(&mut self) -> Option<Box<dyn Inspector<Self::EvmTypes> + '_>>

Removes and returns the active inspector, if any.

fn state_db_mut(&mut self) -> &mut dyn DynDatabase

Returns the accepted state overlay, including earlier committed transactions.

fn commit_state(&mut self, state: &PendingState)

Accepts detached changes after a tracing callback has consumed the pre-state.

fn take_state_cache(&mut self) -> Cache

Takes cached reads and accepted writes for a caller that continues using its database.

fn precompile_ids(&self) -> Vec<(Address, PrecompileId)>

Returns active precompile addresses and identifiers.

fn has_precompile(&self, address: &Address) -> bool

Returns whether an address is an active precompile.

fn account_info( &mut self, address: &Address, ) -> Result<Option<AccountInfo>, BlockExecutionError>

Returns account information visible through the accepted state overlay.

fn move_precompiles( &mut self, moves: impl IntoIterator<Item = (Address, Address)>, ) -> Result<(), MovePrecompileError>

Applies precompile address moves to the active precompile set.

fn transact_and_discard<R>( &mut self, transaction: &Recovered<Self::Transaction>, observe: impl FnOnce(&ExecutedTx<'_, '_, Self::EvmTypes>) -> R, ) -> Result<R, BlockExecutionError>

Executes a transaction, lets observe inspect the executed transaction and its state changes, then discards its writes.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'a, T> Evm for Evm<'a, T>

where T: EvmTypes, <T as EvmTypesHost>::Tx: for<'a> Typed2718,

type EvmTypes = T

type Transaction = <T as EvmTypesHost>::Tx

fn transact( &mut self, transaction: &Recovered<<Evm<'a, T> as Evm>::Transaction>, ) -> Result<TxResultWithState<T>, BlockExecutionError>

fn transact_commit( &mut self, transaction: &Recovered<<Evm<'a, T> as Evm>::Transaction>, ) -> Result<TxResultExt<<T as EvmTypesHost>::TxResultExt>, BlockExecutionError>

fn transact_result( &mut self, transaction: &Recovered<<Evm<'a, T> as Evm>::Transaction>, ) -> Result<TxResultExt<<T as EvmTypesHost>::TxResultExt>, BlockExecutionError>

fn transact_with_inspector<I>( &mut self, transaction: &Recovered<<Evm<'a, T> as Evm>::Transaction>, inspector: I, ) -> Result<(I, TxResultWithState<T>), BlockExecutionError>

where I: Inspector<T> + 'a,

fn set_inspector<I>(&mut self, inspector: I)

where I: Inspector<T> + 'a,

unsafe fn with_inspector<I, R>( &mut self, f: impl FnOnce(&mut I) -> R, ) -> Option<R>

where I: Inspector<T> + 'static,

fn take_inspector(&mut self) -> Option<Box<dyn Inspector<T> + '_>>

fn state_db_mut(&mut self) -> &mut dyn DynDatabase

fn commit_state(&mut self, state: &PendingState)

fn take_state_cache(&mut self) -> Cache

fn precompile_ids(&self) -> Vec<(Address, PrecompileId)>

fn has_precompile(&self, address: &Address) -> bool

fn account_info( &mut self, address: &Address, ) -> Result<Option<AccountInfo>, BlockExecutionError>

fn move_precompiles( &mut self, moves: impl IntoIterator<Item = (Address, Address)>, ) -> Result<(), MovePrecompileError>

fn transact_and_discard<R>( &mut self, transaction: &Recovered<<Evm<'a, T> as Evm>::Transaction>, observe: impl FnOnce(&ExecutedTx<'_, '_, T>) -> R, ) -> Result<R, BlockExecutionError>

Implementors