Struct BbBlockExecutor 

pub(crate) struct BbBlockExecutor<'a, DB, I, P, Spec>
where
    DB: Database,
{
    inner: Option<EthBlockExecutor<'a, EthEvm<DB, I, P>, Spec, RethReceiptBuilder>>,
    plan: Option<BbEvmPlan>,
    accumulated_requests: Requests,
    gas_used_offset: u64,
    blob_gas_used_offset: u64,
    shared_hook: Arc<Mutex<Option<Box<dyn OnStateHook>>>>,
    block_hash_seeder: Option<fn(&mut DB, &[(u64, B256)])>,
}

Block executor that wraps [EthBlockExecutor] and handles segment-boundary changes for big-block execution.

At segment boundaries, the inner executor is finished (applying its end-of-block logic: post-execution system calls, withdrawal balance increments) and a new one is constructed for the next segment (applying its start-of-block logic: EIP-2935/EIP-4788 system calls).

Gas counters reset at each boundary so that each segment’s real gas limit is used (preserving correct GASLIMIT opcode behavior). Accumulated offsets are applied to receipts and totals in finish().

Fields

inner: Option<EthBlockExecutor<'a, EthEvm<DB, I, P>, Spec, RethReceiptBuilder>>

The inner executor. None transiently during apply_segment_boundary.

plan: Option<BbEvmPlan>

accumulated_requests: Requests

Requests accumulated from segments that have been finished at boundaries. Merged into the final result in finish().

gas_used_offset: u64

Cumulative gas used by all segments that have been finished at boundaries. Added to receipts and the final gas total in finish().

blob_gas_used_offset: u64

Cumulative blob gas used by all segments that have been finished at boundaries.

shared_hook: Arc<Mutex<Option<Box<dyn OnStateHook>>>>

Shared state hook that survives inner executor finish/reconstruct cycles at segment boundaries. Each inner executor receives a forwarding hook that delegates to this shared instance.

block_hash_seeder: Option<fn(&mut DB, &[(u64, B256)])>

Callback to reseed block hashes into the DB’s cache at segment boundaries. See BlockHashSeeder.

Implementations

impl<'a, DB, I, P, Spec> BbBlockExecutor<'a, DB, I, P, Spec>

where DB: StateDB, I: Inspector<EthEvmContext<DB>>, P: PrecompileProvider<EthEvmContext<DB>, Output = InterpreterResult>, Spec: EthExecutorSpec + Clone, EthEvm<DB, I, P>: Evm<DB = DB, Tx = TxEnv, HaltReason = HaltReason, Error = EVMError<DB::Error>, Spec = SpecId, BlockEnv = BlockEnv>, TxEnv: FromRecoveredTx<TransactionSigned> + FromTxWithEncoded<TransactionSigned>,

pub(crate) fn new( evm: EthEvm<DB, I, P>, ctx: EthBlockExecutionCtx<'a>, spec: Spec, receipt_builder: RethReceiptBuilder, plan: Option<BbEvmPlan>, block_hash_seeder: Option<fn(&mut DB, &[(u64, B256)])>, ) -> Self

fn forwarding_hook(&self) -> Option<Box<dyn OnStateHook>>

Creates a forwarding OnStateHook that delegates to the shared hook.

const fn inner( &self, ) -> &EthBlockExecutor<'a, EthEvm<DB, I, P>, Spec, RethReceiptBuilder>

const fn inner_mut( &mut self, ) -> &mut EthBlockExecutor<'a, EthEvm<DB, I, P>, Spec, RethReceiptBuilder>

fn reseed_block_hashes_for(&mut self, block_number: u64)

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

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

Trait Implementations

impl<'a, DB, I, P, Spec> BlockExecutor for BbBlockExecutor<'a, DB, I, P, Spec>

where DB: StateDB, I: Inspector<EthEvmContext<DB>>, P: PrecompileProvider<EthEvmContext<DB>, Output = InterpreterResult>, Spec: EthExecutorSpec + Clone, EthEvm<DB, I, P>: Evm<DB = DB, Tx = TxEnv, HaltReason = HaltReason, Error = EVMError<DB::Error>, Spec = SpecId, BlockEnv = BlockEnv>, TxEnv: FromRecoveredTx<TransactionSigned> + FromTxWithEncoded<TransactionSigned>,

type Transaction = EthereumTxEnvelope<TxEip4844>

Input transaction type.

type Receipt = EthereumReceipt

Receipt type this executor produces.

type Evm = EthEvm<DB, I, P>

EVM used by the executor.

type Result = EthTxResult<HaltReason, TxType>

Result of a transaction execution.

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<Self::Result, BlockExecutionError>

Executes a single transaction without committing state changes.

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

Commits a previously executed transaction’s state changes.

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.

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

Exposes immutable reference to EVM.

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

Returns a reference to all recorded receipts.

fn execute_transaction( &mut self, tx: impl ExecutableTx<Self>, ) -> Result<GasOutput, 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(&Self::Result), ) -> Result<GasOutput, BlockExecutionError>

Executes a single transaction and applies execution result to internal state. Invokes the given closure with an internal Self::Result produced by the EVM.

fn execute_transaction_with_commit_condition( &mut self, tx: impl ExecutableTx<Self>, f: impl FnOnce(&Self::Result) -> CommitChanges, ) -> Result<Option<GasOutput>, BlockExecutionError>

Executes a single transaction and applies execution result to internal state. Invokes the given closure with an internal Self::Result 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.

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.