Trait NestedEvm 

pub trait NestedEvm {
    type Spec;
    type Block;
    type Tx: FoundryTransaction;
    type Chain: FoundryChain<Self::Tx>;
    type Journal: FoundryJournal;

    // Required methods
    fn journal_inner_mut(&mut self) -> &mut JournalInner<JournalEntry>;
    fn tx_mut(&mut self) -> &mut Self::Tx;
    fn chain_mut(&mut self) -> &mut Self::Chain;
    fn precompiles_mut(&mut self) -> &mut PrecompilesMap;
    fn journal_mut(&mut self) -> &mut Self::Journal;
    fn run_execution(
        &mut self,
        frame: FrameInput,
    ) -> Result<FrameResult, EVMError<DatabaseError>>;
    fn transact_raw(
        &mut self,
        tx: Self::Tx,
    ) -> Result<ExecResultAndState<ExecutionResult>, Report>;
    fn to_evm_env(&self) -> EvmEnv<Self::Spec, Self::Block>;

    // Provided method
    fn transact_replay(
        &mut self,
        tx: Self::Tx,
        is_system: bool,
    ) -> Result<Option<ExecResultAndState<ExecutionResult>>, Report> { ... }
}

Object-safe EVM operations used by nested execution and fork replay.

This abstracts over the concrete EVM type (FoundryEvm, future TempoEvm, etc.) so that cheatcode impls can build and run nested EVMs without knowing the concrete type.

Required Associated Types

type Spec

The spec type.

type Block

The block environment type.

type Tx: FoundryTransaction

The transaction environment type.

type Chain: FoundryChain<Self::Tx>

Chain context identifying the active transaction position.

type Journal: FoundryJournal

The Journal type, which may own Monad’s reserve-balance-tracker state.

Required Methods

fn journal_inner_mut(&mut self) -> &mut JournalInner<JournalEntry>

Returns a mutable reference to the journal inner state (JournaledState).

fn tx_mut(&mut self) -> &mut Self::Tx

Returns a mutable reference to the transaction environment.

fn chain_mut(&mut self) -> &mut Self::Chain

Returns a mutable reference to the chain-position context.

fn precompiles_mut(&mut self) -> &mut PrecompilesMap

Returns the precompile map.

fn journal_mut(&mut self) -> &mut Self::Journal

Returns a mutable reference to the Journal.

fn run_execution( &mut self, frame: FrameInput, ) -> Result<FrameResult, EVMError<DatabaseError>>

Runs a single execution frame (create or call) through the EVM handler loop.

fn transact_raw( &mut self, tx: Self::Tx, ) -> Result<ExecResultAndState<ExecutionResult>, Report>

Executes a full transaction with the given tx env.

fn to_evm_env(&self) -> EvmEnv<Self::Spec, Self::Block>

Provided Methods

fn transact_replay( &mut self, tx: Self::Tx, is_system: bool, ) -> Result<Option<ExecResultAndState<ExecutionResult>>, Report>

Replays a transaction, skipping unsupported system envelopes.

is_system preserves the RPC envelope classification that conversion to Self::Tx may discard. Returning None must not mutate the EVM, database, or inspector.

Dyn Compatibility

This trait is dyn compatible.

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

Implementations on Foreign Types

impl<'db, I> NestedEvm for BaseEvm<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, I>

where I: FoundryInspectorExt<Context<BlockEnv, BaseTransaction<TxEnv>, CfgEnv<BaseSpecId>, &'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>>, L1BlockInfo>>,

type Spec = BaseSpecId

type Block = BlockEnv

type Tx = BaseTransaction<TxEnv>

type Chain = L1BlockInfo

type Journal = Journal<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>>

fn journal_inner_mut(&mut self) -> &mut JournalInner<JournalEntry>

fn tx_mut( &mut self, ) -> &mut <BaseEvm<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Tx

fn chain_mut( &mut self, ) -> &mut <BaseEvm<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Chain

fn journal_mut( &mut self, ) -> &mut <BaseEvm<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Journal

fn precompiles_mut(&mut self) -> &mut PrecompilesMap

fn run_execution( &mut self, frame: FrameInput, ) -> Result<FrameResult, EVMError<DatabaseError>>

fn transact_raw( &mut self, tx: <BaseEvm<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Tx, ) -> Result<ExecResultAndState<ExecutionResult>, Report>

fn to_evm_env( &self, ) -> EvmEnv<<BaseEvm<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Spec, <BaseEvm<&'db mut dyn DatabaseExt<BaseEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Block>

impl<'db, I> NestedEvm for MonadEvm<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>, I, MonadInstructions<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>>, MonadPrecompilesMap>

where I: FoundryInspectorExt<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>>,

type Spec = MonadHardfork

type Block = BlockEnv

type Tx = TxEnv

type Chain = MonadChainContext

type Journal = MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>

fn tx_mut( &mut self, ) -> &mut <MonadEvm<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>, I, MonadInstructions<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>>, MonadPrecompilesMap> as NestedEvm>::Tx

fn journal_inner_mut(&mut self) -> &mut JournalInner<JournalEntry>

fn chain_mut( &mut self, ) -> &mut <MonadEvm<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>, I, MonadInstructions<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>>, MonadPrecompilesMap> as NestedEvm>::Chain

fn precompiles_mut(&mut self) -> &mut PrecompilesMap

fn journal_mut( &mut self, ) -> &mut <MonadEvm<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>, I, MonadInstructions<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>>, MonadPrecompilesMap> as NestedEvm>::Journal

fn run_execution( &mut self, frame: FrameInput, ) -> Result<FrameResult, EVMError<DatabaseError>>

fn transact_raw( &mut self, tx: <MonadEvm<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>, I, MonadInstructions<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>>, MonadPrecompilesMap> as NestedEvm>::Tx, ) -> Result<ExecResultAndState<ExecutionResult>, Report>

fn transact_replay( &mut self, tx: <MonadEvm<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>, I, MonadInstructions<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>>, MonadPrecompilesMap> as NestedEvm>::Tx, is_system: bool, ) -> Result<Option<ExecResultAndState<ExecutionResult>>, Report>

fn to_evm_env( &self, ) -> EvmEnv<<MonadEvm<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>, I, MonadInstructions<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>>, MonadPrecompilesMap> as NestedEvm>::Spec, <MonadEvm<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>, I, MonadInstructions<Context<BlockEnv, TxEnv, MonadCfgEnv, &'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>, MonadJournal<&'db mut dyn DatabaseExt<MonadEvmFactory, Error = DatabaseError>>, MonadChainContext>>, MonadPrecompilesMap> as NestedEvm>::Block>

impl<'db, I> NestedEvm for OpEvm<Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>, I, EthInstructions<EthInterpreter, Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>>, PrecompilesMap>

where I: FoundryInspectorExt<Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>>,

type Spec = OpSpecId

type Block = BlockEnv

type Tx = OpTx

type Chain = L1BlockInfo

type Journal = Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>

fn tx_mut( &mut self, ) -> &mut <OpEvm<Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>, I, EthInstructions<EthInterpreter, Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>>, PrecompilesMap> as NestedEvm>::Tx

fn journal_inner_mut(&mut self) -> &mut JournalInner<JournalEntry>

fn chain_mut( &mut self, ) -> &mut <OpEvm<Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>, I, EthInstructions<EthInterpreter, Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>>, PrecompilesMap> as NestedEvm>::Chain

fn precompiles_mut(&mut self) -> &mut PrecompilesMap

fn journal_mut( &mut self, ) -> &mut <OpEvm<Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>, I, EthInstructions<EthInterpreter, Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>>, PrecompilesMap> as NestedEvm>::Journal

fn run_execution( &mut self, frame: FrameInput, ) -> Result<FrameResult, EVMError<DatabaseError>>

fn transact_raw( &mut self, tx: <OpEvm<Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>, I, EthInstructions<EthInterpreter, Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>>, PrecompilesMap> as NestedEvm>::Tx, ) -> Result<ExecResultAndState<ExecutionResult>, Report>

fn to_evm_env( &self, ) -> EvmEnv<<OpEvm<Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>, I, EthInstructions<EthInterpreter, Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>>, PrecompilesMap> as NestedEvm>::Spec, <OpEvm<Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>, I, EthInstructions<EthInterpreter, Context<BlockEnv, OpTx, CfgEnv<OpSpecId>, &'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>, Journal<&'db mut dyn DatabaseExt<OpEvmFactory, Error = DatabaseError>>, L1BlockInfo>>, PrecompilesMap> as NestedEvm>::Block>

impl<'db, I> NestedEvm for TempoEvm<&'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, I>

where I: FoundryInspectorExt<Context<TempoBlockEnv, TempoTxEnv, CfgEnv<TempoHardfork>, &'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>>>,

type Spec = TempoHardfork

type Block = TempoBlockEnv

type Tx = TempoTxEnv

type Chain = ()

type Journal = Journal<&'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>>

fn tx_mut( &mut self, ) -> &mut <TempoEvm<&'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Tx

fn journal_inner_mut(&mut self) -> &mut JournalInner<JournalEntry>

fn chain_mut( &mut self, ) -> &mut <TempoEvm<&'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Chain

fn precompiles_mut(&mut self) -> &mut PrecompilesMap

fn journal_mut( &mut self, ) -> &mut <TempoEvm<&'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Journal

fn run_execution( &mut self, frame: FrameInput, ) -> Result<FrameResult, EVMError<DatabaseError>>

fn transact_raw( &mut self, tx: <TempoEvm<&'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Tx, ) -> Result<ExecResultAndState<ExecutionResult>, Report>

fn to_evm_env( &self, ) -> EvmEnv<<TempoEvm<&'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Spec, <TempoEvm<&'db mut dyn DatabaseExt<TempoEvmFactory, Error = DatabaseError>, I> as NestedEvm>::Block>

Implementors

impl<'db, I> NestedEvm for Evm<Context<BlockEnv, TxEnv, CfgEnv, &'db mut dyn DatabaseExt<EthEvmFactory, Error = DatabaseError>>, I, EthInstructions<EthInterpreter, Context<BlockEnv, TxEnv, CfgEnv, &'db mut dyn DatabaseExt<EthEvmFactory, Error = DatabaseError>>>, PrecompilesMap, EthFrame>

where I: FoundryInspectorExt<Context<BlockEnv, TxEnv, CfgEnv, &'db mut dyn DatabaseExt<EthEvmFactory, Error = DatabaseError>>>,

type Spec = SpecId

type Block = BlockEnv

type Tx = TxEnv

type Chain = ()

type Journal = Journal<&'db mut dyn DatabaseExt<EthEvmFactory, Error = DatabaseError>>