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

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,140 @@
+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());
+  }
+}

package/src/utils/aztec.ts

@@ -1,4 +1,3 @@
-import { EthAddress, type PXE } from '@aztec/aztec.js';
 import {
   type ContractArtifact,
   type FunctionAbi,
@@ -6,21 +5,18 @@ 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 { DeployL1ContractsReturnType, Operator } from '@aztec/ethereum/deploy-l1-contracts';
 import { SecretValue } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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,11 +53,13 @@ export async function deployAztecContracts(
   feeJuicePortalInitialBalance: bigint,
   acceleratedTestDeployments: boolean,
   config: L1ContractsConfig,
+  existingToken: EthAddress | undefined,
   realVerifier: boolean,
   createVerificationJson: string | false,
   debugLogger: Logger,
 ): Promise<DeployL1ContractsReturnType> {
-  const { createEthereumChain, deployL1Contracts } = await import('@aztec/ethereum');
+  const { createEthereumChain } = await import('@aztec/ethereum/chain');
+  const { deployL1Contracts } = await import('@aztec/ethereum/deploy-l1-contracts');
   const { mnemonicToAccount, privateKeyToAccount } = await import('viem/accounts');
 
   const account = !privateKey
@@ -78,13 +76,14 @@ export async function deployAztecContracts(
     debugLogger,
     {
       vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
+      protocolContractsHash,
       genesisArchiveRoot,
       salt,
       initialValidators,
       acceleratedTestDeployments,
       feeJuicePortalInitialBalance,
       realVerifier,
+      existingTokenAddress: existingToken,
       ...config,
     },
     config,
@@ -107,9 +106,12 @@ 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');
+  const { createEthereumChain } = await import('@aztec/ethereum/chain');
+  const { createExtendedL1Client } = await import('@aztec/ethereum/client');
+  const { deployRollupForUpgrade } = await import('@aztec/ethereum/deploy-l1-contracts');
   const { mnemonicToAccount, privateKeyToAccount } = await import('viem/accounts');
   const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
 
@@ -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')
@@ -114,6 +112,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 +194,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 +208,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 +262,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 +274,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';
 
 /**

package/src/utils/inspect.ts

@@ -1,13 +1,15 @@
-import type { AztecAddress, ContractArtifact, Fr } from '@aztec/aztec.js';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 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: BlockNumber,
+  log: LogFn,
+  opts: { showTxs?: boolean } = {},
+) {
+  const block = await aztecNode.getBlock(blockNumber);
   if (!block) {
     log(`No block found for block number ${blockNumber}`);
     return;
@@ -25,9 +27,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 +36,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 +54,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 +90,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 +107,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"}