Struct TxProcessor 

pub struct TxProcessor {
    pub poster_fee: U256,
    pub poster_gas: u64,
    pub compute_hold_gas: u64,
    pub delayed_inbox: bool,
    pub top_tx_type: Option<u8>,
    pub current_retryable: Option<B256>,
    pub current_refund_to: Option<Address>,
    pub scheduled_txs: Vec<Vec<u8>>,
    pub programs_depth: HashMap<Address, usize>,
}

Per-transaction state for processing Arbitrum transactions.

Created and freed for every L2 transaction. Tracks ArbOS state that influences transaction processing. In reth, this is used by the block executor’s per-transaction logic.

Fields

poster_fee: U256

The poster’s fee contribution (L1 calldata cost expressed in ETH).

poster_gas: u64

Gas reserved for L1 posting costs.

compute_hold_gas: u64

Gas temporarily held to prevent compute from exceeding the gas limit.

delayed_inbox: bool

Whether this tx was submitted through the delayed inbox.

top_tx_type: Option<u8>

The top-level tx type byte, set in StartTxHook.

current_retryable: Option<B256>

The current retryable ticket being redeemed (if any).

current_refund_to: Option<Address>

The refund-to address for retryable redeems.

scheduled_txs: Vec<Vec<u8>>

Scheduled transactions (e.g., retryable auto-redeems).

programs_depth: HashMap<Address, usize>

Count of open Stylus program contexts per contract address. Used to detect reentrance.

Implementations

impl TxProcessor

pub fn new(coinbase: Address) -> Self

Create a new TxProcessor. The delayed_inbox flag indicates whether the coinbase differs from the batch poster address.

pub fn nonrefundable_gas(&self) -> u64

Gas that should not be refundable (the poster’s L1 cost component).

pub fn held_gas(&self) -> u64

Gas held back to limit computation; must be refunded after computation completes.

pub fn drop_tip(&self, arbos_version: u64) -> bool

Whether the tip should be dropped (version-gated behavior).

pub fn get_paid_gas_price( &self, arbos_version: u64, base_fee: U256, gas_price: U256, ) -> U256

Get the effective gas price paid.

pub fn gas_price_op( &self, arbos_version: u64, base_fee: U256, gas_price: U256, ) -> U256

The GASPRICE opcode return value.

pub fn fill_receipt_gas_used_for_l1(&self) -> u64

Fill receipt info with the poster gas used for L1.

pub fn push_program(&mut self, addr: Address)

Record entering a Stylus program context for a contract address.

pub fn pop_program(&mut self, addr: Address)

Record leaving a Stylus program context for a contract address.

pub fn is_reentrant(&self, addr: &Address) -> bool

Whether the given address has a reentrant Stylus call.

pub fn reverted_tx_hook( &self, tx_hash: Option<B256>, pre_recorded_gas: Option<u64>, is_filtered: bool, ) -> RevertedTxAction

Check for pre-recorded reverted or filtered transactions.

Returns an action describing how the caller should handle this tx before normal execution. The caller should:

• None: proceed with normal execution
• PreRecordedRevert: increment sender nonce, deduct gas_to_consume from gas remaining, and return execution-reverted error
• FilteredTx: increment sender nonce, consume ALL remaining gas, and return filtered-tx error

pub fn set_tx_type(&mut self, tx_type: u8)

Set the top-level transaction type for this tx.

pub fn prepare_retry_tx(&mut self, ticket_id: B256, refund_to: Address)

Set up state for processing a retry transaction.

The caller should:

1. Verify the retryable exists (via RetryableState::open_retryable)
2. Transfer call value from escrow to from
3. Mint prepaid gas (base_fee * gas) to from
4. Continue to gas charging and EVM execution

pub fn gas_charging_hook( &mut self, gas_remaining: &mut u64, intrinsic_gas: u64, params: &GasChargingParams, ) -> Result<(), GasChargingError>

Compute poster gas and held compute gas.

Charges poster data cost from the remaining gas and holds excess compute gas to enforce per-block/per-tx limits. After calling, poster_gas, poster_fee, and compute_hold_gas are set.

pub fn compute_end_tx_fee_distribution( &self, params: &EndTxNormalParams, ) -> EndTxFeeDistribution

Compute fee distribution for a normal (non-retryable) transaction.

Returns the amounts to mint to each fee account and the gas to add to the backlog. The caller executes the balance operations.

pub fn end_tx_retryable<F>( &self, params: &EndTxRetryableParams, burn_fn: impl FnMut(Address, U256), transfer_fn: F, ) -> EndTxRetryableResult

where F: FnMut(Address, Address, U256) -> Result<(), ()>,

Process end-of-tx for a retryable redemption.

Handles undoing geth’s gas refund, distributing refunds between the refund-to address and the sender, and determining whether to delete the retryable or return value to escrow.

Trait Implementations

impl Debug for TxProcessor

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

Formats the value using the given formatter.

impl Default for TxProcessor

fn default() -> Self

Returns the “default value” for a type.