@aztec/cli 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/src/utils/aztec.ts

@@ -1,125 +1,102 @@
-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 { LogFn, Logger } from '@aztec/foundation/log';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  FunctionType,
+  getAllFunctionAbis,
+  loadContractArtifact,
+} from '@aztec/aztec.js/abi';
+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/curves/bn254';
+import { type LogFn, createLogger } 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 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.
  * @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.`);
   }
   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: EthAddress[],
-  genesisArchiveRoot: Fr,
-  genesisBlockHash: Fr,
-  acceleratedTestDeployments: boolean,
-  config: L1ContractsConfig,
-  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(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}` as `0x${string}`);
-  const chain = createEthereumChain(rpcUrls, chainId);
-
-  const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
-
-  return await deployL1Contracts(
-    chain.rpcUrls,
-    account,
-    chain.chainInfo,
-    debugLogger,
-    {
-      l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-      genesisArchiveRoot,
-      genesisBlockHash,
-      salt,
-      initialValidators,
-      acceleratedTestDeployments,
-      ...config,
-    },
-    config,
-  );
-}
-
 export async function deployNewRollupContracts(
   registryAddress: EthAddress,
   rpcUrls: string[],
-  chainId: number,
   privateKey: string | undefined,
+  chainId: number,
   mnemonic: string,
   mnemonicIndex: number,
-  salt: number | undefined,
-  initialValidators: EthAddress[],
+  initialValidators: Operator[],
   genesisArchiveRoot: Fr,
-  genesisBlockHash: Fr,
+  feeJuicePortalInitialBalance: bigint,
   config: L1ContractsConfig,
-  logger: Logger,
-): Promise<{ payloadAddress: EthAddress; rollup: RollupContract }> {
-  const { createEthereumChain, deployRollupAndPeriphery, createL1Clients } = await import('@aztec/ethereum');
+  realVerifier: boolean,
+): Promise<{ rollup: RollupContract; slashFactoryAddress: EthAddress }> {
+  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(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}` as `0x${string}`);
-  const chain = createEthereumChain(rpcUrls, chainId);
-  const clients = createL1Clients(rpcUrls, account, chain.chainInfo, 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.
+    const aminAddressString = '0x3b218d0F26d15B36C715cB06c949210a0d630637';
+    const amin = EthAddress.fromString(aminAddressString);
+
+    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 { payloadAddress, rollup } = await deployRollupAndPeriphery(
-    clients,
+  const { rollup, slashFactoryAddress } = await deployRollupForUpgrade(
+    privateKey as Hex,
+    rpcUrls[0],
+    chainId,
+    registryAddress,
     {
-      salt,
       vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-      l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
+      protocolContractsHash,
       genesisArchiveRoot,
-      genesisBlockHash,
       initialValidators,
+      feeJuicePortalInitialBalance,
+      realVerifier,
       ...config,
     },
-    registryAddress,
-    logger,
-    config,
   );
 
-  return { payloadAddress, rollup };
+  return { rollup, slashFactoryAddress: EthAddress.fromString(slashFactoryAddress!) };
 }
 
 /**
@@ -178,7 +155,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 +167,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 +175,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 +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';
@@ -22,21 +22,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')
@@ -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;
 }
 
@@ -287,7 +324,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 +338,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 +352,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 +385,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

@@ -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';
 
 /**
@@ -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,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, 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: BlockNumber,
+  log: LogFn,
+  opts: { showTxs?: boolean } = {},
+) {
+  const block = await aztecNode.getBlock(blockNumber);
   if (!block) {
     log(`No block found for block number ${blockNumber}`);
     return;
@@ -18,16 +20,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,19 +36,18 @@ 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()})` : ''}`);
+  log(` Status: ${receipt.status}`);
+  if (receipt.executionResult) {
+    log(` Execution result: ${receipt.executionResult}`);
+  }
   if (receipt.error) {
     log(` Error: ${receipt.error}`);
   }
@@ -57,7 +57,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 +87,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 +110,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