feat: add EIP-8037 / TIP-1016 state gas support

crates/context/interface/src/cfg.rs

@@ -87,6 +87,13 @@ pub trait Cfg {
 
     /// Returns the gas params for the EVM.
     fn gas_params(&self) -> &GasParams;
+
+    /// Returns whether EIP-8037 (Amsterdam) state creation gas cost increase is enabled.
+    ///
+    /// When enabled, storage creation gas is tracked separately from regular gas
+    /// via the reservoir model. EIP-8037 specifies concrete gas values based on
+    /// `cost_per_state_byte` and adds a hash cost for deployed bytecode.
+    fn is_amsterdam_eip8037_enabled(&self) -> bool;
 }
 
 /// What bytecode analysis to perform

crates/context/interface/src/cfg/gas.rs

@@ -3,6 +3,149 @@
 use crate::{cfg::GasParams, transaction::AccessListItemTr as _, Transaction, TransactionType};
 use primitives::hardfork::SpecId;
 
+/// Tracker for gas during execution.
+///
+/// This is used to track the gas during execution.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct GasTracker {
+    /// Gas Limit,
+    gas_limit: u64,
+    /// Regular gas remaining (`gas_left`). Reservoir is tracked separately.
+    remaining: u64,
+    /// State gas reservoir (gas exceeding TX_MAX_GAS_LIMIT). Starts as `execution_gas - min(execution_gas, regular_gas_budget)`.
+    /// When 0, all remaining gas is regular gas with hard cap at `TX_MAX_GAS_LIMIT`.
+    reservoir: u64,
+    /// Total state gas spent so far.
+    state_gas_spent: u64,
+    /// Refunded gas. Used to refund the gas to the caller at the end of execution.
+    refunded: i64,
+}
+
+impl GasTracker {
+    /// Creates a new `GasTracker` with the given remaining gas and reservoir.
+    #[inline]
+    pub const fn new(gas_limit: u64, remaining: u64, reservoir: u64) -> Self {
+        Self {
+            gas_limit,
+            remaining,
+            reservoir,
+            state_gas_spent: 0,
+            refunded: 0,
+        }
+    }
+
+    /// Creates a new `GasTracker` with the given used gas and reservoir.
+    #[inline]
+    pub const fn new_used_gas(gas_limit: u64, used_gas: u64, reservoir: u64) -> Self {
+        Self::new(gas_limit, gas_limit - used_gas, reservoir)
+    }
+
+    /// Returns the remaining gas.
+    #[inline]
+    pub const fn remaining(&self) -> u64 {
+        self.remaining
+    }
+
+    /// Sets the remaining gas.
+    #[inline]
+    pub fn set_remaining(&mut self, val: u64) {
+        self.remaining = val;
+    }
+
+    /// Returns the reservoir gas.
+    #[inline]
+    pub const fn reservoir(&self) -> u64 {
+        self.reservoir
+    }
+
+    /// Sets the reservoir gas.
+    #[inline]
+    pub fn set_reservoir(&mut self, val: u64) {
+        self.reservoir = val;
+    }
+
+    /// Returns the state gas spent.
+    #[inline]
+    pub const fn state_gas_spent(&self) -> u64 {
+        self.state_gas_spent
+    }
+
+    /// Sets the state gas spent.
+    #[inline]
+    pub fn set_state_gas_spent(&mut self, val: u64) {
+        self.state_gas_spent = val;
+    }
+
+    /// Returns the refunded gas.
+    #[inline]
+    pub const fn refunded(&self) -> i64 {
+        self.refunded
+    }
+
+    /// Sets the refunded gas.
+    #[inline]
+    pub fn set_refunded(&mut self, val: i64) {
+        self.refunded = val;
+    }
+
+    /// Records a regular gas cost.
+    ///
+    /// Deducts from `remaining`. Returns `false` if insufficient gas.
+    #[inline]
+    #[must_use]
+    pub fn record_regular_cost(&mut self, cost: u64) -> bool {
+        if let Some(new_remaining) = self.remaining.checked_sub(cost) {
+            self.remaining = new_remaining;
+            return true;
+        }
+        false
+    }
+
+    /// Records a state gas cost (EIP-8037 reservoir model).
+    ///
+    /// State gas charges deduct from the reservoir first. If the reservoir is exhausted,
+    /// remaining charges spill into `remaining` (requiring `remaining >= cost`).
+    /// Tracks state gas spent.
+    ///
+    /// Returns `false` if total remaining gas is insufficient.
+    #[inline]
+    pub fn record_state_cost(&mut self, cost: u64) -> bool {
+        if self.reservoir >= cost {
+            self.state_gas_spent = self.state_gas_spent.saturating_add(cost);
+            self.reservoir -= cost;
+            return true;
+        }
+
+        let spill = cost - self.reservoir;
+
+        let success = self.record_regular_cost(spill);
+        if success {
+            self.state_gas_spent = self.state_gas_spent.saturating_add(cost);
+            self.reservoir = 0;
+        }
+        success
+    }
+
+    /// Records a refund value.
+    #[inline]
+    pub fn record_refund(&mut self, refund: i64) {
+        self.refunded += refund;
+    }
+
+    /// Erases a gas cost from remaining (returns gas from child frame).
+    #[inline]
+    pub fn erase_cost(&mut self, returned: u64) {
+        self.remaining += returned;
+    }
+
+    /// Spends all remaining gas excluding the reservoir.
+    #[inline]
+    pub fn spend_all(&mut self) {
+        self.remaining = 0;
+    }
+}
+
 /// Gas cost for operations that consume zero gas.
 pub const ZERO: u64 = 0;
 /// Base gas cost for basic operations.
@@ -112,7 +255,13 @@ pub const CALL_STIPEND: u64 = 2300;
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct InitialAndFloorGas {
     /// Initial gas for transaction.
-    pub initial_gas: u64,
+    pub initial_total_gas: u64,
+    /// State gas component of initial_gas (subset of initial_total_gas).
+    /// Under EIP-8037, this includes:
+    /// - EIP-7702 auth list state gas (per-auth account creation + metadata costs)
+    /// - For CREATE transactions: `create_state_gas` (account creation + contract metadata)
+    /// - For CALL transactions: 0 (state gas is unpredictable at validation time)
+    pub initial_state_gas: u64,
     /// If transaction is a Call and Prague is enabled
     /// floor_gas is at least amount of gas that is going to be spent.
     pub floor_gas: u64,
@@ -121,9 +270,24 @@ pub struct InitialAndFloorGas {
 impl InitialAndFloorGas {
     /// Create a new InitialAndFloorGas instance.
     #[inline]
-    pub const fn new(initial_gas: u64, floor_gas: u64) -> Self {
+    pub const fn new(initial_total_gas: u64, floor_gas: u64) -> Self {
+        Self {
+            initial_total_gas,
+            initial_state_gas: 0,
+            floor_gas,
+        }
+    }
+
+    /// Create a new InitialAndFloorGas instance with state gas tracking.
+    #[inline]
+    pub const fn new_with_state_gas(
+        initial_total_gas: u64,
+        initial_state_gas: u64,
+        floor_gas: u64,
+    ) -> Self {
         Self {
-            initial_gas,
+            initial_total_gas,
+            initial_state_gas,
             floor_gas,
         }
     }