fix(evm): meter each RPC transact against a fresh zk gas budget (#232)

* fix(evm): meter each RPC transact against a fresh zk gas budget

eth_estimateGas reuses one EVM for its repeated simulations (full-gas
run, optimistic run, binary search), but the zk gas meter lives on the
EVM instance and transact_raw never reset it, so in-flight usage
accumulated across runs and falsely tripped the 100M Unzen block limit
(observed live: ~28M zk gas fulfillments failing with "zk gas limit
exceeded" while eth_call succeeded). eth_createAccessList and
eth_simulateV1 leaked the same way.

TaikoEvmWrapper now discards in-flight zk gas at the start of every
transact_raw. The block executor opts out via the new
set_per_transact_zk_gas_reset_enabled switch because it owns the
per-transaction bracket (reset, intrinsic charge, commit), keeping
consensus metering byte-for-byte unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* chore(ci): refresh pinned apt.llvm.org installer hash

Upstream llvm.sh moved from opencollab/llvm-jenkins.debian.net@eeed6742
(the previously pinned 9474ecd7) to HEAD 6dc0d1ad, and apt.llvm.org now
serves the new script byte-for-byte, so the stale pin failed every LLVM
setup step (clippy, test, docker llvm install) at checksum verification.

Reviewed the full delta before repinning: a usage exit-code tweak,
long-option parsing (--help/--version/--), and the LLVM 23/24 version
patterns from upstream's "prepare 23". Nothing affects our
"llvm.sh 22 all" invocation.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(evm): clear inspector step bookkeeping in the zk gas reset

Review round 1: reset_transaction_zk_gas only reset the meter, leaving
the inspector path's deferred/pending step state behind. The unwind of
a failed transaction drains deferred steps through call_end/create_end
on current revm — two adversarial nested-call tests pin that — but the
invariant lived in revm's frame handling; clearing everything in the
reset makes the transact boundary locally provable.

Also corrects the flag documentation: eth_createAccessList uses a fresh
EVM per run and eth_simulateV1 runs through the block executor, so the
raw-EVM reuse set is estimateGas, eth_callBundle, and the intra-block
replay helpers.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: davidtaikocha

.github/scripts/install_llvm_ubuntu.sh

@@ -39,7 +39,7 @@ for attempt in $(seq "$attempts"); do
 done
 # Pin the upstream installer so CI and Docker builds fail loudly when it changes; review the new
 # script before updating this hash.
-echo "9474ecd78b52aba6e923976b1e9773f5613027cc7e237b9956986cb536e02a36  $llvm_installer" | sha256sum -c -
+echo "03878e08f47b66cc95bc4b544b0db3c6d9ce8d60e6cf2492ae357984330a9eae  $llvm_installer" | sha256sum -c -
 chmod +x "$llvm_installer"
 "$llvm_installer" "$version" all
 rm -f "$llvm_installer"

crates/block/src/executor.rs

@@ -145,12 +145,16 @@ where
         receipt_builder: R,
     ) -> Self
     where
-        Evm: TaikoAnchorEvm,
+        Evm: TaikoAnchorEvm + TaikoZkGasEvm,
     {
         // The executor installs the authoritative anchor context through the anchor system
         // call in `apply_pre_execution_changes`; replay-only derivation must stay off so a
         // missing initialization keeps failing loudly.
         evm.set_anchor_ctx_derivation_enabled(false);
+        // The executor owns the per-transaction zk gas bracket (reset, intrinsic charge,
+        // commit) in `execute_transaction_without_commit`; the wrapper's per-transact entry
+        // reset must stay off or it would wipe the intrinsic charged before `transact` runs.
+        evm.set_per_transact_zk_gas_reset_enabled(false);
         Self {
             evm,
             ctx,

crates/evm/src/alloy.rs

@@ -60,6 +60,16 @@ pub struct TaikoEvmWrapper<DB: Database, I, P> {
     /// because it installs the authoritative context through the anchor system call, and a
     /// missing pre-execution initialization must keep failing loudly there.
     derive_anchor_ctx: bool,
+    /// Whether [`Evm::transact_raw`] discards in-flight zk gas before executing. Enabled by
+    /// default so RPC-style consumers that reuse one EVM never accumulate zk gas across
+    /// transacts: `eth_estimateGas`'s repeated runs of the same transaction meter from zero,
+    /// and multi-transaction simulations over one raw EVM (`eth_callBundle`, the intra-block
+    /// replay helpers) get a fresh per-transaction budget rather than a consensus-shaped
+    /// cumulative one. Consensus-shaped execution (including `eth_simulateV1`) runs through
+    /// the block executor, which turns this off because it owns the per-transaction bracket
+    /// (reset, intrinsic charge, commit) and an entry reset here would wipe the intrinsic zk
+    /// gas it charges before execution.
+    reset_zk_gas_per_transact: bool,
 }
 
 impl<DB: Database, I, P> TaikoEvmWrapper<DB, I, P> {
@@ -69,18 +79,23 @@ impl<DB: Database, I, P> TaikoEvmWrapper<DB, I, P> {
     where
         P: PrecompileProvider<TaikoEvmContext<DB>, Output = InterpreterResult>,
     {
-        Self { inner: revmc::revm_evm::JitEvm::disabled(evm), inspect, derive_anchor_ctx: true }
+        Self {
+            inner: revmc::revm_evm::JitEvm::disabled(evm),
+            inspect,
+            derive_anchor_ctx: true,
+            reset_zk_gas_per_transact: true,
+        }
     }
 
     /// Creates an interpreter-backed [`TaikoEvmWrapper`] instance.
     #[cfg(not(feature = "jit"))]
     pub const fn new(evm: BaseTaikoEvm<DB, I, P>, inspect: bool) -> Self {
-        Self { inner: evm, inspect, derive_anchor_ctx: true }
+        Self { inner: evm, inspect, derive_anchor_ctx: true, reset_zk_gas_per_transact: true }
     }
 
     /// Creates a wrapper around an already configured optional JIT dispatcher.
     pub(crate) fn new_with_inner(evm: InnerTaikoEvm<DB, I, P>, inspect: bool) -> Self {
-        Self { inner: evm, inspect, derive_anchor_ctx: true }
+        Self { inner: evm, inspect, derive_anchor_ctx: true, reset_zk_gas_per_transact: true }
     }
 
     /// Consumes self and return the inner EVM instance.
@@ -210,6 +225,16 @@ impl<DB: Database, I, P> TaikoAnchorEvm for TaikoEvmWrapper<DB, I, P> {
 
 /// EVM extension trait for reading and mutating the zk gas meter state.
 pub trait TaikoZkGasEvm {
+    /// Enables or disables the automatic in-flight zk gas reset at the start of every transact.
+    ///
+    /// Enabled by default: RPC-style consumers reuse one EVM across transacts
+    /// (`eth_estimateGas` re-runs the same transaction; `eth_callBundle` and the intra-block
+    /// replay helpers execute a transaction sequence), and each run must meter from zero
+    /// instead of inheriting earlier runs' usage. The block executor disables it because it
+    /// drives the meter through its own reset/intrinsic-charge/commit bracket, which an entry
+    /// reset would corrupt by wiping the intrinsic charged before execution.
+    fn set_per_transact_zk_gas_reset_enabled(&mut self, enabled: bool);
+
     /// Discards any in-flight zk gas recorded for the current transaction.
     fn reset_transaction_zk_gas(&mut self);
 
@@ -236,11 +261,21 @@ where
     I: Inspector<TaikoEvmContext<DB>>,
     P: PrecompileProvider<TaikoEvmContext<DB>, Output = InterpreterResult>,
 {
+    /// Enables or disables the automatic in-flight zk gas reset at the start of every transact.
+    fn set_per_transact_zk_gas_reset_enabled(&mut self, enabled: bool) {
+        self.reset_zk_gas_per_transact = enabled;
+    }
+
     /// Discards any in-flight zk gas recorded for the current transaction.
+    ///
+    /// Covers both metering homes — the production meter on the base EVM and the inspector's
+    /// meter plus its step bookkeeping (only one of the two is ever installed) — so nothing an
+    /// aborted run recorded can charge into the next transaction.
     fn reset_transaction_zk_gas(&mut self) {
-        if let Some(meter) = self.meter_mut() {
+        if let Some(meter) = self.base_evm_mut().zk_gas_meter_mut() {
             meter.reset_transaction();
         }
+        self.base_evm_mut().inner.inspector.reset_transaction();
     }
 
     /// Commits the current transaction's zk gas into the block total and returns the new total.
@@ -363,6 +398,15 @@ where
         &mut self,
         tx: Self::Tx,
     ) -> Result<ResultAndState<Self::HaltReason>, Self::Error> {
+        // RPC callers that reuse one EVM (`eth_estimateGas`'s repeated runs of one transaction,
+        // `eth_callBundle`'s and the intra-block replay helpers' transaction sequences) never
+        // commit the meter, so without a reset the in-flight zk gas of previous runs
+        // accumulates and eventually trips the block budget. The block executor disables this
+        // and manages the per-transaction bracket itself; `eth_simulateV1` and consensus paths
+        // reach the meter through the block executor.
+        if self.reset_zk_gas_per_transact {
+            self.reset_transaction_zk_gas();
+        }
         self.maybe_derive_anchor_execution_ctx(&tx)?;
         self.ctx_mut().set_tx(tx);
         // Run [`TaikoEvmHandler`] against the (possibly JIT-dispatching) inner EVM directly:

crates/evm/src/zk_gas/adapter.rs

@@ -75,6 +75,16 @@ impl<I> ZkGasInspector<I> {
     pub(crate) fn meter_mut(&mut self) -> Option<&mut ZkGasMeter<'static>> {
         self.metering.as_mut().map(|state| &mut state.meter)
     }
+
+    /// Discards in-flight transaction metering state, if metering is enabled.
+    ///
+    /// Clears both the meter's per-transaction usage and the inspector's step bookkeeping so
+    /// nothing recorded by an aborted transaction can charge into the next one.
+    pub(crate) fn reset_transaction(&mut self) {
+        if let Some(metering) = &mut self.metering {
+            metering.reset_transaction();
+        }
+    }
 }
 
 impl<DB, I> Inspector<TaikoEvmContext<DB>, EthInterpreter> for ZkGasInspector<I>
@@ -302,6 +312,21 @@ impl ZkGasMeteringState {
         }
     }
 
+    /// Discards the in-flight transaction zk gas together with all per-frame step bookkeeping.
+    ///
+    /// The unwind of a failed transaction drains deferred steps through `call_end`/`create_end`
+    /// today, but that invariant lives in revm's frame handling; resetting everything here keeps
+    /// the transaction boundary self-contained regardless of how execution aborted.
+    fn reset_transaction(&mut self) {
+        self.meter.reset_transaction();
+        for index in 0..=self.max_active_depth {
+            self.pending_steps[index] = PendingStep::EMPTY;
+            self.deferred_steps[index] = None;
+        }
+        self.has_deferred_steps = false;
+        self.max_active_depth = 0;
+    }
+
     /// Records the opcode and gas snapshot for the current frame depth.
     #[inline(always)]
     fn begin_step(&mut self, depth: usize, opcode: u8, gas_remaining: u64) {
@@ -504,6 +529,24 @@ mod tests {
         assert!(metering.deferred_steps[1].is_some());
     }
 
+    #[test]
+    fn reset_transaction_clears_meter_and_step_bookkeeping() {
+        let mut metering = ZkGasMeteringState::new(&UNZEN_ZK_GAS_SCHEDULE);
+        metering.begin_step(1, 0x01, 10);
+        metering.defer_step(0, FinishedStep { opcode: 0xf1, step_gas: 5, spawned: true });
+        metering.defer_step(1, FinishedStep { opcode: 0x01, step_gas: 3, spawned: false });
+        metering.meter.charge_opcode(0x01, 3).expect("charge fits");
+
+        metering.reset_transaction();
+
+        assert_eq!(metering.meter.tx_zk_gas_used(), 0);
+        assert!(!metering.has_deferred_steps);
+        assert!(metering.deferred_steps[..2].iter().all(Option::is_none));
+        assert_eq!(metering.pending_steps[1].opcode, 0);
+        assert_eq!(metering.pending_steps[1].gas_remaining, 0);
+        assert_eq!(metering.max_active_depth, 0);
+    }
+
     #[test]
     fn charge_finished_step_uses_active_meter_schedule_for_spawn_estimate() {
         let mut metering = ZkGasMeteringState::new(&UNZEN_ZK_GAS_SCHEDULE);