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> + Deref<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>,
        chain_context: Self::Chain,
        inspector: I,
    ) -> Self::FoundryEvm<'db, I>
       where I: FoundryInspectorExt<Self::FoundryContext<'db>>;
    fn create_evm_with_context<DB>(
        &self,
        db: DB,
        evm_env: EvmEnv<Self::Spec, Self::BlockEnv>,
        chain_context: Self::Chain,
    ) -> Self::Evm<DB, NoOpInspector>
       where DB: Database;
    fn create_foundry_nested_evm<'db>(
        &self,
        db: &'db mut dyn DatabaseExt<Self, Error = DatabaseError>,
        evm_env: EvmEnv<Self::Spec, Self::BlockEnv>,
        chain_context: Self::Chain,
        inspector: &'db mut dyn FoundryInspectorExt<Self::FoundryContext<'db>>,
    ) -> Box<dyn NestedEvm<Tx = Self::Tx, Spec = Self::Spec, Journal = <Self::FoundryContext<'db> as ContextTr>::Journal, Chain = Self::Chain, Block = Self::BlockEnv> + 'db>;

    // Provided method
    fn try_transact_system_replay<DB, I>(
        &self,
        _evm: &mut Self::Evm<DB, I>,
        _tx: &Self::Tx,
    ) -> Result<Option<ExecResultAndState<ExecutionResult<Self::HaltReason>>>, Report>
       where DB: Database,
             I: Inspector<Self::Context<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> + Deref<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>, chain_context: Self::Chain, inspector: I, ) -> Self::FoundryEvm<'db, I>

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

Creates a Foundry-wrapped EVM with the given inspector.

fn create_evm_with_context<DB>( &self, db: DB, evm_env: EvmEnv<Self::Spec, Self::BlockEnv>, chain_context: Self::Chain, ) -> Self::Evm<DB, NoOpInspector>

where DB: Database,

Creates an uninspected EVM with explicit transaction-position context.

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

Creates a Foundry-wrapped EVM with a dynamic inspector, returning a boxed NestedEvm.

This helper exists because &mut dyn FoundryInspectorExt<FoundryContext> cannot satisfy the generic I: FoundryInspectorExt<Self::FoundryContext<'db>> bound when the context type is only known through an associated type. Each concrete factory implements this directly, side-stepping the higher-kinded lifetime issue.

Provided Methods

fn try_transact_system_replay<DB, I>( &self, _evm: &mut Self::Evm<DB, I>, _tx: &Self::Tx, ) -> Result<Option<ExecResultAndState<ExecutionResult<Self::HaltReason>>>, Report>

where DB: Database, I: Inspector<Self::Context<DB>>,

Available on crate feature monad only.

Tries to execute a canonical system transaction on a regular Alloy EVM during replay.

Returning Ok(None) means the transaction was not recognized. Implementations must not mutate the EVM, its database, or inspector before returning Ok(None), because callers may fall back to ordinary execution using the same EVM instance.

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 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_evm_with_context<DB>( &self, db: DB, evm_env: EvmEnv, _chain_context: <EthEvmFactory as FoundryEvmFactory>::Chain, ) -> <EthEvmFactory as EvmFactory>::Evm<DB, NoOpInspector>

where DB: Database,

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

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

fn create_foundry_nested_evm<'db>( &self, db: &'db mut dyn DatabaseExt<EthEvmFactory, Error = DatabaseError>, evm_env: EvmEnv, chain_context: <EthEvmFactory as FoundryEvmFactory>::Chain, inspector: &'db mut dyn FoundryInspectorExt<<EthEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>, ) -> Box<dyn NestedEvm<Tx = <EthEvmFactory as EvmFactory>::Tx, Spec = <EthEvmFactory as EvmFactory>::Spec, Journal = <<EthEvmFactory as FoundryEvmFactory>::FoundryContext<'db> as ContextTr>::Journal, Chain = <EthEvmFactory as FoundryEvmFactory>::Chain, Block = <EthEvmFactory as EvmFactory>::BlockEnv> + '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_evm_with_context<DB>( &self, db: DB, evm_env: EvmEnv<<MonadEvmFactory as EvmFactory>::Spec, <MonadEvmFactory as EvmFactory>::BlockEnv>, chain_context: <MonadEvmFactory as FoundryEvmFactory>::Chain, ) -> <MonadEvmFactory as EvmFactory>::Evm<DB, NoOpInspector>

where DB: Database,

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>, chain_context: <MonadEvmFactory as FoundryEvmFactory>::Chain, inspector: I, ) -> <MonadEvmFactory as FoundryEvmFactory>::FoundryEvm<'db, I>

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

fn try_transact_system_replay<DB, I>( &self, evm: &mut <MonadEvmFactory as EvmFactory>::Evm<DB, I>, tx: &<MonadEvmFactory as EvmFactory>::Tx, ) -> Result<Option<ExecResultAndState<ExecutionResult<<MonadEvmFactory as EvmFactory>::HaltReason>>>, Report>

where DB: Database, I: Inspector<<MonadEvmFactory as EvmFactory>::Context<DB>>,

Available on crate feature monad only.

fn create_foundry_nested_evm<'db>( &self, db: &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<MonadEvmFactory as EvmFactory>::Spec, <MonadEvmFactory as EvmFactory>::BlockEnv>, chain_context: <MonadEvmFactory as FoundryEvmFactory>::Chain, inspector: &'db mut dyn FoundryInspectorExt<<MonadEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>, ) -> Box<dyn NestedEvm<Tx = <MonadEvmFactory as EvmFactory>::Tx, Spec = <MonadEvmFactory as EvmFactory>::Spec, Journal = <<MonadEvmFactory as FoundryEvmFactory>::FoundryContext<'db> as ContextTr>::Journal, Chain = <MonadEvmFactory as FoundryEvmFactory>::Chain, Block = <MonadEvmFactory as EvmFactory>::BlockEnv> + '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_evm_with_context<DB>( &self, db: DB, evm_env: EvmEnv<<OpEvmFactory as EvmFactory>::Spec, <OpEvmFactory as EvmFactory>::BlockEnv>, chain_context: <OpEvmFactory as FoundryEvmFactory>::Chain, ) -> <OpEvmFactory as EvmFactory>::Evm<DB, NoOpInspector>

where DB: Database,

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>, chain_context: <OpEvmFactory as FoundryEvmFactory>::Chain, inspector: I, ) -> <OpEvmFactory as FoundryEvmFactory>::FoundryEvm<'db, I>

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

fn create_foundry_nested_evm<'db>( &self, db: &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, evm_env: EvmEnv<<OpEvmFactory as EvmFactory>::Spec, <OpEvmFactory as EvmFactory>::BlockEnv>, chain_context: <OpEvmFactory as FoundryEvmFactory>::Chain, inspector: &'db mut dyn FoundryInspectorExt<<OpEvmFactory as FoundryEvmFactory>::FoundryContext<'db>>, ) -> Box<dyn NestedEvm<Tx = <OpEvmFactory as EvmFactory>::Tx, Spec = <OpEvmFactory as EvmFactory>::Spec, Journal = <<OpEvmFactory as FoundryEvmFactory>::FoundryContext<'db> as ContextTr>::Journal, Chain = <OpEvmFactory as FoundryEvmFactory>::Chain, Block = <OpEvmFactory as EvmFactory>::BlockEnv> + '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_evm_with_context<DB>( &self, db: DB, evm_env: EvmEnv<<TempoEvmFactory as EvmFactory>::Spec, <TempoEvmFactory as EvmFactory>::BlockEnv>, _chain_context: <TempoEvmFactory as FoundryEvmFactory>::Chain, ) -> <TempoEvmFactory as EvmFactory>::Evm<DB, NoOpInspector>

where DB: Database,

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>, _chain_context: <TempoEvmFactory as FoundryEvmFactory>::Chain, inspector: I, ) -> <TempoEvmFactory as FoundryEvmFactory>::FoundryEvm<'db, I>

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

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

Implementors