@aztec/aztec 0.0.1-commit.934299a21 → 0.0.1-commit.949a33fd8

package/src/cli/util.ts

@@ -1,17 +1,18 @@
 import type { AztecNodeConfig } from '@aztec/aztec-node';
 import type { AccountManager } from '@aztec/aztec.js/wallet';
+import { getNetworkConfig } from '@aztec/cli/config';
+import { RegistryContract } from '@aztec/ethereum/contracts';
 import type { ViemClient } from '@aztec/ethereum/types';
-import type { ConfigMappingsType } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ConfigMappingsType, NetworkNames } from '@aztec/foundation/config';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { type LogFn, createLogger } from '@aztec/foundation/log';
-import type { SharedNodeConfig } from '@aztec/node-lib/config';
 import type { ProverConfig } from '@aztec/stdlib/interfaces/server';
-import { getTelemetryClient } from '@aztec/telemetry-client/start';
+import { type VersionCheck, getPackageVersion } from '@aztec/stdlib/update-checker';
 import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import chalk from 'chalk';
 import type { Command } from 'commander';
+import type { Hex } from 'viem';
 
 import { type AztecStartOption, aztecStartOptions } from './aztec_start_options.js';
 
@@ -271,7 +272,7 @@ export async function preloadCrsDataForVerifying(
 ): Promise<void> {
   if (realProofs) {
     const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
-    await Promise.all([Crs.new(2 ** 1, undefined, log), GrumpkinCrs.new(2 ** 16 + 1, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 1, undefined, log), GrumpkinCrs.new(2 ** 16, undefined, log)]);
   }
 }
 
@@ -286,96 +287,62 @@ export async function preloadCrsDataForServerSideProving(
 ): Promise<void> {
   if (realProofs) {
     const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
-    await Promise.all([Crs.new(2 ** 25 + 1, undefined, log), GrumpkinCrs.new(2 ** 18 + 1, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 25, undefined, log), GrumpkinCrs.new(2 ** 18, undefined, log)]);
   }
 }
 
-export async function setupUpdateMonitor(
-  autoUpdateMode: SharedNodeConfig['autoUpdate'],
-  updatesLocation: URL,
+export async function setupVersionChecker(
+  network: NetworkNames,
   followsCanonicalRollup: boolean,
   publicClient: ViemClient,
-  registryContractAddress: EthAddress,
   signalHandlers: Array<() => Promise<void>>,
-  updateNodeConfig?: (config: object) => Promise<void>,
-) {
-  const logger = createLogger('update-check');
-  const { UpdateChecker } = await import('@aztec/stdlib/update-checker');
-  const checker = await UpdateChecker.new({
-    baseURL: updatesLocation,
-    publicClient,
-    registryContractAddress,
-  });
+  cacheDir?: string,
+): Promise<void> {
+  const networkConfig = await getNetworkConfig(network, cacheDir);
+  if (!networkConfig) {
+    return;
+  }
 
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('newRollupVersion', async ({ latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
+  const { VersionChecker } = await import('@aztec/stdlib/update-checker');
 
-    // if node follows canonical rollup then this is equivalent to a config update
-    if (!followsCanonicalRollup) {
-      return;
-    }
+  const logger = createLogger('version_check');
+  const registry = new RegistryContract(publicClient, networkConfig.registryAddress as Hex);
 
-    if (autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') {
-      logger.info(`New rollup version detected. Please restart the node`, { latestVersion, currentVersion });
-      await shutdown(logger.info, ExitCode.ROLLUP_UPGRADE, signalHandlers);
-    } else if (autoUpdateMode === 'notify') {
-      logger.warn(`New rollup detected. Please restart the node`, { latestVersion, currentVersion });
-    }
+  const checks: Array<VersionCheck> = [];
+  checks.push({
+    name: 'node',
+    currentVersion: getPackageVersion() ?? 'unknown',
+    getLatestVersion: async () => {
+      const cfg = await getNetworkConfig(network, cacheDir);
+      return cfg?.nodeVersion;
+    },
   });
 
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('newNodeVersion', async ({ latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
-    if (autoUpdateMode === 'config-and-version') {
-      logger.info(`New node version detected. Please update and restart the node`, { latestVersion, currentVersion });
-      await shutdown(logger.info, ExitCode.VERSION_UPGRADE, signalHandlers);
-    } else if (autoUpdateMode === 'notify') {
-      logger.info(`New node version detected. Please update and restart the node`, { latestVersion, currentVersion });
+  if (followsCanonicalRollup) {
+    const getLatestVersion = async () => {
+      const version = (await registry.getRollupVersions()).at(-1);
+      return version !== undefined ? String(version) : undefined;
+    };
+    const currentVersion = await getLatestVersion();
+    if (currentVersion !== undefined) {
+      checks.push({
+        name: 'rollup',
+        currentVersion,
+        getLatestVersion,
+      });
     }
-  });
+  }
 
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('updateNodeConfig', async config => {
+  const checker = new VersionChecker(checks, 600_000, logger);
+  checker.on('newVersion', ({ name, latestVersion, currentVersion }) => {
     if (isShuttingDown()) {
       return;
     }
 
-    if ((autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') && updateNodeConfig) {
-      logger.warn(`Config change detected. Updating node`, config);
-      try {
-        await updateNodeConfig(config);
-      } catch (err) {
-        logger.warn('Failed to update config', { err });
-      }
-    }
-    // don't notify on these config changes
-  });
-
-  checker.on('updatePublicTelemetryConfig', config => {
-    if (autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') {
-      logger.warn(`Public telemetry config change detected. Updating telemetry client`, config);
-      try {
-        const publicIncludeMetrics: unknown = (config as any).publicIncludeMetrics;
-        if (Array.isArray(publicIncludeMetrics) && publicIncludeMetrics.every(m => typeof m === 'string')) {
-          getTelemetryClient().setExportedPublicTelemetry(publicIncludeMetrics);
-        }
-        const publicMetricsCollectFrom: unknown = (config as any).publicMetricsCollectFrom;
-        if (Array.isArray(publicMetricsCollectFrom) && publicMetricsCollectFrom.every(m => typeof m === 'string')) {
-          getTelemetryClient().setPublicTelemetryCollectFrom(publicMetricsCollectFrom);
-        }
-      } catch (err) {
-        logger.warn('Failed to update config', { err });
-      }
-    }
-    // don't notify on these config changes
+    logger.warn(`New ${name} version available`, { latestVersion, currentVersion });
   });
-
   checker.start();
+  signalHandlers.push(() => checker.stop());
 }
 
 export function stringifyConfig(config: object): string {

package/src/examples/token.ts

@@ -32,7 +32,9 @@ async function main() {
   logger.info(`Fetched Alice and Bob accounts: ${alice.toString()}, ${bob.toString()}`);
 
   logger.info('Deploying Token...');
-  const token = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18).send({ from: alice });
+  const { contract: token } = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18).send({
+    from: alice,
+  });
   logger.info('Token deployed');
 
   // Mint tokens to Alice
@@ -41,7 +43,7 @@ async function main() {
 
   logger.info(`${ALICE_MINT_BALANCE} tokens were successfully minted by Alice and transferred to private`);
 
-  const balanceAfterMint = await token.methods.balance_of_private(alice).simulate({ from: alice });
+  const { result: balanceAfterMint } = await token.methods.balance_of_private(alice).simulate({ from: alice });
   logger.info(`Tokens successfully minted. New Alice's balance: ${balanceAfterMint}`);
 
   // We will now transfer tokens from Alice to Bob
@@ -49,10 +51,10 @@ async function main() {
   await token.methods.transfer(bob, TRANSFER_AMOUNT).send({ from: alice });
 
   // Check the new balances
-  const aliceBalance = await token.methods.balance_of_private(alice).simulate({ from: alice });
+  const { result: aliceBalance } = await token.methods.balance_of_private(alice).simulate({ from: alice });
   logger.info(`Alice's balance ${aliceBalance}`);
 
-  const bobBalance = await token.methods.balance_of_private(bob).simulate({ from: bob });
+  const { result: bobBalance } = await token.methods.balance_of_private(bob).simulate({ from: bob });
   logger.info(`Bob's balance ${bobBalance}`);
 }
 

package/src/local-network/banana_fpc.ts

@@ -48,7 +48,7 @@ export async function getBananaFPCAddress(initialAccounts: InitialAccountData[])
 export async function setupBananaFPC(initialAccounts: InitialAccountData[], wallet: Wallet, log: LogFn) {
   const bananaCoinAddress = await getBananaCoinAddress(initialAccounts);
   const admin = getBananaAdmin(initialAccounts);
-  const [bananaCoin, fpc] = await Promise.all([
+  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,

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

@@ -19,8 +19,9 @@ import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 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 type { GenesisData } from '@aztec/stdlib/world-state';
 import {
   type TelemetryClient,
   getConfigEnvVars as getTelemetryClientConfig,
@@ -38,6 +39,7 @@ 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 { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
 import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 
@@ -68,7 +70,7 @@ 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,
   });
 
@@ -101,9 +103,14 @@ 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 (
@@ -138,10 +145,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();
 
@@ -180,7 +190,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
@@ -249,7 +259,7 @@ 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();

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>;
 
@@ -45,6 +49,7 @@ export class AnvilTestWatcher {
     rollupAddress: EthAddress,
     l1Client: ViemClient,
     private dateProvider?: TestDateProvider,
+    opts: AnvilTestWatcherOpts = {},
   ) {
     this.rollup = getContract({
       address: getAddress(rollupAddress.toString()),
@@ -56,6 +61,9 @@ export class AnvilTestWatcher {
       rollupAddress,
     });
 
+    this.isLocalNetwork = opts.isLocalNetwork ?? false;
+    this.isMarkingAsProven = opts.isMarkingAsProven ?? true;
+
     this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
   }
 
@@ -130,14 +138,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 +166,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;
       }
 
@@ -180,9 +196,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 +209,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,8 @@
 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 { AztecNode, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 /**
  * A class that provides utility functions for interacting with the chain.
@@ -12,6 +11,8 @@ 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,
@@ -30,50 +31,55 @@ export class CheatCodes {
 
   /**
    * 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: 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 });
+    const currentSlot = await this.rollup.getSlot();
+    const targetSlot = await this.rollup.getSlotAt(targetBigInt);
 
-    await retryUntil(
-      async () => {
-        const newL2BlockNumber: BlockNumber = await node.getBlockNumber();
-        return newL2BlockNumber > currentL2BlockNumber;
-      },
-      'new block after warping L2 time',
-      36,
-      1,
-    );
+    let effectiveTimestamp = targetBigInt;
 
-    // Restore original minTxsPerBlock
-    sequencer.updateConfig({ minTxsPerBlock });
+    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;
+    }
+
+    await this.eth.warp(effectiveTimestamp, { resetBlockInterval: true });
+    await node.mineBlock();
   }
 
   /**
    * 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();
+  async warpL2TimeAtLeastBy(node: 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);
-    await this.warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp);
+    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;
@@ -51,9 +51,8 @@ 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);
+    const outHash = computeEpochOutHash(messagesInEpoch);
+    if (!outHash.isZero()) {
       await this.rollupCheatCodes.insertOutbox(epoch, outHash.toBigInt());
     } else {
       this.log.info(`No L2 to L1 messages in epoch ${epoch}`);

package/src/testing/index.ts

@@ -1,4 +1,5 @@
-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';
+export { getTokenAllowedSetupFunctions } from './token_allowed_setup.js';

package/src/testing/token_allowed_setup.ts

@@ -0,0 +1,19 @@
+import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+import { buildAllowedElement } from '@aztec/p2p/msg_validators';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+
+/**
+ * Returns Token-specific allowlist entries needed for FPC-based fee payments.
+ * These are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
+ */
+export async function getTokenAllowedSetupFunctions(): Promise<AllowedElement[]> {
+  const tokenClassId = (await getContractClassFromArtifact(TokenContractArtifact)).id;
+  const target = { classId: tokenClassId };
+  return Promise.all([
+    // Token: needed for private transfers via FPC (transfer_to_public enqueues this)
+    buildAllowedElement(TokenContractArtifact, target, '_increase_public_balance', { onlySelf: true }),
+    // Token: needed for public transfers via FPC (fee_entrypoint_public enqueues this)
+    buildAllowedElement(TokenContractArtifact, target, 'transfer_in_public'),
+  ]);
+}

package/dest/cli/release_version.d.ts

@@ -1,2 +0,0 @@
-export declare const getCliVersion: () => any;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVsZWFzZV92ZXJzaW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpL3JlbGVhc2VfdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxlQUFPLE1BQU0sYUFBYSxXQWV6QixDQUFDIn0=

package/dest/cli/release_version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"release_version.d.ts","sourceRoot":"","sources":["../../src/cli/release_version.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,aAAa,WAezB,CAAC"}

package/dest/cli/release_version.js

@@ -1,14 +0,0 @@
-import { fileURLToPath } from '@aztec/foundation/url';
-import { readFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-export const getCliVersion = ()=>{
-    const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
-    const cliVersion = JSON.parse(readFileSync(packageJsonPath).toString()).version;
-    // If the version is 0.1.0, this is a placeholder version and we are in a docker container; query release please for the latest version
-    if (cliVersion === '0.1.0') {
-        const releasePleasePath = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../.release-please-manifest.json');
-        const releaseVersion = JSON.parse(readFileSync(releasePleasePath).toString())['.'];
-        return releaseVersion;
-    }
-    return cliVersion;
-};

package/src/cli/release_version.ts

@@ -1,21 +0,0 @@
-import { fileURLToPath } from '@aztec/foundation/url';
-
-import { readFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-
-export const getCliVersion = () => {
-  const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
-  const cliVersion: string = JSON.parse(readFileSync(packageJsonPath).toString()).version;
-
-  // If the version is 0.1.0, this is a placeholder version and we are in a docker container; query release please for the latest version
-  if (cliVersion === '0.1.0') {
-    const releasePleasePath = resolve(
-      dirname(fileURLToPath(import.meta.url)),
-      '../../../../.release-please-manifest.json',
-    );
-    const releaseVersion = JSON.parse(readFileSync(releasePleasePath).toString())['.'];
-    return releaseVersion;
-  }
-
-  return cliVersion;
-};