fix(sequencer-client): account for next L1 block slot in fee prediction window

Addresses PR #22116 review comment 8: if the next L1 block lands in the
next L2 slot, the prediction window should start from that slot. Also
moves publicClient to FeePredictor constructor instead of passing it on
every call.

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

Author: spalladino

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

@@ -25,7 +25,9 @@ describe('FeePredictor', () => {
   let rollup: RollupContract;
 
   let slotDuration: number;
+  let ethereumSlotDuration: number;
   let l1GenesisTime: bigint;
+  let dateProvider: DateProvider;
 
   beforeAll(async () => {
     const privateKeyRaw = '0x8b3a350cf5c34c9194ca85829a2df0ec3153be0318b5e2d3348e872092edffba';
@@ -47,7 +49,9 @@ describe('FeePredictor', () => {
     rollupCheatCodes = RollupCheatCodes.create([rpcUrl], deployed.l1ContractAddresses, new DateProvider());
 
     slotDuration = await rollup.getSlotDuration();
+    ethereumSlotDuration = DefaultL1ContractsConfig.ethereumSlotDuration;
     l1GenesisTime = await rollup.getL1GenesisTime();
+    dateProvider = new DateProvider();
   }, 60_000);
 
   afterAll(async () => {
@@ -71,15 +75,29 @@ describe('FeePredictor', () => {
     const l1Fee = await rollup.getManaMinFeeAt(getTimestamp(startSlot), true);
 
     for (const manaUsage of Object.values(ManaUsageEstimate)) {
-      const predictor = new FeePredictor(rollup, slotDuration, l1GenesisTime);
-      const predicted = await predictor.getPredictedMinFees(publicClient, manaUsage);
+      const predictor = new FeePredictor(
+        rollup,
+        publicClient,
+        dateProvider,
+        slotDuration,
+        l1GenesisTime,
+        ethereumSlotDuration,
+      );
+      const predicted = await predictor.getPredictedMinFees(manaUsage);
       expect(predicted[0].feePerL2Gas).toBe(l1Fee);
     }
   });
 
   it('all slots match L1 with ManaUsageEstimate.None and zero congestion', async () => {
-    const predictor = new FeePredictor(rollup, slotDuration, l1GenesisTime);
-    const predicted = await predictor.getPredictedMinFees(publicClient, ManaUsageEstimate.None);
+    const predictor = new FeePredictor(
+      rollup,
+      publicClient,
+      dateProvider,
+      slotDuration,
+      l1GenesisTime,
+      ethereumSlotDuration,
+    );
+    const predicted = await predictor.getPredictedMinFees(ManaUsageEstimate.None);
 
     const startSlot = await getPredictionStartSlot();
     for (let i = 0; i < predicted.length; i++) {
@@ -99,8 +117,15 @@ describe('FeePredictor', () => {
     await cheatCodes.mine();
     await rollupCheatCodes.updateL1GasFeeOracle();
 
-    const predictor = new FeePredictor(rollup, slotDuration, l1GenesisTime);
-    const predicted = await predictor.getPredictedMinFees(publicClient, ManaUsageEstimate.None);
+    const predictor = new FeePredictor(
+      rollup,
+      publicClient,
+      dateProvider,
+      slotDuration,
+      l1GenesisTime,
+      ethereumSlotDuration,
+    );
+    const predicted = await predictor.getPredictedMinFees(ManaUsageEstimate.None);
 
     const startSlot = await getPredictionStartSlot();
     for (let i = 0; i < predicted.length; i++) {
@@ -117,17 +142,31 @@ describe('FeePredictor', () => {
     await cheatCodes.mine();
     await rollupCheatCodes.advanceSlots(3);
 
-    const predictor = new FeePredictor(rollup, slotDuration, l1GenesisTime);
-    const predicted = await predictor.getPredictedMinFees(publicClient, ManaUsageEstimate.None);
+    const predictor = new FeePredictor(
+      rollup,
+      publicClient,
+      dateProvider,
+      slotDuration,
+      l1GenesisTime,
+      ethereumSlotDuration,
+    );
+    const predicted = await predictor.getPredictedMinFees(ManaUsageEstimate.None);
 
     const startSlot = await getPredictionStartSlot();
     const l1Fee = await rollup.getManaMinFeeAt(getTimestamp(startSlot), true);
     expect(predicted[0].feePerL2Gas).toBe(l1Fee);
   });
 
   it('returns exactly FEE_ORACLE_LAG entries', async () => {
-    const predictor = new FeePredictor(rollup, slotDuration, l1GenesisTime);
-    const predicted = await predictor.getPredictedMinFees(publicClient, ManaUsageEstimate.Target);
+    const predictor = new FeePredictor(
+      rollup,
+      publicClient,
+      dateProvider,
+      slotDuration,
+      l1GenesisTime,
+      ethereumSlotDuration,
+    );
+    const predicted = await predictor.getPredictedMinFees(ManaUsageEstimate.Target);
     expect(predicted.length).toBe(FEE_ORACLE_LAG);
   });
 
@@ -155,8 +194,15 @@ describe('FeePredictor', () => {
       const assumedManaUsed =
         estimate === ManaUsageEstimate.None ? 0n : estimate === ManaUsageEstimate.Target ? manaTarget : manaLimit;
 
-      const predictor = new FeePredictor(rollup, slotDuration, l1GenesisTime);
-      const predicted = await predictor.getPredictedMinFees(publicClient, estimate);
+      const predictor = new FeePredictor(
+        rollup,
+        publicClient,
+        dateProvider,
+        slotDuration,
+        l1GenesisTime,
+        ethereumSlotDuration,
+      );
+      const predicted = await predictor.getPredictedMinFees(estimate);
 
       const rollupAddress = EthAddress.fromString(rollup.address);
 
@@ -272,8 +318,15 @@ describe('FeePredictor', () => {
 
     // Step through 6 successive slots, creating a fresh predictor each time.
     for (let step = 0; step < 6; step++) {
-      const predictor = new FeePredictor(rollup, slotDuration, l1GenesisTime);
-      const predicted = await predictor.getPredictedMinFees(publicClient, ManaUsageEstimate.None);
+      const predictor = new FeePredictor(
+        rollup,
+        publicClient,
+        dateProvider,
+        slotDuration,
+        l1GenesisTime,
+        ethereumSlotDuration,
+      );
+      const predicted = await predictor.getPredictedMinFees(ManaUsageEstimate.None);
 
       expect(predicted.length).toBe(FEE_ORACLE_LAG);
 

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

@@ -1,7 +1,8 @@
 import { type L1FeeData, MAX_FEE_ASSET_PRICE_MODIFIER_BPS, type RollupContract } from '@aztec/ethereum/contracts';
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
-import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import type { DateProvider } from '@aztec/foundation/timer';
+import { getSlotAtNextL1Block, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { FEE_ORACLE_LAG, GasFees, ManaUsageEstimate, computeExcessMana, computeManaMinFee } from '@aztec/stdlib/gas';
 
 /** Cached rollup state for fee prediction. Refreshed once per L1 block. */
@@ -29,22 +30,22 @@ export class FeePredictor {
 
   constructor(
     private readonly rollupContract: RollupContract,
+    private readonly publicClient: { getBlockNumber: () => Promise<bigint> },
+    private readonly dateProvider: DateProvider,
     private readonly slotDuration: number,
     private readonly l1GenesisTime: bigint,
+    private readonly ethereumSlotDuration: number,
   ) {}
 
   /** Returns predicted min fees for each slot in the prediction window. */
-  async getPredictedMinFees(
-    publicClient: { getBlockNumber: () => Promise<bigint> },
-    manaUsage: ManaUsageEstimate,
-  ): Promise<GasFees[]> {
-    const state = await this.getState(publicClient);
+  async getPredictedMinFees(manaUsage: ManaUsageEstimate): Promise<GasFees[]> {
+    const state = await this.getState();
     return this.computePredictions(state, manaUsage);
   }
 
   /** Fetches and caches rollup state. Refreshes when L1 block number advances. */
-  private async getState(publicClient: { getBlockNumber: () => Promise<bigint> }): Promise<FeeOracleState> {
-    const blockNumber = await publicClient.getBlockNumber();
+  private async getState(): Promise<FeeOracleState> {
+    const blockNumber = await this.publicClient.getBlockNumber();
     if (this.cachedL1BlockNumber === undefined || blockNumber > this.cachedL1BlockNumber) {
       this.cachedL1BlockNumber = blockNumber;
       this.cachedState = this.fetchState();
@@ -65,8 +66,14 @@ export class FeePredictor {
       ]);
 
     const lastSlot = lastCheckpoint.slotNumber;
-    // Start from the later of: the slot after the last checkpoint, or the current slot.
-    const nextSlot = SlotNumber.add(lastSlot, 1) > currentSlot ? SlotNumber.add(lastSlot, 1) : currentSlot;
+    // The next L1 block may land in the next L2 slot, so we need to account for that
+    const slotAtNextL1Block = getSlotAtNextL1Block(BigInt(this.dateProvider.nowInSeconds()), {
+      l1GenesisTime: this.l1GenesisTime,
+      slotDuration: this.slotDuration,
+      ethereumSlotDuration: this.ethereumSlotDuration,
+    });
+    // Start from the latest of: slot after last checkpoint, current slot, or slot at next L1 block.
+    const nextSlot = SlotNumber(Math.max(SlotNumber.add(lastSlot, 1), currentSlot, slotAtNextL1Block));
     const feeHeader = lastCheckpoint.feeHeader;
 
     const slotConfig = { slotDuration: this.slotDuration, l1GenesisTime: this.l1GenesisTime };

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

@@ -45,7 +45,14 @@ export class FeeProviderImpl implements FeeProvider {
     this.l1GenesisTime = config.l1GenesisTime;
 
     this.rollupContract = new RollupContract(this.publicClient, config.l1Contracts.rollupAddress);
-    this.feePredictor = new FeePredictor(this.rollupContract, config.slotDuration, config.l1GenesisTime);
+    this.feePredictor = new FeePredictor(
+      this.rollupContract,
+      this.publicClient,
+      this.dateProvider,
+      config.slotDuration,
+      config.l1GenesisTime,
+      config.ethereumSlotDuration,
+    );
   }
 
   /**
@@ -83,7 +90,7 @@ export class FeeProviderImpl implements FeeProvider {
   }
 
   public getPredictedMinFees(manaUsage?: ManaUsageEstimate): Promise<GasFees[]> {
-    return this.feePredictor.getPredictedMinFees(this.publicClient, manaUsage ?? ManaUsageEstimate.Target);
+    return this.feePredictor.getPredictedMinFees(manaUsage ?? ManaUsageEstimate.Target);
   }
 }