@aztec/aztec 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/cli/cmds/start_bot.ts

@@ -21,11 +21,9 @@ export async function startBot(
   services: NamespacedApiHandlers,
   userLog: LogFn,
 ) {
-  const { proverNode, archiver, sequencer, p2pBootstrap, txe, prover } = options;
-  if (proverNode || archiver || sequencer || p2pBootstrap || txe || prover) {
-    userLog(
-      `Starting a bot with --prover-node, --prover, --archiver, --sequencer, --p2p-bootstrap, or --txe is not supported.`,
-    );
+  const { proverNode, sequencer, p2pBootstrap, txe, prover } = options;
+  if (proverNode || sequencer || p2pBootstrap || txe || prover) {
+    userLog(`Starting a bot with --prover-node, --prover, --sequencer, --p2p-bootstrap, or --txe is not supported.`);
     process.exit(1);
   }
 
@@ -58,6 +56,11 @@ export async function addBot(
   const config = extractRelevantOptions<BotConfig>(options, botConfigMappings, 'bot');
   userLog?.(`Starting bot with config ${stringifyConfig(config)}`);
 
+  // The bot wallet's embedded PXE syncs to this tip (see start_bot.ts/start_node.ts which build the wallet from the
+  // same options). L1-to-L2 readiness checks must be evaluated at this tip rather than at 'latest', or the bot can
+  // consider a message ready while the PXE simulation anchors to an older block that cannot prove its membership yet.
+  const { syncChainTip } = extractRelevantOptions<PXEConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
+
   const db = await (config.dataDirectory
     ? createStore('bot', BotStore.SCHEMA_VERSION, config)
     : openTmpStore('bot', true, config.dataStoreMapSizeKb));
@@ -65,7 +68,7 @@ export async function addBot(
   const store = new BotStore(db);
   await store.cleanupOldClaims();
 
-  const botRunner = new BotRunner(config, wallet, aztecNode, telemetry, aztecNodeAdmin, store);
+  const botRunner = new BotRunner(config, wallet, aztecNode, telemetry, aztecNodeAdmin, store, syncChainTip);
   if (!config.noStart) {
     void botRunner.start(); // Do not block since bot setup takes time
   }

package/src/cli/cmds/start_node.ts

@@ -1,7 +1,11 @@
-import { type AztecNodeConfig, aztecNodeConfigMappings, getConfigEnvVars } from '@aztec/aztec-node';
+import {
+  type AztecNodeConfig,
+  aztecNodeConfigMappings,
+  getConfigEnvVars,
+  registerAztecNodeRpcHandlers,
+} from '@aztec/aztec-node';
 import { Fr } from '@aztec/aztec.js/fields';
 import { getL1Config } from '@aztec/cli/config';
-import { getPublicClient } from '@aztec/ethereum/client';
 import { getGenesisStateConfigEnvVars } from '@aztec/ethereum/config';
 import { type NetworkNames, SecretValue } from '@aztec/foundation/config';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
@@ -9,10 +13,13 @@ import { Agent, makeUndiciFetch } from '@aztec/foundation/json-rpc/undici';
 import type { LogFn } from '@aztec/foundation/log';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import { ProvingJobConsumerSchema, createProvingJobBrokerClient } from '@aztec/prover-client/broker';
+import {
+  ProvingJobConsumerSchema,
+  createProvingJobBrokerClient,
+  proverBrokerBackoff,
+} from '@aztec/prover-client/broker';
 import { type CliPXEOptions, type PXEConfig, allPxeConfigMappings } from '@aztec/pxe/config';
-import { AztecNodeAdminApiSchema, AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
-import { P2PApiSchema, ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import {
   type TelemetryClientConfig,
   initTelemetryClient,
@@ -22,14 +29,9 @@ import {
 import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import { createAztecNode } from '../../local-network/index.js';
-import {
-  extractNamespacedOptions,
-  extractRelevantOptions,
-  preloadCrsDataForVerifying,
-  setupVersionChecker,
-} from '../util.js';
+import { extractNamespacedOptions, extractRelevantOptions, preloadCrsDataForVerifying } from '../util.js';
 import { getVersions } from '../versioning.js';
-import { computeExpectedGenesisRoot, waitForCompatibleRollup } from './standby.js';
+import { computeExpectedGenesisRoot, setupAutoShutdown, waitForCompatibleRollup } from './standby.js';
 import { startProverBroker } from './start_prover_broker.js';
 
 export async function startNode(
@@ -65,12 +67,8 @@ export async function startNode(
     if (nodeConfig.proverBrokerUrl) {
       // at 1TPS we'd enqueue ~1k chonk verifier proofs and ~1k AVM proofs immediately
       // set a lower connection limit such that we don't overload the server
-      // Keep retrying up to 30s
-      const fetch = makeTracedFetch(
-        [1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3],
-        false,
-        makeUndiciFetch(new Agent({ connections: 100 })),
-      );
+      // Retry indefinitely until the epoch proving times out and the chain reorgs
+      const fetch = makeTracedFetch(proverBrokerBackoff, false, makeUndiciFetch(new Agent({ connections: 100 })));
       broker = createProvingJobBrokerClient(nodeConfig.proverBrokerUrl, getVersions(nodeConfig), fetch);
     } else if (options.proverBroker) {
       ({ broker } = await startProverBroker(options, signalHandlers, services, userLog));
@@ -83,12 +81,12 @@ export async function startNode(
   await preloadCrsDataForVerifying(nodeConfig, userLog);
 
   const genesisConfig = getGenesisStateConfigEnvVars();
-  const { genesisArchiveRoot, prefilledPublicData } = await computeExpectedGenesisRoot(genesisConfig, userLog);
+  const { genesisArchiveRoot, genesis } = await computeExpectedGenesisRoot(genesisConfig, userLog);
 
   const followsCanonicalRollup =
     typeof nodeConfig.rollupVersion !== 'number' || (nodeConfig.rollupVersion as unknown as string) === 'canonical';
 
-  if (!nodeConfig.l1Contracts.registryAddress || nodeConfig.l1Contracts.registryAddress.isZero()) {
+  if (!nodeConfig.registryAddress || nodeConfig.registryAddress.isZero()) {
     throw new Error('L1 registry address is required to start Aztec Node');
   }
 
@@ -102,7 +100,7 @@ export async function startNode(
   );
 
   const { addresses, config } = await getL1Config(
-    nodeConfig.l1Contracts.registryAddress,
+    nodeConfig.registryAddress,
     nodeConfig.l1RpcUrls,
     nodeConfig.l1ChainId,
     nodeConfig.rollupVersion,
@@ -116,13 +114,9 @@ export async function startNode(
     );
   }
 
-  // TODO(#12272): will clean this up.
   nodeConfig = {
     ...nodeConfig,
-    l1Contracts: {
-      ...addresses,
-      slashFactoryAddress: nodeConfig.l1Contracts.slashFactoryAddress,
-    },
+    ...addresses,
     ...config,
   };
 
@@ -158,17 +152,14 @@ export async function startNode(
   const telemetry = await initTelemetryClient(telemetryConfig);
 
   // Create and start Aztec Node
-  const node = await createAztecNode(nodeConfig, { telemetry, proverBroker: broker }, { prefilledPublicData });
+  const node = await createAztecNode(nodeConfig, { telemetry, proverBroker: broker }, { genesis });
 
-  // Add node and p2p to services list
-  services.node = [node, AztecNodeApiSchema];
-  services.p2p = [node.getP2P(), P2PApiSchema];
-  adminServices.nodeAdmin = [node, AztecNodeAdminApiSchema];
+  registerAztecNodeRpcHandlers(node, services, adminServices, { debug: options.nodeDebug });
 
   // Register prover-node services if the prover node subsystem is running
   const proverNode = node.getProverNode();
   if (proverNode) {
-    services.prover = [proverNode, ProverNodeApiSchema];
+    adminServices.prover = [proverNode, ProverNodeApiSchema];
     if (!nodeConfig.proverBrokerUrl) {
       services.provingJobSource = [proverNode.getProver().getProvingJobSource(), ProvingJobConsumerSchema];
     }
@@ -187,15 +178,14 @@ export async function startNode(
     await addBot(options, signalHandlers, services, wallet, node, telemetry, undefined);
   }
 
-  if (nodeConfig.enableVersionCheck && networkName !== 'local') {
-    const cacheDir = process.env.DATA_DIRECTORY ? `${process.env.DATA_DIRECTORY}/cache` : undefined;
+  if (nodeConfig.enableAutoShutdown && networkName !== 'local' && followsCanonicalRollup) {
     try {
-      await setupVersionChecker(
-        networkName,
-        followsCanonicalRollup,
-        getPublicClient(nodeConfig!),
+      await setupAutoShutdown(
+        nodeConfig,
+        nodeConfig.registryAddress,
+        (nodeConfig.rollupVersion as number | 'canonical') ?? 'canonical',
+        { genesisArchiveRoot, vkTreeRoot: getVKTreeRoot(), protocolContractsHash },
         signalHandlers,
-        cacheDir,
       );
     } catch {
       /* no-op */

package/src/cli/cmds/start_prover_agent.ts

@@ -9,6 +9,7 @@ import {
   createProofStore,
   createProvingJobBrokerClient,
   proverAgentConfigMappings,
+  proverBrokerBackoff,
 } from '@aztec/prover-client/broker';
 import { getProverNodeAgentConfigFromEnv } from '@aztec/prover-node';
 import { ProverAgentApiSchema } from '@aztec/stdlib/interfaces/server';
@@ -23,8 +24,8 @@ export async function startProverAgent(
   services: NamespacedApiHandlers,
   userLog: LogFn,
 ) {
-  if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
-    userLog(`Starting a prover agent with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+  if (options.node || options.sequencer || options.p2pBootstrap || options.txe) {
+    userLog(`Starting a prover agent with --node, --sequencer, --p2p-bootstrap, or --txe is not supported.`);
     process.exit(1);
   }
 
@@ -45,12 +46,8 @@ export async function startProverAgent(
 
   await preloadCrsDataForServerSideProving(config, userLog);
 
-  const fetch = makeTracedFetch(
-    // retry connections every 3s, up to 30s before giving up
-    [1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3],
-    false,
-    makeUndiciFetch(new Agent({ connections: 10 })),
-  );
+  // Retry indefinitely until the epoch proving times out and the chain reorgs
+  const fetch = makeTracedFetch(proverBrokerBackoff, false, makeUndiciFetch(new Agent({ connections: 10 })));
   const broker = createProvingJobBrokerClient(config.proverBrokerUrl, getVersions(), fetch);
 
   const telemetry = await initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));

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/artifacts.ts

@@ -6,6 +6,11 @@ export interface CompiledArtifact {
   file_map: unknown;
   functions: ContractFunction[];
   bytecode?: string;
+  /**
+   * Set to true by the AVM transpiler (invoked via `bb aztec_process`) once the contract has been transpiled and its
+   * verification keys generated. Absent on raw `nargo compile` output, hence optional.
+   */
+  transpiled?: boolean;
 }
 
 export interface ContractFunction {

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

@@ -0,0 +1,118 @@
+import TOML from '@iarna/toml';
+import { existsSync } from 'fs';
+import { mkdir, readFile, stat } from 'fs/promises';
+import { homedir } from 'os';
+import { dirname, join, resolve } from 'path';
+
+import { run } from './spawn.js';
+
+/**
+ * Recursively collects crate directories starting from startCrateDir by following dependencies declared in Nargo.toml
+ * files.
+ *
+ * When `skipGitDeps` is false (default), git-based deps are followed and fetched into the nargo cache
+ * (`$HOME/nargo/<domain>/<repo-path>/<tag>`) if not already present.
+ *
+ * When `skipGitDeps` is true, git-based deps are ignored entirely.
+ */
+export async function collectCrateDirs(startCrateDir: string, opts?: { skipGitDeps?: boolean }): Promise<string[]> {
+  const { skipGitDeps = false } = opts ?? {};
+  const visited = new Set<string>();
+
+  async function visit(crateDir: string): Promise<void> {
+    const absDir = resolve(crateDir);
+    if (visited.has(absDir)) {
+      return;
+    }
+    visited.add(absDir);
+
+    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) {
+        await visit(resolve(absDir, member));
+      }
+    } else {
+      // Single crate — follow its deps
+      const deps = (parsed.dependencies as Record<string, any>) ?? {};
+      for (const dep of Object.values(deps)) {
+        if (!dep || typeof dep !== 'object') {
+          continue;
+        }
+        if (typeof dep.path === 'string') {
+          // Dependency contains "path" hence it's a local dependency. We just check it's a real directory and then we
+          // recursively search through it
+          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);
+        } else if (!skipGitDeps && typeof dep.git === 'string' && typeof dep.tag === 'string') {
+          // Dependency contains "git" hence it's a git dependency. We ensure it has been fetched and fetch it if
+          // it's not the case and then we recursively search through it.
+          await fetchAndVisit(dep.git, dep.tag, dep.directory);
+        }
+      }
+    }
+  }
+
+  async function fetchAndVisit(gitUrl: string, tag: string, directory?: string): Promise<void> {
+    // `directory` is set when the dep lives in a subdirectory of a repository, e.g.:
+    //   aztec = { git = "https://github.com/AztecProtocol/aztec-packages", tag = "v0.82.0",
+    //             directory = "noir-projects/aztec-nr/aztec" }
+    // In that case nargo clones the whole repo and the crate root is <cachePath>/<directory>.
+    const cachePath = nargoGitDepPath(gitUrl, tag);
+    const crateDir = directory ? join(cachePath, directory) : cachePath;
+    await ensureGitDepCached(gitUrl, tag, cachePath);
+    await visit(crateDir);
+  }
+
+  await visit(startCrateDir);
+  return [...visited];
+}
+
+/**
+ * Computes the local nargo cache path for a git dependency, mirroring nargo's own `git_dep_location` function.
+ * Path format: `$HOME/nargo/<domain>/<repo-path>/<tag>`
+ * e.g. `~/nargo/github.com/AztecProtocol/aztec-packages/v0.82.0`
+ *
+ * Source: noir/noir-repo/tooling/nargo_toml/src/git.rs
+ */
+export function nargoGitDepPath(gitUrl: string, tag: string): string {
+  const url = new URL(gitUrl);
+  const domain = url.hostname;
+  const repoPath = url.pathname.replace(/^\//, '');
+  return join(process.env.HOME ?? homedir(), 'nargo', domain, repoPath, tag);
+}
+
+/**
+ * Ensures a git dep is present in the nargo cache, cloning it if it isn't. Mirrors nargo's `clone_git_repo`.
+ * If cloning fails (e.g. no network), throws with a message suggesting `nargo check` to prime the cache.
+ *
+ * Source: noir/noir-repo/tooling/nargo_toml/src/git.rs
+ */
+async function ensureGitDepCached(gitUrl: string, tag: string, cachePath: string): Promise<void> {
+  if (existsSync(cachePath)) {
+    return;
+  }
+  await mkdir(dirname(cachePath), { recursive: true });
+  try {
+    await run('git', ['-c', 'advice.detachedHead=false', 'clone', '--depth', '1', '--branch', tag, gitUrl, cachePath]);
+  } catch (err: any) {
+    throw new Error(
+      `Failed to fetch git dependency ${gitUrl}@${tag}: ${err?.message ?? err}.\n` +
+        `Try running \`nargo check\` first to prime the dependency cache.`,
+    );
+  }
+}

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,76 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { DEV_VERSION, 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';
+
+/** Returns true if the given git URL points to the AztecProtocol/aztec-nr repository. */
+function isAztecNrGitUrl(gitUrl: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(gitUrl);
+  } catch {
+    return false;
+  }
+  if (url.hostname !== 'github.com') {
+    return false;
+  }
+  const repoPath = url.pathname
+    .replace(/^\//, '')
+    .replace(/\.git$/, '')
+    .replace(/\/$/, '');
+  return repoPath === 'AztecProtocol/aztec-nr';
+}
+
+/** 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 === DEV_VERSION) {
+    return;
+  }
+
+  const expectedTag = `v${version}`;
+  const mismatches: { file: string; depName: 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 deps = (parsed.dependencies as Record<string, any>) ?? {};
+
+    for (const [depName, dep] of Object.entries(deps)) {
+      // Skip non-object deps (e.g. malformed entries) and anything that isn't a tagged git dep.
+      if (!dep || typeof dep !== 'object' || typeof dep.git !== 'string' || typeof dep.tag !== 'string') {
+        continue;
+      }
+      // Only flag deps that are sourced from the aztec-nr repo.
+      if (!isAztecNrGitUrl(dep.git)) {
+        continue;
+      }
+      if (dep.tag !== expectedTag) {
+        mismatches.push({ file: tomlPath, depName, tag: dep.tag });
+      }
+    }
+  }
+
+  if (mismatches.length > 0) {
+    const details = mismatches.map(m => `  ${m.file} — ${m.depName} (${m.tag})`).join('\n');
+    log(
+      `WARNING: Aztec dependency version mismatch detected.\n` +
+        `The following aztec-nr dependencies do not match the CLI version (${expectedTag}):\n` +
+        `${details}\n\n` +
+        `See https://docs.aztec.network/errors/9 for how to update your dependencies.`,
+    );
+  }
+}