Struct L2PricingState 

pub struct L2PricingState<'a, D> {
    pub backing_storage: Storage<'a, D>,
    pub arbos_version: u64,
    /* private fields */
}

L2 pricing state manages gas pricing for L2 execution.

Fields

backing_storage: Storage<'a, D>

arbos_version: u64

Implementations

impl<D: Database> L2PricingState<'_, D>

pub fn gas_model_to_use<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<GasModel, L2PricingError>

Determine which gas model to use based on ArbOS version and stored constraints.

pub fn grow_backlog<B: StorageBackend>( &self, backend: &mut B, used_gas: u64, used_multi_gas: MultiGas, ) -> Result<(), L2PricingError>

Grow the gas backlog for the active pricing model.

pub fn shrink_backlog<B: StorageBackend>( &self, backend: &mut B, used_gas: u64, used_multi_gas: MultiGas, ) -> Result<(), L2PricingError>

Shrink the gas backlog for the active pricing model.

pub fn update_pricing_model<B: StorageBackend>( &self, backend: &mut B, time_passed: u64, arbos_version: u64, ) -> Result<(), L2PricingError>

Update the pricing model for a new block.

pub fn calc_multi_gas_constraints_exponents<B: StorageBackend>( &self, backend: &mut B, ) -> Result<[u64; 9], L2PricingError>

Calculate exponent (in basis points) per resource kind across all constraints.

pub fn calc_base_fee_from_exponent<B: StorageBackend>( &self, backend: &mut B, exponent_bips: u64, ) -> Result<U256, L2PricingError>

Calculate base fee from an exponent in basis points. base_fee = min_base_fee * exp(exponent_bips / 10000)

pub fn get_multi_gas_base_fee_per_resource<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<[U256; 9], L2PricingError>

pub fn get_current_multi_gas_fees<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<[U256; 9], L2PricingError>

Reads the 8 current-block multi-gas fees (non-SingleDim). Intended for block-level caching by the executor: these values are only written by commit_next_to_current, which runs before any tx in the block. Zero is kept (not substituted to base_fee_wei) so the caller can do the substitution with a fresh base_fee read on every use.

pub fn commit_multi_gas_fees<B: StorageBackend>( &self, backend: &mut B, ) -> Result<(), L2PricingError>

Rotate next-block multi-gas fees into current-block fees.

pub fn backlog_update_cost<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, L2PricingError>

Calculate the cost for a backlog update operation.

pub fn set_gas_constraints_from_legacy<B: StorageBackend>( &self, backend: &mut B, ) -> Result<(), L2PricingError>

Set gas constraints from legacy parameters (for upgrades).

pub fn set_multi_gas_constraints_from_single_gas_constraints<B: StorageBackend>( &self, backend: &mut B, ) -> Result<(), L2PricingError>

Convert single-gas constraints to multi-gas constraints (for upgrades).

pub fn multi_dimensional_price_for_refund<B: SystemStateBackend>( &self, backend: &mut B, gas_used: MultiGas, ) -> Result<U256, L2PricingError>

Compute total cost for a multi-gas usage, for refund calculations.

Returns sum(gas_used[kind] * base_fee[kind]) across all resource kinds.

pub fn multi_dimensional_price_for_refund_with_fees<B: SystemStateBackend>( &self, backend: &mut B, gas_used: MultiGas, cached_fees: &[U256; 9], ) -> Result<U256, L2PricingError>

Variant of multi_dimensional_price_for_refund that uses precomputed current-block multi-gas fees (as returned by get_current_multi_gas_fees).

Single-dimensional gas and any resource whose current-block fee is zero are valued at the live base_fee_wei (the per-block floor), matching get_multi_gas_base_fee_per_resource. The refund reconciles the single-gas cost the sender paid (base_fee × gasUsed) against this multi-dimensional cost over the raw, pre-refund resource usage.

impl<'a, D> L2PricingState<'a, D>

pub fn open(sto: Storage<'a, D>, arbos_version: u64) -> Self

pub fn initialize<B: StorageBackend>( sto: &Storage<'_, D>, backend: &mut B, ) -> Result<(), L2PricingError>

pub fn base_fee_wei<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<U256, L2PricingError>

pub fn set_base_fee_wei<B: StorageBackend>( &self, backend: &mut B, val: U256, ) -> Result<(), L2PricingError>

pub fn min_base_fee_wei<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<U256, L2PricingError>

pub fn set_min_base_fee_wei<B: StorageBackend>( &self, backend: &mut B, val: U256, ) -> Result<(), L2PricingError>

pub fn speed_limit_per_second<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, L2PricingError>

pub fn set_speed_limit_per_second<B: StorageBackend>( &self, backend: &mut B, limit: u64, ) -> Result<(), L2PricingError>

pub fn per_block_gas_limit<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, L2PricingError>

pub fn set_max_per_block_gas_limit<B: StorageBackend>( &self, backend: &mut B, limit: u64, ) -> Result<(), L2PricingError>

pub fn per_tx_gas_limit<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, L2PricingError>

pub fn set_max_per_tx_gas_limit<B: StorageBackend>( &self, backend: &mut B, limit: u64, ) -> Result<(), L2PricingError>

pub fn gas_backlog<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, L2PricingError>

pub fn set_gas_backlog<B: StorageBackend>( &self, backend: &mut B, backlog: u64, ) -> Result<(), L2PricingError>

pub fn pricing_inertia<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, L2PricingError>

pub fn set_pricing_inertia<B: StorageBackend>( &self, backend: &mut B, val: u64, ) -> Result<(), L2PricingError>

pub fn backlog_tolerance<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, L2PricingError>

pub fn set_backlog_tolerance<B: StorageBackend>( &self, backend: &mut B, val: u64, ) -> Result<(), L2PricingError>

pub fn gas_constraints_length<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, L2PricingError>

pub fn open_gas_constraint_at(&self, index: u64) -> GasConstraint

pub fn add_gas_constraint<B: StorageBackend>( &self, backend: &mut B, target: u64, adjustment_window: u64, backlog: u64, ) -> Result<(), L2PricingError>

pub fn clear_gas_constraints<B: StorageBackend>( &self, backend: &mut B, ) -> Result<(), L2PricingError>

pub fn multi_gas_constraints_length<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, L2PricingError>

pub fn open_multi_gas_constraint_at(&self, index: u64) -> MultiGasConstraint

pub fn add_multi_gas_constraint<B: StorageBackend>( &self, backend: &mut B, target: u64, adjustment_window: u32, backlog: u64, weights: &[u64; 9], ) -> Result<(), L2PricingError>

pub fn clear_multi_gas_constraints<B: StorageBackend>( &self, backend: &mut B, ) -> Result<(), L2PricingError>

pub fn restrict(&self, _err: ())

pub fn multi_gas_fees(&self) -> MultiGasFees<'a, D>

Per-resource-kind base fee accessor for the current/next block.