@aztec/aztec 0.0.1-commit.88e6f9396 → 0.0.1-commit.8c0b8ff

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

@@ -1,6 +1,7 @@
-import TOML from '@iarna/toml';
-import { readFile, readdir, stat } from 'fs/promises';
-import { join, resolve } from 'path';
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+
+import { collectCrateDirs } from './collect_crate_dirs.js';
 
 /**
  * Returns true if recompilation is needed: either no artifacts exist in target/ or any .nr or Nargo.toml source file
@@ -16,7 +17,10 @@ export async function needsRecompile(): Promise<boolean> {
     return true;
   }
 
-  const crateDirs = await collectCrateDirs('.');
+  // Git deps are pinned to a specific tag in Nargo.toml and nargo always fetches an exact tag, so their contents never
+  // change without Nargo.toml itself changing — and Nargo.toml is already tracked as a source file. Hence we can
+  // safely ignore checking source files of git deps.
+  const crateDirs = await collectCrateDirs('.', { skipGitDeps: true });
   return hasNewerSourceFile(crateDirs, oldestArtifactMs);
 }
 
@@ -49,63 +53,6 @@ async function getOldestArtifactModificationTime(targetDir: string): Promise<num
   return oldest;
 }
 
-/**
- * Recursively collects crate directories starting from startCrateDir by following path-based dependencies declared in
- * Nargo.toml files. Git-based deps are ignored (they only change when Nargo.toml itself is modified since the deps are
- * tagged).
- */
-async function collectCrateDirs(startCrateDir: string): Promise<string[]> {
-  // We have a set of visited dirs we check against when entering a new dir because we could stumble upon a directory
-  // multiple times in case multiple deps shared a dep (e.g. dep A and dep B both sharing dep C).
-  const visited = new Set<string>();
-
-  async function visit(crateDir: string): Promise<void> {
-    const absDir = resolve(crateDir);
-    if (visited.has(absDir)) {
-      return;
-    }
-    visited.add(absDir);
-
-    // Every dep is its own crate and every crate needs to have Nargo.toml defined in the root so we try to load it and
-    // error out if it's not the case.
-    const tomlPath = join(absDir, 'Nargo.toml');
-    const content = await readFile(tomlPath, 'utf-8').catch(() => {
-      throw new Error(`Incorrectly defined dependency. Nargo.toml not found in ${absDir}`);
-    });
-
-    const parsed = TOML.parse(content) as Record<string, any>;
-
-    const members = (parsed.workspace as Record<string, any>)?.members as string[] | undefined;
-
-    // A Nargo.toml is either a workspace root (has workspace.members) or a single crate (has dependencies).
-    if (Array.isArray(members)) {
-      // The crate is a workspace root and has members defined so we visit the members
-      for (const member of members) {
-        const memberPath = resolve(absDir, member);
-        await visit(memberPath);
-      }
-    } else {
-      // The crate is not a workspace root so we check for dependencies
-      const deps = (parsed.dependencies as Record<string, any>) ?? {};
-      for (const dep of Object.values(deps)) {
-        if (dep && typeof dep === 'object' && typeof dep.path === 'string') {
-          const depPath = resolve(absDir, dep.path);
-          const s = await stat(depPath);
-          if (!s.isDirectory()) {
-            throw new Error(
-              `Dependency path "${dep.path}" in ${tomlPath} resolves to ${depPath} which is not a directory`,
-            );
-          }
-          await visit(depPath);
-        }
-      }
-    }
-  }
-
-  await visit(startCrateDir);
-  return [...visited];
-}
-
 /**
  * Walks crate dirs looking for .nr and Nargo.toml files newer than thresholdMs. Short-circuits on the first match.
  */

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

@@ -0,0 +1,54 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { getPackageVersion } from '@aztec/stdlib/update-checker';
+
+import TOML from '@iarna/toml';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+import { collectCrateDirs } from './collect_crate_dirs.js';
+
+/** Warns if the `aztec` dependency tag in any crate's Nargo.toml 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.`);
+    return;
+  }
+
+  const expectedTag = `v${version}`;
+  const mismatches: { file: string; tag: string }[] = [];
+
+  const crateDirs = await collectCrateDirs('.', { skipGitDeps: true });
+
+  for (const dir of crateDirs) {
+    const tomlPath = join(dir, 'Nargo.toml');
+    let content: string;
+    try {
+      content = await readFile(tomlPath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const parsed = TOML.parse(content) as Record<string, any>;
+    const aztecDep = (parsed.dependencies as Record<string, any>)?.aztec;
+    if (!aztecDep || typeof aztecDep !== 'object' || typeof aztecDep.tag !== 'string') {
+      // If a dep called "aztec" doesn't exist or it does not get parsed to an object or it doesn't have a tag defined
+      // we skip the check.
+      continue;
+    }
+
+    if (aztecDep.tag !== expectedTag) {
+      mismatches.push({ file: tomlPath, tag: aztecDep.tag });
+    }
+  }
+
+  if (mismatches.length > 0) {
+    const details = mismatches.map(m => `  ${m.file} (${m.tag})`).join('\n');
+    log(
+      `WARNING: Aztec dependency version mismatch detected.\n` +
+        `The following crates have an aztec dependency that does not match the CLI version (${expectedTag}):\n` +
+        `${details}\n\n` +
+        `See https://docs.aztec.network/errors/9 for how to update your dependencies.`,
+    );
+  }
+}

package/src/cli/util.ts

@@ -272,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, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 1, undefined, log), GrumpkinCrs.new(2 ** 16 + 1, undefined, log)]);
   }
 }
 
@@ -287,7 +287,7 @@ export async function preloadCrsDataForServerSideProving(
 ): Promise<void> {
   if (realProofs) {
     const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
-    await Promise.all([Crs.new(2 ** 25, undefined, log), GrumpkinCrs.new(2 ** 18, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 25 + 1, undefined, log), GrumpkinCrs.new(2 ** 18 + 1, undefined, log)]);
   }
 }
 

package/src/testing/anvil_test_watcher.ts

@@ -130,14 +130,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 +158,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 +188,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 +201,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);
   }
 }