@aztec/aztec 0.0.1-commit.179ed20 → 0.0.1-commit.189eedb3

package/src/local-network/local-network.ts

@@ -11,6 +11,7 @@ import { waitForPublicClient } from '@aztec/ethereum/client';
 import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
 import { NULL_KEY } from '@aztec/ethereum/constants';
 import { deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { EthCheatCodes } from '@aztec/ethereum/test';
 import { SecretValue } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -18,13 +19,18 @@ import type { LogFn } from '@aztec/foundation/log';
 import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { SequencerState } from '@aztec/sequencer-client';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { TxStatus } from '@aztec/stdlib/tx';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import {
   type TelemetryClient,
   getConfigEnvVars as getTelemetryClientConfig,
   initTelemetryClient,
 } from '@aztec/telemetry-client';
-import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
+import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { type Hex, createPublicClient, fallback, http as httpViemTransport } from 'viem';
@@ -35,11 +41,19 @@ import { createAccountLogs } from '../cli/util.js';
 import { DefaultMnemonic } from '../mnemonic.js';
 import { AnvilTestWatcher } from '../testing/anvil_test_watcher.js';
 import { EpochTestSettler } from '../testing/epoch_test_settler.js';
+import { getTokenAllowedSetupFunctions } from '../testing/token_allowed_setup.js';
+import { publishStandardAuthRegistry } from './auth_registry.js';
 import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
 import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 
 const logger = createLogger('local-network');
 
+// The embedded wallet defaults to waiting for PROPOSED, which returns as soon as a tx lands in a
+// proposed L2 block. That is flaky for the serial sandbox setup below: a proposed block can be
+// pruned before its checkpoint is published, dropping a tx we already moved on from ("Tx dropped by
+// P2P node"). Wait for the checkpoint so each setup tx is durably included before the next is sent.
+const setupWaitOpts = { waitForStatus: TxStatus.CHECKPOINTED };
+
 const localAnvil = foundry;
 
 /**
@@ -54,7 +68,7 @@ export async function deployContractsToL1(
     genesisArchiveRoot?: Fr;
     feeJuicePortalInitialBalance?: bigint;
   } = {},
-) {
+): Promise<L1ContractAddresses> {
   await waitForPublicClient(aztecNodeConfig);
 
   const l1Contracts = await deployAztecL1Contracts(aztecNodeConfig.l1RpcUrls[0], privateKey, foundry.id, {
@@ -65,14 +79,14 @@ export async function deployContractsToL1(
     genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
     feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
     aztecTargetCommitteeSize: 0, // no committee in local network
-    slasherFlavor: 'none', // no slashing in local network
+    slasherEnabled: false, // no slashing in local network
     realVerifier: false,
   });
 
-  aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
+  Object.assign(aztecNodeConfig, l1Contracts.l1ContractAddresses);
   aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
 
-  return aztecNodeConfig.l1Contracts;
+  return l1Contracts.l1ContractAddresses;
 }
 
 /** Local network settings. */
@@ -98,18 +112,25 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
     logger.warn(`Multiple L1 RPC URLs provided. Local networks will only use the first one: ${l1RpcUrl}`);
   }
 
+  // The local network deploys a banana FPC with Token contracts, so include Token entries
+  // in the setup allowlist so FPC-based fee payments work out of the box.
+  const tokenAllowList = await getTokenAllowedSetupFunctions();
+
   const aztecNodeConfig: AztecNodeConfig = {
     ...getConfigEnvVars(),
     ...config,
+    txPublicSetupAllowListExtend: [...tokenAllowList, ...(config.txPublicSetupAllowListExtend ?? [])],
   };
   const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
   if (
-    aztecNodeConfig.publisherPrivateKeys == undefined ||
-    !aztecNodeConfig.publisherPrivateKeys.length ||
-    aztecNodeConfig.publisherPrivateKeys[0].getValue() === NULL_KEY
+    aztecNodeConfig.sequencerPublisherPrivateKeys == undefined ||
+    !aztecNodeConfig.sequencerPublisherPrivateKeys.length ||
+    aztecNodeConfig.sequencerPublisherPrivateKeys[0].getValue() === NULL_KEY
   ) {
     const privKey = hdAccount.getHdKey().privateKey;
-    aztecNodeConfig.publisherPrivateKeys = [new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const)];
+    aztecNodeConfig.sequencerPublisherPrivateKeys = [
+      new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const),
+    ];
   }
   if (!aztecNodeConfig.validatorPrivateKeys?.getValue().length) {
     const privKey = hdAccount.getHdKey().privateKey;
@@ -133,10 +154,13 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
 
   const bananaFPC = await getBananaFPCAddress(initialAccounts);
   const sponsoredFPC = await getSponsoredFPCAddress();
-  const fundedAddresses = initialAccounts.length
-    ? [...initialAccounts.map(a => a.address), bananaFPC, sponsoredFPC]
-    : [];
-  const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(fundedAddresses);
+  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const fundedAddresses = [
+    ...initialAccounts.map(a => a.address),
+    ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
+    ...prefundAddresses,
+  ];
+  const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(fundedAddresses);
 
   const dateProvider = new TestDateProvider();
 
@@ -175,7 +199,37 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   const telemetry = await initTelemetryClient(getTelemetryClientConfig());
   // Create a local blob client client inside the local network, no http connectivity
   const blobClient = createBlobClient();
-  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { prefilledPublicData });
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { genesis });
+
+  // Now that the node is up, let the watcher check for pending txs so it can skip unfilled slots faster when
+  // transactions are waiting in the mempool. Also let it check if the sequencer is actively building, to avoid
+  // warping time out from under an in-progress block.
+  watcher?.setGetPendingTxCount(() => node.getPendingTxCount());
+  const sequencer = node.getSequencer()?.getSequencer();
+  if (sequencer) {
+    const idleStates: Set<string> = new Set([
+      SequencerState.STOPPED,
+      SequencerState.STOPPING,
+      SequencerState.IDLE,
+      SequencerState.SYNCHRONIZING,
+    ]);
+    watcher?.setIsSequencerBuilding(() => !idleStates.has(sequencer.getState()));
+    // Under proposer pipelining the L1 publish for slot N happens during wall-clock slot N,
+    // but the proposer for slot N has already built the checkpoint during slot N-1 and is
+    // waiting for L1 to advance. We need to fast-forward L1 to wake that wait — and the wait
+    // we have to break first is `waitForValidParentCheckpointOnL1`, which blocks the
+    // checkpoint_proposal_job's background submission task until the archiver has synced past
+    // the build slot. That wait happens *before* `PUBLISHING_CHECKPOINT` is set, so a hook on
+    // that state transition would be circular (L1 has to advance before the state we'd use to
+    // advance L1 fires). The earliest pre-wait signal is `block-proposed`, which the sequencer
+    // emits once each block is built. In sandbox single-block-per-slot mode this is
+    // effectively "checkpoint built", and the watcher warp is harmless if a subsequent
+    // assembly/validation/parent-wait step aborts: L1 just sits one slot ahead, which the
+    // cascade absorbs.
+    if (watcher) {
+      sequencer.on('block-proposed', ({ slot }) => watcher!.setProposedTargetSlot(Number(slot)));
+    }
+  }
 
   let epochTestSettler: EpochTestSettler | undefined;
   if (!aztecNodeConfig.p2pEnabled) {
@@ -190,19 +244,20 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   }
 
   if (initialAccounts.length) {
-    const PXEConfig = { proverEnabled: aztecNodeConfig.realProofs };
-    const wallet = await TestWallet.create(node, PXEConfig);
+    const wallet = await EmbeddedWallet.create(node, {
+      pxeConfig: { proverEnabled: aztecNodeConfig.realProofs },
+      ephemeral: true,
+    });
 
     userLog('Setting up funded test accounts...');
-    const accountManagers = await deployFundedSchnorrAccounts(wallet, initialAccounts);
-    const accountsWithSecrets = accountManagers.map((manager, i) => ({
-      account: manager,
-      secretKey: initialAccounts[i].secret,
-    }));
-    const accLogs = await createAccountLogs(accountsWithSecrets, wallet);
+    const accountManagers = await deployFundedSchnorrAccounts(wallet, initialAccounts, setupWaitOpts);
+    const accLogs = await createAccountLogs(accountManagers, wallet);
     userLog(accLogs.join(''));
 
-    await setupBananaFPC(initialAccounts, wallet, userLog);
+    userLog('Publishing standard AuthRegistry contract...');
+    await publishStandardAuthRegistry(wallet, initialAccounts[0].address, setupWaitOpts);
+
+    await setupBananaFPC(initialAccounts, wallet, userLog, setupWaitOpts);
 
     userLog(`SponsoredFPC: ${await getSponsoredFPCAddress()}`);
 
@@ -225,16 +280,24 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
  */
 export async function createAztecNode(
   config: Partial<AztecNodeConfig> = {},
-  deps: { telemetry?: TelemetryClient; blobClient?: BlobClientInterface; dateProvider?: DateProvider } = {},
-  options: { prefilledPublicData?: PublicDataTreeLeaf[] } = {},
+  deps: {
+    telemetry?: TelemetryClient;
+    blobClient?: BlobClientInterface;
+    dateProvider?: DateProvider;
+    proverBroker?: ProvingJobBroker;
+  } = {},
+  options: { genesis?: GenesisData } = {},
 ) {
   // TODO(#12272): will clean this up. This is criminal.
-  const { l1Contracts, ...rest } = getConfigEnvVars();
+  // Not sure why this was ever done. Will be fixed in A-989, A-991, A-990.
   const aztecNodeConfig: AztecNodeConfig = {
-    ...rest,
+    ...getConfigEnvVars(),
     ...config,
-    l1Contracts: { ...l1Contracts, ...config.l1Contracts },
   };
-  const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps, options);
+  const node = await AztecNodeService.createAndSync(
+    aztecNodeConfig,
+    { ...deps, proverNodeDeps: { broker: deps.proverBroker } },
+    options,
+  );
   return node;
 }

package/src/testing/anvil_test_watcher.ts

@@ -9,6 +9,11 @@ import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
 import { type GetContractReturnType, getAddress, getContract } from 'viem';
 
+export type AnvilTestWatcherOpts = {
+  isLocalNetwork?: boolean;
+  isMarkingAsProven?: boolean;
+};
+
 /**
  * Represents a watcher for a rollup contract.
  *
@@ -17,7 +22,8 @@ import { type GetContractReturnType, getAddress, getContract } from 'viem';
  * block within the slot. And if so, it will time travel into the next slot.
  */
 export class AnvilTestWatcher {
-  private isLocalNetwork: boolean = false;
+  private isLocalNetwork;
+  private isMarkingAsProven;
 
   private rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
   private rollupCheatCodes: RollupCheatCodes;
@@ -29,13 +35,27 @@ export class AnvilTestWatcher {
 
   private logger: Logger = createLogger(`aztecjs:utils:watcher`);
 
-  private isMarkingAsProven = true;
+  // Optional callback to check if there are pending txs in the mempool.
+  private getPendingTxCount?: () => Promise<number>;
+
+  // Optional callback to check if the sequencer is actively building a block.
+  private isSequencerBuilding?: () => boolean;
+
+  // Tracks when we first observed the current unfilled slot with pending txs (real wall time).
+  private unfilledSlotFirstSeen?: { slot: number; realTime: number };
+
+  // Latest target slot for which the proposer has built a block destined for L1 but which has
+  // not yet been committed. Set by the proposer-pipelining hook from `block-proposed` events so
+  // the watcher can advance L1 (and the injected date provider) to the target slot ahead of the
+  // publisher's `sendRequestsAt` sleep, instead of waiting a full wall-clock slot.
+  private proposedTargetSlot?: number;
 
   constructor(
     private cheatcodes: EthCheatCodes,
     rollupAddress: EthAddress,
     l1Client: ViemClient,
     private dateProvider?: TestDateProvider,
+    opts: AnvilTestWatcherOpts = {},
   ) {
     this.rollup = getContract({
       address: getAddress(rollupAddress.toString()),
@@ -47,6 +67,9 @@ export class AnvilTestWatcher {
       rollupAddress,
     });
 
+    this.isLocalNetwork = opts.isLocalNetwork ?? false;
+    this.isMarkingAsProven = opts.isMarkingAsProven ?? true;
+
     this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
   }
 
@@ -59,6 +82,28 @@ export class AnvilTestWatcher {
     this.isLocalNetwork = isLocalNetwork;
   }
 
+  /** Sets a callback to check for pending txs, used to skip unfilled slots faster when txs are waiting. */
+  setGetPendingTxCount(fn: () => Promise<number>) {
+    this.getPendingTxCount = fn;
+  }
+
+  /** Sets a callback to check if the sequencer is actively building, to avoid warping while it works. */
+  setIsSequencerBuilding(fn: () => boolean) {
+    this.isSequencerBuilding = fn;
+  }
+
+  /**
+   * Records the target slot for which the proposer has built a block destined for L1. Used by
+   * the local-network watcher to fast-forward L1 (and the injected date provider) ahead of the
+   * pipelined publisher's `sendRequestsAt` sleep so it ends promptly instead of waiting a full
+   * wall-clock slot. Only ratchets up — late warps for stale slots are no-ops.
+   */
+  setProposedTargetSlot(slot: number) {
+    if (this.proposedTargetSlot === undefined || slot > this.proposedTargetSlot) {
+      this.proposedTargetSlot = slot;
+    }
+  }
+
   async start() {
     if (this.filledRunningPromise) {
       throw new Error('Watcher already watching for filled slot');
@@ -111,14 +156,21 @@ export class AnvilTestWatcher {
       return;
     }
 
-    const l1Time = (await this.cheatcodes.timestamp()) * 1000;
+    const l1Time = (await this.cheatcodes.lastBlockTimestamp()) * 1000;
     const wallTime = this.dateProvider.now();
     if (l1Time > wallTime) {
       this.logger.warn(`L1 is ahead of wall time. Syncing wall time to L1 time`);
       this.dateProvider.setTime(l1Time);
     } else if (l1Time + Number(this.l2SlotDuration) * 1000 < wallTime) {
-      this.logger.warn(`L1 is more than 1 L2 slot behind wall time. Warping to wall time`);
-      await this.cheatcodes.warp(Math.ceil(wallTime / 1000));
+      // Warp L1 to the slot boundary at-or-before wall time. Rounding to a slot boundary (rather than
+      // `ceil(wallTime / 1000)`) keeps this loop's target aligned with `warpTimeIfNeeded`'s
+      // `nextSlotTimestamp` target, avoiding a race where the two loops pick timestamps a fraction of
+      // a second apart and one of them is then rejected by anvil as non-monotonic.
+      const wallSec = Math.floor(wallTime / 1000);
+      const targetSlot = await this.rollup.read.getSlotAt([BigInt(wallSec)]);
+      const targetTimestamp = Number(await this.rollup.read.getTimestampForSlot([targetSlot]));
+      this.logger.warn(`L1 is more than 1 L2 slot behind wall time. Warping to slot ${targetSlot} boundary`);
+      await this.warpToTimestamp(targetTimestamp);
     }
   }
 
@@ -131,16 +183,10 @@ export class AnvilTestWatcher {
       const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([BigInt(nextSlot)]));
 
       if (BigInt(currentSlot) === checkpointLog.slotNumber) {
-        // We should jump to the next slot
-        try {
-          await this.cheatcodes.warp(nextSlotTimestamp, {
-            resetBlockInterval: true,
-          });
-        } catch (e) {
-          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+        // The current slot has been filled, we should jump to the next slot.
+        if (await this.warpToTimestamp(nextSlotTimestamp)) {
+          this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
         }
-
-        this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
         return;
       }
 
@@ -149,18 +195,79 @@ export class AnvilTestWatcher {
         return;
       }
 
+      // Pipelined-publish shortcut: if the proposer has built a block destined for a slot
+      // beyond the current L1 slot, fast-forward L1 to that slot's timestamp so the publisher's
+      // `sendRequestsAt(targetSlot)` sleep ends and the multicall mines inside the target slot.
+      // Without this, the publisher waits up to a full real-time slot for wall clock to catch up.
+      if (this.proposedTargetSlot !== undefined && this.proposedTargetSlot > currentSlot) {
+        const targetSlotTimestamp = Number(
+          await this.rollup.read.getTimestampForSlot([BigInt(this.proposedTargetSlot)]),
+        );
+        if (await this.warpToTimestamp(targetSlotTimestamp)) {
+          this.logger.info(`Warped L1 to target slot ${this.proposedTargetSlot} for pipelined publish`);
+        }
+        return;
+      }
+
+      // If there are pending txs and the sequencer missed them, warp quickly (after a 2s real-time debounce) so the
+      // sequencer can retry in the next slot. Without this, we'd have to wait a full real-time slot duration (~36s) for
+      // the dateProvider to catch up to the next slot timestamp. We skip the warp if the sequencer is actively building
+      // to avoid invalidating its in-progress work.
+      if (this.getPendingTxCount) {
+        const pendingTxs = await this.getPendingTxCount();
+        if (pendingTxs > 0) {
+          if (this.isSequencerBuilding?.()) {
+            this.unfilledSlotFirstSeen = undefined;
+            return;
+          }
+
+          const realNow = Date.now();
+          if (!this.unfilledSlotFirstSeen || this.unfilledSlotFirstSeen.slot !== currentSlot) {
+            this.unfilledSlotFirstSeen = { slot: currentSlot, realTime: realNow };
+            return;
+          }
+
+          if (realNow - this.unfilledSlotFirstSeen.realTime > 2000) {
+            if (await this.warpToTimestamp(nextSlotTimestamp)) {
+              this.logger.info(`Slot ${currentSlot} was missed with pending txs, jumped to next slot`);
+            }
+            this.unfilledSlotFirstSeen = undefined;
+          }
+
+          return;
+        }
+      }
+
+      // Fallback: warp when the dateProvider time has passed the next slot timestamp.
       const currentTimestamp = this.dateProvider?.now() ?? Date.now();
       if (currentTimestamp > nextSlotTimestamp * 1000) {
-        try {
-          await this.cheatcodes.warp(nextSlotTimestamp, { resetBlockInterval: true });
-        } catch (e) {
-          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+        if (await this.warpToTimestamp(nextSlotTimestamp)) {
+          this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
         }
-
-        this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
       }
     } catch {
       this.logger.error('mineIfSlotFilled failed');
     }
   }
+
+  /**
+   * Warps L1 to `timestamp`, unless L1 is already at or past it. Returns true when a warp actually
+   * happened, false when skipped or on error. Callers use the return value to gate success logs.
+   */
+  private async warpToTimestamp(timestamp: number): Promise<boolean> {
+    try {
+      // Anvil rejects evm_setNextBlockTimestamp values <= the current block's timestamp. The two
+      // watcher loops can race and pick targets a fraction of a second apart; skip here rather than
+      // letting the second one error out noisily.
+      const lastTimestamp = await this.cheatcodes.lastBlockTimestamp();
+      if (timestamp <= lastTimestamp) {
+        return false;
+      }
+      await this.cheatcodes.warp(timestamp, { resetBlockInterval: true });
+      return true;
+    } catch (e) {
+      this.logger.error(`Failed to warp to timestamp ${timestamp}: ${e}`);
+      return false;
+    }
+  }
 }

package/src/testing/cheat_codes.ts

@@ -1,9 +1,9 @@
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { retryUntil } from '@aztec/foundation/retry';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { SequencerClient } from '@aztec/sequencer-client';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { AutomineSequencer } from '@aztec/sequencer-client';
+import type { AztecNode, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 /**
  * A class that provides utility functions for interacting with the chain.
@@ -12,68 +12,121 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
  * codes, please consider whether it makes sense to just introduce new utils in your tests instead.
  */
 export class CheatCodes {
+  private logger = createLogger('aztecjs:cheat_codes');
+
   constructor(
     /** Cheat codes for L1.*/
     public eth: EthCheatCodes,
     /** Cheat codes for the Aztec Rollup contract on L1. */
     public rollup: RollupCheatCodes,
+    /** When wired, redirects time-warps through the AutomineSequencer queue (test-only). */
+    private automine?: AutomineSequencer,
   ) {}
 
-  static async create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider): Promise<CheatCodes> {
+  static async create(
+    rpcUrls: string[],
+    node: AztecNode,
+    dateProvider: DateProvider,
+    automine?: AutomineSequencer,
+  ): Promise<CheatCodes> {
     const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
     const rollupCheatCodes = new RollupCheatCodes(
       ethCheatCodes,
       await node.getNodeInfo().then(n => n.l1ContractAddresses),
     );
-    return new CheatCodes(ethCheatCodes, rollupCheatCodes);
+    return new CheatCodes(ethCheatCodes, rollupCheatCodes, automine);
   }
 
   /**
    * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
-   * the target timestamp. L2 timestamp is not advanced exactly to the target timestamp because it is determined
-   * by the slot number, which advances in fixed intervals.
-   * This is useful for testing time-dependent contract behavior.
-   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-   * @param node - The Aztec node used to query if a new block has been mined.
+   * the target timestamp. If the target timestamp falls within the current L2 slot (which already has a block),
+   * the timestamp is automatically adjusted forward to the start of the next slot so that `mineBlock()` succeeds.
+   * @param node - The Aztec node used to force an empty block to be mined.
    * @param targetTimestamp - The target timestamp to warp to (in seconds)
    */
-  async warpL2TimeAtLeastTo(sequencerClient: SequencerClient, node: AztecNode, targetTimestamp: bigint | number) {
-    const currentL2BlockNumber: BlockNumber = await node.getBlockNumber();
+  async warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number) {
+    const targetBigInt = BigInt(targetTimestamp);
+    const currentTimestamp = BigInt(await this.eth.lastBlockTimestamp());
 
-    // We warp the L1 timestamp
-    await this.eth.warp(targetTimestamp, { resetBlockInterval: true });
+    if (targetBigInt <= currentTimestamp) {
+      throw new Error(
+        `warpL2TimeAtLeastTo: target timestamp ${targetBigInt} is not in the future (current L1 timestamp is ${currentTimestamp}).`,
+      );
+    }
 
-    // Wait until an L2 block is mined
-    const sequencer = sequencerClient.getSequencer();
-    const minTxsPerBlock = sequencer.getConfig().minTxsPerBlock;
-    sequencer.updateConfig({ minTxsPerBlock: 0 });
+    // AutomineSequencer owns time control through its serial queue — delegate to keep warps atomic
+    // with respect to any in-flight build, and avoid the mineBlock-loop hack below.
+    // `warpTo` internally builds an empty L2 checkpoint, which auto-mines exactly one L1 block at
+    // the target slot boundary, so no separate `node.mineBlock()` is needed here.
+    if (this.automine) {
+      await this.automine.warpTo(Number(targetBigInt));
+      return;
+    }
 
-    await retryUntil(
-      async () => {
-        const newL2BlockNumber: BlockNumber = await node.getBlockNumber();
-        return newL2BlockNumber > currentL2BlockNumber;
-      },
-      'new block after warping L2 time',
-      36,
-      1,
-    );
+    const currentSlot = await this.rollup.getSlot();
+    const targetSlot = await this.rollup.getSlotAt(targetBigInt);
+
+    let effectiveTimestamp = targetBigInt;
+    let effectiveTargetSlot = targetSlot;
+
+    if (targetSlot <= currentSlot) {
+      // Target lands in the same (or earlier) slot — auto-adjust to the next slot's start.
+      const nextSlot = SlotNumber(currentSlot + 1);
+      const nextSlotTimestamp = await this.rollup.getTimestampForSlot(nextSlot);
+      this.logger.warn(
+        `warpL2TimeAtLeastTo: target timestamp ${targetBigInt} falls in current slot ${currentSlot}. ` +
+          `Auto-adjusting to start of slot ${nextSlot} at timestamp ${nextSlotTimestamp}.`,
+      );
+      effectiveTimestamp = nextSlotTimestamp;
+      effectiveTargetSlot = nextSlot;
+    }
 
-    // Restore original minTxsPerBlock
-    sequencer.updateConfig({ minTxsPerBlock });
+    await this.eth.warp(effectiveTimestamp, { resetBlockInterval: true });
+
+    // The sequencer's polling loop may have a `work()` cycle in flight that captured pre-warp slot/timestamp values
+    // just before our warp landed. That cycle would mine an L2 block at the stale slot — the L1 sync prunes such a
+    // block from the canonical chain, but it lingers in local world state and the PXE will use it as the anchor for
+    // subsequent txs, leading to `expiration_timestamp` values that are already in the past relative to L1. Mine
+    // until we observe an L2 block at (or past) the post-warp slot, ensuring the next tx anchors to a fresh block.
+    const maxAttempts = 5;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      await node.mineBlock();
+      const blockData = await node.getBlockData('latest');
+      const blockSlot = blockData?.header.globalVariables.slotNumber;
+      if (blockSlot !== undefined && BigInt(blockSlot) >= BigInt(effectiveTargetSlot)) {
+        return;
+      }
+      this.logger.warn(
+        `warpL2TimeAtLeastTo: mined L2 block at slot ${blockSlot}, expected at least ${effectiveTargetSlot}. ` +
+          `Retrying mineBlock (attempt ${attempt}/${maxAttempts}).`,
+      );
+    }
+    throw new Error(
+      `warpL2TimeAtLeastTo: failed to mine an L2 block at or past slot ${effectiveTargetSlot} after ${maxAttempts} attempts.`,
+    );
   }
 
   /**
    * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
-   * least by the duration. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
-   * number, which advances in fixed intervals.
-   * This is useful for testing time-dependent contract behavior.
-   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-   * @param node - The Aztec node used to query if a new block has been mined.
+   * least by the duration. If the duration is too short to cross an L2 slot boundary, the warp is automatically
+   * extended to the start of the next slot so that `mineBlock()` succeeds.
+   * @param node - The Aztec node used to force an empty block to be mined.
    * @param duration - The duration to advance time by (in seconds)
    */
-  async warpL2TimeAtLeastBy(sequencerClient: SequencerClient, node: AztecNode, duration: bigint | number) {
-    const currentTimestamp = await this.eth.timestamp();
-    const targetTimestamp = BigInt(currentTimestamp) + BigInt(duration);
-    await this.warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp);
+  async warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number) {
+    if (BigInt(duration) <= 0n) {
+      throw new Error(`warpL2TimeAtLeastBy: duration must be positive, got ${duration} seconds.`);
+    }
+
+    // Advance relative to whichever clock leads. A live sequencer mines L2 blocks at slot boundaries that can run
+    // ahead of anvil's L1 timestamp, so basing the target on L1 alone would advance the L2 timestamp by less than
+    // `duration`. Anchoring to the latest L2 block timestamp when it leads guarantees the post-warp L2 block is at
+    // least `duration` ahead of the current one.
+    const currentL1Timestamp = BigInt(await this.eth.lastBlockTimestamp());
+    const latestBlockData = await node.getBlockData('latest');
+    const latestL2Timestamp = latestBlockData ? BigInt(latestBlockData.header.globalVariables.timestamp) : 0n;
+    const baseTimestamp = latestL2Timestamp > currentL1Timestamp ? latestL2Timestamp : currentL1Timestamp;
+    const targetTimestamp = baseTimestamp + BigInt(duration);
+    await this.warpL2TimeAtLeastTo(node, targetTimestamp);
   }
 }

package/src/testing/epoch_test_settler.ts

@@ -4,7 +4,7 @@ import { type EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { Logger } from '@aztec/foundation/log';
 import { EpochMonitor } from '@aztec/prover-node';
 import type { EthAddress, L2BlockSource } from '@aztec/stdlib/block';
-import { computeL2ToL1MembershipWitnessFromMessagesInEpoch } from '@aztec/stdlib/messaging';
+import { computeEpochOutHash } from '@aztec/stdlib/messaging';
 
 export class EpochTestSettler {
   private rollupCheatCodes: RollupCheatCodes;
@@ -31,8 +31,7 @@ export class EpochTestSettler {
   }
 
   async handleEpochReadyToProve(epoch: EpochNumber): Promise<boolean> {
-    const checkpointedBlocks = await this.l2BlockSource.getCheckpointedBlocksForEpoch(epoch);
-    const blocks = checkpointedBlocks.map(b => b.block);
+    const blocks = await this.l2BlockSource.getBlocks({ epoch, onlyCheckpointed: true });
     this.log.info(
       `Settling epoch ${epoch} with blocks ${blocks[0]?.header.getBlockNumber()} to ${blocks.at(-1)?.header.getBlockNumber()}`,
       { blocks: blocks.map(b => b.toBlockInfo()) },
@@ -51,15 +50,14 @@ export class EpochTestSettler {
       messagesInEpoch[checkpointIndex].push(block.body.txEffects.map(txEffect => txEffect.l2ToL1Msgs));
     }
 
-    const [firstMessage] = messagesInEpoch.flat(3);
-    if (firstMessage) {
-      const { root: outHash } = computeL2ToL1MembershipWitnessFromMessagesInEpoch(messagesInEpoch, firstMessage);
-      await this.rollupCheatCodes.insertOutbox(epoch, outHash.toBigInt());
+    const outHash = computeEpochOutHash(messagesInEpoch);
+    if (!outHash.isZero()) {
+      await this.rollupCheatCodes.insertOutbox(epoch, messagesInEpoch.length, outHash.toBigInt());
     } else {
       this.log.info(`No L2 to L1 messages in epoch ${epoch}`);
     }
 
-    const lastCheckpoint = checkpointedBlocks.at(-1)?.checkpointNumber;
+    const lastCheckpoint = blocks.at(-1)?.checkpointNumber;
     if (lastCheckpoint !== undefined) {
       await this.rollupCheatCodes.markAsProven(lastCheckpoint);
     } else {