fix(forge): account gas limit per fork when script simulate

Author: grandizzy

crates/cheatcodes/src/inspector.rs

@@ -40,7 +40,7 @@ use foundry_common::{
 use foundry_evm_core::{
     InspectorExt,
     abi::Vm::stopExpectSafeMemoryCall,
-    backend::{DatabaseError, DatabaseExt, RevertDiagnostic},
+    backend::{DatabaseError, DatabaseExt, LocalForkId, RevertDiagnostic},
     constants::{CHEATCODE_ADDRESS, HARDHAT_CONSOLE_ADDRESS, MAGIC_ASSUME},
     evm::{FoundryEvm, new_evm_with_existing_context},
 };
@@ -499,6 +499,8 @@ pub struct Cheatcodes {
     pub wallets: Option<Wallets>,
     /// Signatures identifier for decoding events and functions
     pub signatures_identifier: Option<SignaturesIdentifier>,
+    /// Broadcast gas limits, per fork.
+    pub broadcast_gas_limits: HashMap<LocalForkId, u64>,
 }
 
 // This is not derived because calling this in `fn new` with `..Default::default()` creates a second
@@ -554,6 +556,7 @@ impl Cheatcodes {
             deprecated: Default::default(),
             wallets: Default::default(),
             signatures_identifier: SignaturesIdentifier::new(true).ok(),
+            broadcast_gas_limits: Default::default(),
         }
     }
 
@@ -852,7 +855,11 @@ impl Cheatcodes {
                         });
                     }
 
-                    let is_fixed_gas_limit = check_if_fixed_gas_limit(&ecx, call.gas_limit);
+                    let is_fixed_gas_limit = check_if_fixed_gas_limit(
+                        &mut self.broadcast_gas_limits,
+                        &ecx,
+                        call.gas_limit,
+                    );
 
                     let input = TransactionInput::new(call.input.bytes(ecx));
 
@@ -1612,7 +1619,11 @@ impl Inspector<EthEvmContext<&mut dyn DatabaseExt>> for Cheatcodes {
 
             if curr_depth == broadcast.depth {
                 input.set_caller(broadcast.new_origin);
-                let is_fixed_gas_limit = check_if_fixed_gas_limit(&ecx, input.gas_limit());
+                let is_fixed_gas_limit = check_if_fixed_gas_limit(
+                    &mut self.broadcast_gas_limits,
+                    &ecx,
+                    input.gas_limit(),
+                );
 
                 let account = &ecx.journaled_state.inner.state()[&broadcast.new_origin];
                 self.broadcastable_transactions.push_back(BroadcastableTransaction {
@@ -2320,17 +2331,33 @@ fn disallowed_mem_write(
 }
 
 // Determines if the gas limit on a given call was manually set in the script and should therefore
-// not be overwritten by later estimations
-fn check_if_fixed_gas_limit(ecx: &Ecx, call_gas_limit: u64) -> bool {
+// not be overwritten by later estimations. Applies the gas limit per each fork.
+fn check_if_fixed_gas_limit(
+    broadcast_gas_limits: &mut HashMap<LocalForkId, u64>,
+    ecx: &Ecx,
+    call_gas_limit: u64,
+) -> bool {
+    let call_limit_on_active_fork =
+        ecx.journaled_state.database.active_fork_id().map_or(0, |fork_id| {
+            let total_limits: u64 = broadcast_gas_limits.values().sum();
+            let other_forks_limit =
+                total_limits - broadcast_gas_limits.get(&fork_id).copied().unwrap_or(0);
+            // Calculate and update call limit for the current fork.
+            let call_limit_on_active_fork =
+                ecx.tx.gas_limit.saturating_sub(call_gas_limit + other_forks_limit);
+            broadcast_gas_limits.insert(fork_id, call_limit_on_active_fork);
+            call_limit_on_active_fork
+        });
+
     // If the gas limit was not set in the source code it is set to the estimated gas left at the
-    // time of the call, which should be rather close to configured gas limit.
+    // time of the call, per fork, which should be rather close to configured gas limit.
     // TODO: Find a way to reliably make this determination.
     // For example by generating it in the compilation or EVM simulation process
     ecx.tx.gas_limit > ecx.block.gas_limit &&
-        call_gas_limit <= ecx.block.gas_limit
+        call_limit_on_active_fork <= ecx.block.gas_limit
         // Transfers in forge scripts seem to be estimated at 2300 by revm leading to "Intrinsic
         // gas too low" failure when simulated on chain
-        && call_gas_limit > 2300
+        && call_limit_on_active_fork > 2300
 }
 
 /// Returns true if the kind of account access is a call.