Trait BlockExecutorFactory

pub trait BlockExecutorFactory: 'static {
    type EvmFactory: EvmFactory;
    type ExecutionCtx<'a>: Clone;
    type Transaction;
    type Receipt;

    // Required methods
    fn evm_factory(&self) -> &Self::EvmFactory;
    fn create_executor<'a, DB, I>(
        &'a self,
        evm: <Self::EvmFactory as EvmFactory>::Evm<&'a mut State<DB>, I>,
        ctx: Self::ExecutionCtx<'a>,
    ) -> impl BlockExecutorFor<'a, Self, DB, I>
       where DB: Database + 'a,
             I: Inspector<<Self::EvmFactory as EvmFactory>::Context<&'a mut State<DB>>> + 'a;
}

Available on crate feature evm only.

A factory that can create BlockExecutors.

This trait extends crate::EvmFactory and provides a way to construct a BlockExecutor. Executor is expected to derive most of the context for block execution from the EVM (which includes [revm::context::BlockEnv]), and any additional context should be contained in configured ExecutionCtx.

Every block executor factory is expected to contain and expose an EvmFactory instance.

For more context on the executor design, see the documentation for BlockExecutor.

Required Associated Types

type EvmFactory: EvmFactory

The EVM factory used by the executor.

type ExecutionCtx<'a>: Clone

Context required for block execution.

This is similar to crate::EvmEnv, but only contains context unrelated to EVM and required for execution of an entire block.

type Transaction

Transaction type used by the executor, see BlockExecutor::Transaction.

type Receipt

Receipt type produced by the executor, see BlockExecutor::Receipt.

Required Methods

fn evm_factory(&self) -> &Self::EvmFactory

Reference to EVM factory used by the executor.

fn create_executor<'a, DB, I>( &'a self, evm: <Self::EvmFactory as EvmFactory>::Evm<&'a mut State<DB>, I>, ctx: Self::ExecutionCtx<'a>, ) -> impl BlockExecutorFor<'a, Self, DB, I>

where DB: Database + 'a, I: Inspector<<Self::EvmFactory as EvmFactory>::Context<&'a mut State<DB>>> + 'a,

Creates an executor with given EVM and execution context.

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.

Implementations on Foreign Types

impl<T> BlockExecutorFactory for Arc<T>

where T: BlockExecutorFactory + ?Sized, Arc<T>: 'static,

type EvmFactory = <T as BlockExecutorFactory>::EvmFactory

type ExecutionCtx<'a> = <T as BlockExecutorFactory>::ExecutionCtx<'a>

type Transaction = <T as BlockExecutorFactory>::Transaction

type Receipt = <T as BlockExecutorFactory>::Receipt

fn evm_factory(&self) -> &<Arc<T> as BlockExecutorFactory>::EvmFactory

fn create_executor<'a, DB, I>( &'a self, evm: <<Arc<T> as BlockExecutorFactory>::EvmFactory as EvmFactory>::Evm<&'a mut State<DB>, I>, ctx: <Arc<T> as BlockExecutorFactory>::ExecutionCtx<'a>, ) -> impl BlockExecutorFor<'a, Arc<T>, DB, I>

where DB: Database + 'a, I: Inspector<<<Arc<T> as BlockExecutorFactory>::EvmFactory as EvmFactory>::Context<&'a mut State<DB>>> + 'a,

Implementors

impl<R, Spec, EvmF> BlockExecutorFactory for OpBlockExecutorFactory<R, Spec, EvmF>

where R: OpReceiptBuilder, <R as OpReceiptBuilder>::Transaction: Transaction + Encodable2718, <R as OpReceiptBuilder>::Receipt: TxReceipt, Spec: OpHardforks, EvmF: EvmFactory, <EvmF as EvmFactory>::Tx: FromRecoveredTx<<R as OpReceiptBuilder>::Transaction>, OpBlockExecutorFactory<R, Spec, EvmF>: 'static,

type EvmFactory = EvmF

type ExecutionCtx<'a> = OpBlockExecutionCtx

type Transaction = <R as OpReceiptBuilder>::Transaction

type Receipt = <R as OpReceiptBuilder>::Receipt

impl<R, Spec, EvmF> BlockExecutorFactory for EthBlockExecutorFactory<R, Spec, EvmF>

where R: ReceiptBuilder, <R as ReceiptBuilder>::Transaction: Transaction + Encodable2718, <R as ReceiptBuilder>::Receipt: TxReceipt<Log = Log>, Spec: EthExecutorSpec, EvmF: EvmFactory, <EvmF as EvmFactory>::Tx: FromRecoveredTx<<R as ReceiptBuilder>::Transaction>, EthBlockExecutorFactory<R, Spec, EvmF>: 'static,

type EvmFactory = EvmF

type ExecutionCtx<'a> = EthBlockExecutionCtx<'a>

type Transaction = <R as ReceiptBuilder>::Transaction

type Receipt = <R as ReceiptBuilder>::Receipt