Struct ArbBlockExecutor 

pub struct ArbBlockExecutor<'a, Evm, Spec, R: ReceiptBuilder> {
    pub inner: EthBlockExecutor<'a, Evm, Spec, R>,
    pub arb_hooks: Option<DefaultArbOsHooks>,
    pub arb_ctx: ArbBlockExecutionCtx,
    pub block_gas_left: u64,
    pub gas_used_for_l1: Vec<u64>,
    pub multi_gas_used: Vec<MultiGas>,
    /* private fields */
}

Arbitrum block executor wrapping EthBlockExecutor.

Adds ArbOS-specific pre/post execution logic:

• Loads ArbOS state at block start (version, fee accounts)
• Adjusts gas accounting for L1 poster costs
• Distributes fees to network/infra/poster accounts after each tx
• Tracks block gas consumption for rate limiting

Fields

inner: EthBlockExecutor<'a, Evm, Spec, R>

Inner Ethereum block executor.

arb_hooks: Option<DefaultArbOsHooks>

ArbOS hooks for per-transaction processing.

arb_ctx: ArbBlockExecutionCtx

Arbitrum-specific block context.

block_gas_left: u64

Remaining block gas for rate limiting. Starts at per_block_gas_limit and decreases with each tx’s compute gas.

gas_used_for_l1: Vec<u64>

Per-receipt poster gas (L1 gas component), parallel to the receipts vector. Used to populate gasUsedForL1 in RPC receipt responses.

multi_gas_used: Vec<MultiGas>

Per-receipt multi-dimensional gas, parallel to the receipts vector.

Implementations

impl<'a, Evm, Spec, R: ReceiptBuilder> ArbBlockExecutor<'a, Evm, Spec, R>

pub fn with_hooks(self, hooks: DefaultArbOsHooks) -> Self

Set the ArbOS hooks for this block execution.

pub fn with_arb_ctx(self, ctx: ArbBlockExecutionCtx) -> Self

Set the Arbitrum execution context.

pub fn zombie_accounts(&self) -> HashSet<Address>

Returns the set of zombie account addresses.

Zombie accounts are empty accounts that should be preserved in the state trie (not deleted by EIP-161) because they were re-created by a zero-value transfer on pre-Stylus ArbOS.

pub fn finalise_deleted(&self) -> &HashSet<Address>

Returns accounts deleted by per-tx Finalise (EIP-161). These may need trie deletion if they existed pre-block.

pub fn deduct_failed_tx_gas(&mut self, is_user_tx: bool)

Deduct TX_GAS from block gas budget for a failed/invalid transaction. Call this when a user transaction fails execution so the block budget and user-tx counter stay in sync (TX_GAS is charged for invalid txs and userTxsProcessed is incremented).

pub fn drain_scheduled_txs(&mut self) -> Vec<Vec<u8>>

Drain any scheduled transactions (e.g. auto-redeem retry txs) produced by the most recently committed transaction. The caller should decode and re-inject these as new transactions in the same block.

Trait Implementations

impl<'a, Evm, Spec, R: ReceiptBuilder> ArbScheduledTxDrain for ArbBlockExecutor<'a, Evm, Spec, R>

fn drain_scheduled_txs(&mut self) -> Vec<Vec<u8>>

Drain any scheduled transactions (e.g. auto-redeem retry txs) produced by the most recently committed transaction.

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

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

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.

type Result = EthTxResult<<E as Evm>::HaltReason, <<R as ReceiptBuilder>::Transaction as TransactionEnvelope>::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<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 receipts(&self) -> &[Self::Receipt]

Returns a reference to all recorded receipts.

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.