Trait FoundryEvmFactory 

pub trait FoundryEvmFactory:
    EvmFactory<Precompiles = PrecompilesMap>
    + Clone
    + Debug
    + Default
    + 'static
where
    Self::Spec: Into<SpecId> + ExecutionSpec + Default + Copy + Unpin + Send + 'static,
    Self::BlockEnv: FoundryBlock + ForkBlockEnv + Default + Unpin,
    Self::Tx: Clone + Debug + FoundryTransaction + FromAnyRpcTransaction + Default + Send + Sync,
    Self::HaltReason: IntoInstructionResult,
{
    type Chain: FoundryChain<Self::Tx>;
    type FoundryContext<'db>: FoundryContextExt<Block = Self::BlockEnv, Tx = Self::Tx, Spec = Self::Spec, Chain = Self::Chain>
       where <Self::FoundryContext<'db> as ContextTr>::Journal: FoundryJournal,
             <Self::FoundryContext<'db> as ContextTr>::Db: DatabaseExt<Self>,
             Self: 'db;
    type FoundryEvm<'db, I: FoundryInspectorExt<Self::FoundryContext<'db>>>: Evm<DB = &'db mut dyn DatabaseExt<Self, Error = DatabaseError>, Tx = Self::Tx, BlockEnv = Self::BlockEnv, Spec = Self::Spec, HaltReason = Self::HaltReason> + DerefMut<Target = Self::FoundryContext<'db>>
       where Self: 'db;

    // Required methods
    fn create_foundry_evm_with_inspector<'db, I>(
        &self,
        db: &'db mut dyn DatabaseExt<Self, Error = DatabaseError>,
        evm_env: EvmEnv<Self::Spec, Self::BlockEnv>,
        inspector: I,
    ) -> Self::FoundryEvm<'db, I>
       where I: FoundryInspectorExt<Self::FoundryContext<'db>>;
    fn create_nested_evm_with_inspector<'db, I>(
        &self,
        db: &'db mut dyn DatabaseExt<Self, Error = DatabaseError>,
        evm_env: EvmEnv<Self::Spec, Self::BlockEnv>,
        inspector: I,
    ) -> Box<dyn NestedEvm<Spec = Self::Spec, Block = Self::BlockEnv, Chain = Self::Chain, Tx = Self::Tx, Journal = <Self::FoundryContext<'db> as ContextTr>::Journal> + 'db>
       where I: FoundryInspectorExt<Self::FoundryContext<'db>> + 'db;

    // Provided method
    fn create_nested_evm<'db>(
        &self,
        db: &'db mut dyn DatabaseExt<Self, Error = DatabaseError>,
        evm_env: EvmEnv<Self::Spec, Self::BlockEnv>,
    ) -> Box<dyn NestedEvm<Spec = Self::Spec, Block = Self::BlockEnv, Chain = Self::Chain, Tx = Self::Tx, Journal = <Self::FoundryContext<'db> as ContextTr>::Journal> + 'db> { ... }
}

Required Associated Types

type Chain: FoundryChain<Self::Tx>

Chain type for EVM’s context created by this factory.

type FoundryContext<'db>: FoundryContextExt<Block = Self::BlockEnv, Tx = Self::Tx, Spec = Self::Spec, Chain = Self::Chain> where <Self::FoundryContext<'db> as ContextTr>::Journal: FoundryJournal, <Self::FoundryContext<'db> as ContextTr>::Db: DatabaseExt<Self>, Self: 'db

Foundry Context abstraction

type FoundryEvm<'db, I: FoundryInspectorExt<Self::FoundryContext<'db>>>: Evm<DB = &'db mut dyn DatabaseExt<Self, Error = DatabaseError>, Tx = Self::Tx, BlockEnv = Self::BlockEnv, Spec = Self::Spec, HaltReason = Self::HaltReason> + DerefMut<Target = Self::FoundryContext<'db>> where Self: 'db

The Foundry-wrapped EVM type produced by this factory.

Required Methods

fn create_foundry_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<Self, Error = DatabaseError>, evm_env: EvmEnv<Self::Spec, Self::BlockEnv>, inspector: I, ) -> Self::FoundryEvm<'db, I>

where I: FoundryInspectorExt<Self::FoundryContext<'db>>,

Creates a Foundry-wrapped EVM with the given inspector.

Callers carrying execution context must install it through the returned context’s chain_mut before executing. This also preserves OP’s block-derived L1 fee information.

fn create_nested_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<Self, Error = DatabaseError>, evm_env: EvmEnv<Self::Spec, Self::BlockEnv>, inspector: I, ) -> Box<dyn NestedEvm<Spec = Self::Spec, Block = Self::BlockEnv, Chain = Self::Chain, Tx = Self::Tx, Journal = <Self::FoundryContext<'db> as ContextTr>::Journal> + 'db>

where I: FoundryInspectorExt<Self::FoundryContext<'db>> + 'db,

Creates a Foundry-wrapped nested EVM with the given inspector. Install inherited chain state with NestedEvm::chain_mut before executing or restoring journal-derived state.

Provided Methods

fn create_nested_evm<'db>( &self, db: &'db mut dyn DatabaseExt<Self, Error = DatabaseError>, evm_env: EvmEnv<Self::Spec, Self::BlockEnv>, ) -> Box<dyn NestedEvm<Spec = Self::Spec, Block = Self::BlockEnv, Chain = Self::Chain, Tx = Self::Tx, Journal = <Self::FoundryContext<'db> as ContextTr>::Journal> + 'db>

Creates a Foundry-wrapped nested EVM without an inspector.

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl FoundryEvmFactory for BaseEvmFactory

type Chain = L1BlockInfo

type FoundryContext<'db> = Context<BlockEnv, BaseTransaction<TxEnv>, CfgEnv<BaseSpecId>, &'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>>, L1BlockInfo>

type FoundryEvm<'db, I: FoundryInspectorExt<<BaseEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>> = BaseEvm<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, I>

fn create_foundry_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<BaseEvmFactory as EvmFactory>::Spec, <BaseEvmFactory as EvmFactory>::BlockEnv>, inspector: I, ) -> <BaseEvmFactory as FoundryEvmFactory>::FoundryEvm<'db, I>

where I: FoundryInspectorExt<<BaseEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>,

fn create_nested_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<BaseEvmFactory as EvmFactory>::Spec, <BaseEvmFactory as EvmFactory>::BlockEnv>, inspector: I, ) -> Box<dyn NestedEvm<Spec = <BaseEvmFactory as EvmFactory>::Spec, Block = <BaseEvmFactory as EvmFactory>::BlockEnv, Chain = <BaseEvmFactory as FoundryEvmFactory>::Chain, Tx = <BaseEvmFactory as EvmFactory>::Tx, Journal = <<BaseEvmFactory as FoundryEvmFactory>::FoundryContext<'db> as ContextTr>::Journal> + 'db>

where I: FoundryInspectorExt<<BaseEvmFactory as FoundryEvmFactory>::FoundryContext<'db>> + 'db,

impl FoundryEvmFactory for EthEvmFactory

type Chain = ()

type FoundryContext<'db> = Context<BlockEnv, TxEnv, CfgEnv, &'db mut dyn DatabaseExt<EthEvmFactory, Error = DatabaseError>>

type FoundryEvm<'db, I: FoundryInspectorExt<<EthEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>> = EthEvm<&'db mut dyn DatabaseExt<EthEvmFactory, Error = DatabaseError>, I, <EthEvmFactory as EvmFactory>::Precompiles>

fn create_foundry_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<EthEvmFactory, Error = DatabaseError>, evm_env: EvmEnv, inspector: I, ) -> <EthEvmFactory as FoundryEvmFactory>::FoundryEvm<'db, I>

where I: FoundryInspectorExt<<EthEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>,

fn create_nested_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<EthEvmFactory, Error = DatabaseError>, evm_env: EvmEnv, inspector: I, ) -> Box<dyn NestedEvm<Spec = <EthEvmFactory as EvmFactory>::Spec, Block = <EthEvmFactory as EvmFactory>::BlockEnv, Chain = <EthEvmFactory as FoundryEvmFactory>::Chain, Tx = <EthEvmFactory as EvmFactory>::Tx, Journal = <<EthEvmFactory as FoundryEvmFactory>::FoundryContext<'db> as ContextTr>::Journal> + 'db>

where I: FoundryInspectorExt<<EthEvmFactory as FoundryEvmFactory>::FoundryContext<'db>> + 'db,

impl FoundryEvmFactory for MonadEvmFactory

type Chain = MonadChainContext

type FoundryContext<'db> = Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>

type FoundryEvm<'db, I: FoundryInspectorExt<<MonadEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>> = MonadEvm<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, I>

fn create_foundry_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<MonadEvmFactory as EvmFactory>::Spec, <MonadEvmFactory as EvmFactory>::BlockEnv>, inspector: I, ) -> <MonadEvmFactory as FoundryEvmFactory>::FoundryEvm<'db, I>

where I: FoundryInspectorExt<<MonadEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>,

fn create_nested_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<MonadEvmFactory as EvmFactory>::Spec, <MonadEvmFactory as EvmFactory>::BlockEnv>, inspector: I, ) -> Box<dyn NestedEvm<Spec = <MonadEvmFactory as EvmFactory>::Spec, Block = <MonadEvmFactory as EvmFactory>::BlockEnv, Chain = <MonadEvmFactory as FoundryEvmFactory>::Chain, Tx = <MonadEvmFactory as EvmFactory>::Tx, Journal = <<MonadEvmFactory as FoundryEvmFactory>::FoundryContext<'db> as ContextTr>::Journal> + 'db>

where I: FoundryInspectorExt<<MonadEvmFactory as FoundryEvmFactory>::FoundryContext<'db>> + 'db,

impl FoundryEvmFactory for OpEvmFactory

type Chain = L1BlockInfo

type FoundryContext<'db> = Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>

type FoundryEvm<'db, I: FoundryInspectorExt<<OpEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>> = OpEvm<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, I, <OpEvmFactory as EvmFactory>::Precompiles>

fn create_foundry_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<OpEvmFactory as EvmFactory>::Spec, <OpEvmFactory as EvmFactory>::BlockEnv>, inspector: I, ) -> <OpEvmFactory as FoundryEvmFactory>::FoundryEvm<'db, I>

where I: FoundryInspectorExt<<OpEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>,

fn create_nested_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<OpEvmFactory as EvmFactory>::Spec, <OpEvmFactory as EvmFactory>::BlockEnv>, inspector: I, ) -> Box<dyn NestedEvm<Spec = <OpEvmFactory as EvmFactory>::Spec, Block = <OpEvmFactory as EvmFactory>::BlockEnv, Chain = <OpEvmFactory as FoundryEvmFactory>::Chain, Tx = <OpEvmFactory as EvmFactory>::Tx, Journal = <<OpEvmFactory as FoundryEvmFactory>::FoundryContext<'db> as ContextTr>::Journal> + 'db>

where I: FoundryInspectorExt<<OpEvmFactory as FoundryEvmFactory>::FoundryContext<'db>> + 'db,

impl FoundryEvmFactory for TempoEvmFactory

type Chain = ()

type FoundryContext<'db> = Context<TempoBlockEnv, TempoTxEnv, CfgEnv<TempoHardfork>, &'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>>

type FoundryEvm<'db, I: FoundryInspectorExt<<TempoEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>> = TempoEvm<&'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, I>

fn create_foundry_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<TempoEvmFactory as EvmFactory>::Spec, <TempoEvmFactory as EvmFactory>::BlockEnv>, inspector: I, ) -> <TempoEvmFactory as FoundryEvmFactory>::FoundryEvm<'db, I>

where I: FoundryInspectorExt<<TempoEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>,

fn create_nested_evm_with_inspector<'db, I>( &self, db: &'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<TempoEvmFactory as EvmFactory>::Spec, <TempoEvmFactory as EvmFactory>::BlockEnv>, inspector: I, ) -> Box<dyn NestedEvm<Spec = <TempoEvmFactory as EvmFactory>::Spec, Block = <TempoEvmFactory as EvmFactory>::BlockEnv, Chain = <TempoEvmFactory as FoundryEvmFactory>::Chain, Tx = <TempoEvmFactory as EvmFactory>::Tx, Journal = <<TempoEvmFactory as FoundryEvmFactory>::FoundryContext<'db> as ContextTr>::Journal> + 'db>

where I: FoundryInspectorExt<<TempoEvmFactory as FoundryEvmFactory>::FoundryContext<'db>> + 'db,

Implementors