@aztec-labs/aztec 6.0.0-nightly.20260829

package/src/cli/cmds/utils/warn_if_aztec_version_mismatch.ts

@@ -0,0 +1,75 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { DEV_VERSION, getPackageVersion } from '@aztec-labs/stdlib/update-checker';
+import TOML from '@iarna/toml';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+import { collectCrateDirs } from './collect_crate_dirs.js';
+
+/** Returns true if the given git URL points to the AztecProtocol/aztec-nr repository. */
+function isAztecNrGitUrl(gitUrl: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(gitUrl);
+  } catch {
+    return false;
+  }
+  if (url.hostname !== 'github.com') {
+    return false;
+  }
+  const repoPath = url.pathname
+    .replace(/^\//, '')
+    .replace(/\.git$/, '')
+    .replace(/\/$/, '');
+  return repoPath === 'AztecProtocol/aztec-nr';
+}
+
+/** Warns if any aztec-nr git dependency in a crate's Nargo.toml has a tag that doesn't match the CLI version. */
+export async function warnIfAztecVersionMismatch(log: LogFn, cliVersion?: string): Promise<void> {
+  const version = cliVersion ?? getPackageVersion();
+  if (version === DEV_VERSION) {
+    return;
+  }
+
+  const expectedTag = `v${version}`;
+  const mismatches: { file: string; depName: string; tag: string }[] = [];
+
+  const crateDirs = await collectCrateDirs('.', { skipGitDeps: true });
+
+  for (const dir of crateDirs) {
+    const tomlPath = join(dir, 'Nargo.toml');
+    let content: string;
+    try {
+      content = await readFile(tomlPath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const parsed = TOML.parse(content) as Record<string, any>;
+    const deps = (parsed.dependencies as Record<string, any>) ?? {};
+
+    for (const [depName, dep] of Object.entries(deps)) {
+      // Skip non-object deps (e.g. malformed entries) and anything that isn't a tagged git dep.
+      if (!dep || typeof dep !== 'object' || typeof dep.git !== 'string' || typeof dep.tag !== 'string') {
+        continue;
+      }
+      // Only flag deps that are sourced from the aztec-nr repo.
+      if (!isAztecNrGitUrl(dep.git)) {
+        continue;
+      }
+      if (dep.tag !== expectedTag) {
+        mismatches.push({ file: tomlPath, depName, tag: dep.tag });
+      }
+    }
+  }
+
+  if (mismatches.length > 0) {
+    const details = mismatches.map(m => `  ${m.file} — ${m.depName} (${m.tag})`).join('\n');
+    log(
+      `WARNING: Aztec dependency version mismatch detected.\n` +
+        `The following aztec-nr dependencies do not match the CLI version (${expectedTag}):\n` +
+        `${details}\n\n` +
+        `See https://docs.aztec.network/errors/9 for how to update your dependencies.`,
+    );
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1 @@
+export * from './cli.js';

package/src/cli/preload_crs.ts

@@ -0,0 +1,7 @@
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+
+import { preloadCrsDataForServerSideProving } from './util.js';
+
+export async function preloadCrs(_options: any, userLog: LogFn, _debugLogger: Logger) {
+  await preloadCrsDataForServerSideProving({ realProofs: true }, userLog);
+}

package/src/cli/util.ts

@@ -0,0 +1,310 @@
+import type { AztecNodeConfig } from '@aztec-labs/aztec-node';
+import type { AccountManager } from '@aztec-labs/aztec.js/wallet';
+import type { ConfigMappingsType } from '@aztec-labs/foundation/config';
+import { jsonStringify } from '@aztec-labs/foundation/json-rpc';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { ProverConfig } from '@aztec-labs/stdlib/interfaces/server';
+import type { EmbeddedWallet } from '@aztec-labs/wallets/embedded';
+import chalk from 'chalk';
+import type { Command } from 'commander';
+
+import { type AztecStartOption, aztecStartOptions } from './aztec_start_options.js';
+
+export const enum ExitCode {
+  SUCCESS = 0,
+  ERROR = 1,
+  ROLLUP_UPGRADE = 78, // EX_CONFIG from FreeBSD (https://man.freebsd.org/cgi/man.cgi?query=sysexits)
+  VERSION_UPGRADE = 79, // prev + 1 because there's nothing better
+  // 128 + int(SIGNAL)
+  SIGHUP = 129,
+  SIGINT = 130,
+  SIGQUIT = 131,
+  SIGTERM = 143,
+}
+
+let shutdownPromise: Promise<never> | undefined;
+export function shutdown(logFn: LogFn, exitCode: ExitCode, cb?: Array<() => Promise<void>>): Promise<never> {
+  if (shutdownPromise) {
+    logFn('Already shutting down.');
+    return shutdownPromise;
+  }
+
+  logFn('Shutting down...', { exitCode });
+  if (cb) {
+    shutdownPromise = Promise.allSettled(cb.map(fn => fn())).then(() => process.exit(exitCode));
+  } else {
+    // synchronously shuts down the process
+    // no need to set shutdownPromise on this branch of the if statement because no more code will be executed
+    process.exit(exitCode);
+  }
+
+  return shutdownPromise;
+}
+
+export function isShuttingDown(): boolean {
+  return shutdownPromise !== undefined;
+}
+
+/**
+ * Stops the node's subsystems (via the registered signal handlers) without exiting the process, leaving
+ * the HTTP health server listening so K8s liveness/readiness probes keep passing. Unlike {@link shutdown}
+ * this deliberately does not latch `shutdownPromise` or call `process.exit`; instead it re-arms
+ * SIGTERM/SIGINT so a later K8s pod deletion still terminates the wound-down pod with a clean exit.
+ */
+export async function softShutdown(logFn: LogFn, signalHandlers: Array<() => Promise<void>>): Promise<void> {
+  logFn('Canonical rollup upgrade detected: stopping subsystems, health server stays up.', {
+    exitCode: ExitCode.ROLLUP_UPGRADE,
+  });
+  await Promise.allSettled(signalHandlers.map(fn => fn()));
+  for (const sig of ['SIGTERM', 'SIGINT'] as const) {
+    process.removeAllListeners(sig);
+    process.once(sig, () => process.exit(ExitCode.ROLLUP_UPGRADE));
+  }
+  logFn('Subsystems stopped due to rollup upgrade. Health server remains active.');
+}
+
+export const installSignalHandlers = (logFn: LogFn, cb?: Array<() => Promise<void>>) => {
+  const signals = [
+    ['SIGINT', ExitCode.SIGINT],
+    ['SIGTERM', ExitCode.SIGTERM],
+    ['SIGHUP', ExitCode.SIGHUP],
+    ['SIQUIT', ExitCode.SIGQUIT],
+  ] as const;
+
+  for (const [signal, exitCode] of signals) {
+    process.removeAllListeners(signal);
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    process.once(signal, () => shutdown(logFn, exitCode, cb));
+  }
+};
+
+/**
+ * Creates logs for the initial accounts
+ * @param accounts - The initial accounts
+ * @param wallet - A EmbeddedWallet instance to get the registered accounts
+ * @returns A string array containing the initial accounts details
+ */
+export async function createAccountLogs(accountManagers: AccountManager[], wallet: EmbeddedWallet) {
+  const registeredAccounts = await wallet.getAccounts();
+  const accountLogStrings = [`Initial Accounts:\n\n`];
+  for (const accountManager of accountManagers) {
+    const account = await accountManager.getAccount();
+    const completeAddress = account.getCompleteAddress();
+    if (registeredAccounts.find(a => a.item.equals(completeAddress.address))) {
+      accountLogStrings.push(` Address: ${completeAddress.address.toString()}\n`);
+      accountLogStrings.push(` Partial Address: ${completeAddress.partialAddress.toString()}\n`);
+      accountLogStrings.push(` Secret Key: ${accountManager.getSecretKey().toString()}\n`);
+      accountLogStrings.push(` Master nullifier public key hash: ${completeAddress.publicKeys.npkMHash.toString()}\n`);
+      accountLogStrings.push(` Master incoming viewing public key: ${completeAddress.publicKeys.ivpkM.toString()}\n\n`);
+      accountLogStrings.push(
+        ` Master outgoing viewing public key hash: ${completeAddress.publicKeys.ovpkMHash.toString()}\n\n`,
+      );
+      accountLogStrings.push(` Master tagging public key hash: ${completeAddress.publicKeys.tpkMHash.toString()}\n\n`);
+      accountLogStrings.push(
+        ` Master message-signing public key hash: ${completeAddress.publicKeys.mspkMHash.toString()}\n\n`,
+      );
+      accountLogStrings.push(
+        ` Master fallback public key hash: ${completeAddress.publicKeys.fbpkMHash.toString()}\n\n`,
+      );
+    }
+  }
+  return accountLogStrings;
+}
+
+export function getMaxLengths(sections: { [key: string]: AztecStartOption[] }): [number, number] {
+  let maxFlagLength = 0;
+  let maxDefaultLength = 0;
+
+  Object.values(sections).forEach(options => {
+    options.forEach(option => {
+      if (option.flag.length > maxFlagLength) {
+        maxFlagLength = option.flag.length;
+      }
+      const defaultLength = option.defaultValue ? option.defaultValue.length : 0;
+      if (defaultLength > maxDefaultLength) {
+        maxDefaultLength = defaultLength;
+      }
+    });
+  });
+
+  return [maxFlagLength + 1, maxDefaultLength + 1];
+}
+
+export function formatHelpLine(
+  option: string,
+  defaultValue: string,
+  envVar: string,
+  maxOptionLength: number,
+  maxDefaultLength: number,
+): string {
+  const paddedOption = option.padEnd(maxOptionLength + 2, ' ');
+  const paddedDefault = defaultValue.padEnd(maxDefaultLength + 2, ' ');
+
+  return `${chalk.cyan(paddedOption)}${chalk.yellow(paddedDefault)}${chalk.green(envVar)}`;
+}
+
+const getDefaultOrEnvValue = (opt: AztecStartOption) => {
+  let val;
+
+  // if the option is set in the environment, use that
+  if (opt.env) {
+    val = process.env[opt.env];
+  }
+
+  // if we have fallback env vars, check those
+  if (!val && opt.fallback && opt.fallback.length > 0) {
+    for (const fallback of opt.fallback) {
+      val = process.env[fallback];
+      if (val) {
+        break;
+      }
+    }
+  }
+
+  // if we have a value, optionally parse it and return
+  if (val) {
+    if (opt.parseVal) {
+      return opt.parseVal(val);
+    }
+    return val;
+  } else if (opt.defaultValue !== undefined) {
+    return opt.defaultValue;
+  }
+  return undefined;
+};
+
+// Function to add options dynamically
+export const addOptions = (cmd: Command, options: AztecStartOption[]) => {
+  options.forEach(opt => {
+    cmd.option(
+      opt.flag,
+      `${opt.description} (default: ${opt.defaultValue}) ($${opt.env})`,
+      opt.parseVal ? opt.parseVal : val => val,
+      getDefaultOrEnvValue(opt),
+    );
+  });
+};
+
+export const printAztecStartHelpText = () => {
+  const helpTextLines: string[] = [''];
+  const [maxFlagLength, maxDefaultLength] = getMaxLengths(aztecStartOptions);
+
+  Object.keys(aztecStartOptions).forEach(category => {
+    helpTextLines.push(chalk.bold.blue(`  ${category}`));
+    helpTextLines.push('');
+
+    aztecStartOptions[category].forEach(opt => {
+      const defaultValueText =
+        opt.defaultValue || (Array.isArray(opt.defaultValue) && opt.defaultValue.length > 0)
+          ? `(default: ${opt.printDefault ? opt.printDefault(opt.defaultValue) : opt.defaultValue})`
+          : '';
+      const envVarText = opt.env ? `($${opt.env})` : '';
+      const flagText = `${opt.flag}`;
+
+      const paddedText = formatHelpLine(flagText, defaultValueText, envVarText, maxFlagLength, maxDefaultLength);
+
+      helpTextLines.push(`    ${paddedText}`);
+      helpTextLines.push(`          ${chalk.white(opt.description)}`);
+      helpTextLines.push('');
+    });
+  });
+
+  return helpTextLines.join('\n');
+};
+
+/**
+ * Extracts namespaced options from a key-value map.
+ * @param options - Key-value map of options.
+ * @param namespace - The namespace to extract.
+ * @returns Key-value map of namespaced options.
+ */
+export const extractNamespacedOptions = (options: Record<string, any>, namespace: string) => {
+  const extract = `${namespace}.`;
+  const namespacedOptions: Record<string, any> = {};
+  for (const key in options) {
+    if (key.startsWith(extract)) {
+      namespacedOptions[key.replace(extract, '')] = options[key];
+    }
+  }
+  return namespacedOptions;
+};
+
+/**
+ * Extracts relevant options from a key-value map.
+ * @template T - The type of the relevant options.
+ * @param options - Key-value map of options.
+ * @param mappings - The mappings to extract.
+ * @param namespace - The namespace to extract for.
+ * @returns Key-value map of relevant options.
+ */
+export const extractRelevantOptions = <T>(
+  options: Record<string, any>,
+  mappings: ConfigMappingsType<T>,
+  namespace: string,
+): T => {
+  const relevantOptions: T = {} as T;
+
+  // Iterate over each key in the options
+  Object.keys(options).forEach(optionKey => {
+    const keyParts = optionKey.split('.');
+    const optionNamespace = keyParts.length > 1 ? keyParts[0] : '';
+    const mainKey = keyParts.length > 1 ? keyParts[1] : keyParts[0];
+
+    // Check if the key exists in the mappings
+    if (mainKey in mappings) {
+      // Check for duplicates in the options
+      const duplicates = Object.keys(options).filter(optKey => {
+        const optKeyParts = optKey.split('.');
+        return optKeyParts[1] === mainKey || optKeyParts[0] === mainKey;
+      });
+
+      // If duplicates are found, use the namespace to differentiate
+      if (duplicates.length > 1) {
+        if (namespace === optionNamespace) {
+          relevantOptions[mainKey as keyof T] = options[optionKey];
+        }
+      } else {
+        // If no duplicates, extract the value without considering the namespace
+        relevantOptions[mainKey as keyof T] = options[optionKey];
+      }
+    }
+  });
+
+  return relevantOptions;
+};
+
+/**
+ * Downloads just enough points to be able to verify Chonk proofs.
+ * @param opts - Whether proof are to be verifier
+ * @param log - Logging function
+ */
+export async function preloadCrsDataForVerifying(
+  { realProofs }: Pick<AztecNodeConfig, 'realProofs'>,
+  log: LogFn,
+): Promise<void> {
+  if (realProofs) {
+    const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
+    await Promise.all([Crs.new(2 ** 1, undefined, log), GrumpkinCrs.new(2 ** 16, undefined, log)]);
+  }
+}
+
+/**
+ * Downloads enough points to be able to prove every server-side circuit
+ * @param opts - Whether real proof are to be generated
+ * @param log - Logging function
+ */
+export async function preloadCrsDataForServerSideProving(
+  { realProofs }: Pick<ProverConfig, 'realProofs'>,
+  log: LogFn,
+): Promise<void> {
+  if (realProofs) {
+    const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
+    await Promise.all([Crs.new(2 ** 25, undefined, log), GrumpkinCrs.new(2 ** 18, undefined, log)]);
+  }
+}
+
+export function stringifyConfig(config: object): string {
+  return Object.entries(config)
+    .map(([key, value]) => `${key}=${jsonStringify(value)}`)
+    .join(' ');
+}

package/src/cli/versioning.ts

@@ -0,0 +1,13 @@
+import { getVKTreeRoot } from '@aztec-labs/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import type { ChainConfig } from '@aztec-labs/stdlib/config';
+import { type ComponentsVersions, getComponentsVersionsFromConfig } from '@aztec-labs/stdlib/versioning';
+
+export function getVersions(config?: ChainConfig): Partial<ComponentsVersions> {
+  return config
+    ? getComponentsVersionsFromConfig(config, protocolContractsHash, getVKTreeRoot())
+    : {
+        l2CircuitsVkTreeRoot: getVKTreeRoot().toString(),
+        l2ProtocolContractsHash: protocolContractsHash.toString(),
+      };
+}

package/src/examples/token.ts

@@ -0,0 +1,77 @@
+import { getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import { createAztecNodeClient } from '@aztec-labs/aztec.js/node';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { TokenContract } from '@aztec-labs/noir-contracts.js/Token';
+import { EmbeddedWallet } from '@aztec-labs/wallets/embedded';
+
+const logger = createLogger('example:token');
+
+const nodeUrl = 'http://localhost:8080';
+
+const node = createAztecNodeClient(nodeUrl);
+
+const ALICE_MINT_BALANCE = 333n;
+const TRANSFER_AMOUNT = 33n;
+
+/**
+ * Main function.
+ */
+async function main() {
+  logger.info('Running token contract test on HTTP interface.');
+
+  const wallet = await EmbeddedWallet.create(node);
+
+  // During local network setup we create a few initializerless accounts. Below we add them to our wallet.
+  const [aliceInitialAccountData, bobInitialAccountData] = await getInitialTestAccountsData();
+  await wallet.createSchnorrInitializerlessAccount(
+    aliceInitialAccountData.secret,
+    aliceInitialAccountData.salt,
+    aliceInitialAccountData.signingKey,
+  );
+  await wallet.createSchnorrInitializerlessAccount(
+    bobInitialAccountData.secret,
+    bobInitialAccountData.salt,
+    bobInitialAccountData.signingKey,
+  );
+
+  const alice = aliceInitialAccountData.address;
+  const bob = bobInitialAccountData.address;
+
+  logger.info(`Fetched Alice and Bob accounts: ${alice.toString()}, ${bob.toString()}`);
+
+  logger.info('Deploying Token...');
+  const { contract: token } = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18).send({
+    from: alice,
+  });
+  logger.info('Token deployed');
+
+  // Mint tokens to Alice
+  logger.info(`Minting ${ALICE_MINT_BALANCE} more coins to Alice...`);
+  await token.methods.mint_to_private(alice, ALICE_MINT_BALANCE).send({ from: alice });
+
+  logger.info(`${ALICE_MINT_BALANCE} tokens were successfully minted by Alice and transferred to private`);
+
+  const { result: balanceAfterMint } = await token.methods.balance_of_private(alice).simulate({ from: alice });
+  logger.info(`Tokens successfully minted. New Alice's balance: ${balanceAfterMint}`);
+
+  // We will now transfer tokens from Alice to Bob
+  logger.info(`Transferring ${TRANSFER_AMOUNT} tokens from Alice to Bob...`);
+  await token.methods.transfer(bob, TRANSFER_AMOUNT).send({ from: alice });
+
+  // Check the new balances
+  const { result: aliceBalance } = await token.methods.balance_of_private(alice).simulate({ from: alice });
+  logger.info(`Alice's balance ${aliceBalance}`);
+
+  const { result: bobBalance } = await token.methods.balance_of_private(bob).simulate({ from: bob });
+  logger.info(`Bob's balance ${bobBalance}`);
+}
+
+main()
+  .then(() => {
+    logger.info('Finished running successfully.');
+    process.exit(0);
+  })
+  .catch(err => {
+    logger.error('Error in main fn: ', err);
+    process.exit(1);
+  });

package/src/examples/util.ts

@@ -0,0 +1,42 @@
+import { EthAddress } from '@aztec-labs/aztec.js/addresses';
+import type { ExtendedViemWalletClient } from '@aztec-labs/ethereum/types';
+import { jsonStringify } from '@aztec-labs/foundation/json-rpc';
+import type { Abi, Narrow } from 'abitype';
+import type { Hex } from 'viem';
+
+/**
+ * Helper function to deploy ETH contracts.
+ * @param l1Client - A viem WalletClient extended with public actions.
+ * @param abi - The ETH contract's ABI (as abitype's Abi).
+ * @param bytecode  - The ETH contract's bytecode.
+ * @param args - Constructor arguments for the contract.
+ * @returns The ETH address the contract was deployed to.
+ */
+export async function deployL1Contract(
+  l1Client: ExtendedViemWalletClient,
+  abi: Narrow<Abi | readonly unknown[]>,
+  bytecode: Hex,
+  args: readonly unknown[] = [],
+): Promise<EthAddress> {
+  const hash = await l1Client.deployContract({
+    abi,
+    bytecode,
+    args,
+  });
+
+  const receipt = await l1Client.waitForTransactionReceipt({ hash });
+  const contractAddress = receipt.contractAddress;
+  if (!contractAddress) {
+    throw new Error(`No contract address found in receipt: ${jsonStringify(receipt)}`);
+  }
+
+  return EthAddress.fromString(receipt.contractAddress!);
+}
+
+/**
+ * Sleep for a given number of milliseconds.
+ * @param ms - the number of milliseconds to sleep for
+ */
+export function delay(ms: number): Promise<void> {
+  return new Promise<void>(resolve => setTimeout(resolve, ms));
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export {
+  createLocalNetwork,
+  registerDeployedBananaCoinInWalletAndGetAddress,
+  registerDeployedBananaFPCInWalletAndGetAddress,
+  registerDeployedSponsoredFPCInWalletAndGetAddress,
+} from './local-network/index.js';

package/src/local-network/auth_registry.ts

@@ -0,0 +1,19 @@
+import type { WaitOpts } from '@aztec-labs/aztec.js/contracts';
+import { publishContractClass, publishInstance } from '@aztec-labs/aztec.js/deployment';
+import type { Wallet } from '@aztec-labs/aztec.js/wallet';
+import { AuthRegistryArtifact, getStandardAuthRegistry } from '@aztec-labs/standard-contracts/auth-registry';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+
+export async function publishStandardAuthRegistry(
+  wallet: Wallet,
+  from: AztecAddress,
+  waitOpts?: WaitOpts,
+): Promise<void> {
+  const { instance, contractClass } = await getStandardAuthRegistry();
+  if (!(await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
+    await (await publishContractClass(wallet, AuthRegistryArtifact)).send({ from, wait: waitOpts });
+  }
+  if (!(await wallet.getContractMetadata(instance.address)).isContractPublished) {
+    await publishInstance(wallet, instance).send({ from, wait: waitOpts });
+  }
+}

package/src/local-network/banana_fpc.ts

@@ -0,0 +1,89 @@
+import { type InitialAccountData, getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import type { WaitOpts } from '@aztec-labs/aztec.js/contracts';
+import type { Wallet } from '@aztec-labs/aztec.js/wallet';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { FPCContract } from '@aztec-labs/noir-contracts.js/FPC';
+import { TokenContract } from '@aztec-labs/noir-contracts.js/Token';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import {
+  type ContractInstanceWithAddress,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec-labs/stdlib/contract';
+
+const BANANA_COIN_SALT = new Fr(0);
+const bananaCoinArgs = {
+  name: 'BC',
+  symbol: 'BC',
+  decimal: 18n,
+};
+
+const BANANA_FPC_SALT = new Fr(0);
+
+function getBananaAdmin(initialAccounts: InitialAccountData[]): AztecAddress {
+  return initialAccounts[0]?.address ?? AztecAddress.ZERO;
+}
+
+async function getBananaCoinInstance(initialAccounts: InitialAccountData[]): Promise<ContractInstanceWithAddress> {
+  const admin = getBananaAdmin(initialAccounts);
+  return await getContractInstanceFromInstantiationParams(TokenContract.artifact, {
+    constructorArgs: [admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal],
+    salt: BANANA_COIN_SALT,
+  });
+}
+
+export async function getBananaCoinAddress(initialAccounts: InitialAccountData[]) {
+  return (await getBananaCoinInstance(initialAccounts)).address;
+}
+
+async function getBananaFPCInstance(initialAccounts: InitialAccountData[]): Promise<ContractInstanceWithAddress> {
+  const bananaCoin = await getBananaCoinAddress(initialAccounts);
+  const admin = getBananaAdmin(initialAccounts);
+  return await getContractInstanceFromInstantiationParams(FPCContract.artifact, {
+    constructorArgs: [bananaCoin, admin],
+    salt: BANANA_FPC_SALT,
+  });
+}
+
+export async function getBananaFPCAddress(initialAccounts: InitialAccountData[]) {
+  return (await getBananaFPCInstance(initialAccounts)).address;
+}
+
+export async function setupBananaFPC(
+  initialAccounts: InitialAccountData[],
+  wallet: Wallet,
+  log: LogFn,
+  waitOpts?: WaitOpts,
+) {
+  const bananaCoinAddress = await getBananaCoinAddress(initialAccounts);
+  const admin = getBananaAdmin(initialAccounts);
+  const [{ contract: bananaCoin }, { contract: fpc }] = await Promise.all([
+    TokenContract.deploy(wallet, admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal, {
+      salt: BANANA_COIN_SALT,
+      universalDeploy: true,
+    }).send({ from: admin, wait: waitOpts }),
+    FPCContract.deploy(wallet, bananaCoinAddress, admin, { salt: BANANA_FPC_SALT, universalDeploy: true }).send({
+      from: admin,
+      wait: waitOpts,
+    }),
+  ]);
+
+  log(`BananaCoin: ${bananaCoin.address}`);
+  log(`FPC: ${fpc.address}`);
+}
+
+export async function registerDeployedBananaCoinInWalletAndGetAddress(wallet: Wallet) {
+  const initialAccounts = await getInitialTestAccountsData();
+  const bananaCoin = await getBananaCoinInstance(initialAccounts);
+  // The following is no-op if the contract is already registered
+  await wallet.registerContract(bananaCoin, TokenContract.artifact);
+  return bananaCoin.address;
+}
+
+export async function registerDeployedBananaFPCInWalletAndGetAddress(wallet: Wallet) {
+  const initialAccounts = await getInitialTestAccountsData();
+  const fpc = await getBananaFPCInstance(initialAccounts);
+  // The following is no-op if the contract is already registered
+  await wallet.registerContract(fpc, FPCContract.artifact);
+  return fpc.address;
+}

package/src/local-network/index.ts

@@ -0,0 +1,7 @@
+export * from './local-network.js';
+
+export {
+  registerDeployedBananaCoinInWalletAndGetAddress,
+  registerDeployedBananaFPCInWalletAndGetAddress,
+} from './banana_fpc.js';
+export { registerDeployedSponsoredFPCInWalletAndGetAddress } from './sponsored_fpc.js';