@aztec-labs/cli 6.0.0-nightly.20260829

package/src/cmds/misc/index.ts

@@ -0,0 +1,67 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { Command } from 'commander';
+
+import { l1ChainIdOption, prettyPrintJSON } from '../../utils/commands.js';
+
+export function injectCommands(program: Command, log: LogFn) {
+  program
+    .command('generate-keys')
+    .summary('Generates encryption and signing private keys.')
+    .description('Generates and encryption and signing private key pair.')
+    .option('--json', 'Output the keys in JSON format')
+    .action(async ({ json }) => {
+      const { generateSecretKey } = await import('./generate_secret_key.js');
+      const { secretKey } = generateSecretKey();
+      if (json) {
+        log(prettyPrintJSON({ secretKey: secretKey.toString() }));
+      } else {
+        log(`Secret Key: ${secretKey}`);
+      }
+    });
+
+  program
+    .command('generate-p2p-private-key')
+    .summary('Generates a LibP2P peer private key.')
+    .description('Generates a private key that can be used for running a node on a LibP2P network.')
+    .action(async () => {
+      const { generateP2PPrivateKey } = await import('./generate_p2p_private_key.js');
+      await generateP2PPrivateKey(log);
+    });
+
+  program
+    .command('generate-bootnode-enr')
+    .summary('Generates the encoded ENR record for a bootnode.')
+    .description('Generates the encoded ENR record for a bootnode.')
+    .argument('<privateKey>', 'The peer id private key of the bootnode')
+    .argument('<p2pIp>', 'The bootnode P2P IP address')
+    .argument('<p2pPort>', 'The bootnode P2P port')
+    .addOption(l1ChainIdOption)
+    .action(async (privateKey: string, p2pIp: string, p2pPort: number, options) => {
+      const { generateEncodedBootnodeENR } = await import('./generate_bootnode_enr.js');
+      await generateEncodedBootnodeENR(privateKey, p2pIp, p2pPort, options.l1ChainId, log);
+    });
+
+  program
+    .command('decode-enr')
+    .summary('Decodes an ENR record')
+    .description('Decodes and ENR record')
+    .argument('<enr>', 'The encoded ENR string')
+    .action(async (enr: string) => {
+      const { printENR } = await import('@aztec-labs/p2p/enr');
+      await printENR(enr, log);
+    });
+
+  program
+    .command('update')
+    .description('Updates Nodejs and Noir dependencies')
+    .argument('[projectPath]', 'Path to the project directory', process.cwd())
+    .option('--contract [paths...]', 'Paths to contracts to update dependencies', [])
+    .option('--aztec-version <semver>', 'The version to update Aztec packages to. Defaults to latest', 'latest')
+    .action(async (projectPath: string, options) => {
+      const { updateProject } = await import('./update.js');
+      const { contract, aztecVersion } = options;
+      await updateProject(projectPath, contract, aztecVersion, log);
+    });
+
+  return program;
+}

package/src/cmds/misc/update/common.ts

@@ -0,0 +1,16 @@
+/**
+ * Tracks changes to dependencies
+ */
+export type DependencyChanges = {
+  /** Which file was changed */
+  file: string;
+  /** changes done to the file */
+  dependencies: Array<{
+    /** Name of the dependency being changed */
+    name: string;
+    /** Previous version of the dependency */
+    from: string;
+    /** New version of the dependency (after the update) */
+    to: string;
+  }>;
+};

package/src/cmds/misc/update/github.ts

@@ -0,0 +1,2 @@
+export const GITHUB_OWNER = 'AztecProtocol';
+export const GITHUB_REPO = 'aztec-packages';

package/src/cmds/misc/update/noir.ts

@@ -0,0 +1,56 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { parseNoirPackageConfig } from '@aztec-labs/foundation/noir';
+import TOML from '@iarna/toml';
+import { readFile } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+
+import type { DependencyChanges } from './common.js';
+import { atomicUpdateFile, prettyPrintNargoToml } from './utils.js';
+
+/**
+ * Updates Aztec.nr dependencies
+ * @param contractPath - Path to the contract to be updated
+ * @param tag - The tag to update to
+ * @param log - Logging function
+ */
+export async function updateAztecNr(contractPath: string, tag: string, log: LogFn): Promise<DependencyChanges> {
+  const configFilepath = resolve(join(contractPath, 'Nargo.toml'));
+  const packageConfig = parseNoirPackageConfig(TOML.parse(await readFile(configFilepath, 'utf-8')));
+  const changes: DependencyChanges = {
+    dependencies: [],
+    file: configFilepath,
+  };
+
+  log(`Updating Aztec.nr libraries to ${tag} in ${relative(process.cwd(), changes.file)}`);
+  for (const dep of Object.values(packageConfig.dependencies)) {
+    if (!('git' in dep)) {
+      continue;
+    }
+
+    // remove trailing slash
+    const gitUrl = dep.git.toLowerCase().replace(/\/$/, '');
+    if (gitUrl !== 'https://github.com/aztecprotocol/aztec-packages') {
+      continue;
+    }
+
+    if (dep.tag !== tag) {
+      // show the Aztec.nr package name rather than the lib name
+      const dirParts = dep.directory?.split('/') ?? [];
+      changes.dependencies.push({
+        name: dirParts.slice(-2).join('/'),
+        from: dep.tag,
+        to: tag,
+      });
+
+      dep.tag = tag;
+      dep.directory = dep.directory?.replace('yarn-project/', 'noir-projects/');
+    }
+  }
+
+  if (changes.dependencies.length > 0) {
+    const contents = prettyPrintNargoToml(packageConfig);
+    await atomicUpdateFile(configFilepath, contents);
+  }
+
+  return changes;
+}

package/src/cmds/misc/update/npm.ts

@@ -0,0 +1,148 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+import { type SemVer, parse } from 'semver';
+
+import type { DependencyChanges } from './common.js';
+import { atomicUpdateFile } from './utils.js';
+
+const deprecatedNpmPackages = new Set<string>(['@aztec-labs/cli', '@aztec/aztec-local-network']);
+const npmDeprecationMessage = `
+The following packages have been deprecated and will no longer be updated on the npm registry:
+${Array.from(deprecatedNpmPackages)
+  .map(pkg => `  - ${pkg}`)
+  .join('\n')}
+Remove them from package.json
+`;
+
+/**
+ * Looks up a package.json file and returns its contents
+ * @param projectPath - Path to Nodejs project
+ * @returns The parsed package.json
+ */
+export async function readPackageJson(projectPath: string): Promise<{
+  /** dependencies */
+  dependencies?: Record<string, string>;
+  /** devDependencies */
+  devDependencies?: Record<string, string>;
+}> {
+  const configFilepath = resolve(join(projectPath, 'package.json'));
+  const pkg = JSON.parse(await readFile(configFilepath, 'utf-8'));
+
+  return pkg;
+}
+
+/**
+ * Queries the npm registry for the latest version of a package
+ * @param packageName - The package to query
+ * @param distTag - The distribution tag
+ * @returns The latest version of the package on that distribution tag
+ */
+export async function getNewestVersion(packageName: string, distTag = 'latest'): Promise<SemVer> {
+  const url = new URL(packageName, 'https://registry.npmjs.org/');
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}`);
+  }
+
+  const body = await response.json();
+  const latestVersion = parse(body['dist-tags'][distTag]);
+  if (!latestVersion) {
+    throw new Error(`Failed to get latest version from registry`);
+  }
+
+  return latestVersion;
+}
+
+/**
+ * Updates a project's \@aztec-labs/* dependencies to the specific version
+ * @param projectPath - Path to Nodejs project
+ * @param aztecVersion - The version to update to
+ * @returns True if the project was updated
+ */
+export async function updateAztecDeps(
+  projectPath: string,
+  aztecVersion: SemVer,
+  log: LogFn,
+): Promise<DependencyChanges> {
+  const pkg = await readPackageJson(projectPath);
+  const changes: DependencyChanges = {
+    file: resolve(join(projectPath, 'package.json')),
+    dependencies: [],
+  };
+
+  log(`Updating @aztec-labs packages to ${aztecVersion} in ${relative(process.cwd(), changes.file)}`);
+  const version = aztecVersion.version;
+
+  let detectedDeprecatedPackages = false;
+
+  for (const depType of ['dependencies', 'devDependencies'] as const) {
+    const dependencies = pkg[depType];
+    if (!dependencies) {
+      continue;
+    }
+
+    for (const name of Object.keys(dependencies)) {
+      if (!name.startsWith('@aztec-labs/')) {
+        continue;
+      }
+
+      if (deprecatedNpmPackages.has(name)) {
+        detectedDeprecatedPackages = true;
+        continue;
+      }
+
+      if (dependencies[name] !== version) {
+        changes.dependencies.push({
+          name,
+          from: dependencies[name],
+          to: version,
+        });
+
+        dependencies[name] = version;
+      }
+    }
+  }
+
+  if (detectedDeprecatedPackages) {
+    log(npmDeprecationMessage);
+  }
+
+  if (changes.dependencies.length > 0) {
+    const contents = JSON.stringify(pkg, null, 2) + '\n';
+    await atomicUpdateFile(resolve(join(projectPath, 'package.json')), contents);
+  }
+
+  return changes;
+}
+
+/**
+ * Updates a project's yarn.lock or package-lock.json
+ * @param projectPath - Path to Nodejs project
+ */
+export function updateLockfile(projectPath: string, log: LogFn): void {
+  const isNpm = existsSync(resolve(join(projectPath, 'package-lock.json')));
+  const isYarn = existsSync(resolve(join(projectPath, 'yarn.lock')));
+  const isPnpm = existsSync(resolve(join(projectPath, 'pnpm-lock.yaml')));
+
+  if (isPnpm) {
+    spawnSync('pnpm', ['install'], {
+      cwd: projectPath,
+      stdio: 'inherit',
+    });
+  } else if (isYarn) {
+    spawnSync('yarn', ['install'], {
+      cwd: projectPath,
+      stdio: 'inherit',
+    });
+  } else if (isNpm) {
+    spawnSync('npm', ['install'], {
+      cwd: projectPath,
+      stdio: 'inherit',
+    });
+  } else {
+    log(`No lockfile found in ${projectPath}. Skipping lockfile update...`);
+  }
+}

package/src/cmds/misc/update/utils.ts

@@ -0,0 +1,49 @@
+import type { NoirPackageConfig } from '@aztec-labs/foundation/noir';
+import TOML from '@iarna/toml';
+import { CommanderError } from 'commander';
+import { rename, writeFile } from 'fs/promises';
+
+/**
+ * Updates a file in place atomically.
+ * @param filePath - Path to file
+ * @param contents - New contents to write
+ */
+export async function atomicUpdateFile(filePath: string, contents: string) {
+  const tmpFilepath = filePath + '.tmp';
+  try {
+    await writeFile(tmpFilepath, contents, {
+      // let's crash if the tmp file already exists
+      flag: 'wx',
+    });
+    await rename(tmpFilepath, filePath);
+  } catch (e) {
+    if (e instanceof Error && 'code' in e && e.code === 'EEXIST') {
+      const commanderError = new CommanderError(
+        1,
+        e.code,
+        `Temporary file already exists: ${tmpFilepath}. Delete this file and try again.`,
+      );
+      commanderError.nestedError = e.message;
+      throw commanderError;
+    } else {
+      throw e;
+    }
+  }
+}
+
+/**
+ * Pretty prints Nargo.toml contents to a string
+ * @param config - Nargo.toml contents
+ * @returns The Nargo.toml contents as a string
+ */
+export function prettyPrintNargoToml(config: NoirPackageConfig): string {
+  const withoutDependencies = Object.fromEntries(Object.entries(config).filter(([key]) => key !== 'dependencies'));
+
+  const partialToml = TOML.stringify(withoutDependencies);
+  const dependenciesToml = Object.entries(config.dependencies).map(([name, dep]) => {
+    const depToml = TOML.stringify.value(dep);
+    return `${name} = ${depToml}`;
+  });
+
+  return partialToml + '\n[dependencies]\n' + dependenciesToml.join('\n') + '\n';
+}

package/src/cmds/misc/update.ts

@@ -0,0 +1,71 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { relative, resolve } from 'path';
+import { parse } from 'semver';
+
+import type { DependencyChanges } from './update/common.js';
+import { updateAztecNr } from './update/noir.js';
+import { getNewestVersion, updateAztecDeps, updateLockfile } from './update/npm.js';
+
+const AZTECJS_PACKAGE = '@aztec-labs/aztec.js';
+const UPDATE_DOCS_URL = 'https://docs.aztec.network/developers/guides/local_env/versions-updating';
+
+export async function updateProject(
+  projectPath: string,
+  contracts: string[],
+  aztecVersion: string,
+  log: LogFn,
+): Promise<void> {
+  const targetAztecVersion =
+    aztecVersion === 'latest' ? await getNewestVersion(AZTECJS_PACKAGE, 'latest') : parse(aztecVersion);
+
+  if (!targetAztecVersion) {
+    throw new Error(`Invalid aztec version ${aztecVersion}`);
+  }
+
+  const projectDependencyChanges: DependencyChanges[] = [];
+  try {
+    const npmChanges = await updateAztecDeps(resolve(process.cwd(), projectPath), targetAztecVersion, log);
+    if (npmChanges.dependencies.length > 0) {
+      updateLockfile(projectPath, log);
+    }
+
+    projectDependencyChanges.push(npmChanges);
+  } catch (err) {
+    if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+      log(`No package.json found in ${projectPath}. Skipping npm update...`);
+    } else {
+      throw err;
+    }
+  }
+
+  for (const contract of contracts) {
+    try {
+      projectDependencyChanges.push(
+        await updateAztecNr(resolve(process.cwd(), projectPath, contract), `v${targetAztecVersion.version}`, log),
+      );
+    } catch (err) {
+      if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+        log(`No Nargo.toml found in ${relative(process.cwd(), contract)}. Skipping...`);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  log(`To update Docker containers follow instructions at ${UPDATE_DOCS_URL}`);
+
+  projectDependencyChanges.forEach(changes => {
+    printChanges(changes, log);
+  });
+}
+
+function printChanges(changes: DependencyChanges, log: LogFn): void {
+  log(`\nIn ${relative(process.cwd(), changes.file)}:`);
+  if (changes.dependencies.length === 0) {
+    log('  No changes');
+  } else {
+    changes.dependencies.forEach(({ name, from, to }) => {
+      log(`  Updated ${name} from ${from} to ${to}`);
+    });
+  }
+}

package/src/cmds/validator_keys/add.ts

@@ -0,0 +1,122 @@
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { loadKeystoreFile } from '@aztec-labs/node-keystore/loader';
+import type { KeyStore } from '@aztec-labs/node-keystore/types';
+import { wordlist } from '@scure/bip39/wordlists/english.js';
+import { dirname, isAbsolute, join } from 'path';
+import { generateMnemonic } from 'viem/accounts';
+
+import type { NewValidatorKeystoreOptions } from './new.js';
+import {
+  buildValidatorEntries,
+  logValidatorSummaries,
+  maybePrintJson,
+  writeBlsBn254ToFile,
+  writeEthJsonV3ToFile,
+  writeKeystoreFile,
+} from './shared.js';
+import { validateBlsPathOptions, validatePublisherOptions, validateRemoteSignerOptions } from './utils.js';
+
+export type AddValidatorKeysOptions = NewValidatorKeystoreOptions;
+
+export async function addValidatorKeys(existing: string, options: AddValidatorKeysOptions, log: LogFn) {
+  // validate bls-path inputs before proceeding with key generation
+  validateBlsPathOptions(options);
+  // validate publisher options
+  validatePublisherOptions(options);
+  // validate remote signer options
+  validateRemoteSignerOptions(options);
+
+  const {
+    dataDir,
+    file,
+    count,
+    publisherCount = 0,
+    publishers,
+    mnemonic,
+    accountIndex = 0,
+    addressIndex,
+    ikm,
+    blsPath,
+    json,
+    feeRecipient: feeRecipientOpt,
+    coinbase: coinbaseOpt,
+    remoteSigner: remoteSignerOpt,
+    password,
+    encryptedKeystoreDir,
+  } = options;
+
+  const validatorCount = typeof count === 'number' && Number.isFinite(count) && count > 0 ? Math.floor(count) : 1;
+  const baseAddressIndex = addressIndex ?? 0;
+
+  const keystore: KeyStore = loadKeystoreFile(existing);
+
+  if (!keystore.validators || !Array.isArray(keystore.validators)) {
+    throw new Error('Invalid keystore: missing validators array');
+  }
+
+  const first = keystore.validators[0] ?? {};
+  const feeRecipient = feeRecipientOpt ?? first.feeRecipient;
+  if (!feeRecipient) {
+    throw new Error('feeRecipient is required (either present in existing file or via --fee-recipient)');
+  }
+  const coinbase = (coinbaseOpt as EthAddress | undefined) ?? (first.coinbase as EthAddress | undefined);
+  const derivedRemoteSigner = (first.attester as any)?.remoteSignerUrl || (first.attester as any)?.eth?.remoteSignerUrl;
+  const remoteSigner = remoteSignerOpt ?? derivedRemoteSigner;
+
+  // Ensure we always have a mnemonic for key derivation if none was provided
+  const mnemonicToUse = mnemonic ?? generateMnemonic(wordlist);
+
+  // If user explicitly provided --address-index, use it as-is. Otherwise, append after existing validators.
+  const effectiveBaseAddressIndex =
+    addressIndex === undefined ? baseAddressIndex + keystore.validators.length : baseAddressIndex;
+
+  const { validators, summaries } = await buildValidatorEntries({
+    validatorCount,
+    publisherCount,
+    publishers,
+    accountIndex,
+    baseAddressIndex: effectiveBaseAddressIndex,
+    mnemonic: mnemonicToUse,
+    ikm,
+    blsPath,
+    feeRecipient,
+    coinbase,
+    remoteSigner,
+  });
+
+  keystore.validators.push(...validators);
+
+  // If password provided, write ETH JSON V3 and BLS BN254 keystores and replace plaintext
+  if (password !== undefined) {
+    let targetDir: string;
+    if (encryptedKeystoreDir && encryptedKeystoreDir.length > 0) {
+      targetDir = encryptedKeystoreDir;
+    } else if (dataDir && dataDir.length > 0) {
+      targetDir = dataDir;
+    } else {
+      targetDir = dirname(existing);
+    }
+    await writeEthJsonV3ToFile(keystore.validators, { outDir: targetDir, password });
+    await writeBlsBn254ToFile(keystore.validators, { outDir: targetDir, password, blsPath });
+  }
+
+  let outputPath = existing;
+  if (file && file.length > 0) {
+    if (isAbsolute(file)) {
+      outputPath = file;
+    } else if (dataDir && dataDir.length > 0) {
+      outputPath = join(dataDir, file);
+    } else {
+      outputPath = join(dirname(existing), file);
+    }
+  }
+
+  await writeKeystoreFile(outputPath, keystore);
+
+  if (!json) {
+    log(`Updated keystore ${outputPath} with ${validators.length} new validator(s)`);
+    logValidatorSummaries(log, summaries);
+  }
+  maybePrintJson(log, !!json, keystore as unknown as Record<string, any>);
+}

package/src/cmds/validator_keys/eth_json_v3_worker.ts

@@ -0,0 +1,30 @@
+import { Wallet } from '@ethersproject/wallet';
+import { parentPort, workerData } from 'worker_threads';
+
+type EthJsonV3WorkerData = {
+  privateKeyHex: string;
+  password: string;
+};
+
+type SerializedError = {
+  message: string;
+  name?: string;
+  stack?: string;
+};
+
+function serializeError(error: unknown): SerializedError {
+  if (error instanceof Error) {
+    return { message: error.message, name: error.name, stack: error.stack };
+  }
+  return { message: String(error) };
+}
+
+void (async () => {
+  try {
+    const { privateKeyHex, password } = workerData as EthJsonV3WorkerData;
+    const json = await new Wallet(privateKeyHex).encrypt(password);
+    parentPort?.postMessage({ json });
+  } catch (error) {
+    parentPort?.postMessage({ error: serializeError(error) });
+  }
+})();

package/src/cmds/validator_keys/generate_bls_keypair.ts

@@ -0,0 +1,33 @@
+import { deriveBlsPrivateKey } from '@aztec-labs/foundation/crypto/bls';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { writeFile } from 'fs/promises';
+
+import { computeBlsPublicKeyCompressed, withValidatorIndex } from './shared.js';
+import { defaultBlsPath } from './utils.js';
+
+export type GenerateBlsKeypairOptions = {
+  mnemonic?: string;
+  ikm?: string;
+  blsPath?: string;
+  g2?: boolean;
+  compressed?: boolean;
+  json?: boolean;
+  out?: string;
+};
+
+export async function generateBlsKeypair(options: GenerateBlsKeypairOptions, log: LogFn) {
+  const { mnemonic, ikm, blsPath, compressed = true, json, out } = options;
+  const path = withValidatorIndex(blsPath ?? defaultBlsPath, 0);
+  const priv = deriveBlsPrivateKey(mnemonic, ikm, path);
+  const pub = await computeBlsPublicKeyCompressed(priv);
+  const result = { path, privateKey: priv, publicKey: pub, format: compressed ? 'compressed' : 'uncompressed' };
+  if (out) {
+    await writeFile(out, JSON.stringify(result, null, 2), { encoding: 'utf-8' });
+    if (!json) {
+      log(`Wrote BLS keypair to ${out}`);
+    }
+  }
+  if (json || !out) {
+    log(JSON.stringify(result, null, 2));
+  }
+}