@aztec/cli 0.0.0-test.1 → 0.0.1-fake-c83136db25

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,15 +1,25 @@
-import type { EthAddress, PXE } from '@aztec/aztec.js';
-import { type ContractArtifact, type FunctionArtifact, loadContractArtifact } from '@aztec/aztec.js/abi';
-import type { DeployL1ContractsReturnType, L1ContractsConfig, RollupContract } from '@aztec/ethereum';
-import type { Fr } from '@aztec/foundation/fields';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  FunctionType,
+  getAllFunctionAbis,
+  loadContractArtifact,
+} from '@aztec/aztec.js/abi';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import {
+  type DeployL1ContractsReturnType,
+  type L1ContractsConfig,
+  type Operator,
+  RollupContract,
+} from '@aztec/ethereum';
+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 { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { FunctionType } from '@aztec/stdlib/abi';
+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';
 
@@ -19,8 +29,8 @@ import { encodeArgs } from './encoding.js';
  * @param fnName - Function name to be found.
  * @returns The function's ABI.
  */
-export function getFunctionArtifact(artifact: ContractArtifact, fnName: string): FunctionArtifact {
-  const fn = artifact.functions.find(({ name }) => name === fnName);
+export function getFunctionAbi(artifact: ContractArtifact, fnName: string): FunctionAbi {
+  const fn = getAllFunctionAbis(artifact).find(({ name }) => name === fnName);
   if (!fn) {
     throw Error(`Function ${fnName} not found in contract ABI.`);
   }
@@ -41,11 +51,14 @@ export async function deployAztecContracts(
   mnemonic: string,
   mnemonicIndex: number,
   salt: number | undefined,
-  initialValidators: EthAddress[],
+  initialValidators: Operator[],
   genesisArchiveRoot: Fr,
-  genesisBlockHash: Fr,
+  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');
@@ -53,29 +66,33 @@ export async function deployAztecContracts(
 
   const account = !privateKey
     ? mnemonicToAccount(mnemonic!, { addressIndex: mnemonicIndex })
-    : privateKeyToAccount(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}` as `0x${string}`);
+    : privateKeyToAccount(addLeadingHex(privateKey));
   const chain = createEthereumChain(rpcUrls, chainId);
 
   const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
 
-  return await deployL1Contracts(
+  const result = await deployL1Contracts(
     chain.rpcUrls,
     account,
     chain.chainInfo,
     debugLogger,
     {
-      l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
       vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
+      protocolContractsHash,
       genesisArchiveRoot,
-      genesisBlockHash,
       salt,
       initialValidators,
       acceleratedTestDeployments,
+      feeJuicePortalInitialBalance,
+      realVerifier,
+      existingTokenAddress: existingToken,
       ...config,
     },
     config,
+    createVerificationJson,
   );
+
+  return result;
 }
 
 export async function deployNewRollupContracts(
@@ -86,40 +103,59 @@ export async function deployNewRollupContracts(
   mnemonic: string,
   mnemonicIndex: number,
   salt: number | undefined,
-  initialValidators: EthAddress[],
+  initialValidators: Operator[],
   genesisArchiveRoot: Fr,
-  genesisBlockHash: Fr,
+  feeJuicePortalInitialBalance: bigint,
   config: L1ContractsConfig,
+  realVerifier: boolean,
+  createVerificationJson: string | false,
   logger: Logger,
-): Promise<{ payloadAddress: EthAddress; rollup: RollupContract }> {
-  const { createEthereumChain, deployRollupAndPeriphery, createL1Clients } = await import('@aztec/ethereum');
+): Promise<{ rollup: RollupContract; slashFactoryAddress: EthAddress }> {
+  const { createEthereumChain, deployRollupForUpgrade, createExtendedL1Client } = await import('@aztec/ethereum');
   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(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}` as `0x${string}`);
+    : privateKeyToAccount(addLeadingHex(privateKey));
   const chain = createEthereumChain(rpcUrls, chainId);
-  const clients = createL1Clients(rpcUrls, account, chain.chainInfo, mnemonicIndex);
+  const client = createExtendedL1Client(rpcUrls, account, chain.chainInfo, undefined, mnemonicIndex);
+
+  if (!initialValidators || initialValidators.length === 0) {
+    // initialize the new rollup with Amin's validator address.
+    const aminAddressString = '0x3b218d0F26d15B36C715cB06c949210a0d630637';
+    const amin = EthAddress.fromString(aminAddressString);
 
-  const { payloadAddress, rollup } = await deployRollupAndPeriphery(
-    clients,
+    initialValidators = [
+      {
+        attester: amin,
+        withdrawer: amin,
+        // No secrets here. The actual keys are not currently used.
+        bn254SecretKey: new SecretValue(Fr.fromHexString(aminAddressString).toBigInt()),
+      },
+    ];
+    logger.info('Initializing new rollup with old attesters', { initialValidators });
+  }
+
+  const { rollup, slashFactoryAddress } = await deployRollupForUpgrade(
+    client,
     {
       salt,
       vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-      l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
+      protocolContractsHash,
       genesisArchiveRoot,
-      genesisBlockHash,
       initialValidators,
+      feeJuicePortalInitialBalance,
+      realVerifier,
       ...config,
     },
     registryAddress,
     logger,
     config,
+    createVerificationJson,
   );
 
-  return { payloadAddress, rollup };
+  return { rollup, slashFactoryAddress };
 }
 
 /**
@@ -178,7 +214,7 @@ export async function getContractArtifact(fileDir: string, log: LogFn) {
  */
 export async function prepTx(contractFile: string, functionName: string, _functionArgs: string[], log: LogFn) {
   const contractArtifact = await getContractArtifact(contractFile, log);
-  const functionArtifact = getFunctionArtifact(contractArtifact, functionName);
+  const functionArtifact = getFunctionAbi(contractArtifact, functionName);
   const functionArgs = encodeArgs(_functionArgs, functionArtifact.parameters);
   const isPrivate = functionArtifact.functionType === FunctionType.PRIVATE;
 
@@ -190,7 +226,7 @@ export async function prepTx(contractFile: string, functionName: string, _functi
  * @param hex - A hex string
  * @returns A new string with leading 0x removed
  */
-export const stripLeadingHex = (hex: string) => {
+export const stripLeadingHex = (hex: string): string => {
   if (hex.length > 2 && hex.startsWith('0x')) {
     return hex.substring(2);
   }
@@ -198,6 +234,18 @@ export const stripLeadingHex = (hex: string) => {
 };
 
 /**
+ * Adds a leading 0x to a hex string. If a leading 0x is already present the string is returned unchanged.
+ * @param hex - A hex string
+ * @returns A new string with leading 0x added
+ */
+export const addLeadingHex = (hex: string): `0x${string}` => {
+  if (hex.length > 2 && hex.startsWith('0x')) {
+    return hex as `0x${string}`;
+  }
+  return `0x${hex}`;
+};
+
+/*
  * Pretty prints Nargo.toml contents to a string
  * @param config - Nargo.toml contents
  * @returns The Nargo.toml contents as a string
@@ -213,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';
@@ -22,21 +21,20 @@ export const getLocalhost = () =>
     .catch(() => 'localhost');
 
 export const LOCALHOST = await getLocalhost();
-export const { ETHEREUM_HOSTS = `http://${LOCALHOST}:8545`, PRIVATE_KEY, API_KEY, CLI_VERSION } = process.env;
+export const { ETHEREUM_HOSTS = `http://${LOCALHOST}:8545`, PRIVATE_KEY, MNEMONIC, API_KEY, CLI_VERSION } = process.env;
 
 export function addOptions(program: Command, options: Option[]) {
   options.forEach(option => program.addOption(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')
@@ -287,7 +285,7 @@ export function parsePublicKey(publicKey: string): PublicKeys | undefined {
   }
   try {
     return PublicKeys.fromString(publicKey);
-  } catch (err) {
+  } catch {
     throw new InvalidArgumentError(`Invalid public key: ${publicKey}`);
   }
 }
@@ -301,7 +299,7 @@ export function parsePublicKey(publicKey: string): PublicKeys | undefined {
 export function parsePartialAddress(address: string): Fr {
   try {
     return Fr.fromHexString(address);
-  } catch (err) {
+  } catch {
     throw new InvalidArgumentError(`Invalid partial address: ${address}`);
   }
 }
@@ -315,7 +313,7 @@ export function parsePartialAddress(address: string): Fr {
 export function parseSecretKey(secretKey: string): Fr {
   try {
     return Fr.fromHexString(secretKey);
-  } catch (err) {
+  } catch {
     throw new InvalidArgumentError(`Invalid encryption secret key: ${secretKey}`);
   }
 }
@@ -348,7 +346,7 @@ export function parseField(field: string): Fr {
     }
 
     return new Fr(BigInt(field));
-  } catch (err) {
+  } catch {
     throw new InvalidArgumentError(`Invalid field: ${field}`);
   }
 }

package/src/utils/encoding.ts

@@ -35,7 +35,7 @@ function encodeArg(arg: string, abiType: AbiType, name: string): any {
     let res: bigint;
     try {
       res = BigInt(arg);
-    } catch (err) {
+    } catch {
       throw new Error(
         `Invalid value passed for ${name}. Could not parse ${arg} as a${kind === 'integer' ? 'n' : ''} ${kind}.`,
       );

package/src/utils/github.ts

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

package/src/utils/index.ts

@@ -2,3 +2,4 @@ export * from './commands.js';
 export * from './aztec.js';
 export * from './encoding.js';
 export * from './github.js';
+export * from './setup_contracts.js';

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, NoteStatus } 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;
@@ -18,16 +19,15 @@ export async function inspectBlock(pxe: PXE, blockNumber: number, log: LogFn, op
   log(` Total fees: ${block.header.totalFees.toBigInt()}`);
   log(` Total mana used: ${block.header.totalManaUsed.toBigInt()}`);
   log(
-    ` Fee per gas unit: DA=${block.header.globalVariables.gasFees.feePerDaGas.toBigInt()} L2=${block.header.globalVariables.gasFees.feePerL2Gas.toBigInt()}`,
+    ` Fee per gas unit: DA=${block.header.globalVariables.gasFees.feePerDaGas} L2=${block.header.globalVariables.gasFees.feePerL2Gas}`,
   );
   log(` Coinbase: ${block.header.globalVariables.coinbase}`);
   log(` Fee recipient: ${block.header.globalVariables.feeRecipient}`);
-  log(` Timestamp: ${new Date(block.header.globalVariables.timestamp.toNumber() * 500)}`);
+  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,16 +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, getNotes] = await Promise.all([
-    pxe.getTxReceipt(txHash),
-    pxe.getTxEffect(txHash),
-    pxe.getNotes({ txHash, status: NoteStatus.ACTIVE_OR_NULLIFIED }),
-  ]);
+  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()})` : ''}`);
@@ -57,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()})`);
@@ -88,45 +83,18 @@ export async function inspectTx(
   const notes = effects.noteHashes;
   if (notes.length > 0) {
     log(' Created notes:');
-    log(`  Total: ${notes.length}. Found: ${getNotes.length}.`);
-    if (getNotes.length) {
-      log('  Found notes:');
-      for (const note of getNotes) {
-        inspectNote(note, artifactMap, log);
-      }
+    log(`  Total: ${notes.length}`);
+    for (const note of notes) {
+      log(`  Note hash: ${note.toShortString()}`);
     }
   }
 
-  // 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 [note] = await pxe.getNotes({ siloedNullifier: nullifier });
-      const deployed = deployNullifiers[nullifier.toString()];
-      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()}`);
     }
   }
 
@@ -138,71 +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();
-  const type = artifact?.notes[note.noteTypeId.toString()]?.typ ?? note.noteTypeId.toField().toShortString();
-  log(`  ${text} type ${type} at ${contract}`);
-  log(`    Owner: ${toFriendlyAddress(note.owner, 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.ContractInstanceDeployer;
-  const registererAddress = ProtocolContractAddress.ContractClassRegisterer;
-  const initNullifiers: Record<string, AztecAddress> = {};
-  const deployNullifiers: Record<string, AztecAddress> = {};
-  const classNullifiers: Record<string, string> = {};
-  for (const contract of knownContracts) {
-    initNullifiers[siloNullifier(contract, contract.toField()).toString()] = contract;
-    deployNullifiers[siloNullifier(deployerAddress, contract.toField()).toString()] = contract;
-  }
-  for (const artifact of Object.values(artifactMap)) {
-    classNullifiers[
-      siloNullifier(registererAddress, 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

@@ -0,0 +1,19 @@
+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';
+
+async function getSponsoredFPCContract() {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { SponsoredFPCContract } = await import('@aztec/noir-contracts.js/SponsoredFPC');
+  return SponsoredFPCContract;
+}
+
+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;
+}

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":"AAqBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAiB3D,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,iBA4EjB"}