Struct L1PricingState 

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

L1 pricing state manages the cost model for L1 data posting.

Fields

backing_storage: Storage<'a, D>

arbos_version: u64

Implementations

impl<'a, D> L1PricingState<'a, D>

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

pub fn batch_poster_table(&self) -> BatchPostersTable<'a, D>

pub fn pay_rewards_to<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<Address, L1PricingError>

pub fn set_pay_rewards_to<B: StorageBackend>( &self, backend: &mut B, addr: Address, ) -> Result<(), L1PricingError>

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

pub fn set_equilibration_units<B: StorageBackend>( &self, backend: &mut B, units: U256, ) -> Result<(), L1PricingError>

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

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

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

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

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

pub fn set_last_update_time<B: StorageBackend>( &self, backend: &mut B, time: u64, ) -> Result<(), L1PricingError>

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

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

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

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

pub fn add_to_units_since_update<B: StorageBackend>( &self, backend: &mut B, units: u64, ) -> Result<(), L1PricingError>

pub fn subtract_from_units_since_update<B: StorageBackend>( &self, backend: &mut B, units: u64, ) -> Result<(), L1PricingError>

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

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

pub fn last_surplus<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<(U256, bool), L1PricingError>

pub fn set_last_surplus<B: StorageBackend>( &self, backend: &mut B, magnitude: U256, negative: bool, ) -> Result<(), L1PricingError>

pub fn per_batch_gas_cost<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<i64, L1PricingError>

pub fn set_per_batch_gas_cost<B: StorageBackend>( &self, backend: &mut B, val: i64, ) -> Result<(), L1PricingError>

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

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

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

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

pub fn add_to_l1_fees_available<B: StorageBackend>( &self, backend: &mut B, amount: U256, ) -> Result<(), L1PricingError>

pub fn transfer_from_l1_fees_available<B: StorageBackend>( &self, backend: &mut B, amount: U256, ) -> Result<U256, L1PricingError>

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

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

pub fn get_l1_pricing_surplus<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<(U256, bool), L1PricingError>

pub fn poster_data_cost<B: SystemStateBackend>( &self, backend: &mut B, calldata_units: u64, ) -> Result<U256, L1PricingError>

pub fn compute_poster_cost<B: SystemStateBackend>( &self, backend: &mut B, poster: Address, tx_bytes: &[u8], brotli_compression_level: u64, ) -> Result<(U256, u64), L1PricingError>

Compute poster cost and units for a transaction on-chain.

pub fn poster_data_cost_for_estimation<B: SystemStateBackend>( &self, backend: &mut B, tx_bytes: &[u8], brotli_compression_level: u64, ) -> Result<(U256, u64), L1PricingError>

Compute poster data cost for gas estimation (with padding).

pub fn get_poster_units_without_cache( &self, tx_bytes: &[u8], brotli_compression_level: u64, ) -> u64

Compute the L1 calldata units for a transaction.

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

pub fn initialize<B: StorageBackend>( sto: &Storage<'_, D>, backend: &mut B, rewards_recipient: Address, initial_l1_base_fee: U256, ) -> Result<(), L1PricingError>

pub fn get_poster_info<B: StorageBackend>( &self, backend: &mut B, poster: Address, ) -> Result<(U256, Address), L1PricingError>

pub fn update_for_batch_poster_spending<F, B>( &self, backend: &mut B, update_time: u64, current_time: u64, batch_poster: Address, wei_spent: U256, l1_basefee: U256, transfer_fn: F, ) -> Result<(), L1PricingError>

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

Update pricing based on a batch poster spending report.