@aztec/cli 3.0.0-canary.a9708bd → 3.0.0-devnet.3

package/src/config/network_config.ts

@@ -0,0 +1,102 @@
+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 NETWORK_CONFIG_CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
+
+/**
+ * Fetches remote network configuration from GitHub with caching support.
+ * Uses the reusable cachedFetch utility.
+ *
+ * @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 not found/error
+ */
+export async function getNetworkConfig(
+  networkName: NetworkNames,
+  cacheDir?: string,
+): Promise<NetworkConfig | undefined> {
+  let url: URL | undefined;
+  const configLocation = process.env.NETWORK_CONFIG_LOCATION || DEFAULT_CONFIG_URL;
+
+  if (!configLocation) {
+    return undefined;
+  }
+
+  try {
+    if (configLocation.includes('://')) {
+      url = new URL(configLocation);
+    } else {
+      url = new URL(`file://${configLocation}`);
+    }
+  } catch {
+    /* no-op */
+  }
+
+  if (!url) {
+    return undefined;
+  }
+
+  try {
+    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;
+    }
+  } catch {
+    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
+ */
+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;
+  }
+
+  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());
+  }
+}

package/src/utils/aztec.ts

@@ -1,4 +1,3 @@
-import { EthAddress, type PXE } from '@aztec/aztec.js';
 import {
   type ContractArtifact,
   type FunctionAbi,
@@ -6,6 +5,7 @@ import {
   getAllFunctionAbis,
   loadContractArtifact,
 } from '@aztec/aztec.js/abi';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import {
   type DeployL1ContractsReturnType,
   type L1ContractsConfig,
@@ -16,11 +16,10 @@ import { SecretValue } from '@aztec/foundation/config';
 import { Fr } from '@aztec/foundation/fields';
 import type { LogFn, Logger } 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 { encodeArgs } from './encoding.js';
 
@@ -57,6 +56,7 @@ export async function deployAztecContracts(
   feeJuicePortalInitialBalance: bigint,
   acceleratedTestDeployments: boolean,
   config: L1ContractsConfig,
+  existingToken: EthAddress | undefined,
   realVerifier: boolean,
   createVerificationJson: string | false,
   debugLogger: Logger,
@@ -78,13 +78,14 @@ export async function deployAztecContracts(
     debugLogger,
     {
       vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
+      protocolContractsHash,
       genesisArchiveRoot,
       salt,
       initialValidators,
       acceleratedTestDeployments,
       feeJuicePortalInitialBalance,
       realVerifier,
+      existingTokenAddress: existingToken,
       ...config,
     },
     config,
@@ -107,6 +108,7 @@ export async function deployNewRollupContracts(
   feeJuicePortalInitialBalance: bigint,
   config: L1ContractsConfig,
   realVerifier: boolean,
+  createVerificationJson: string | false,
   logger: Logger,
 ): Promise<{ rollup: RollupContract; slashFactoryAddress: EthAddress }> {
   const { createEthereumChain, deployRollupForUpgrade, createExtendedL1Client } = await import('@aztec/ethereum');
@@ -140,7 +142,7 @@ export async function deployNewRollupContracts(
     {
       salt,
       vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
+      protocolContractsHash,
       genesisArchiveRoot,
       initialValidators,
       feeJuicePortalInitialBalance,
@@ -150,6 +152,7 @@ export async function deployNewRollupContracts(
     registryAddress,
     logger,
     config,
+    createVerificationJson,
   );
 
   return { rollup, slashFactoryAddress };
@@ -258,38 +261,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,11 +1,10 @@
 import { FunctionSelector } from '@aztec/aztec.js/abi';
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { EthAddress } from '@aztec/aztec.js/eth_address';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
 import { Fr } from '@aztec/aztec.js/fields';
-import { LogId } from '@aztec/aztec.js/log_id';
-import { TxHash } from '@aztec/aztec.js/tx_hash';
+import { LogId } from '@aztec/aztec.js/log';
+import { TxHash } from '@aztec/aztec.js/tx';
 import type { LogFn } from '@aztec/foundation/log';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { PXE } from '@aztec/pxe/server';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
 import { type Command, CommanderError, InvalidArgumentError, Option } from 'commander';
@@ -29,14 +28,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')

package/src/utils/inspect.ts

@@ -1,13 +1,14 @@
-import type { AztecAddress, ContractArtifact, Fr } from '@aztec/aztec.js';
 import type { LogFn } from '@aztec/foundation/log';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { siloNullifier } from '@aztec/stdlib/hash';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { ExtendedNote } from '@aztec/stdlib/note';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { TxHash } from '@aztec/stdlib/tx';
 
-export async function inspectBlock(pxe: PXE, blockNumber: number, log: LogFn, opts: { showTxs?: boolean } = {}) {
-  const block = await pxe.getBlock(blockNumber);
+export async function inspectBlock(
+  aztecNode: AztecNode,
+  blockNumber: number,
+  log: LogFn,
+  opts: { showTxs?: boolean } = {},
+) {
+  const block = await aztecNode.getBlock(blockNumber);
   if (!block) {
     log(`No block found for block number ${blockNumber}`);
     return;
@@ -25,9 +26,8 @@ export async function inspectBlock(pxe: PXE, blockNumber: number, log: LogFn, op
   log(` Timestamp: ${new Date(Number(block.header.globalVariables.timestamp) * 500)}`);
   if (opts.showTxs) {
     log(``);
-    const artifactMap = await getKnownArtifacts(pxe);
     for (const txHash of block.body.txEffects.map(tx => tx.txHash)) {
-      await inspectTx(pxe, txHash, log, { includeBlockInfo: false, artifactMap });
+      await inspectTx(aztecNode, txHash, log, { includeBlockInfo: false });
     }
   } else {
     log(` Transactions: ${block.body.txEffects.length}`);
@@ -35,12 +35,12 @@ export async function inspectBlock(pxe: PXE, blockNumber: number, log: LogFn, op
 }
 
 export async function inspectTx(
-  pxe: PXE,
+  aztecNode: AztecNode,
   txHash: TxHash,
   log: LogFn,
-  opts: { includeBlockInfo?: boolean; artifactMap?: ArtifactMap } = {},
+  opts: { includeBlockInfo?: boolean } = {},
 ) {
-  const [receipt, effectsInBlock] = await Promise.all([pxe.getTxReceipt(txHash), pxe.getTxEffect(txHash)]);
+  const [receipt, effectsInBlock] = await Promise.all([aztecNode.getTxReceipt(txHash), aztecNode.getTxEffect(txHash)]);
   // Base tx data
   log(`Tx ${txHash.toString()}`);
   log(` Status: ${receipt.status} ${effectsInBlock ? `(${effectsInBlock.data.revertCode.getDescription()})` : ''}`);
@@ -53,7 +53,6 @@ export async function inspectTx(
   }
 
   const effects = effectsInBlock.data;
-  const artifactMap = opts?.artifactMap ?? (await getKnownArtifacts(pxe));
 
   if (opts.includeBlockInfo) {
     log(` Block: ${receipt.blockNumber} (${receipt.blockHash?.toString()})`);
@@ -90,38 +89,12 @@ export async function inspectTx(
     }
   }
 
-  // Nullifiers
-  const nullifierCount = effects.nullifiers.length;
-  const { deployNullifiers, initNullifiers, classNullifiers } = await getKnownNullifiers(pxe, artifactMap);
-  if (nullifierCount > 0) {
-    log(' Nullifiers:');
-    for (const nullifier of effects.nullifiers) {
-      const deployed = deployNullifiers[nullifier.toString()];
-      const note = deployed
-        ? (await pxe.getNotes({ siloedNullifier: nullifier, contractAddress: deployed }))[0]
-        : undefined;
-      const initialized = initNullifiers[nullifier.toString()];
-      const registered = classNullifiers[nullifier.toString()];
-      if (nullifier.toBuffer().equals(txHash.toBuffer())) {
-        log(`  Transaction hash nullifier ${nullifier.toShortString()}`);
-      } else if (note) {
-        inspectNote(note, artifactMap, log, `Nullifier ${nullifier.toShortString()} for note`);
-      } else if (deployed) {
-        log(
-          `  Contract ${toFriendlyAddress(deployed, artifactMap)} deployed via nullifier ${nullifier.toShortString()}`,
-        );
-      } else if (initialized) {
-        log(
-          `  Contract ${toFriendlyAddress(
-            initialized,
-            artifactMap,
-          )} initialized via nullifier ${nullifier.toShortString()}`,
-        );
-      } else if (registered) {
-        log(`  Class ${registered} registered via nullifier ${nullifier.toShortString()}`);
-      } else {
-        log(`  Unknown nullifier ${nullifier.toString()}`);
-      }
+  // Created nullifiers
+  const nullifiers = effects.nullifiers;
+  if (nullifiers.length > 0) {
+    log(' Created nullifiers:');
+    for (const nullifier of nullifiers) {
+      log(`  Nullifier: ${nullifier.toShortString()}`);
     }
   }
 
@@ -133,69 +106,3 @@ export async function inspectTx(
     }
   }
 }
-
-function inspectNote(note: ExtendedNote, artifactMap: ArtifactMap, log: LogFn, text = 'Note') {
-  const artifact = artifactMap[note.contractAddress.toString()];
-  const contract = artifact?.name ?? note.contractAddress.toString();
-  log(`  ${text} at ${contract}`);
-  log(`    Recipient: ${toFriendlyAddress(note.recipient, artifactMap)}`);
-  for (const field of note.note.items) {
-    log(`    ${field.toString()}`);
-  }
-}
-
-function toFriendlyAddress(address: AztecAddress, artifactMap: ArtifactMap) {
-  const artifact = artifactMap[address.toString()];
-  if (!artifact) {
-    return address.toString();
-  }
-
-  return `${artifact.name}<${address.toString()}>`;
-}
-
-async function getKnownNullifiers(pxe: PXE, artifactMap: ArtifactMap) {
-  const knownContracts = await pxe.getContracts();
-  const deployerAddress = ProtocolContractAddress.ContractInstanceRegistry;
-  const classRegistryAddress = ProtocolContractAddress.ContractClassRegistry;
-  const initNullifiers: Record<string, AztecAddress> = {};
-  const deployNullifiers: Record<string, AztecAddress> = {};
-  const classNullifiers: Record<string, string> = {};
-  for (const contract of knownContracts) {
-    initNullifiers[(await siloNullifier(contract, contract.toField())).toString()] = contract;
-    deployNullifiers[(await siloNullifier(deployerAddress, contract.toField())).toString()] = contract;
-  }
-  for (const artifact of Object.values(artifactMap)) {
-    classNullifiers[(await siloNullifier(classRegistryAddress, artifact.classId)).toString()] =
-      `${artifact.name}Class<${artifact.classId}>`;
-  }
-  return { initNullifiers, deployNullifiers, classNullifiers };
-}
-
-type ArtifactMap = Record<string, ContractArtifactWithClassId>;
-type ContractArtifactWithClassId = ContractArtifact & { classId: Fr };
-async function getKnownArtifacts(pxe: PXE): Promise<ArtifactMap> {
-  const knownContractAddresses = await pxe.getContracts();
-  const knownContracts = (
-    await Promise.all(knownContractAddresses.map(contractAddress => pxe.getContractMetadata(contractAddress)))
-  ).map(contractMetadata => contractMetadata.contractInstance);
-  const classIds = [...new Set(knownContracts.map(contract => contract?.currentContractClassId))];
-  const knownArtifacts = (
-    await Promise.all(classIds.map(classId => (classId ? pxe.getContractClassMetadata(classId) : undefined)))
-  ).map(contractClassMetadata =>
-    contractClassMetadata
-      ? { ...contractClassMetadata.artifact, classId: contractClassMetadata.contractClass?.id }
-      : undefined,
-  );
-  const map: Record<string, ContractArtifactWithClassId> = {};
-  for (const instance of knownContracts) {
-    if (instance) {
-      const artifact = knownArtifacts.find(a =>
-        a?.classId?.equals(instance.currentContractClassId),
-      ) as ContractArtifactWithClassId;
-      if (artifact) {
-        map[instance.address.toString()] = artifact;
-      }
-    }
-  }
-  return map;
-}

package/src/utils/setup_contracts.ts

@@ -1,17 +1,7 @@
-import {
-  AztecAddress,
-  DefaultWaitOpts,
-  Fr,
-  type PXE,
-  SignerlessWallet,
-  SponsoredFeePaymentMethod,
-  type WaitForProvenOpts,
-  getContractInstanceFromInstantiationParams,
-  waitForProven,
-} from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
 import { SPONSORED_FPC_SALT } from '@aztec/constants';
-import { DefaultMultiCallEntrypoint } from '@aztec/entrypoints/multicall';
-import type { LogFn } from '@aztec/foundation/log';
 
 async function getSponsoredFPCContract() {
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -20,39 +10,10 @@ async function getSponsoredFPCContract() {
   return SponsoredFPCContract;
 }
 
-export async function getSponsoredFPCAddress() {
+export async function getSponsoredFPCAddress(): Promise<AztecAddress> {
   const SponsoredFPCContract = await getSponsoredFPCContract();
   const sponsoredFPCInstance = await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
     salt: new Fr(SPONSORED_FPC_SALT),
   });
   return sponsoredFPCInstance.address;
 }
-
-export async function setupSponsoredFPC(
-  pxe: PXE,
-  log: LogFn,
-  waitOpts = DefaultWaitOpts,
-  waitForProvenOptions?: WaitForProvenOpts,
-) {
-  const SponsoredFPCContract = await getSponsoredFPCContract();
-  const address = await getSponsoredFPCAddress();
-  const paymentMethod = new SponsoredFeePaymentMethod(address);
-  const { l1ChainId: chainId, rollupVersion } = await pxe.getNodeInfo();
-
-  const deployer = new SignerlessWallet(pxe, new DefaultMultiCallEntrypoint(chainId, rollupVersion));
-
-  const deployTx = SponsoredFPCContract.deploy(deployer).send({
-    from: AztecAddress.ZERO,
-    contractAddressSalt: new Fr(SPONSORED_FPC_SALT),
-    universalDeploy: true,
-    fee: { paymentMethod },
-  });
-
-  const deployed = await deployTx.deployed(waitOpts);
-
-  if (waitForProvenOptions !== undefined) {
-    await waitForProven(pxe, await deployTx.getReceipt(), waitForProvenOptions);
-  }
-
-  log(`SponsoredFPC: ${deployed.address}`);
-}

package/dest/cmds/devnet/bootstrap_network.d.ts

@@ -1,3 +0,0 @@
-import type { LogFn, Logger } from '@aztec/foundation/log';
-export declare function bootstrapNetwork(pxeUrl: string, l1Urls: string[], l1ChainId: string, l1PrivateKey: `0x${string}` | undefined, l1Mnemonic: string, addressIndex: number, json: boolean, log: LogFn, debugLog: Logger): Promise<void>;
-//# sourceMappingURL=bootstrap_network.d.ts.map

package/dest/cmds/devnet/bootstrap_network.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bootstrap_network.d.ts","sourceRoot":"","sources":["../../../src/cmds/devnet/bootstrap_network.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAqB3D,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EAAE,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,EACvC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,KAAK,EACV,QAAQ,EAAE,MAAM,iBAkFjB"}