@aztec/aztec 0.0.1-commit.b2a5d0dd1 → 0.0.1-commit.b3d3157a

package/src/cli/cmds/start_prover_broker.ts

@@ -24,38 +24,37 @@ export async function startProverBroker(
   services: NamespacedApiHandlers,
   userLog: LogFn,
 ): Promise<{ broker: ProvingJobBroker; config: ProverBrokerConfig }> {
-  if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
-    userLog(`Starting a prover broker with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+  if (options.node || options.sequencer || options.p2pBootstrap || options.txe) {
+    userLog(`Starting a prover broker with --node, --sequencer, --p2p-bootstrap, or --txe is not supported.`);
     process.exit(1);
   }
 
-  const config: ProverBrokerConfig = {
+  const baseConfig: ProverBrokerConfig = {
     ...getProverNodeBrokerConfigFromEnv(), // get default config from env
     ...extractRelevantOptions<ProverBrokerConfig>(options, proverBrokerConfigMappings, 'proverBroker'), // override with command line options
   };
 
-  if (!config.l1Contracts.registryAddress || config.l1Contracts.registryAddress.isZero()) {
+  if (!baseConfig.registryAddress || baseConfig.registryAddress.isZero()) {
     throw new Error('L1 registry address is required to start Aztec Node without --deploy-aztec-contracts option');
   }
 
   const genesisConfig = getGenesisStateConfigEnvVars();
   const { genesisArchiveRoot } = await computeExpectedGenesisRoot(genesisConfig, userLog);
   await waitForCompatibleRollup(
-    config,
+    baseConfig,
     { genesisArchiveRoot, vkTreeRoot: getVKTreeRoot(), protocolContractsHash },
     options.port,
     userLog,
   );
 
   const { addresses, config: rollupConfig } = await getL1Config(
-    config.l1Contracts.registryAddress,
-    config.l1RpcUrls,
-    config.l1ChainId,
-    config.rollupVersion,
+    baseConfig.registryAddress,
+    baseConfig.l1RpcUrls,
+    baseConfig.l1ChainId,
+    baseConfig.rollupVersion,
   );
 
-  config.l1Contracts = addresses;
-  config.rollupVersion = rollupConfig.rollupVersion;
+  const config: ProverBrokerConfig = { ...baseConfig, ...addresses, rollupVersion: rollupConfig.rollupVersion };
 
   const client = await initTelemetryClient(getTelemetryClientConfig());
   const broker = await createAndStartProvingBroker(config, client);

package/src/cli/cmds/start_txe.ts

@@ -1,15 +1,17 @@
 import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
 import type { Logger } from '@aztec/foundation/log';
-import { createTXERpcServer } from '@aztec/txe';
+import { createTXERpcServer } from '@aztec/txe/server';
 
-export async function startTXE(options: any, debugLogger: Logger) {
+export async function startTXE(options: any, signalHandlers: Array<() => Promise<void>>, debugLogger: Logger) {
   debugLogger.info(`Setting up TXE...`);
 
-  const txeServer = createTXERpcServer(debugLogger);
-  const { port } = await startHttpRpcServer(txeServer, {
+  const txeServer = await createTXERpcServer(debugLogger);
+  const httpServer = await startHttpRpcServer(txeServer, {
     port: options.port,
     timeoutMs: 1e3 * 60 * 5,
   });
 
-  debugLogger.info(`TXE listening on port ${port}`);
+  signalHandlers.push(() => new Promise<void>(resolve => httpServer.close(() => resolve())));
+
+  debugLogger.info(`TXE listening on port ${httpServer.port}`);
 }

package/src/cli/cmds/utils/warn_if_aztec_version_mismatch.ts

@@ -1,5 +1,5 @@
 import type { LogFn } from '@aztec/foundation/log';
-import { getPackageVersion } from '@aztec/stdlib/update-checker';
+import { DEV_VERSION, getPackageVersion } from '@aztec/stdlib/update-checker';
 
 import TOML from '@iarna/toml';
 import { readFile } from 'fs/promises';
@@ -28,8 +28,7 @@ function isAztecNrGitUrl(gitUrl: string): boolean {
 /** Warns if any aztec-nr git dependency in a crate's Nargo.toml has a tag that doesn't match the CLI version. */
 export async function warnIfAztecVersionMismatch(log: LogFn, cliVersion?: string): Promise<void> {
   const version = cliVersion ?? getPackageVersion();
-  if (!version) {
-    log(`WARNING: aztec CLI version not found. Skipping dependency compatibility check.`);
+  if (version === DEV_VERSION) {
     return;
   }
 

package/src/cli/util.ts

@@ -82,17 +82,17 @@ export async function createAccountLogs(accountManagers: AccountManager[], walle
       accountLogStrings.push(` Address: ${completeAddress.address.toString()}\n`);
       accountLogStrings.push(` Partial Address: ${completeAddress.partialAddress.toString()}\n`);
       accountLogStrings.push(` Secret Key: ${account.getSecretKey().toString()}\n`);
+      accountLogStrings.push(` Master nullifier public key hash: ${completeAddress.publicKeys.npkMHash.toString()}\n`);
+      accountLogStrings.push(` Master incoming viewing public key: ${completeAddress.publicKeys.ivpkM.toString()}\n\n`);
       accountLogStrings.push(
-        ` Master nullifier public key: ${completeAddress.publicKeys.masterNullifierPublicKey.toString()}\n`,
+        ` Master outgoing viewing public key hash: ${completeAddress.publicKeys.ovpkMHash.toString()}\n\n`,
       );
+      accountLogStrings.push(` Master tagging public key hash: ${completeAddress.publicKeys.tpkMHash.toString()}\n\n`);
       accountLogStrings.push(
-        ` Master incoming viewing public key: ${completeAddress.publicKeys.masterIncomingViewingPublicKey.toString()}\n\n`,
+        ` Master message-signing public key hash: ${completeAddress.publicKeys.mspkMHash.toString()}\n\n`,
       );
       accountLogStrings.push(
-        ` Master outgoing viewing public key: ${completeAddress.publicKeys.masterOutgoingViewingPublicKey.toString()}\n\n`,
-      );
-      accountLogStrings.push(
-        ` Master tagging public key: ${completeAddress.publicKeys.masterTaggingPublicKey.toString()}\n\n`,
+        ` Master fallback public key hash: ${completeAddress.publicKeys.fbpkMHash.toString()}\n\n`,
       );
     }
   }
@@ -311,7 +311,7 @@ export async function setupVersionChecker(
   const checks: Array<VersionCheck> = [];
   checks.push({
     name: 'node',
-    currentVersion: getPackageVersion() ?? 'unknown',
+    currentVersion: getPackageVersion(),
     getLatestVersion: async () => {
       const cfg = await getNetworkConfig(network, cacheDir);
       return cfg?.nodeVersion;

package/src/local-network/auth_registry.ts

@@ -0,0 +1,19 @@
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
+import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { AuthRegistryArtifact, getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+export async function publishStandardAuthRegistry(
+  wallet: Wallet,
+  from: AztecAddress,
+  waitOpts?: WaitOpts,
+): Promise<void> {
+  const { instance, contractClass } = await getStandardAuthRegistry();
+  if (!(await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
+    await (await publishContractClass(wallet, AuthRegistryArtifact)).send({ from, wait: waitOpts });
+  }
+  if (!(await wallet.getContractMetadata(instance.address)).isContractPublished) {
+    await publishInstance(wallet, instance).send({ from, wait: waitOpts });
+  }
+}

package/src/local-network/banana_fpc.ts

@@ -1,4 +1,5 @@
 import { type InitialAccountData, getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn } from '@aztec/foundation/log';
@@ -45,19 +46,22 @@ export async function getBananaFPCAddress(initialAccounts: InitialAccountData[])
   return (await getBananaFPCInstance(initialAccounts)).address;
 }
 
-export async function setupBananaFPC(initialAccounts: InitialAccountData[], wallet: Wallet, log: LogFn) {
+export async function setupBananaFPC(
+  initialAccounts: InitialAccountData[],
+  wallet: Wallet,
+  log: LogFn,
+  waitOpts?: WaitOpts,
+) {
   const bananaCoinAddress = await getBananaCoinAddress(initialAccounts);
   const admin = getBananaAdmin(initialAccounts);
   const [{ contract: bananaCoin }, { contract: fpc }] = await Promise.all([
-    TokenContract.deploy(wallet, admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal).send({
-      from: admin,
-      contractAddressSalt: BANANA_COIN_SALT,
+    TokenContract.deploy(wallet, admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal, {
+      salt: BANANA_COIN_SALT,
       universalDeploy: true,
-    }),
-    FPCContract.deploy(wallet, bananaCoinAddress, admin).send({
+    }).send({ from: admin, wait: waitOpts }),
+    FPCContract.deploy(wallet, bananaCoinAddress, admin, { salt: BANANA_FPC_SALT, universalDeploy: true }).send({
       from: admin,
-      contractAddressSalt: BANANA_FPC_SALT,
-      universalDeploy: true,
+      wait: waitOpts,
     }),
   ]);
 

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,6 +22,7 @@ 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 { TxStatus } from '@aztec/stdlib/tx';
 import type { GenesisData } from '@aztec/stdlib/world-state';
 import {
   type TelemetryClient,
@@ -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, {
@@ -74,10 +83,10 @@ export async function deployContractsToL1(
     realVerifier: false,
   });
 
-  aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
+  Object.assign(aztecNodeConfig, l1Contracts.l1ContractAddresses);
   aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
 
-  return aztecNodeConfig.l1Contracts;
+  return l1Contracts.l1ContractAddresses;
 }
 
 /** Local network settings. */
@@ -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()}`);
 
@@ -262,11 +289,10 @@ export async function createAztecNode(
   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

@@ -44,6 +44,12 @@ 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,
@@ -86,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');
@@ -177,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

package/src/testing/cheat_codes.ts

@@ -2,6 +2,7 @@ import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
+import type { AutomineSequencer } from '@aztec/sequencer-client';
 import type { AztecNode, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 /**
@@ -18,15 +19,22 @@ export class CheatCodes {
     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);
   }
 
   /**
@@ -36,7 +44,7 @@ export class CheatCodes {
    * @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(node: AztecNodeDebug, targetTimestamp: bigint | number) {
+  async warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number) {
     const targetBigInt = BigInt(targetTimestamp);
     const currentTimestamp = BigInt(await this.eth.lastBlockTimestamp());
 
@@ -46,10 +54,20 @@ export class CheatCodes {
       );
     }
 
+    // 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;
+    }
+
     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.
@@ -60,10 +78,32 @@ export class CheatCodes {
           `Auto-adjusting to start of slot ${nextSlot} at timestamp ${nextSlotTimestamp}.`,
       );
       effectiveTimestamp = nextSlotTimestamp;
+      effectiveTargetSlot = nextSlot;
     }
 
     await this.eth.warp(effectiveTimestamp, { resetBlockInterval: true });
-    await node.mineBlock();
+
+    // 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.`,
+    );
   }
 
   /**
@@ -73,13 +113,20 @@ export class CheatCodes {
    * @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(node: AztecNodeDebug, duration: bigint | number) {
+  async warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number) {
     if (BigInt(duration) <= 0n) {
       throw new Error(`warpL2TimeAtLeastBy: duration must be positive, got ${duration} seconds.`);
     }
 
-    const currentTimestamp = await this.eth.lastBlockTimestamp();
-    const targetTimestamp = BigInt(currentTimestamp) + BigInt(duration);
+    // 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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnRfYXJjaGl2ZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbGkvY21kcy9zdGFydF9hcmNoaXZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQW9FLE1BQU0saUJBQWlCLENBQUM7QUFJeEgsT0FBTyxLQUFLLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUUvRSxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQXNCLE1BQU0sd0JBQXdCLENBQUM7QUFLbEYsWUFBWSxFQUFFLGNBQWMsRUFBRSxlQUFlLEVBQUUsQ0FBQztBQUVoRCxvQ0FBb0M7QUFDcEMsd0JBQXNCLGFBQWEsQ0FDakMsT0FBTyxFQUFFLEdBQUcsRUFDWixjQUFjLEVBQUUsQ0FBQyxNQUFNLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxFQUFFLEVBQ3ZDLFFBQVEsRUFBRSxxQkFBcUIsR0FDOUIsT0FBTyxDQUFDO0lBQUUsTUFBTSxFQUFFLGNBQWMsR0FBRyxlQUFlLENBQUE7Q0FBRSxDQUFDLENBcUN2RCJ9

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,CAqCvD"}

package/dest/cli/cmds/start_archiver.js

@@ -1,50 +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, {
-        // dataConfigMappings must come first: its l1Contracts only maps rollupAddress,
-        // while archiverConfigMappings (spread later) maps all L1 contract addresses.
-        ...dataConfigMappings,
-        ...archiverConfigMappings,
-        ...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,56 +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,
-    {
-      // dataConfigMappings must come first: its l1Contracts only maps rollupAddress,
-      // while archiverConfigMappings (spread later) maps all L1 contract addresses.
-      ...dataConfigMappings,
-      ...archiverConfigMappings,
-      ...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 };
-}