Struct EthBlockExecutor 

pub struct EthBlockExecutor<'a, Evm, Spec, R: ReceiptBuilder> {
    pub spec: Spec,
    pub ctx: EthBlockExecutionCtx<'a>,
    pub evm: Evm,
    pub system_caller: SystemCaller<Spec>,
    pub receipt_builder: R,
    pub receipts: Vec<R::Receipt>,
    pub gas_used: u64,
    pub blob_gas_used: u64,
}

Block executor for Ethereum.

Fields

spec: Spec

Reference to the specification object.

ctx: EthBlockExecutionCtx<'a>

Context for block execution.

evm: Evm

Inner EVM.

system_caller: SystemCaller<Spec>

Utility to call system smart contracts.

receipt_builder: R

Receipt builder.

receipts: Vec<R::Receipt>

Receipts of executed transactions.

gas_used: u64

Total gas used by transactions in this block.

blob_gas_used: u64

Blob gas used by the block. Before cancun activation, this is always 0.

Implementations

impl<'a, Evm, Spec, R> EthBlockExecutor<'a, Evm, Spec, R>

where Spec: Clone, R: ReceiptBuilder,

pub fn new( evm: Evm, ctx: EthBlockExecutionCtx<'a>, spec: Spec, receipt_builder: R, ) -> Self

Creates a new EthBlockExecutor

Trait Implementations

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

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

type Transaction = <R as ReceiptBuilder>::Transaction

Input transaction type.

type Receipt = <R as ReceiptBuilder>::Receipt

Receipt type this executor produces.

type Evm = E

EVM used by the executor.

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

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

fn execute_transaction_without_commit( &mut self, tx: impl ExecutableTx<Self>, ) -> Result<ResultAndState<<Self::Evm as Evm>::HaltReason>, BlockExecutionError>

Executes a single transaction without committing state changes.

fn commit_transaction( &mut self, output: ResultAndState<<Self::Evm as Evm>::HaltReason>, tx: impl ExecutableTx<Self>, ) -> Result<u64, BlockExecutionError>

Commits a previously executed transaction’s state changes.

fn finish( self, ) -> Result<(Self::Evm, BlockExecutionResult<R::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.

fn evm(&self) -> &Self::Evm

Exposes immutable reference to EVM.

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

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

fn execute_transaction_with_result_closure( &mut self, tx: impl ExecutableTx<Self>, 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 execute_transaction_with_commit_condition( &mut self, tx: impl ExecutableTx<Self>, f: impl FnOnce(&ExecutionResult<<Self::Evm as Evm>::HaltReason>) -> CommitChanges, ) -> Result<Option<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, and commits the transaction to the state on CommitChanges::Yes.

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.

fn execute_block( self, transactions: impl IntoIterator<Item = impl ExecutableTx<Self>>, ) -> Result<BlockExecutionResult<Self::Receipt>, BlockExecutionError>

where Self: Sized,

Executes all transactions in a block, applying pre and post execution changes.

impl<'a, Evm: Debug, Spec: Debug, R: Debug + ReceiptBuilder> Debug for EthBlockExecutor<'a, Evm, Spec, R>

where R::Receipt: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.