@aztec/cli 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/config/enrich_env.ts

@@ -0,0 +1,15 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import type { EnvVar } from '@aztec/foundation/config';
+
+export function enrichVar(envVar: EnvVar, value: string | undefined) {
+  // Don't override
+  if (process.env[envVar] || value === undefined) {
+    return;
+  }
+  process.env[envVar] = value;
+}
+
+export function enrichEthAddressVar(envVar: EnvVar, value: string) {
+  // EthAddress doesn't like being given empty strings
+  enrichVar(envVar, value || EthAddress.ZERO.toString());
+}

package/src/config/get_l1_config.ts

@@ -0,0 +1,31 @@
+import { getPublicClient } from '@aztec/ethereum/client';
+import { RegistryContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { getL1ContractsConfig } from '@aztec/ethereum/queries';
+import { EthAddress } from '@aztec/foundation/eth-address';
+
+export async function getL1Config(
+  registryAddress: EthAddress,
+  l1RpcUrls: string[],
+  l1ChainId: number,
+  rollupVersion: number | 'canonical' = 'canonical',
+): Promise<{ addresses: L1ContractAddresses; config: Awaited<ReturnType<typeof getL1ContractsConfig>> }> {
+  const publicClient = getPublicClient({ l1RpcUrls, l1ChainId });
+  const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress, rollupVersion);
+
+  const config = await getL1ContractsConfig(publicClient, addresses);
+
+  return {
+    addresses,
+    config,
+  };
+}
+
+export async function getL1RollupAddressFromEnv(l1RpcUrls: string[], l1ChainId: number) {
+  const registryAddress = process.env.REGISTRY_CONTRACT_ADDRESS;
+  if (!registryAddress || !EthAddress.isAddress(registryAddress)) {
+    throw new Error(`Failed to extract registry address`);
+  }
+  const { addresses } = await getL1Config(EthAddress.fromString(registryAddress), l1RpcUrls, l1ChainId);
+  return addresses.rollupAddress;
+}

package/src/config/index.ts

@@ -0,0 +1,4 @@
+export * from './cached_fetch.js';
+export * from './chain_l2_config.js';
+export * from './get_l1_config.js';
+export * from './network_config.js';

package/src/config/network_config.ts

@@ -0,0 +1,147 @@
+import { type NetworkConfig, NetworkConfigMapSchema, type NetworkNames } from '@aztec/foundation/config';
+
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+import { cachedFetch } from './cached_fetch.js';
+import { enrichEthAddressVar, enrichVar } from './enrich_env.js';
+
+const DEFAULT_CONFIG_URL =
+  'https://raw.githubusercontent.com/AztecProtocol/networks/refs/heads/main/network_config.json';
+const FALLBACK_CONFIG_URL = 'https://metadata.aztec.network/network_config.json';
+const NETWORK_CONFIG_CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
+
+/**
+ * Fetches remote network configuration from GitHub with caching support.
+ * Uses the reusable cachedFetch utility. Falls back to metadata.aztec.network if the default URL fails.
+ *
+ * @param networkName - The network name to fetch config for
+ * @param cacheDir - Optional cache directory for storing fetched config
+ * @returns Remote configuration for the specified network, or undefined if network not found in config
+ * @throws Error if both primary and fallback URLs fail to fetch
+ */
+export async function getNetworkConfig(
+  networkName: NetworkNames,
+  cacheDir?: string,
+): Promise<NetworkConfig | undefined> {
+  // Try with the primary URL (env var or default)
+  const configLocation = process.env.NETWORK_CONFIG_LOCATION || DEFAULT_CONFIG_URL;
+
+  let primaryError: Error | undefined;
+  let config: NetworkConfig | undefined;
+
+  // First try the primary config location
+  try {
+    config = await fetchNetworkConfigFromUrl(configLocation, networkName, cacheDir);
+  } catch (error) {
+    primaryError = error as Error;
+  }
+
+  // If primary fails and we were using the default URL, try the fallback
+  if (!config && configLocation === DEFAULT_CONFIG_URL) {
+    try {
+      config = await fetchNetworkConfigFromUrl(FALLBACK_CONFIG_URL, networkName, cacheDir);
+    } catch {
+      // Both failed - throw the primary error
+      if (primaryError) {
+        throw primaryError;
+      }
+    }
+  } else if (primaryError) {
+    // Primary failed and no fallback to try
+    throw primaryError;
+  }
+
+  return config;
+}
+
+/**
+ * Helper function to fetch network config from a specific URL.
+ * @param configLocation - The URL or file path to fetch from
+ * @param networkName - The network name to fetch config for
+ * @param cacheDir - Optional cache directory for storing fetched config
+ * @returns Remote configuration for the specified network, or undefined if network not found in config, or undefined if URL invalid
+ * @throws Error if fetch/parse fails
+ */
+async function fetchNetworkConfigFromUrl(
+  configLocation: string,
+  networkName: NetworkNames,
+  cacheDir?: string,
+): Promise<NetworkConfig | undefined> {
+  let url: URL | undefined;
+  try {
+    if (configLocation.includes('://')) {
+      url = new URL(configLocation);
+    } else {
+      url = new URL(`file://${configLocation}`);
+    }
+  } catch {
+    /* no-op */
+  }
+
+  if (!url) {
+    return undefined;
+  }
+
+  let rawConfig: any;
+
+  if (url.protocol === 'http:' || url.protocol === 'https:') {
+    rawConfig = await cachedFetch(url.href, {
+      cacheDurationMs: NETWORK_CONFIG_CACHE_DURATION_MS,
+      cacheFile: cacheDir ? join(cacheDir, networkName, 'network_config.json') : undefined,
+    });
+  } else if (url.protocol === 'file:') {
+    rawConfig = JSON.parse(await readFile(url.pathname, 'utf-8'));
+  } else {
+    throw new Error('Unsupported Aztec network config protocol: ' + url.href);
+  }
+
+  if (!rawConfig) {
+    return undefined;
+  }
+
+  const networkConfigMap = NetworkConfigMapSchema.parse(rawConfig);
+  if (networkName in networkConfigMap) {
+    return networkConfigMap[networkName];
+  } else {
+    return undefined;
+  }
+}
+
+/**
+ * Enriches environment variables with remote network configuration.
+ * This function is called before node config initialization to set env vars
+ * from the remote config, following the same pattern as enrichEnvironmentWithChainConfig().
+ *
+ * @param networkName - The network name to fetch remote config for
+ * @throws Error if network config fetch fails (network errors, parse errors, etc.)
+ * Does not throw if the network simply doesn't exist in the config - just returns without enriching
+ */
+export async function enrichEnvironmentWithNetworkConfig(networkName: NetworkNames) {
+  if (networkName === 'local') {
+    return; // No remote config for local development
+  }
+
+  const cacheDir = process.env.DATA_DIRECTORY ? join(process.env.DATA_DIRECTORY, 'cache') : undefined;
+  const networkConfig = await getNetworkConfig(networkName, cacheDir);
+
+  if (!networkConfig) {
+    return; // Network not found in config, continue without enriching
+  }
+
+  enrichVar('BOOTSTRAP_NODES', networkConfig.bootnodes.join(','));
+  enrichVar('L1_CHAIN_ID', String(networkConfig.l1ChainId));
+  enrichVar('SYNC_SNAPSHOTS_URLS', networkConfig.snapshots.join(','));
+
+  enrichEthAddressVar('REGISTRY_CONTRACT_ADDRESS', networkConfig.registryAddress.toString());
+  if (networkConfig.feeAssetHandlerAddress) {
+    enrichEthAddressVar('FEE_ASSET_HANDLER_CONTRACT_ADDRESS', networkConfig.feeAssetHandlerAddress.toString());
+  }
+
+  if (networkConfig.blobFileStoreUrls?.length) {
+    enrichVar('BLOB_FILE_STORE_URLS', networkConfig.blobFileStoreUrls.join(','));
+  }
+  if (networkConfig.blockDurationMs !== undefined) {
+    enrichVar('SEQ_BLOCK_DURATION_MS', String(networkConfig.blockDurationMs));
+  }
+}

package/src/utils/aztec.ts

@@ -1,4 +1,3 @@
-import { EthAddress, type PXE } from '@aztec/aztec.js';
 import {
   type ContractArtifact,
   type FunctionAbi,
@@ -6,24 +5,24 @@ import {
   getAllFunctionAbis,
   loadContractArtifact,
 } from '@aztec/aztec.js/abi';
-import {
-  type DeployL1ContractsReturnType,
-  type L1ContractsConfig,
-  type Operator,
-  RollupContract,
-} from '@aztec/ethereum';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import type { L1ContractsConfig } from '@aztec/ethereum/config';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { Operator } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { SecretValue } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type LogFn, createLogger } from '@aztec/foundation/log';
 import type { NoirPackageConfig } from '@aztec/foundation/noir';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 
 import TOML from '@iarna/toml';
 import { readFile } from 'fs/promises';
-import { gtr, ltr, satisfies, valid } from 'semver';
+import type { HDAccount, Hex, PrivateKeyAccount } from 'viem';
 
 import { encodeArgs } from './encoding.js';
 
+const logger = createLogger('cli:utils:aztec');
+
 /**
  * Helper to get an ABI function or throw error if it doesn't exist.
  * @param artifact - Contract's build artifact in JSON format.
@@ -38,86 +37,32 @@ export function getFunctionAbi(artifact: ContractArtifact, fnName: string): Func
   return fn;
 }
 
-/**
- * Function to execute the 'deployRollupContracts' command.
- * @param rpcUrls - The RPC URL of the ethereum node.
- * @param chainId - The chain ID of the L1 host.
- * @param privateKey - The private key to be used in contract deployment.
- * @param mnemonic - The mnemonic to be used in contract deployment.
- */
-export async function deployAztecContracts(
-  rpcUrls: string[],
-  chainId: number,
-  privateKey: string | undefined,
-  mnemonic: string,
-  mnemonicIndex: number,
-  salt: number | undefined,
-  initialValidators: Operator[],
-  genesisArchiveRoot: Fr,
-  feeJuicePortalInitialBalance: bigint,
-  acceleratedTestDeployments: boolean,
-  config: L1ContractsConfig,
-  realVerifier: boolean,
-  createVerificationJson: string | false,
-  debugLogger: Logger,
-): Promise<DeployL1ContractsReturnType> {
-  const { createEthereumChain, deployL1Contracts } = await import('@aztec/ethereum');
-  const { mnemonicToAccount, privateKeyToAccount } = await import('viem/accounts');
-
-  const account = !privateKey
-    ? mnemonicToAccount(mnemonic!, { addressIndex: mnemonicIndex })
-    : privateKeyToAccount(addLeadingHex(privateKey));
-  const chain = createEthereumChain(rpcUrls, chainId);
-
-  const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
-
-  const result = await deployL1Contracts(
-    chain.rpcUrls,
-    account,
-    chain.chainInfo,
-    debugLogger,
-    {
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-      genesisArchiveRoot,
-      salt,
-      initialValidators,
-      acceleratedTestDeployments,
-      feeJuicePortalInitialBalance,
-      realVerifier,
-      ...config,
-    },
-    config,
-    createVerificationJson,
-  );
-
-  return result;
-}
-
 export async function deployNewRollupContracts(
   registryAddress: EthAddress,
   rpcUrls: string[],
-  chainId: number,
   privateKey: string | undefined,
+  chainId: number,
   mnemonic: string,
   mnemonicIndex: number,
-  salt: number | undefined,
   initialValidators: Operator[],
   genesisArchiveRoot: Fr,
   feeJuicePortalInitialBalance: bigint,
   config: L1ContractsConfig,
   realVerifier: boolean,
-  logger: Logger,
 ): Promise<{ rollup: RollupContract; slashFactoryAddress: EthAddress }> {
-  const { createEthereumChain, deployRollupForUpgrade, createExtendedL1Client } = await import('@aztec/ethereum');
+  const { deployRollupForUpgrade } = await import('@aztec/ethereum/deploy-aztec-l1-contracts');
   const { mnemonicToAccount, privateKeyToAccount } = await import('viem/accounts');
   const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
 
-  const account = !privateKey
-    ? mnemonicToAccount(mnemonic!, { addressIndex: mnemonicIndex })
-    : privateKeyToAccount(addLeadingHex(privateKey));
-  const chain = createEthereumChain(rpcUrls, chainId);
-  const client = createExtendedL1Client(rpcUrls, account, chain.chainInfo, undefined, mnemonicIndex);
+  let account: HDAccount | PrivateKeyAccount;
+  if (privateKey) {
+    account = privateKeyToAccount(addLeadingHex(privateKey));
+  } else {
+    account = mnemonicToAccount(mnemonic!, { addressIndex: mnemonicIndex });
+    const privateKeyBuf = account.getHdKey().privateKey;
+    const privateKeyHex = Buffer.from(privateKeyBuf!).toString('hex');
+    privateKey = `0x${privateKeyHex}`;
+  }
 
   if (!initialValidators || initialValidators.length === 0) {
     // initialize the new rollup with Amin's validator address.
@@ -136,23 +81,22 @@ export async function deployNewRollupContracts(
   }
 
   const { rollup, slashFactoryAddress } = await deployRollupForUpgrade(
-    client,
+    privateKey as Hex,
+    rpcUrls[0],
+    chainId,
+    registryAddress,
     {
-      salt,
       vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
+      protocolContractsHash,
       genesisArchiveRoot,
       initialValidators,
       feeJuicePortalInitialBalance,
       realVerifier,
       ...config,
     },
-    registryAddress,
-    logger,
-    config,
   );
 
-  return { rollup, slashFactoryAddress };
+  return { rollup, slashFactoryAddress: EthAddress.fromString(slashFactoryAddress!) };
 }
 
 /**
@@ -258,38 +202,3 @@ export function prettyPrintNargoToml(config: NoirPackageConfig): string {
 
   return partialToml + '\n[dependencies]\n' + dependenciesToml.join('\n') + '\n';
 }
-
-/** Mismatch between server and client versions. */
-class VersionMismatchError extends Error {}
-
-/**
- * Checks that Private eXecution Environment (PXE) version matches the expected one by this CLI. Throws if not.
- * @param pxe - PXE client.
- * @param expectedVersionRange - Expected version by CLI.
- */
-export async function checkServerVersion(pxe: PXE, expectedVersionRange: string) {
-  const serverName = 'Aztec Node';
-  const { nodeVersion } = await pxe.getNodeInfo();
-  if (!nodeVersion) {
-    throw new VersionMismatchError(`Couldn't determine ${serverName} version. You may run into issues.`);
-  }
-  if (!nodeVersion || !valid(nodeVersion)) {
-    throw new VersionMismatchError(
-      `Missing or invalid version identifier for ${serverName} (${nodeVersion ?? 'empty'}).`,
-    );
-  } else if (!satisfies(nodeVersion, expectedVersionRange)) {
-    if (gtr(nodeVersion, expectedVersionRange)) {
-      throw new VersionMismatchError(
-        `${serverName} is running version ${nodeVersion} which is newer than the expected by this CLI (${expectedVersionRange}). Consider upgrading your CLI to a newer version.`,
-      );
-    } else if (ltr(nodeVersion, expectedVersionRange)) {
-      throw new VersionMismatchError(
-        `${serverName} is running version ${nodeVersion} which is older than the expected by this CLI (${expectedVersionRange}). Consider upgrading your ${serverName} to a newer version.`,
-      );
-    } else {
-      throw new VersionMismatchError(
-        `${serverName} is running version ${nodeVersion} which does not match the expected by this CLI (${expectedVersionRange}).`,
-      );
-    }
-  }
-}

package/src/utils/commands.ts

@@ -1,12 +1,12 @@
-import { FunctionSelector } from '@aztec/aztec.js/abi';
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { EthAddress } from '@aztec/aztec.js/eth_address';
-import { Fr } from '@aztec/aztec.js/fields';
-import { LogId } from '@aztec/aztec.js/log_id';
-import { TxHash } from '@aztec/aztec.js/tx_hash';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn } from '@aztec/foundation/log';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { PXE } from '@aztec/pxe/server';
+import { FunctionSelector } from '@aztec/stdlib/abi/function-selector';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { PublicKeys } from '@aztec/stdlib/keys';
+import { LogId } from '@aztec/stdlib/logs/log-id';
+import { TxHash } from '@aztec/stdlib/tx/tx-hash';
 
 import { type Command, CommanderError, InvalidArgumentError, Option } from 'commander';
 import { lookup } from 'dns/promises';
@@ -29,14 +29,13 @@ export function addOptions(program: Command, options: Option[]) {
   return program;
 }
 
-export const makePxeOption = (mandatory: boolean) =>
-  new Option('-u, --rpc-url <string>', 'URL of the PXE')
-    .env('PXE_URL')
+export const makeNodeOption = (mandatory: boolean) =>
+  new Option('-n, --node-url <string>', 'URL of the Aztec node')
+    .env('AZTEC_NODE_URL')
     .default(`http://${LOCALHOST}:8080`)
-    .conflicts('remote-pxe')
     .makeOptionMandatory(mandatory);
 
-export const pxeOption = makePxeOption(true);
+export const nodeOption = makeNodeOption(true);
 
 export const l1ChainIdOption = new Option('-c, --l1-chain-id <number>', 'Chain ID of the ethereum host')
   .env('L1_CHAIN_ID')
@@ -114,6 +113,34 @@ export async function getTxSender(pxe: PXE, _from?: string) {
   return from;
 }
 
+/**
+ * Parses and validates a hex string. Removes leading 0x if present, checks for hex validity,
+ * and enforces an optional minimum length.
+ * @param hex - The hex string to validate.
+ * @param minLen - Optional minimum length (in hex characters, after stripping '0x').
+ * @returns The normalized hex string (without leading 0x).
+ * @throws InvalidArgumentError if the string is not valid hex or does not meet the minimum length.
+ */
+// minLen is now interpreted as the minimum number of bytes (2 hex characters per byte)
+export function parseHex(hex: string, minLen?: number): `0x${string}` {
+  const normalized = hex.startsWith('0x') ? hex.slice(2) : hex;
+
+  if (!/^[0-9a-fA-F]*$/.test(normalized)) {
+    throw new InvalidArgumentError('Invalid hex string');
+  }
+
+  if (minLen !== undefined) {
+    const minHexLen = minLen * 2;
+    if (normalized.length < minHexLen) {
+      throw new InvalidArgumentError(
+        `Hex string is too short (length ${normalized.length}), minimum byte length is ${minLen} (hex chars: ${minHexLen})`,
+      );
+    }
+  }
+
+  return `0x${normalized}`;
+}
+
 /**
  * Removes the leading 0x from a hex string. If no leading 0x is found the string is returned unchanged.
  * @param hex - A hex string
@@ -168,7 +195,7 @@ export function parseAztecAddress(address: string): AztecAddress {
   try {
     return AztecAddress.fromString(address);
   } catch {
-    throw new InvalidArgumentError(`Invalid address: ${address}`);
+    throw new InvalidArgumentError(`Invalid Aztec address: ${address}`);
   }
 }
 
@@ -182,7 +209,7 @@ export function parseEthereumAddress(address: string): EthAddress {
   try {
     return EthAddress.fromString(address);
   } catch {
-    throw new InvalidArgumentError(`Invalid address: ${address}`);
+    throw new InvalidArgumentError(`Invalid Ethereumaddress: ${address}`);
   }
 }
 
@@ -236,7 +263,11 @@ export function parseOptionalSelector(selector: string): FunctionSelector | unde
  * @returns The parsed integer, or undefined if the input string is falsy.
  * @throws If the input is not a valid integer.
  */
-export function parseOptionalInteger(value: string): number | undefined {
+export function parseOptionalInteger(
+  value: string,
+  min: number = Number.MIN_SAFE_INTEGER,
+  max: number = Number.MAX_SAFE_INTEGER,
+): number | undefined {
   if (!value) {
     return undefined;
   }
@@ -244,6 +275,12 @@ export function parseOptionalInteger(value: string): number | undefined {
   if (!Number.isInteger(parsed)) {
     throw new InvalidArgumentError('Invalid integer.');
   }
+  if (parsed < min) {
+    throw new InvalidArgumentError(`Value must be greater than ${min}.`);
+  }
+  if (parsed > max) {
+    throw new InvalidArgumentError(`Value must be less than ${max}.`);
+  }
   return parsed;
 }
 

package/src/utils/encoding.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ABIParameter, AbiType, StructType } from '@aztec/stdlib/abi';
 
 /**