fix(sequencer-client): reduce prediction window from LAG+1 to LAG entries

Addresses PR #22116 review comment 9: the last entry in the LAG+1 window
could be invalidated by a concurrent oracle update. LAG entries are all
guaranteed stable.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: spalladino

yarn-project/sequencer-client/src/global_variable_builder/README.md

@@ -5,10 +5,9 @@ oracle state and an assumed mana usage pattern.
 
 ## Prediction Window
 
-The prediction covers `LAG + 1 = 3` entries (the next available slot plus 2 more).
-The window is LAG slots because a new oracle update can be enqueued at any time (if
-the cooldown has passed), and its new values activate LAG slots later. Beyond LAG
-slots, the L1 fees could change unpredictably.
+The prediction covers `LAG = 2` entries (the next available slot plus 1 more).
+A new oracle update can activate at `startSlot + LAG`, so only the first LAG entries
+are guaranteed stable. Beyond that, L1 fees could change unpredictably.
 
 Each entry uses:
 
@@ -17,12 +16,11 @@ Each entry uses:
 - A **configurable congestion assumption** (`ManaUsageEstimate`): none (0 mana), target
   (steady state), or limit (worst case, 2x target).
 
-The client picks `max(predicted[0..LAG])` as their `maxFeesPerGas`.
+The client picks `max(predicted[0..LAG-1])` as their `maxFeesPerGas`.
 
 ```
 predicted[0]  →  fee at next slot     (current oracle + current congestion)
 predicted[1]  →  fee at next slot + 1 (congestion may change based on usage estimate)
-predicted[2]  →  fee at next slot + 2 (oracle may transition here)
 ```
 
 ## Why LAG and not LIFETIME?
@@ -42,5 +40,5 @@ With a LIFETIME-sized window, we'd give a false sense of coverage: the predictio
 would look like it covers 6 slots, but slots beyond LAG could be wrong if an update
 is enqueued after the prediction is computed.
 
-By limiting to LAG, we guarantee that the predicted L1 fees are the ones that will
-actually be used — no oracle update can change them within this window.
+By limiting to LAG entries, we guarantee that all predicted L1 fees are the ones that
+will actually be used — no oracle update can change them within this window.

yarn-project/sequencer-client/src/global_variable_builder/fee_predictor.test.ts

@@ -125,10 +125,10 @@ describe('FeePredictor', () => {
     expect(predicted[0].feePerL2Gas).toBe(l1Fee);
   });
 
-  it('returns exactly FEE_ORACLE_LAG + 1 entries', async () => {
+  it('returns exactly FEE_ORACLE_LAG entries', async () => {
     const predictor = new FeePredictor(rollup, slotDuration, l1GenesisTime);
     const predicted = await predictor.getPredictedMinFees(publicClient, ManaUsageEstimate.Target);
-    expect(predicted.length).toBe(FEE_ORACLE_LAG + 1);
+    expect(predicted.length).toBe(FEE_ORACLE_LAG);
   });
 
   it.each([
@@ -275,7 +275,7 @@ describe('FeePredictor', () => {
       const predictor = new FeePredictor(rollup, slotDuration, l1GenesisTime);
       const predicted = await predictor.getPredictedMinFees(publicClient, ManaUsageEstimate.None);
 
-      expect(predicted.length).toBe(FEE_ORACLE_LAG + 1);
+      expect(predicted.length).toBe(FEE_ORACLE_LAG);
 
       const startSlot = await getPredictionStartSlot();
       for (let i = 0; i < predicted.length; i++) {

yarn-project/sequencer-client/src/global_variable_builder/fee_predictor.ts

@@ -18,10 +18,10 @@ type FeeOracleState = {
 };
 
 /**
- * Predicts min fees for the current slot and next LAG slots based on the L1 oracle state.
- * The prediction window is LAG slots because a new oracle update can activate after LAG slots,
- * making predictions beyond that unreliable.
- * Caches L1 queries per L1 block and recomputes predictions for each mana usage estimate.
+ * Predicts min fees for LAG upcoming slots based on the L1 oracle state.
+ * A new oracle update can activate at startSlot + LAG, so only the first LAG entries
+ * are guaranteed stable. Caches L1 queries per L1 block and recomputes predictions
+ * for each mana usage estimate.
  */
 export class FeePredictor {
   private cachedState: Promise<FeeOracleState> | undefined;
@@ -70,7 +70,7 @@ export class FeePredictor {
     const feeHeader = lastCheckpoint.feeHeader;
 
     const slotConfig = { slotDuration: this.slotDuration, l1GenesisTime: this.l1GenesisTime };
-    const slotCount = FEE_ORACLE_LAG + 1;
+    const slotCount = FEE_ORACLE_LAG;
     const timestamps = times(slotCount, i => getTimestampForSlot(SlotNumber.add(nextSlot, i), slotConfig));
     const l1FeesBySlot = await Promise.all(timestamps.map(ts => this.rollupContract.getL1FeesAt(ts)));
 
@@ -97,7 +97,7 @@ export class FeePredictor {
     // Slot 0: current state (next available slot after last checkpoint)
     result.push(this.computeGasFees(state, excessMana, ethPerFeeAsset, state.l1FeesBySlot[0]));
 
-    // Slots 1..LAG: advance excessMana with the assumed mana usage per checkpoint,
+    // Slots 1..LAG-1: advance excessMana with the assumed mana usage per checkpoint,
     // and decay ethPerFeeAsset by MAX_FEE_ASSET_PRICE_MODIFIER_BPS per slot for conservative estimates.
     // Lower ethPerFeeAsset means higher fees in fee asset terms.
     for (let i = 1; i < state.l1FeesBySlot.length; i++) {