@aztec/ethereum 0.0.1-commit.04852196a → 0.0.1-commit.04d373f

package/src/l1_tx_utils/readonly_l1_tx_utils.ts

@@ -130,9 +130,10 @@ export class ReadOnlyL1TxUtils {
     const numBlocks = Math.ceil(gasConfig.stallTimeMs! / BLOCK_TIME_MS);
     for (let i = 0; i < numBlocks; i++) {
       // each block can go up 12.5% from previous baseFee
-      maxFeePerGas = (maxFeePerGas * (1_000n + 125n)) / 1_000n;
+      // ceil, (a+b-1)/b, to avoid truncation at small values (e.g. 1 wei blob base fee)
+      maxFeePerGas = (maxFeePerGas * (1_000n + 125n) + 999n) / 1_000n;
       // same for blob gas fee
-      maxFeePerBlobGas = (maxFeePerBlobGas * (1_000n + 125n)) / 1_000n;
+      maxFeePerBlobGas = (maxFeePerBlobGas * (1_000n + 125n) + 999n) / 1_000n;
     }
 
     if (attempt > 0) {
@@ -242,13 +243,16 @@ export class ReadOnlyL1TxUtils {
     const gasConfig = { ...this.config, ..._gasConfig };
     let initialEstimate = 0n;
     if (_blobInputs) {
-      // @note requests with blobs also require maxFeePerBlobGas to be set
+      // @note requests with blobs also require maxFeePerBlobGas to be set.
+      // Use 2x buffer for maxFeePerBlobGas to avoid stale fees and to pass EIP-4844 validation (even if it is a gas estimation call).
+      // 1. maxFeePerBlobGas >= blobBaseFee
+      // 2. account balance >= gas * maxFeePerGas + maxFeePerBlobGas * blobCount + value
       const gasPrice = await this.getGasPrice(gasConfig, true, 0);
       initialEstimate = await this.client.estimateGas({
         account,
         ...request,
         ..._blobInputs,
-        maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
+        maxFeePerBlobGas: gasPrice.maxFeePerBlobGas! * 2n,
         gas: MAX_L1_TX_LIMIT,
         blockTag: 'latest',
       });

package/src/l1_tx_utils/tx_delayer.ts

@@ -81,7 +81,11 @@ export class Delayer {
 
   public maxInclusionTimeIntoSlot: number | undefined = undefined;
   public ethereumSlotDuration: bigint;
-  public nextWait: { l1Timestamp: bigint } | { l1BlockNumber: bigint } | { indefinitely: true } | undefined = undefined;
+  public nextWait:
+    | { l1Timestamp: bigint; timeoutSeconds?: number }
+    | { l1BlockNumber: bigint; timeoutSeconds?: number }
+    | { indefinitely: true }
+    | undefined = undefined;
   public sentTxHashes: Hex[] = [];
   public cancelledTxs: Hex[] = [];
 
@@ -110,13 +114,13 @@ export class Delayer {
   }
 
   /** Delays the next tx to be sent so it lands on the given L1 block number. */
-  pauseNextTxUntilBlock(l1BlockNumber: number | bigint) {
-    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber) };
+  pauseNextTxUntilBlock(l1BlockNumber: number | bigint, timeoutSeconds?: number) {
+    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber), timeoutSeconds };
   }
 
   /** Delays the next tx to be sent so it lands on the given timestamp. */
-  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint) {
-    this.nextWait = { l1Timestamp: BigInt(l1Timestamp) };
+  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint, timeoutSeconds?: number) {
+    this.nextWait = { l1Timestamp: BigInt(l1Timestamp), timeoutSeconds };
   }
 
   /** Delays the next tx to be sent indefinitely. */
@@ -198,9 +202,14 @@ export function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer:
           // Or wait until the desired block number or timestamp
           wait =
             'l1BlockNumber' in waitUntil
-              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger)
+              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger, waitUntil.timeoutSeconds)
               : 'l1Timestamp' in waitUntil
-                ? waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger)
+                ? waitUntilL1Timestamp(
+                    publicClient,
+                    waitUntil.l1Timestamp - delayer.ethereumSlotDuration,
+                    logger,
+                    waitUntil.timeoutSeconds,
+                  )
                 : undefined;
 
           logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {

package/src/publisher_manager.ts

@@ -1,6 +1,8 @@
 import { pick } from '@aztec/foundation/collection';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
 
+import { Multicall3 } from './contracts/multicall.js';
 import { L1TxUtils, TxUtilsState } from './l1_tx_utils/index.js';
 
 // Defines the order in which we prioritise publishers based on their state (first is better)
@@ -27,24 +29,72 @@ const busyStates: TxUtilsState[] = [
 
 export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
 
+/** Config accepted by PublisherManager. */
+type PublisherManagerConfig = {
+  publisherAllowInvalidStates?: boolean;
+  publisherFundingThreshold?: bigint;
+  publisherFundingAmount?: bigint;
+};
+
 export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
   private log: Logger;
-  private config: { publisherAllowInvalidStates?: boolean };
+  private config: PublisherManagerConfig;
+  private static readonly FUNDING_CHECK_INTERVAL_MS = 2 * 60 * 1000;
+  private funder?: UtilsType;
+  private fundingPromise?: RunningPromise;
 
   constructor(
     private publishers: UtilsType[],
-    config: { publisherAllowInvalidStates?: boolean },
-    bindings?: LoggerBindings,
+    config: PublisherManagerConfig,
+    opts?: { bindings?: LoggerBindings; funder?: UtilsType },
   ) {
-    this.log = createLogger('publisher:manager', bindings);
+    this.funder = opts?.funder;
+    this.log = createLogger('publisher:manager', opts?.bindings);
     this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
     this.publishers = publishers;
-    this.config = pick(config, 'publisherAllowInvalidStates');
+    this.config = pick(config, 'publisherAllowInvalidStates', 'publisherFundingThreshold', 'publisherFundingAmount');
+
+    const hasThreshold = this.config.publisherFundingThreshold !== undefined;
+    const hasAmount = this.config.publisherFundingAmount !== undefined;
+    if (hasThreshold !== hasAmount) {
+      this.log.warn(`Incomplete funding config: both publisherFundingThreshold and publisherFundingAmount must be set`);
+    }
+
+    if (this.funder) {
+      const funderAddress = this.funder.getSenderAddress();
+      if (publishers.some(p => p.getSenderAddress().equals(funderAddress))) {
+        this.log.error(`Funding account ${funderAddress} is also a publisher, disabling funding to avoid self-funding`);
+        this.funder = undefined;
+      }
+    }
   }
 
-  /** Loads the state of all publishers and resumes monitoring any pending txs */
-  public async loadState(): Promise<void> {
-    await Promise.all(this.publishers.map(pub => pub.loadStateAndResumeMonitoring()));
+  /** Loads the state of all publishers and the funder, and starts periodic funding checks. */
+  public async start(): Promise<void> {
+    await Promise.all([
+      ...this.publishers.map(pub => pub.loadStateAndResumeMonitoring()),
+      this.funder?.loadStateAndResumeMonitoring(),
+    ]);
+
+    if (
+      this.funder &&
+      this.config.publisherFundingThreshold !== undefined &&
+      this.config.publisherFundingAmount !== undefined
+    ) {
+      this.fundingPromise = new RunningPromise(
+        () => this.triggerFundingIfNeeded(),
+        this.log,
+        PublisherManager.FUNDING_CHECK_INTERVAL_MS,
+      );
+      this.fundingPromise.start();
+    }
+  }
+
+  /** Stops the funding loop and interrupts all publishers. */
+  public async stop(): Promise<void> {
+    await this.fundingPromise?.stop();
+    this.publishers.forEach(pub => pub.interrupt());
+    this.funder?.interrupt();
   }
 
   // Finds and prioritises available publishers based on
@@ -102,7 +152,52 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
     return sortedPublishers[0].publisher;
   }
 
-  public interrupt() {
-    this.publishers.forEach(pub => pub.interrupt());
+  /** Check all publisher balances and fund those below threshold. */
+  private async triggerFundingIfNeeded(): Promise<void> {
+    const { funder, config } = this;
+    if (!funder || config.publisherFundingThreshold === undefined || config.publisherFundingAmount === undefined) {
+      return;
+    }
+
+    const allBalances = await Promise.all(
+      this.publishers.map(async pub => ({ balance: await pub.getSenderBalance(), publisher: pub })),
+    );
+    const lowBalance = allBalances.filter(p => p.balance < config.publisherFundingThreshold!);
+    if (lowBalance.length === 0) {
+      return;
+    }
+
+    const fundingAmount = config.publisherFundingAmount!;
+    const funderBalance = await funder.getSenderBalance();
+
+    if (funderBalance < 10n * fundingAmount) {
+      this.log.warn(`Funding account balance is low`, { funderBalance, threshold: 10n * fundingAmount });
+    }
+    const affordableCount = Number(funderBalance / fundingAmount);
+    if (affordableCount === 0) {
+      this.log.error(`Funding account balance too low to fund any publisher`, { funderBalance, fundingAmount });
+      return;
+    }
+    if (affordableCount < lowBalance.length) {
+      this.log.warn(`Funder can only afford ${affordableCount}/${lowBalance.length} publishers`, {
+        funderBalance,
+        fundingAmount,
+      });
+    }
+
+    const toFund = lowBalance.slice(0, affordableCount).map(p => p.publisher);
+    await this.fundPublishers(toFund);
+  }
+
+  /** Fund publishers via a single Multicall3 aggregate3Value transaction. */
+  private async fundPublishers(publishers: UtilsType[]): Promise<void> {
+    const fundingAmount = this.config.publisherFundingAmount!;
+    const calls = publishers.map(pub => ({
+      to: pub.getSenderAddress().toString(),
+      value: fundingAmount,
+    }));
+
+    await Multicall3.forwardValue(calls, this.funder!, this.log);
+    this.log.info(`Funded ${publishers.length} publishers`);
   }
 }

package/src/queries.ts

@@ -1,11 +1,77 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 
+import { BaseError, type Block } from 'viem';
+
 import { DefaultL1ContractsConfig, type L1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
 import { GovernanceProposerContract } from './contracts/governance_proposer.js';
 import { InboxContract } from './contracts/inbox.js';
 import { RollupContract } from './contracts/rollup.js';
-import type { ViemPublicClient } from './types.js';
+import type { ViemClient, ViemPublicClient } from './types.js';
+
+/**
+ * Returns the L1 finalized block, or `undefined` if the chain does not yet have one
+ * (common on freshly started devnets). Rethrows any other RPC error.
+ */
+export async function getFinalizedL1Block(client: ViemClient): Promise<Block<bigint, false, 'finalized'> | undefined> {
+  try {
+    return await client.getBlock({ blockTag: 'finalized', includeTransactions: false });
+  } catch (err) {
+    if (isFinalizedBlockTagNotFoundError(err)) {
+      return undefined;
+    }
+    throw err;
+  }
+}
+
+// Error messages returned by popular Ethereum execution clients when
+// eth_getBlockByNumber / eth_call is called with blockTag "finalized" or
+// "safe" and no such block has been produced yet:
+//
+//   geth       "finalized block not found"
+//              "safe block not found"
+//   reth       "block not found: finalized"
+//              "block not found: safe"
+//   nethermind "Unknown block error"           (same for both tags)
+//   besu       "Unknown block"
+//   erigon     'block "finalized" not available (head block: N)'
+//              'block "safe" not available (head block: N)'
+//
+// A combined regex covers all five:
+const FINALIZED_BLOCK_TAG_NOT_FOUND_MESSAGE_RE =
+  /(finalized|safe) block not found|block not found: (finalized|safe)|unknown block|block "(finalized|safe)" not available/i;
+
+/**
+ * Returns true if the error originates from an RPC call that failed because
+ * the "finalized" (or "safe") block tag is not yet available on the chain.
+ */
+export function isFinalizedBlockTagNotFoundError(err: unknown): boolean {
+  if (!err) {
+    return false;
+  }
+
+  if (err instanceof BaseError) {
+    const hit = err.walk((e: any) => matchesFinalizedBlockTagNotFound(e));
+    if (hit) {
+      return true;
+    }
+  }
+
+  for (let cur: any = err, i = 0; cur && i < 10; cur = cur.cause, i++) {
+    if (matchesFinalizedBlockTagNotFound(cur)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function matchesFinalizedBlockTagNotFound(e: any): boolean {
+  if (!e) {
+    return false;
+  }
+  const text = `${e.details ?? ''} ${e.message ?? ''} ${e.shortMessage ?? ''}`;
+  return FINALIZED_BLOCK_TAG_NOT_FOUND_MESSAGE_RE.test(text);
+}
 
 /** Reads the L1ContractsConfig from L1 contracts. */
 export async function getL1ContractsConfig(
@@ -76,8 +142,8 @@ export async function getL1ContractsConfig(
     slasherProposer?.getRoundSize() ?? 0n,
     slasherProposer?.getLifetimeInRounds() ?? 0n,
     slasherProposer?.getExecutionDelayInRounds() ?? 0n,
-    slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
-    slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [0n, 0n, 0n],
+    slasherProposer?.getSlashOffsetInRounds() ?? 0n,
+    slasherProposer?.getSlashingAmounts() ?? [0n, 0n, 0n],
     slasher?.getVetoer() ?? EthAddress.ZERO,
     slasher?.getSlashingDisableDuration() ?? 0,
     rollup.getManaTarget(),
@@ -114,7 +180,7 @@ export async function getL1ContractsConfig(
     rollupVersion: Number(rollupVersion),
     genesisArchiveTreeRoot: genesisArchiveTreeRoot.toString(),
     exitDelaySeconds: Number(exitDelay),
-    slasherFlavor: slasherProposer?.type ?? 'tally',
+    slasherEnabled: !!slasherProposer,
     slashingOffsetInRounds: Number(slashingOffsetInRounds),
     slashAmountSmall: slashingAmounts[0],
     slashAmountMedium: slashingAmounts[1],

package/src/test/chain_monitor.ts

@@ -1,4 +1,4 @@
-import type { RollupContract } from '@aztec/ethereum/contracts';
+import type { ManaMinFeeComponents, RollupContract } from '@aztec/ethereum/contracts';
 import { InboxContract } from '@aztec/ethereum/contracts';
 import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -10,6 +10,20 @@ import { EventEmitter } from 'events';
 
 import type { ViemClient } from '../types.js';
 
+/** L2 fee data reported by the chain monitor. */
+export type L2FeeData = ManaMinFeeComponents & {
+  /** Total minimum fee per mana in Fee Juice (sum of sequencerCost + proverCost + congestionCost). */
+  minFeePerMana: bigint;
+  /** L1 base fee observed by the oracle. */
+  l1BaseFee: bigint;
+  /** L1 blob fee observed by the oracle. */
+  l1BlobFee: bigint;
+  /** ETH per fee asset exchange rate (1e12 precision). */
+  ethPerFeeAsset: bigint;
+  /** Mana target per checkpoint. */
+  manaTarget: bigint;
+};
+
 export type ChainMonitorEventMap = {
   'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
   checkpoint: [
@@ -19,6 +33,7 @@ export type ChainMonitorEventMap = {
   'l2-messages': [{ totalL2Messages: number; l1BlockNumber: number }];
   'l2-epoch': [{ l2EpochNumber: EpochNumber; timestamp: bigint; committee: EthAddress[] | undefined }];
   'l2-slot': [{ l2SlotNumber: SlotNumber; timestamp: bigint }];
+  'l2-fees': [L2FeeData];
 };
 
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
@@ -45,6 +60,8 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
   public l2EpochNumber!: EpochNumber;
   /** Current L2 slot number */
   public l2SlotNumber!: SlotNumber;
+  /** Current L2 fee data (components of the minimum fee per mana). */
+  public l2FeeData!: L2FeeData;
 
   constructor(
     private readonly rollup: RollupContract,
@@ -77,7 +94,7 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     }
   }
 
-  private async getInbox() {
+  protected async getInbox() {
     if (!this.inbox) {
       const { inboxAddress } = await this.rollup.getRollupAddresses();
       this.inbox = new InboxContract(this.l1Client, inboxAddress);
@@ -158,7 +175,7 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.l2EpochNumber = l2Epoch;
       committee = await this.rollup.getCurrentEpochCommittee();
       this.emit('l2-epoch', { l2EpochNumber: l2Epoch, timestamp, committee });
-      msg += ` starting new epoch ${this.l2EpochNumber} `;
+      msg += ` starting new epoch ${this.l2EpochNumber}`;
     }
 
     if (l2SlotNumber !== this.l2SlotNumber) {
@@ -166,6 +183,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.emit('l2-slot', { l2SlotNumber, timestamp });
     }
 
+    const feeData = await this.fetchFeeData(timestamp);
+    if (this.hasFeeDataChanged(feeData)) {
+      msg += ` with L2 min fee ${feeData.minFeePerMana}`;
+      this.l2FeeData = feeData;
+      this.emit('l2-fees', feeData);
+    }
+
     this.logger.info(msg, {
       currentTimestamp: this.dateProvider.nowInSeconds(),
       l1Timestamp: timestamp,
@@ -176,6 +200,7 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       provenCheckpointNumber: this.provenCheckpointNumber,
       totalL2Messages: this.totalL2Messages,
       committee,
+      ...this.l2FeeData,
     });
 
     return this;
@@ -196,6 +221,11 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     });
   }
 
+  public async waitUntilNextL2Slot(): Promise<void> {
+    const targetSlot = SlotNumber.add((await this.run()).l2SlotNumber, 1);
+    return this.waitUntilL2Slot(targetSlot);
+  }
+
   public waitUntilL1Block(block: number | bigint): Promise<void> {
     const targetBlock = typeof block === 'bigint' ? block.valueOf() : block;
     if (this.l1BlockNumber >= targetBlock) {
@@ -242,4 +272,36 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.on('checkpoint', listener);
     });
   }
+
+  private async fetchFeeData(timestamp: bigint): Promise<L2FeeData> {
+    const [components, minFeePerMana, l1Fees, ethPerFeeAsset, manaTarget] = await Promise.all([
+      this.rollup.getManaMinFeeComponentsAt(timestamp, true),
+      this.rollup.getManaMinFeeAt(timestamp, true),
+      this.rollup.getL1FeesAt(timestamp),
+      this.rollup.getEthPerFeeAsset(),
+      this.rollup.getManaTarget(),
+    ]);
+    return {
+      ...components,
+      minFeePerMana,
+      l1BaseFee: l1Fees.baseFee,
+      l1BlobFee: l1Fees.blobFee,
+      ethPerFeeAsset,
+      manaTarget,
+    };
+  }
+
+  private hasFeeDataChanged(newData: L2FeeData): boolean {
+    if (!this.l2FeeData) {
+      return true;
+    }
+    return (
+      this.l2FeeData.sequencerCost !== newData.sequencerCost ||
+      this.l2FeeData.proverCost !== newData.proverCost ||
+      this.l2FeeData.congestionCost !== newData.congestionCost ||
+      this.l2FeeData.l1BaseFee !== newData.l1BaseFee ||
+      this.l2FeeData.l1BlobFee !== newData.l1BlobFee ||
+      this.l2FeeData.ethPerFeeAsset !== newData.ethPerFeeAsset
+    );
+  }
 }

package/src/test/eth_cheat_codes.ts

@@ -85,14 +85,26 @@ export class EthCheatCodes {
   }
 
   /**
-   * Get the current timestamp
-   * @returns The current timestamp
+   * Get the timestamp of the latest mined L1 block.
+   * Note: this is NOT the current time — it's the discrete timestamp of the last block.
+   * Between blocks, the actual chain time advances but no new block reflects it.
+   * @returns The latest block timestamp in seconds
    */
-  public async timestamp(): Promise<number> {
+  public async lastBlockTimestamp(): Promise<number> {
     const res = await this.doRpcCall('eth_getBlockByNumber', ['latest', true]);
     return parseInt(res.timestamp, 16);
   }
 
+  /**
+   * Get the timestamp of the pending L1 block — the block that anvil will mine next.
+   * Reflects any prior `setNextBlockTimestamp` call or the configured block interval.
+   * @returns The pending block timestamp in seconds.
+   */
+  public async nextBlockTimestamp(): Promise<number> {
+    const res = await this.doRpcCall('eth_getBlockByNumber', ['pending', false]);
+    return parseInt(res.timestamp, 16);
+  }
+
   /**
    * Advance the chain by a number of blocks
    * @param numberOfBlocks - The number of blocks to mine
@@ -552,7 +564,7 @@ export class EthCheatCodes {
   }
 
   public async syncDateProvider() {
-    const timestamp = await this.timestamp();
+    const timestamp = await this.lastBlockTimestamp();
     if ('setTime' in this.dateProvider) {
       this.dateProvider.setTime(timestamp * 1000);
     }

package/src/test/rollup_cheat_codes.ts

@@ -15,6 +15,7 @@ import {
   getContract,
   hexToBigInt,
   http,
+  keccak256,
 } from 'viem';
 
 import { EthCheatCodes } from './eth_cheat_codes.js';
@@ -53,7 +54,17 @@ export class RollupCheatCodes {
   /** Returns the current slot */
   public async getSlot(): Promise<SlotNumber> {
     const ts = BigInt((await this.client.getBlock()).timestamp);
-    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([ts]));
+    return this.getSlotAt(ts);
+  }
+
+  /** Returns the slot number at a given timestamp. */
+  public async getSlotAt(timestamp: bigint): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([timestamp]));
+  }
+
+  /** Returns the timestamp for the start of a given slot. */
+  public async getTimestampForSlot(slot: SlotNumber): Promise<bigint> {
+    return await this.rollup.read.getTimestampForSlot([BigInt(slot)]);
   }
 
   /** Returns the number of seconds until the start of the given slot based on L1 block timestamp. */
@@ -168,6 +179,21 @@ export class RollupCheatCodes {
     return [timestamp, nextSlot];
   }
 
+  /**
+   * Warps L1 time to the start of an explicit absolute slot. Unlike `advanceSlots(N)` which is
+   * relative to the current L1 timestamp at call time and therefore races with real-time
+   * progression between query and warp, this lands at the slot regardless of latency.
+   *
+   * Throws if the requested slot is in the past relative to current L1 time (anvil cannot
+   * rewind).
+   */
+  public async advanceToSlot(slot: SlotNumber) {
+    const timestamp = await this.rollup.read.getTimestampForSlot([BigInt(slot)]);
+    await this.ethCheatCodes.warp(Number(timestamp), { silent: true, resetBlockInterval: true });
+    this.logger.warn(`Advanced to slot ${slot}`, { timestamp });
+    return timestamp;
+  }
+
   /**
    * Warps time in L1 equivalent to however many slots.
    * @param howMany - The number of slots to advance.
@@ -259,12 +285,14 @@ export class RollupCheatCodes {
     });
   }
 
-  public insertOutbox(epoch: EpochNumber, outHash: bigint) {
+  public insertOutbox(epoch: EpochNumber, numCheckpointsInEpoch: number, outHash: bigint) {
     return this.ethCheatCodes.execWithPausedAnvil(async () => {
       const outboxAddress = await this.rollup.read.getOutbox();
-      const epochRootSlot = OutboxContract.getEpochRootStorageSlot(epoch);
+      const epochRootSlot = OutboxContract.getEpochRootStorageSlot(epoch, numCheckpointsInEpoch);
       await this.ethCheatCodes.store(EthAddress.fromString(outboxAddress), epochRootSlot, outHash);
-      this.logger.warn(`Advanced outbox to epoch ${epoch} with out hash ${outHash}`);
+      this.logger.warn(
+        `Advanced outbox to epoch ${epoch} numCheckpointsInEpoch ${numCheckpointsInEpoch} with out hash ${outHash}`,
+      );
     });
   }
 
@@ -313,7 +341,8 @@ export class RollupCheatCodes {
   }
 
   /**
-   * Directly updates proving cost per mana.
+   * Directly updates proving cost per mana. Throws if the on-chain tx reverts
+   * (e.g. rate-limit cooldown, step cap, or floor) instead of silently succeeding.
    * @param ethValue - The new proving cost per mana in ETH
    */
   public async setProvingCostPerMana(ethValue: bigint) {
@@ -323,8 +352,37 @@ export class RollupCheatCodes {
         chain: this.client.chain,
         gasLimit: 1000000n,
       });
-      await this.client.waitForTransactionReceipt({ hash });
+      const receipt = await this.client.waitForTransactionReceipt({ hash });
+      if (receipt.status !== 'success') {
+        throw new Error(
+          `setProvingCostPerMana(${ethValue}) reverted on L1 (tx ${hash}). ` +
+            `Likely FeeLib rate-limit (30-day cooldown or 1.5x step cap); ` +
+            `use clearProvingCostCooldown() between successive updates.`,
+        );
+      }
       this.logger.warn(`Updated proving cost per mana to ${ethValue}`);
     });
   }
+
+  /**
+   * Resets the 30-day proving-cost update cooldown enforced by FeeLib.updateProvingCostPerMana
+   * by zeroing `FeeStore.provingCostLastUpdate` directly in contract storage. Use between
+   * successive setProvingCostPerMana / bumpProvingCostPerMana calls so the later update can
+   * land instead of reverting. Does not touch L1 time, so PXE/tx-expiration state stays intact.
+   *
+   * @note This is tightly coupled to the `FeeStore` layout in
+   * l1-contracts/src/core/libraries/rollup/FeeLib.sol:
+   *   slot + 0: CompressedFeeConfig config          (uint256)
+   *   slot + 1: L1GasOracleValues l1GasOracleValues (14+14+4 bytes, packed)
+   *   slot + 2: uint64 provingCostLastUpdate        (only member — zeroing the slot is safe)
+   * If the struct layout changes, update the offset below.
+   */
+  public async clearProvingCostCooldown() {
+    const feeStoreBaseSlot = hexToBigInt(keccak256(Buffer.from('aztec.fee.storage', 'utf-8')));
+    const provingCostLastUpdateSlot = feeStoreBaseSlot + 2n;
+    await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provingCostLastUpdateSlot, 0n, {
+      silent: true,
+    });
+    this.logger.warn(`Cleared proving-cost update cooldown`);
+  }
 }

package/src/test/start_anvil.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
+import type { TestDateProvider } from '@aztec/foundation/timer';
 import { fileURLToPath } from '@aztec/foundation/url';
 
 import { type ChildProcess, spawn } from 'child_process';
@@ -26,6 +27,19 @@ export async function startAnvil(
     chainId?: number;
     /** The hardfork to use (e.g. 'cancun', 'latest'). */
     hardfork?: string;
+    /**
+     * Number of slots per epoch used by anvil to compute the 'finalized' and 'safe' block tags.
+     * Anvil reports `finalized = latest - slotsInAnEpoch * 2`.
+     * Defaults to 1 so the finalized block advances immediately, making tests that check
+     * L1-finality-based logic work without needing hundreds of mined blocks.
+     */
+    slotsInAnEpoch?: number;
+    /**
+     * If provided, the date provider will be synced to anvil's block time on every mined block.
+     * This keeps the dateProvider in lockstep with anvil's chain time, avoiding drift between
+     * the wall clock and the L1 chain when computing L1 slot timestamps.
+     */
+    dateProvider?: TestDateProvider;
   } = {},
 ): Promise<{ anvil: Anvil; methodCalls?: string[]; rpcUrl: string; stop: () => Promise<void> }> {
   const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
@@ -55,6 +69,7 @@ export async function startAnvil(
       if (opts.hardfork !== undefined) {
         args.push('--hardfork', opts.hardfork);
       }
+      args.push('--slots-in-an-epoch', String(opts.slotsInAnEpoch ?? 1));
 
       const child = spawn(anvilBinary, args, {
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -100,12 +115,15 @@ export async function startAnvil(
         child.once('close', onClose);
       });
 
-      // Continue piping for logging / method-call capture after startup.
-      if (logger || opts.captureMethodCalls) {
+      // Continue piping for logging, method-call capture, and/or dateProvider sync after startup.
+      if (logger || opts.captureMethodCalls || opts.dateProvider) {
         child.stdout?.on('data', (data: Buffer) => {
           const text = data.toString();
           logger?.debug(text.trim());
           methodCalls?.push(...(text.match(/eth_[^\s]+/g) || []));
+          if (opts.dateProvider) {
+            syncDateProviderFromAnvilOutput(text, opts.dateProvider);
+          }
         });
         child.stderr?.on('data', (data: Buffer) => {
           logger?.debug(data.toString().trim());
@@ -152,6 +170,19 @@ export async function startAnvil(
   return { anvil: anvilObj, methodCalls, stop, rpcUrl: `http://127.0.0.1:${port}` };
 }
 
+/** Extracts block time from anvil stdout and syncs the dateProvider. */
+function syncDateProviderFromAnvilOutput(text: string, dateProvider: TestDateProvider): void {
+  // Anvil logs mined blocks as:
+  //   Block Time: "Fri, 20 Mar 2026 02:10:46 +0000"
+  const match = text.match(/Block Time:\s*"([^"]+)"/);
+  if (match) {
+    const blockTimeMs = new Date(match[1]).getTime();
+    if (!isNaN(blockTimeMs)) {
+      dateProvider.setTime(blockTimeMs);
+    }
+  }
+}
+
 /** Send SIGTERM, wait up to 5 s, then SIGKILL. All timers are always cleared. */
 function killChild(child: ChildProcess): Promise<void> {
   return new Promise<void>(resolve => {