Trait BlockExecutor

pub trait BlockExecutor {
    type Transaction;
    type Receipt;
    type Evm: Evm;

    // Required methods
    fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError>;
    fn execute_transaction_with_result_closure(
        &mut self,
        tx: Recovered<&Self::Transaction>,
        f: impl FnOnce(&ExecutionResult<<Self::Evm as Evm>::HaltReason>),
    ) -> Result<u64, BlockExecutionError>;
    fn finish(
        self,
    ) -> Result<(Self::Evm, BlockExecutionResult<Self::Receipt>), BlockExecutionError>;
    fn set_state_hook(&mut self, hook: Option<Box<dyn OnStateHook>>);
    fn evm_mut(&mut self) -> &mut Self::Evm;

    // Provided methods
    fn execute_transaction(
        &mut self,
        tx: Recovered<&Self::Transaction>,
    ) -> Result<u64, BlockExecutionError> { ... }
    fn apply_post_execution_changes(
        self,
    ) -> Result<BlockExecutionResult<Self::Receipt>, BlockExecutionError>
       where Self: Sized { ... }
    fn with_state_hook(self, hook: Option<Box<dyn OnStateHook>>) -> Self
       where Self: Sized { ... }
}

Available on crate feature evm only.

A type that knows how to execute a single block.

The current abstraction assumes that block execution consists of the following steps:

1. Apply pre-execution changes. Those might include system calls, irregular state transitions (DAO fork), etc.
2. Apply block transactions to the state.
3. Apply post-execution changes and finalize the state. This might include other system calls, block rewards, etc.

The output of BlockExecutor::finish is a BlockExecutionResult which contains all relevant information about the block execution.

Required Associated Types

type Transaction

Input transaction type.

type Receipt

Receipt type this executor produces.

type Evm: Evm

EVM used by the executor.

Required Methods

fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError>

Applies any necessary changes before executing the block’s transactions.

fn execute_transaction_with_result_closure( &mut self, tx: Recovered<&Self::Transaction>, f: impl FnOnce(&ExecutionResult<<Self::Evm as Evm>::HaltReason>), ) -> Result<u64, BlockExecutionError>

Executes a single transaction and applies execution result to internal state. Invokes the given closure with an internal [ExecutionResult] produced by the EVM.

fn finish( self, ) -> Result<(Self::Evm, BlockExecutionResult<Self::Receipt>), BlockExecutionError>

Applies any necessary changes after executing the block’s transactions, completes execution and returns the underlying EVM along with execution result.

fn set_state_hook(&mut self, hook: Option<Box<dyn OnStateHook>>)

Sets a hook to be called after each state change during execution.

fn evm_mut(&mut self) -> &mut Self::Evm

Exposes mutable reference to EVM.

Provided Methods

fn execute_transaction( &mut self, tx: Recovered<&Self::Transaction>, ) -> Result<u64, BlockExecutionError>

Executes a single transaction and applies execution result to internal state.

Returns the gas used by the transaction.

fn apply_post_execution_changes( self, ) -> Result<BlockExecutionResult<Self::Receipt>, BlockExecutionError>

where Self: Sized,

A helper to invoke BlockExecutor::finish returning only the BlockExecutionResult.

fn with_state_hook(self, hook: Option<Box<dyn OnStateHook>>) -> Self

where Self: Sized,

A builder-style helper to invoke BlockExecutor::set_state_hook.

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<'db, DB, E, R, Spec> BlockExecutor for OpBlockExecutor<E, R, Spec>

where DB: Database + 'db, E: Evm<DB = &'db mut State<DB>>, <E as Evm>::Tx: FromRecoveredTx<<R as OpReceiptBuilder>::Transaction>, R: OpReceiptBuilder, <R as OpReceiptBuilder>::Transaction: Transaction + Encodable2718, <R as OpReceiptBuilder>::Receipt: TxReceipt, Spec: OpHardforks,

type Transaction = <R as OpReceiptBuilder>::Transaction

type Receipt = <R as OpReceiptBuilder>::Receipt

type Evm = E

fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError>

fn execute_transaction_with_result_closure( &mut self, tx: Recovered<&<OpBlockExecutor<E, R, Spec> as BlockExecutor>::Transaction>, f: impl FnOnce(&ExecutionResult<<<OpBlockExecutor<E, R, Spec> as BlockExecutor>::Evm as Evm>::HaltReason>), ) -> Result<u64, BlockExecutionError>

fn finish( self, ) -> Result<(<OpBlockExecutor<E, R, Spec> as BlockExecutor>::Evm, BlockExecutionResult<<R as OpReceiptBuilder>::Receipt>), BlockExecutionError>

fn set_state_hook(&mut self, hook: Option<Box<dyn OnStateHook>>)

fn evm_mut( &mut self, ) -> &mut <OpBlockExecutor<E, R, Spec> as BlockExecutor>::Evm

Implementors

impl<'db, DB, E, Spec, R> BlockExecutor for EthBlockExecutor<'_, E, Spec, R>

where DB: Database + 'db, E: Evm<DB = &'db mut State<DB>>, <E as Evm>::Tx: FromRecoveredTx<<R as ReceiptBuilder>::Transaction>, Spec: EthExecutorSpec, R: ReceiptBuilder, <R as ReceiptBuilder>::Transaction: Transaction + Encodable2718, <R as ReceiptBuilder>::Receipt: TxReceipt<Log = Log>,

type Transaction = <R as ReceiptBuilder>::Transaction

type Receipt = <R as ReceiptBuilder>::Receipt

type Evm = E