Struct EthBlockExecutor 

pub struct EthBlockExecutor<'a, T = BaseEvmTypes, R = RethReceiptBuilder>
where
    T: EvmTypes<Tx: Typed2718, TxResultExt: Send + Sync>,
    R: ReceiptBuilder,
{
    pub evm: Evm<'a, T>,
    pub block_state: BlockState,
    pub receipts: Vec<R::Receipt>,
    pub cumulative_gas_used: u64,
    pub blob_gas_used: u64,
    /* private fields */
}

Configured Ethereum block executor backed by evm2.

Fields

evm: Evm<'a, T>

EVM containing the execution overlay and optional block access list builder.

block_state: BlockState

Accumulated state changes, including state committed through the executor’s hooks.

receipts: Vec<R::Receipt>

Transaction receipts in execution order.

cumulative_gas_used: u64

Total receipt gas used.

blob_gas_used: u64

Total blob gas used.

Implementations

impl<'a, T, R> EthBlockExecutor<'a, T, R>

where T: EvmTypes<Tx: Typed2718, TxResultExt: Send + Sync>, R: ReceiptBuilder,

pub fn new<C>( evm: Evm<'a, T>, ctx: EthBlockExecutionCtx<'a>, chain_spec: &C, receipt_builder: R, ) -> Self

where C: EthChainSpec + EthereumHardforks + ?Sized,

Creates a configured Ethereum block executor.

pub const fn context(&self) -> &EthBlockExecutionCtx<'a>

Returns the block execution context.

pub const fn block_state(&self) -> &BlockState

Returns the accumulated block state.

pub fn commit_pending_state(&mut self, state: &PendingState)

Commits detached state without recording a transaction receipt or gas usage.

pub const fn set_spec_id(&mut self, spec_id: SpecId)

Sets the Ethereum fork used for block system calls and deposit request processing.

Trait Implementations

impl<'a, T, R> BlockExecutor for EthBlockExecutor<'a, T, R>

where T: EvmTypes<Tx: Typed2718, TxResultExt: Send + Sync>, R: ReceiptBuilder,

type Transaction = <R as ReceiptBuilder>::Transaction

Consensus transaction type executed by this executor.

type Receipt = <R as ReceiptBuilder>::Receipt

Receipt type produced by this executor.

type Evm = Evm<'a, T>

EVM instance used by this executor.

type TransactionResultWithState = EthTransactionResultWithState<T, <<R as ReceiptBuilder>::Transaction as TransactionEnvelope>::TxType>

Owned transaction execution result and detached state changes.

type BlockAccessList = Bal

EVM-native block access list used for indexed reads.

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

Returns the underlying EVM.

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

Returns the underlying EVM mutably.

fn set_state_hook( &mut self, hook: impl FnMut(StateUpdate) + Send + 'static, ) -> bool

Sets a hook for state updates emitted during block execution, including pre-execution block changes and transaction changes.

fn convert_block_access_list( block_access_list: &BlockAccessList, ) -> Result<Self::BlockAccessList, BlockExecutionError>

Converts a canonical EIP-7928 block access list into the EVM-native representation.

fn set_block_access_list( &mut self, block_access_list: Arc<Self::BlockAccessList>, )

Attaches an EIP-7928 block access list for indexed state reads.

fn set_block_access_index(&mut self, index: BlockAccessIndex)

Sets the EIP-7928 block access index used by state reads and BAL construction.

fn enable_block_access_list_builder(&mut self)

Enables construction of an EIP-7928 block access list from committed state changes.

fn take_block_access_list(&mut self) -> Option<BlockAccessList>

Takes the canonical EIP-7928 block access list built from committed state changes.

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

Applies pre-execution block changes.

fn into_state(self) -> BundleState

Consumes the executor and returns the state accumulated so far without applying post-execution block changes.

fn validate_transaction_gas_limit( &mut self, transaction_gas_limit: u64, ) -> Result<(), BlockExecutionError>

Validates transaction gas admission against the executor’s current block or segment budget. Speculative workers and ordered commits must perform the same check before accepting a transaction’s result or execution error.

fn execute_transaction_with_commit_condition( &mut self, transaction: impl ExecutorTx<Self>, commit: impl FnOnce(&TxResult<T>, TxStateChanges<'_>) -> CommitChanges, ) -> Result<Option<GasOutput>, BlockExecutionError>

Executes a transaction, invokes f with the borrowed execution result and state changes, and commits changes when f returns [CommitChanges::Yes].

fn execute_transaction_without_commit( &mut self, transaction: impl ExecutorTx<Self>, ) -> Result<Self::TransactionResultWithState, BlockExecutionError>

Executes a transaction and detaches its state changes without committing them.

fn commit_transaction( &mut self, output: Self::TransactionResultWithState, ) -> Result<GasOutput, BlockExecutionError>

Commits detached transaction state and records its receipt and gas accounting.

fn receipts(&self) -> &[Self::Receipt]

Returns receipts accumulated so far.

fn finish_with_block_access_list( self, ) -> Result<(BlockExecutionOutput<Self::Receipt>, Option<BlockAccessList>), BlockExecutionError>

Finishes block execution and returns the output.

fn finish_with_prepared_block_access_list( self, ) -> Result<(BlockExecutionOutput<Self::Receipt>, Option<Bal>), BlockExecutionError>

Finishes execution while retaining the prepared evm2 BAL for downstream consumers.

fn execute_transaction_with_result_closure( &mut self, transaction: impl ExecutorTx<Self>, f: impl FnOnce(&TxResultExt<<<Self::Evm as Evm>::EvmTypes as EvmTypesHost>::TxResultExt>), ) -> Result<GasOutput, BlockExecutionError>

Executes a transaction, invokes f with the borrowed execution result, and commits changes.

fn execute_transaction( &mut self, transaction: impl ExecutorTx<Self>, ) -> Result<GasOutput, BlockExecutionError>

Executes a transaction and commits changes.

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

Finishes block execution and returns the output.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.