@aztec/aztec 0.0.1-commit.b6e433891 → 0.0.1-commit.b9865e97

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';
@@ -21,7 +22,8 @@ import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { SequencerState } from '@aztec/sequencer-client';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { TxStatus } from '@aztec/stdlib/tx';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import {
   type TelemetryClient,
   getConfigEnvVars as getTelemetryClientConfig,
@@ -40,11 +42,18 @@ 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;
 
 /**
@@ -59,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, {
@@ -70,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. */
@@ -151,7 +160,7 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
     ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
     ...prefundAddresses,
   ];
-  const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(fundedAddresses);
+  const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(fundedAddresses);
 
   const dateProvider = new TestDateProvider();
 
@@ -190,7 +199,7 @@ 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
@@ -205,6 +214,21 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
       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;
@@ -226,11 +250,14 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
     });
 
     userLog('Setting up funded test accounts...');
-    const accountManagers = await deployFundedSchnorrAccounts(wallet, initialAccounts);
+    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()}`);
 
@@ -259,14 +286,13 @@ export async function createAztecNode(
     dateProvider?: DateProvider;
     proverBroker?: ProvingJobBroker;
   } = {},
-  options: { prefilledPublicData?: PublicDataTreeLeaf[] } = {},
+  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,

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,8 +35,6 @@ 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>;
 
@@ -40,11 +44,18 @@ export class AnvilTestWatcher {
   // 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()),
@@ -56,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}`);
   }
 
@@ -78,6 +92,18 @@ export class AnvilTestWatcher {
     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');
@@ -130,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);
     }
   }
 
@@ -151,8 +184,9 @@ export class AnvilTestWatcher {
 
       if (BigInt(currentSlot) === checkpointLog.slotNumber) {
         // The current slot has been filled, we should jump to the next slot.
-        await this.warpToTimestamp(nextSlotTimestamp);
-        this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
+        if (await this.warpToTimestamp(nextSlotTimestamp)) {
+          this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
+        }
         return;
       }
 
@@ -161,6 +195,20 @@ 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
@@ -180,9 +228,10 @@ export class AnvilTestWatcher {
           }
 
           if (realNow - this.unfilledSlotFirstSeen.realTime > 2000) {
-            await this.warpToTimestamp(nextSlotTimestamp);
+            if (await this.warpToTimestamp(nextSlotTimestamp)) {
+              this.logger.info(`Slot ${currentSlot} was missed with pending txs, jumped to next slot`);
+            }
             this.unfilledSlotFirstSeen = undefined;
-            this.logger.info(`Slot ${currentSlot} was missed with pending txs, jumped to next slot`);
           }
 
           return;
@@ -192,19 +241,33 @@ export class AnvilTestWatcher {
       // Fallback: warp when the dateProvider time has passed the next slot timestamp.
       const currentTimestamp = this.dateProvider?.now() ?? Date.now();
       if (currentTimestamp > nextSlotTimestamp * 1000) {
-        await this.warpToTimestamp(nextSlotTimestamp);
-        this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
+        if (await this.warpToTimestamp(nextSlotTimestamp)) {
+          this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
+        }
       }
     } catch {
       this.logger.error('mineIfSlotFilled failed');
     }
   }
 
-  private async warpToTimestamp(timestamp: number) {
+  /**
+   * 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

@@ -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()) },
@@ -53,12 +52,12 @@ export class EpochTestSettler {
 
     const outHash = computeEpochOutHash(messagesInEpoch);
     if (!outHash.isZero()) {
-      await this.rollupCheatCodes.insertOutbox(epoch, outHash.toBigInt());
+      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 {

package/src/testing/index.ts

@@ -1,4 +1,4 @@
-export { AnvilTestWatcher } from './anvil_test_watcher.js';
+export { AnvilTestWatcher, type AnvilTestWatcherOpts } from './anvil_test_watcher.js';
 export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
 export { CheatCodes } from './cheat_codes.js';
 export { EpochTestSettler } from './epoch_test_settler.js';

package/dest/cli/cmds/start_archiver.d.ts

@@ -1,9 +0,0 @@
-import { type ArchiverConfig } from '@aztec/archiver';
-import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import { type DataStoreConfig } from '@aztec/stdlib/kv-store';
-export type { ArchiverConfig, DataStoreConfig };
-/** Starts a standalone archiver. */
-export declare function startArchiver(options: any, signalHandlers: (() => Promise<void>)[], services: NamespacedApiHandlers): Promise<{
-    config: ArchiverConfig & DataStoreConfig;
-}>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnRfYXJjaGl2ZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbGkvY21kcy9zdGFydF9hcmNoaXZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQW9FLE1BQU0saUJBQWlCLENBQUM7QUFJeEgsT0FBTyxLQUFLLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUUvRSxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQXNCLE1BQU0sd0JBQXdCLENBQUM7QUFLbEYsWUFBWSxFQUFFLGNBQWMsRUFBRSxlQUFlLEVBQUUsQ0FBQztBQUVoRCxvQ0FBb0M7QUFDcEMsd0JBQXNCLGFBQWEsQ0FDakMsT0FBTyxFQUFFLEdBQUcsRUFDWixjQUFjLEVBQUUsQ0FBQyxNQUFNLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxFQUFFLEVBQ3ZDLFFBQVEsRUFBRSxxQkFBcUIsR0FDOUIsT0FBTyxDQUFDO0lBQUUsTUFBTSxFQUFFLGNBQWMsR0FBRyxlQUFlLENBQUE7Q0FBRSxDQUFDLENBK0J2RCJ9

package/dest/cli/cmds/start_archiver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start_archiver.d.ts","sourceRoot":"","sources":["../../../src/cli/cmds/start_archiver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAoE,MAAM,iBAAiB,CAAC;AAIxH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAE/E,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAKlF,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,CAAC;AAEhD,oCAAoC;AACpC,wBAAsB,aAAa,CACjC,OAAO,EAAE,GAAG,EACZ,cAAc,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,EACvC,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CAAC;IAAE,MAAM,EAAE,cAAc,GAAG,eAAe,CAAA;CAAE,CAAC,CA+BvD"}

package/dest/cli/cmds/start_archiver.js

@@ -1,48 +0,0 @@
-import { archiverConfigMappings, createArchiver, getArchiverConfigFromEnv } from '@aztec/archiver';
-import { createLogger } from '@aztec/aztec.js/log';
-import { blobClientConfigMapping, createBlobClient } from '@aztec/blob-client/client';
-import { getL1Config } from '@aztec/cli/config';
-import { ArchiverApiSchema } from '@aztec/stdlib/interfaces/server';
-import { dataConfigMappings } from '@aztec/stdlib/kv-store';
-import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
-import { extractRelevantOptions } from '../util.js';
-/** Starts a standalone archiver. */ export async function startArchiver(options, signalHandlers, services) {
-    const envConfig = getArchiverConfigFromEnv();
-    const cliOptions = extractRelevantOptions(options, {
-        ...archiverConfigMappings,
-        ...dataConfigMappings,
-        ...blobClientConfigMapping
-    }, 'archiver');
-    let archiverConfig = {
-        ...envConfig,
-        ...cliOptions
-    };
-    archiverConfig.dataStoreMapSizeKb = archiverConfig.archiverStoreMapSizeKb ?? archiverConfig.dataStoreMapSizeKb;
-    if (!archiverConfig.l1Contracts.registryAddress || archiverConfig.l1Contracts.registryAddress.isZero()) {
-        throw new Error('L1 registry address is required to start an Archiver');
-    }
-    const { addresses, config: l1Config } = await getL1Config(archiverConfig.l1Contracts.registryAddress, archiverConfig.l1RpcUrls, archiverConfig.l1ChainId);
-    archiverConfig.l1Contracts = addresses;
-    archiverConfig = {
-        ...archiverConfig,
-        ...l1Config
-    };
-    const telemetry = await initTelemetryClient(getTelemetryClientConfig());
-    const blobClient = createBlobClient(archiverConfig, {
-        logger: createLogger('archiver:blob-client:client')
-    });
-    const archiver = await createArchiver(archiverConfig, {
-        telemetry,
-        blobClient
-    }, {
-        blockUntilSync: true
-    });
-    services.archiver = [
-        archiver,
-        ArchiverApiSchema
-    ];
-    signalHandlers.push(archiver.stop);
-    return {
-        config: archiverConfig
-    };
-}

package/src/cli/cmds/start_archiver.ts

@@ -1,50 +0,0 @@
-import { type ArchiverConfig, archiverConfigMappings, createArchiver, getArchiverConfigFromEnv } from '@aztec/archiver';
-import { createLogger } from '@aztec/aztec.js/log';
-import { type BlobClientConfig, blobClientConfigMapping, createBlobClient } from '@aztec/blob-client/client';
-import { getL1Config } from '@aztec/cli/config';
-import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import { ArchiverApiSchema } from '@aztec/stdlib/interfaces/server';
-import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
-import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
-
-import { extractRelevantOptions } from '../util.js';
-
-export type { ArchiverConfig, DataStoreConfig };
-
-/** Starts a standalone archiver. */
-export async function startArchiver(
-  options: any,
-  signalHandlers: (() => Promise<void>)[],
-  services: NamespacedApiHandlers,
-): Promise<{ config: ArchiverConfig & DataStoreConfig }> {
-  const envConfig = getArchiverConfigFromEnv();
-  const cliOptions = extractRelevantOptions<ArchiverConfig & DataStoreConfig & BlobClientConfig>(
-    options,
-    { ...archiverConfigMappings, ...dataConfigMappings, ...blobClientConfigMapping },
-    'archiver',
-  );
-
-  let archiverConfig = { ...envConfig, ...cliOptions };
-  archiverConfig.dataStoreMapSizeKb = archiverConfig.archiverStoreMapSizeKb ?? archiverConfig.dataStoreMapSizeKb;
-
-  if (!archiverConfig.l1Contracts.registryAddress || archiverConfig.l1Contracts.registryAddress.isZero()) {
-    throw new Error('L1 registry address is required to start an Archiver');
-  }
-
-  const { addresses, config: l1Config } = await getL1Config(
-    archiverConfig.l1Contracts.registryAddress,
-    archiverConfig.l1RpcUrls,
-    archiverConfig.l1ChainId,
-  );
-
-  archiverConfig.l1Contracts = addresses;
-  archiverConfig = { ...archiverConfig, ...l1Config };
-
-  const telemetry = await initTelemetryClient(getTelemetryClientConfig());
-  const blobClient = createBlobClient(archiverConfig, { logger: createLogger('archiver:blob-client:client') });
-  const archiver = await createArchiver(archiverConfig, { telemetry, blobClient }, { blockUntilSync: true });
-  services.archiver = [archiver, ArchiverApiSchema];
-  signalHandlers.push(archiver.stop);
-
-  return { config: archiverConfig };
-}