@aztec/aztec 0.0.0-test.1 → 0.0.1-commit.017a351

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

@@ -0,0 +1,98 @@
+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
+ * (including path-based dependencies) is newer than the oldest artifact. We compare against the oldest artifact so
+ * that a source change between the oldest and newest compilation (e.g. in a multi-contract workspace) still triggers
+ * a recompile.
+ *
+ * Note: The above implies that if there is a random json file in the target dir we would be always recompiling.
+ */
+export async function needsRecompile(): Promise<boolean> {
+  const oldestArtifactMs = await getOldestArtifactModificationTime('target');
+  if (oldestArtifactMs === undefined) {
+    return true;
+  }
+
+  // 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);
+}
+
+/**
+ * Returns the last modification time (timestamp in ms) of the oldest .json artifact in targetDir, or undefined if
+ * none exist.
+ */
+async function getOldestArtifactModificationTime(targetDir: string): Promise<number | undefined> {
+  let entries: string[];
+  try {
+    entries = (await readdir(targetDir)).filter(f => f.endsWith('.json'));
+  } catch (err: any) {
+    if (err?.code === 'ENOENT') {
+      return undefined;
+    }
+    throw err;
+  }
+
+  if (entries.length === 0) {
+    return undefined;
+  }
+
+  let oldest = Infinity;
+  for (const entry of entries) {
+    const s = await stat(join(targetDir, entry));
+    if (s.mtimeMs < oldest) {
+      oldest = s.mtimeMs;
+    }
+  }
+  return oldest;
+}
+
+/**
+ * Walks crate dirs looking for .nr and Nargo.toml files newer than thresholdMs. Short-circuits on the first match.
+ */
+async function hasNewerSourceFile(crateDirs: string[], thresholdMs: number): Promise<boolean> {
+  // Returns true if it find a new file than thresholdMs, false otherwise
+  async function walkForNewer(dir: string): Promise<boolean> {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+
+    // We iterate over the entries in the dir
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        // If the entry is a dir and it's not called `target` we recursively enter it
+        if (entry.name === 'target') {
+          continue;
+        }
+        if (await walkForNewer(fullPath)) {
+          return true;
+        }
+      } else if (entry.name === 'Nargo.toml' || entry.name.endsWith('.nr')) {
+        // The entry is a Nargo.toml file or *.nr file so we check the timestamp
+        const s = await stat(fullPath);
+        if (s.mtimeMs > thresholdMs) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  // We search through the crate dirs
+  for (const dir of crateDirs) {
+    if (await walkForNewer(dir)) {
+      return true;
+    }
+  }
+  return false;
+}

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

@@ -0,0 +1,16 @@
+import { spawn } from 'child_process';
+
+/** Spawns a command with inherited stdio and rejects on non-zero exit. */
+export function run(cmd: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit' });
+    child.on('error', reject);
+    child.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(`${cmd} exited with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}

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.`,
+    );
+  }
+}

package/src/cli/preload_crs.ts

@@ -0,0 +1,7 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import { preloadCrsDataForServerSideProving } from './util.js';
+
+export async function preloadCrs(_options: any, userLog: LogFn, _debugLogger: Logger) {
+  await preloadCrsDataForServerSideProving({ realProofs: true }, userLog);
+}

package/src/cli/util.ts

@@ -1,67 +1,98 @@
-import type { AccountManager, Fr } from '@aztec/aztec.js';
-import type { ConfigMappingsType } from '@aztec/foundation/config';
-import type { LogFn } from '@aztec/foundation/log';
-import type { PXEService } from '@aztec/pxe/server';
+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, NetworkNames } from '@aztec/foundation/config';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { type LogFn, createLogger } from '@aztec/foundation/log';
+import type { ProverConfig } from '@aztec/stdlib/interfaces/server';
+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';
 
+export const enum ExitCode {
+  SUCCESS = 0,
+  ERROR = 1,
+  ROLLUP_UPGRADE = 78, // EX_CONFIG from FreeBSD (https://man.freebsd.org/cgi/man.cgi?query=sysexits)
+  VERSION_UPGRADE = 79, // prev + 1 because there's nothing better
+  // 128 + int(SIGNAL)
+  SIGHUP = 129,
+  SIGINT = 130,
+  SIGQUIT = 131,
+  SIGTERM = 143,
+}
+
+let shutdownPromise: Promise<never> | undefined;
+export function shutdown(logFn: LogFn, exitCode: ExitCode, cb?: Array<() => Promise<void>>): Promise<never> {
+  if (shutdownPromise) {
+    logFn('Already shutting down.');
+    return shutdownPromise;
+  }
+
+  logFn('Shutting down...', { exitCode });
+  if (cb) {
+    shutdownPromise = Promise.allSettled(cb.map(fn => fn())).then(() => process.exit(exitCode));
+  } else {
+    // synchronously shuts down the process
+    // no need to set shutdownPromise on this branch of the if statement because no more code will be executed
+    process.exit(exitCode);
+  }
+
+  return shutdownPromise;
+}
+
+export function isShuttingDown(): boolean {
+  return shutdownPromise !== undefined;
+}
+
 export const installSignalHandlers = (logFn: LogFn, cb?: Array<() => Promise<void>>) => {
-  const shutdown = async () => {
-    logFn('Shutting down...');
-    if (cb) {
-      await Promise.all(cb);
-    }
-    process.exit(0);
-  };
-  process.removeAllListeners('SIGINT');
-  process.removeAllListeners('SIGTERM');
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  process.once('SIGINT', shutdown);
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  process.once('SIGTERM', shutdown);
+  const signals = [
+    ['SIGINT', ExitCode.SIGINT],
+    ['SIGTERM', ExitCode.SIGTERM],
+    ['SIGHUP', ExitCode.SIGHUP],
+    ['SIQUIT', ExitCode.SIGQUIT],
+  ] as const;
+
+  for (const [signal, exitCode] of signals) {
+    process.removeAllListeners(signal);
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    process.once(signal, () => shutdown(logFn, exitCode, cb));
+  }
 };
 
 /**
  * Creates logs for the initial accounts
  * @param accounts - The initial accounts
- * @param pxe - A PXE instance to get the registered accounts
+ * @param wallet - A EmbeddedWallet instance to get the registered accounts
  * @returns A string array containing the initial accounts details
  */
-export async function createAccountLogs(
-  accountsWithSecretKeys: {
-    /**
-     * The account object
-     */
-    account: AccountManager;
-    /**
-     * The secret key of the account
-     */
-    secretKey: Fr;
-  }[],
-  pxe: PXEService,
-) {
-  const registeredAccounts = await pxe.getRegisteredAccounts();
+export async function createAccountLogs(accountManagers: AccountManager[], wallet: EmbeddedWallet) {
+  const registeredAccounts = await wallet.getAccounts();
   const accountLogStrings = [`Initial Accounts:\n\n`];
-  for (const accountWithSecretKey of accountsWithSecretKeys) {
-    const completeAddress = await accountWithSecretKey.account.getCompleteAddress();
-    if (registeredAccounts.find(a => a.equals(completeAddress))) {
+  for (const accountManager of accountManagers) {
+    const account = await accountManager.getAccount();
+    const completeAddress = account.getCompleteAddress();
+    if (registeredAccounts.find(a => a.item.equals(completeAddress.address))) {
       accountLogStrings.push(` Address: ${completeAddress.address.toString()}\n`);
       accountLogStrings.push(` Partial Address: ${completeAddress.partialAddress.toString()}\n`);
-      accountLogStrings.push(` Secret Key: ${accountWithSecretKey.secretKey.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`,
       );
     }
   }
@@ -102,18 +133,32 @@ export function formatHelpLine(
 
 const getDefaultOrEnvValue = (opt: AztecStartOption) => {
   let val;
-  // if the option is set in the environment, use that & parse it
-  if (opt.envVar && process.env[opt.envVar]) {
-    val = process.env[opt.envVar];
-    if (val && opt.parseVal) {
-      return opt.parseVal(val);
+
+  // if the option is set in the environment, use that
+  if (opt.env) {
+    val = process.env[opt.env];
+  }
+
+  // if we have fallback env vars, check those
+  if (!val && opt.fallback && opt.fallback.length > 0) {
+    for (const fallback of opt.fallback) {
+      val = process.env[fallback];
+      if (val) {
+        break;
+      }
     }
-    // if no env variable, use the default value
-  } else if (opt.defaultValue) {
-    val = opt.defaultValue;
   }
 
-  return val;
+  // if we have a value, optionally parse it and return
+  if (val) {
+    if (opt.parseVal) {
+      return opt.parseVal(val);
+    }
+    return val;
+  } else if (opt.defaultValue !== undefined) {
+    return opt.defaultValue;
+  }
+  return undefined;
 };
 
 // Function to add options dynamically
@@ -121,7 +166,7 @@ export const addOptions = (cmd: Command, options: AztecStartOption[]) => {
   options.forEach(opt => {
     cmd.option(
       opt.flag,
-      `${opt.description} (default: ${opt.defaultValue}) ($${opt.envVar})`,
+      `${opt.description} (default: ${opt.defaultValue}) ($${opt.env})`,
       opt.parseVal ? opt.parseVal : val => val,
       getDefaultOrEnvValue(opt),
     );
@@ -137,10 +182,11 @@ export const printAztecStartHelpText = () => {
     helpTextLines.push('');
 
     aztecStartOptions[category].forEach(opt => {
-      const defaultValueText = opt.defaultValue
-        ? `(default: ${opt.printDefault ? opt.printDefault(opt.defaultValue) : opt.defaultValue})`
-        : '';
-      const envVarText = opt.envVar ? `($${opt.envVar})` : '';
+      const defaultValueText =
+        opt.defaultValue || (Array.isArray(opt.defaultValue) && opt.defaultValue.length > 0)
+          ? `(default: ${opt.printDefault ? opt.printDefault(opt.defaultValue) : opt.defaultValue})`
+          : '';
+      const envVarText = opt.env ? `($${opt.env})` : '';
       const flagText = `${opt.flag}`;
 
       const paddedText = formatHelpLine(flagText, defaultValueText, envVarText, maxFlagLength, maxDefaultLength);
@@ -214,3 +260,93 @@ export const extractRelevantOptions = <T>(
 
   return relevantOptions;
 };
+
+/**
+ * Downloads just enough points to be able to verify Chonk proofs.
+ * @param opts - Whether proof are to be verifier
+ * @param log - Logging function
+ */
+export async function preloadCrsDataForVerifying(
+  { realProofs }: Pick<AztecNodeConfig, 'realProofs'>,
+  log: LogFn,
+): 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)]);
+  }
+}
+
+/**
+ * Downloads enough points to be able to prove every server-side circuit
+ * @param opts - Whether real proof are to be generated
+ * @param log - Logging function
+ */
+export async function preloadCrsDataForServerSideProving(
+  { realProofs }: Pick<ProverConfig, 'realProofs'>,
+  log: LogFn,
+): 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)]);
+  }
+}
+
+export async function setupVersionChecker(
+  network: NetworkNames,
+  followsCanonicalRollup: boolean,
+  publicClient: ViemClient,
+  signalHandlers: Array<() => Promise<void>>,
+  cacheDir?: string,
+): Promise<void> {
+  const networkConfig = await getNetworkConfig(network, cacheDir);
+  if (!networkConfig) {
+    return;
+  }
+
+  const { VersionChecker } = await import('@aztec/stdlib/update-checker');
+
+  const logger = createLogger('version_check');
+  const registry = new RegistryContract(publicClient, networkConfig.registryAddress as Hex);
+
+  const checks: Array<VersionCheck> = [];
+  checks.push({
+    name: 'node',
+    currentVersion: getPackageVersion(),
+    getLatestVersion: async () => {
+      const cfg = await getNetworkConfig(network, cacheDir);
+      return cfg?.nodeVersion;
+    },
+  });
+
+  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,
+      });
+    }
+  }
+
+  const checker = new VersionChecker(checks, 600_000, logger);
+  checker.on('newVersion', ({ name, latestVersion, currentVersion }) => {
+    if (isShuttingDown()) {
+      return;
+    }
+
+    logger.warn(`New ${name} version available`, { latestVersion, currentVersion });
+  });
+  checker.start();
+  signalHandlers.push(() => checker.stop());
+}
+
+export function stringifyConfig(config: object): string {
+  return Object.entries(config)
+    .map(([key, value]) => `${key}=${jsonStringify(value)}`)
+    .join(' ');
+}

package/src/cli/versioning.ts

@@ -1,13 +1,13 @@
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import { type ComponentsVersions, getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 
 export function getVersions(config?: ChainConfig): Partial<ComponentsVersions> {
   return config
-    ? getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot())
+    ? getComponentsVersionsFromConfig(config, protocolContractsHash, getVKTreeRoot())
     : {
         l2CircuitsVkTreeRoot: getVKTreeRoot().toString(),
-        l2ProtocolContractsTreeRoot: protocolContractTreeRoot.toString(),
+        l2ProtocolContractsHash: protocolContractsHash.toString(),
       };
 }