@aztec/ethereum 0.0.1-commit.4d3c002 → 0.0.1-commit.4d9804df

package/src/test/blob_kzg_warmup.ts

@@ -0,0 +1,65 @@
+import { getBytesPerBlob, getBytesPerCommitment, getKzg } from '@aztec/blob-lib';
+import type { Logger } from '@aztec/foundation/log';
+
+import type { ExtendedViemWalletClient } from '../types.js';
+
+/**
+ * Warms both KZG trusted setups in parallel for tests against a local anvil:
+ *   - anvil's own setup, loaded lazily when it first validates a blob sidecar in `eth_sendRawTransaction`
+ *   - our `@crate-crypto/node-eth-kzg` singleton (`getKzg()`, a ~2.2s synchronous precomp build)
+ *
+ * Without this, the first checkpoint publish pays both serially (~4.4s). The recipe does all RPC round
+ * trips up front, fires a single bare raw send carrying a fake (garbage) blob sidecar that anvil rejects
+ * after loading its trusted setup, yields once to flush the socket write, then synchronously builds our
+ * own precomp tables while anvil warms in parallel. The fake tx is rejected at admission, so it never
+ * enters the pool, mines no block, and burns no nonce — sending it from the passed client is harmless.
+ *
+ * Best-effort: any failure is debug-logged and swallowed, leaving lazy init as the fallback. Never throws.
+ *
+ * @param l1Client - The L1 client whose account sends the (rejected) warm-up blob tx.
+ */
+export async function warmBlobKzg(l1Client: ExtendedViemWalletClient, logger?: Logger): Promise<void> {
+  try {
+    // A pure-JS fake kzg: returns deterministic garbage of the correct lengths (commitment and proof are
+    // both 48 bytes). It makes viem build a syntactically valid sidecar without initializing any native
+    // module, so anvil loads its trusted setup to validate the (invalid) proof and then rejects the tx.
+    const fakeKzg = {
+      blobToKzgCommitment: () => {
+        const commitment = new Uint8Array(getBytesPerCommitment());
+        commitment.fill(0xab);
+        commitment[0] = 0xc0;
+        return commitment;
+      },
+      computeBlobKzgProof: () => {
+        const proof = new Uint8Array(getBytesPerCommitment());
+        proof.fill(0xcd);
+        proof[0] = 0xc0;
+        return proof;
+      },
+    };
+
+    // All RPC round trips (nonce, fees, gas) happen here, so only a single socket write remains to flush.
+    const prepared = await l1Client.prepareTransactionRequest({
+      blobs: [new Uint8Array(getBytesPerBlob())],
+      kzg: fakeKzg,
+      to: '0x0000000000000000000000000000000000000000',
+      value: 0n,
+      maxFeePerBlobGas: 1_000_000_000_000n,
+    });
+    const serialized = await l1Client.signTransaction(prepared);
+
+    // Fire the raw send without awaiting and swallow the expected rejection.
+    const sent = l1Client.request({ method: 'eth_sendRawTransaction', params: [serialized] }).catch(() => {});
+
+    // Flush the single socket write so anvil receives the tx and starts loading its trusted setup in its
+    // own process before we block the event loop below.
+    await new Promise(resolve => setImmediate(resolve));
+
+    // Synchronously build our precomp tables (~2.2s, event-loop-blocking); anvil warms in parallel.
+    getKzg();
+
+    await sent;
+  } catch (err) {
+    logger?.debug('Failed to warm blob KZG; falling back to lazy init', { err });
+  }
+}

package/src/test/chain_monitor.ts

@@ -36,9 +36,20 @@ export type ChainMonitorEventMap = {
   'l2-fees': [L2FeeData];
 };
 
+/** Options for tuning what the {@link ChainMonitor} polls on each new L1 block. */
+export type ChainMonitorOptions = {
+  /**
+   * Whether to fetch L2 fee/oracle data (5 extra rollup reads per new L1 block) and emit `l2-fees`.
+   * Defaults to `true`. Set to `false` for tests that only care about slot/checkpoint/proven state to
+   * avoid the extra round-trips.
+   */
+  includeFeeData?: boolean;
+};
+
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
 export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
   private readonly l1Client: ViemClient;
+  private readonly includeFeeData: boolean;
   private inbox: InboxContract | undefined;
   private handle: NodeJS.Timeout | undefined;
   // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
@@ -68,9 +79,11 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     private readonly dateProvider: DateProvider = new DateProvider(),
     private readonly logger = createLogger('aztecjs:utils:chain_monitor'),
     private readonly intervalMs = 200,
+    options: ChainMonitorOptions = {},
   ) {
     super();
     this.l1Client = rollup.client;
+    this.includeFeeData = options.includeFeeData ?? true;
   }
 
   start() {
@@ -183,11 +196,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);
+    if (this.includeFeeData) {
+      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, {
@@ -221,6 +236,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) {
@@ -268,6 +288,74 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     });
   }
 
+  /**
+   * Resolves with the first `checkpoint` event whose payload satisfies `match`. Unlike
+   * {@link waitUntilCheckpoint} (which waits for a target number), this lets callers wait for an
+   * arbitrary checkpoint property (e.g. one published in the first half of its slot). Rejects after
+   * `opts.timeout` ms if provided; otherwise waits indefinitely.
+   *
+   * By default this is purely event-driven and only resolves on the *next* matching checkpoint that
+   * arrives after the call. Set `checkCurrentCheckpoint` to also test the current checkpoint first (via
+   * a fresh {@link run} snapshot) and short-circuit if it already satisfies `match`. Use it only for
+   * latching state predicates (e.g. "checkpoint number has passed N"), where an already-satisfied
+   * result is valid and you want to avoid missing an advance that landed before the listener attached.
+   * Do NOT set it when the predicate depends on observing the checkpoint live (e.g. one published
+   * mid-slot that the caller then times against wall-clock), since it may return a checkpoint whose
+   * slot has already elapsed.
+   */
+  public async waitForCheckpoint(
+    match: (event: ChainMonitorEventMap['checkpoint'][0]) => boolean,
+    opts: { timeout?: number; checkCurrentCheckpoint?: boolean } = {},
+  ): Promise<ChainMonitorEventMap['checkpoint'][0]> {
+    if (opts.checkCurrentCheckpoint) {
+      await this.run();
+      const current: ChainMonitorEventMap['checkpoint'][0] = {
+        checkpointNumber: this.checkpointNumber,
+        l1BlockNumber: this.l1BlockNumber,
+        l2SlotNumber: this.l2SlotNumber,
+        timestamp: this.checkpointTimestamp,
+      };
+      if (match(current)) {
+        return current;
+      }
+    }
+    return new Promise((resolve, reject) => {
+      let timer: NodeJS.Timeout | undefined;
+      const listener = (event: ChainMonitorEventMap['checkpoint'][0]) => {
+        if (match(event)) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          this.off('checkpoint', listener);
+          resolve(event);
+        }
+      };
+      if (opts.timeout !== undefined) {
+        timer = setTimeout(() => {
+          this.off('checkpoint', listener);
+          reject(new Error(`Timed out after ${opts.timeout}ms waiting for a matching checkpoint`));
+        }, opts.timeout);
+      }
+      this.on('checkpoint', listener);
+    });
+  }
+
+  /** Resolves once the proven checkpoint number reaches `checkpointNumber`. */
+  public waitUntilCheckpointProven(checkpointNumber: CheckpointNumber): Promise<void> {
+    if (this.provenCheckpointNumber >= checkpointNumber) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { provenCheckpointNumber: CheckpointNumber; timestamp: bigint }) => {
+        if (data.provenCheckpointNumber >= checkpointNumber) {
+          this.off('checkpoint-proven', listener);
+          resolve();
+        }
+      };
+      this.on('checkpoint-proven', listener);
+    });
+  }
+
   private async fetchFeeData(timestamp: bigint): Promise<L2FeeData> {
     const [components, minFeePerMana, l1Fees, ethPerFeeAsset, manaTarget] = await Promise.all([
       this.rollup.getManaMinFeeComponentsAt(timestamp, true),

package/src/test/eth_cheat_codes.ts

@@ -95,6 +95,16 @@ export class EthCheatCodes {
     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
@@ -196,6 +206,22 @@ export class EthCheatCodes {
     }
   }
 
+  /**
+   * Starts interval mining from a freshly mined block and syncs the date provider to the block timestamp.
+   */
+  public async startIntervalMiningWithFreshBlock(seconds: number): Promise<void> {
+    if (seconds <= 0) {
+      throw new Error(`Interval mining requires a positive interval, got ${seconds}`);
+    }
+
+    await this.setAutomine(false);
+    await this.setIntervalMining(0, { silent: true });
+    await this.evmMine();
+    await this.syncDateProvider();
+    await this.setIntervalMining(seconds);
+    this.logger.warn(`Started L1 interval mining at ${seconds} seconds from a fresh block`);
+  }
+
   /**
    * Set the automine status of the underlying anvil chain
    * @param automine - The automine status to set
@@ -468,58 +494,67 @@ export class EthCheatCodes {
   }
 
   /**
-   * Mines an empty block by temporarily removing all pending transactions from the mempool,
-   * mining a block, and then re-adding the transactions back to the pool.
+   * Mines empty blocks while leaving any pending transactions untouched in the mempool.
+   *
+   * Never manipulates the mempool, so it is immune to the race that dropping and re-adding txs has against a
+   * concurrent publisher that is monitoring and re-broadcasting the same in-flight tx (with that approach the
+   * in-flight tx could reappear in the pool and be swept into the "empty" block, mining a proposal the caller
+   * expected to stay pending). Works in two steps: first the block gas limit is temporarily lowered below the
+   * intrinsic cost of any transaction (21000 gas) and the blocks are mined, so no pending tx is includable;
+   * then those blocks are reorged out and replaced with empty blocks mined at the restored gas limit. The
+   * reorg is needed because anvil applies a new gas limit only to future blocks: without it the just-mined
+   * blocks would keep the tiny gas limit, and an `eth_call` against `latest` (whose gas is capped by the
+   * block gas limit) would revert with "intrinsic gas too high".
+   *
+   * The replacement blocks advance L1 time. `anvil_reorg` stamps each replacement as `parent + N*interval`,
+   * so on its own it would freeze L1 time at the parent timestamp; callers that measure elapsed L1 time
+   * (L1TxUtils stall/timeout detection, `syncDateProvider`-driven slot advancement) rely on it moving
+   * forward. We reproduce the wall-clock advance the mine step just made (at least 1s per block) via a
+   * temporary block-timestamp interval, then restore any pre-existing interval.
    */
   public async mineEmptyBlock(blockCount: number = 1): Promise<void> {
     await this.execWithPausedAnvil(async () => {
-      // Get all pending and queued transactions from the pool
-      const txs = await this.getTxPoolContents();
-
-      this.logger.debug(`Found ${txs.length} transactions in pool`);
-
-      // Get raw transactions before dropping them
-      const rawTxs: Hex[] = [];
-      for (const tx of txs) {
-        try {
-          const rawTx = await this.doRpcCall('debug_getRawTransaction', [tx.hash]);
-          if (rawTx) {
-            rawTxs.push(rawTx);
-            this.logger.debug(`Got raw tx for ${tx.hash}`);
-          } else {
-            this.logger.warn(`No raw tx found for ${tx.hash}`);
-          }
-        } catch {
-          this.logger.warn(`Failed to get raw transaction for ${tx.hash}`);
-        }
+      const originalGasLimit = await this.getBlockGasLimit();
+      const parentTimestamp = await this.lastBlockTimestamp();
+      // anvil has no getter for the block-timestamp interval, but the pending block is stamped
+      // `latest + interval`, so this delta is the standing interval (0 when none is set).
+      const priorInterval = (await this.nextBlockTimestamp()) - parentTimestamp;
+      try {
+        await this.setBlockGasLimit(1n);
+        await this.doMine(blockCount);
+      } finally {
+        await this.setBlockGasLimit(originalGasLimit);
       }
-
-      this.logger.debug(`Retrieved ${rawTxs.length} raw transactions`);
-
-      // Drop all transactions from the mempool
-      await this.doRpcCall('anvil_dropAllTransactions', []);
-
-      // Mine an empty block
-      await this.doMine(blockCount);
-
-      // Re-add the transactions to the pool
-      for (const rawTx of rawTxs) {
-        try {
-          const txHash = await this.doRpcCall('eth_sendRawTransaction', [rawTx]);
-          this.logger.debug(`Re-added transaction ${txHash}`);
-        } catch (err) {
-          this.logger.warn(`Failed to re-add transaction: ${err}`);
+      const advance = (await this.lastBlockTimestamp()) - parentTimestamp;
+      const perBlockInterval = Math.max(1, Math.floor(advance / blockCount));
+      // Replace the tiny-gas-limit blocks with empty blocks at the restored gas limit, keeping the same
+      // height. The reorged-out blocks held no transactions, so nothing returns to the pool.
+      await this.doRpcCall('anvil_setBlockTimestampInterval', [perBlockInterval]);
+      try {
+        await this.doRpcCall('anvil_reorg', [blockCount, []]);
+      } finally {
+        if (priorInterval > 0) {
+          await this.doRpcCall('anvil_setBlockTimestampInterval', [priorInterval]);
+        } else {
+          await this.doRpcCall('anvil_removeBlockTimestampInterval', []);
         }
       }
-
-      if (rawTxs.length !== txs.length) {
-        this.logger.warn(`Failed to add all txs back: had ${txs.length} but re-added ${rawTxs.length}`);
-      }
     });
 
     this.logger.warn(`Mined ${blockCount} empty L1 ${pluralize('block', blockCount)}`);
   }
 
+  /** Returns the gas limit of the latest mined L1 block. */
+  public async getBlockGasLimit(): Promise<bigint> {
+    const block = await this.doRpcCall('eth_getBlockByNumber', ['latest', false]);
+    return BigInt(block.gasLimit);
+  }
+
+  /** Sets the block gas limit applied to subsequently mined L1 blocks. */
+  public async setBlockGasLimit(gasLimit: bigint): Promise<void> {
+    await this.doRpcCall('anvil_setBlockGasLimit', [toHex(gasLimit)]);
+  }
+
   public async execWithPausedAnvil<T>(fn: () => Promise<T>): Promise<T> {
     const [blockInterval, wasAutoMining] = await Promise.all([this.getIntervalMining(), this.isAutoMining()]);
     try {

package/src/test/index.ts

@@ -1,3 +1,4 @@
+export * from './blob_kzg_warmup.js';
 export * from './eth_cheat_codes.js';
 export * from './eth_cheat_codes_with_state.js';
 export * from './start_anvil.js';

package/src/test/rollup_cheat_codes.ts

@@ -4,6 +4,7 @@ import type { ViemPublicClient } from '@aztec/ethereum/types';
 import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import type { DateProvider } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
@@ -15,6 +16,7 @@ import {
   getContract,
   hexToBigInt,
   http,
+  keccak256,
 } from 'viem';
 
 import { EthCheatCodes } from './eth_cheat_codes.js';
@@ -53,7 +55,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 +180,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.
@@ -218,6 +245,56 @@ export class RollupCheatCodes {
     });
   }
 
+  /**
+   * Polls the rollup until its current epoch reaches `epoch`. Unlike {@link advanceToEpoch} this does
+   * not warp the L1 clock; it only waits for the chain to reach `epoch` through external activity.
+   */
+  public async waitForEpoch(epoch: EpochNumber, opts: { timeout?: number; interval?: number } = {}): Promise<void> {
+    await retryUntil(
+      async () => (await this.getEpoch()) >= epoch || undefined,
+      `rollup epoch >= ${epoch}`,
+      opts.timeout ?? 60,
+      opts.interval ?? 1,
+    );
+  }
+
+  /**
+   * Polls the rollup until its current slot reaches `slot`. Unlike {@link advanceToSlot} this does not
+   * warp the L1 clock; it only waits for the chain to reach `slot` through external activity.
+   */
+  public async waitForSlot(slot: SlotNumber, opts: { timeout?: number; interval?: number } = {}): Promise<void> {
+    await retryUntil(
+      async () => (await this.getSlot()) >= slot || undefined,
+      `rollup slot >= ${slot}`,
+      opts.timeout ?? 60,
+      opts.interval ?? 1,
+    );
+  }
+
+  /**
+   * Polls the rollup until its pending checkpoint settles below `checkpoint` on a freshly mined, non-zero
+   * checkpoint, and returns that new pending checkpoint number. Reads the L1 rollup contract directly
+   * rather than a node, since a rollback lands on L1 first.
+   *
+   * A prune can momentarily drop the pending checkpoint to 0 before the post-deadline propose mines its
+   * replacement, so a caller detecting a rollback wants the new lower checkpoint, not that transient
+   * empty state — hence the non-zero guard.
+   */
+  public async waitForCheckpointBelow(
+    checkpoint: CheckpointNumber,
+    opts: { timeout?: number; interval?: number } = {},
+  ): Promise<CheckpointNumber> {
+    return await retryUntil(
+      async () => {
+        const { pending } = await this.getTips();
+        return pending > 0 && pending < checkpoint ? pending : undefined;
+      },
+      `rollup checkpoint in (0, ${checkpoint})`,
+      opts.timeout ?? 60,
+      opts.interval ?? 1,
+    );
+  }
+
   /**
    * Overrides the inProgress field of the Inbox contract state
    * @param howMuch - How many checkpoints to move it forward
@@ -259,12 +336,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 +392,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 +403,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,10 +1,10 @@
 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';
-import { dirname, resolve } from 'path';
+
+import { resolveFoundryBinary } from '../foundry_binary.js';
 
 /** Minimal interface matching the @viem/anvil Anvil shape used by callers. */
 export interface Anvil {
@@ -14,6 +14,30 @@ export interface Anvil {
   stop(): Promise<void>;
 }
 
+// Watchdog wrapper: instead of spawning anvil directly, we spawn a small bash supervisor that runs
+// anvil as a background child and polls its own parent (this node process). If the parent dies for
+// ANY reason — including SIGKILL / crash / OOM, where node's own exit handlers never run — the poll
+// loop ends and the EXIT trap reaps anvil. The script is inlined (rather than shipped as a `.sh`) so
+// it works from the published npm tarball too, and the resolved anvil binary is passed via
+// `$ANVIL_BIN` so it works without `anvil` on PATH.
+//
+// `$@` is the anvil argv; `bash -c <script> bash <...args>` puts the args in `$@` and `$0` = 'bash'.
+//
+// The EXIT trap reaps anvil; INT/TERM just `exit` (which fires the EXIT trap) so a signal terminates
+// the supervisor promptly instead of being swallowed — a trapped TERM does NOT terminate the shell,
+// so trapping the kill directly on TERM would leave the poll loop running and the caller's teardown
+// hanging until its SIGKILL escalation. `sleep & wait` makes the poll interruptible, so INT/TERM are
+// handled immediately rather than after the current `sleep` returns.
+const ANVIL_WATCHDOG = `
+set -u
+parent=$PPID
+"$ANVIL_BIN" "$@" &
+anvil_pid=$!
+trap 'kill "$anvil_pid" 2>/dev/null' EXIT
+trap 'exit 0' INT TERM
+while kill -0 "$parent" 2>/dev/null; do sleep 1 & wait $!; done
+`;
+
 /**
  * Ensures there's a running Anvil instance and returns the RPC URL.
  */
@@ -42,7 +66,7 @@ export async function startAnvil(
     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');
+  const anvilBinary = resolveFoundryBinary('anvil');
   const logger = opts.log ? createLogger('ethereum:anvil') : undefined;
   const methodCalls = opts.captureMethodCalls ? ([] as string[]) : undefined;
 
@@ -50,6 +74,9 @@ export async function startAnvil(
 
   const anvil = await retry(
     async () => {
+      // `--port 0` lets anvil bind an OS-assigned ephemeral port; the actual port is read back from
+      // its "Listening on host:port" stdout below, so independent suites can spawn their own anvil
+      // in parallel without fighting over a fixed port.
       const port = opts.port ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : 8545);
       const args: string[] = [
         '--host',
@@ -71,9 +98,11 @@ export async function startAnvil(
       }
       args.push('--slots-in-an-epoch', String(opts.slotsInAnEpoch ?? 1));
 
-      const child = spawn(anvilBinary, args, {
+      // Spawn the watchdog (see ANVIL_WATCHDOG). It launches anvil with these args and reaps it if we
+      // die; `$0` is 'bash' and `$@` is the anvil argv.
+      const child = spawn('bash', ['-c', ANVIL_WATCHDOG, 'bash', ...args], {
         stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, RAYON_NUM_THREADS: '1' },
+        env: { ...process.env, ANVIL_BIN: anvilBinary, RAYON_NUM_THREADS: '1' },
       });
 
       // Wait for "Listening on" or an early exit.
@@ -183,7 +212,10 @@ function syncDateProviderFromAnvilOutput(text: string, dateProvider: TestDatePro
   }
 }
 
-/** Send SIGTERM, wait up to 5 s, then SIGKILL. All timers are always cleared. */
+/**
+ * Send SIGTERM to the watchdog, wait up to 5 s, then SIGKILL. The watchdog's trap forwards the
+ * signal to anvil, so terminating it tears down anvil too. All timers are always cleared.
+ */
 function killChild(child: ChildProcess): Promise<void> {
   return new Promise<void>(resolve => {
     if (child.exitCode !== null || child.killed) {