fix(forge): fix dynamic gas limit check (#12267)

* fix(forge): fix dynamic gas limit check

* add repro

Author: grandizzy

crates/cheatcodes/src/inspector.rs

@@ -506,11 +506,8 @@ pub struct Cheatcodes {
     pub wallets: Option<Wallets>,
     /// Signatures identifier for decoding events and functions
     signatures_identifier: OnceLock<Option<SignaturesIdentifier>>,
-    /// Used to determine whether the broadcasted call has non-fixed gas limit.
-    /// Holds values for (seen opcode GAS, seen opcode CALL) pair.
-    /// If GAS opcode is followed by CALL opcode then both flags are marked true and call
-    /// has non-fixed gas limit, otherwise the call is considered to have fixed gas limit.
-    pub dynamic_gas_limit_sequence: Option<(bool, bool)>,
+    /// Used to determine whether the broadcasted call has dynamic gas limit.
+    pub dynamic_gas_limit: bool,
     // Custom execution evm version.
     pub execution_evm_version: Option<SpecId>,
 }
@@ -569,7 +566,7 @@ impl Cheatcodes {
             deprecated: Default::default(),
             wallets: Default::default(),
             signatures_identifier: Default::default(),
-            dynamic_gas_limit_sequence: Default::default(),
+            dynamic_gas_limit: Default::default(),
             execution_evm_version: None,
         }
     }
@@ -859,6 +856,11 @@ impl Cheatcodes {
 
         // Apply our broadcast
         if let Some(broadcast) = &self.broadcast {
+            // Additional check as transfers in forge scripts seem to be estimated at 2300
+            // by revm leading to "Intrinsic gas too low" failure when simulated on chain.
+            let is_fixed_gas_limit = call.gas_limit >= 21_000 && !self.dynamic_gas_limit;
+            self.dynamic_gas_limit = false;
+
             // We only apply a broadcast *to a specific depth*.
             //
             // We do this because any subsequent contract calls *must* exist on chain and
@@ -886,15 +888,6 @@ impl Cheatcodes {
                         });
                     }
 
-                    let (gas_seen, call_seen) =
-                        self.dynamic_gas_limit_sequence.take().unwrap_or_default();
-                    // Transaction has fixed gas limit if no GAS opcode seen before CALL opcode.
-                    let mut is_fixed_gas_limit = !(gas_seen && call_seen);
-                    // Additional check as transfers in forge scripts seem to be estimated at 2300
-                    // by revm leading to "Intrinsic gas too low" failure when simulated on chain.
-                    if call.gas_limit < 21_000 {
-                        is_fixed_gas_limit = false;
-                    }
                     let input = TransactionInput::new(call.input.bytes(ecx));
 
                     let account =
@@ -1122,7 +1115,7 @@ impl Inspector<EthEvmContext<&mut dyn DatabaseExt>> for Cheatcodes {
         self.pc = interpreter.bytecode.pc();
 
         if self.broadcast.is_some() {
-            self.record_gas_limit_opcode(interpreter);
+            self.set_gas_limit_type(interpreter);
         }
 
         // `pauseGasMetering`: pause / resume interpreter gas.
@@ -1165,10 +1158,6 @@ impl Inspector<EthEvmContext<&mut dyn DatabaseExt>> for Cheatcodes {
     }
 
     fn step_end(&mut self, interpreter: &mut Interpreter, ecx: Ecx) {
-        if self.broadcast.is_some() {
-            self.set_gas_limit_type(interpreter);
-        }
-
         if self.gas_metering.paused {
             self.meter_gas_end(interpreter);
         }
@@ -2362,38 +2351,18 @@ impl Cheatcodes {
     }
 
     #[cold]
-    fn record_gas_limit_opcode(&mut self, interpreter: &mut Interpreter) {
+    fn set_gas_limit_type(&mut self, interpreter: &mut Interpreter) {
         match interpreter.bytecode.opcode() {
-            // If current opcode is CREATE2 then set non-fixed gas limit.
-            op::CREATE2 => self.dynamic_gas_limit_sequence = Some((true, true)),
-            op::GAS => {
-                if self.dynamic_gas_limit_sequence.is_none() {
-                    // If current opcode is GAS then mark as seen.
-                    self.dynamic_gas_limit_sequence = Some((true, false));
-                }
+            op::CREATE2 => self.dynamic_gas_limit = true,
+            op::CALL => {
+                // If first element of the stack is close to current remaining gas then assume
+                // dynamic gas limit.
+                self.dynamic_gas_limit =
+                    try_or_return!(interpreter.stack.peek(0)) >= interpreter.gas.remaining() - 100
             }
-            _ => {}
+            _ => self.dynamic_gas_limit = false,
         }
     }
-
-    #[cold]
-    fn set_gas_limit_type(&mut self, interpreter: &mut Interpreter) {
-        // Early exit in case we already determined is non-fixed gas limit.
-        if matches!(self.dynamic_gas_limit_sequence, Some((true, true))) {
-            return;
-        }
-
-        // Record CALL opcode if GAS opcode was seen.
-        if matches!(self.dynamic_gas_limit_sequence, Some((true, false)))
-            && interpreter.bytecode.opcode() == op::CALL
-        {
-            self.dynamic_gas_limit_sequence = Some((true, true));
-            return;
-        }
-
-        // Reset dynamic gas limit sequence if GAS opcode was not followed by a CALL opcode.
-        self.dynamic_gas_limit_sequence = None;
-    }
 }
 
 /// Helper that expands memory, stores a revert string pertaining to a disallowed memory write,