@aztec/aztec 0.0.1-commit.9ef841308 → 0.0.1-commit.a4600f49

package/src/cli/cmds/start_node.ts

@@ -1,7 +1,11 @@
-import { type AztecNodeConfig, aztecNodeConfigMappings, getConfigEnvVars } from '@aztec/aztec-node';
+import {
+  type AztecNodeConfig,
+  aztecNodeConfigMappings,
+  getConfigEnvVars,
+  registerAztecNodeRpcHandlers,
+} from '@aztec/aztec-node';
 import { Fr } from '@aztec/aztec.js/fields';
 import { getL1Config } from '@aztec/cli/config';
-import { getPublicClient } from '@aztec/ethereum/client';
 import { getGenesisStateConfigEnvVars } from '@aztec/ethereum/config';
 import { type NetworkNames, SecretValue } from '@aztec/foundation/config';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
@@ -9,10 +13,13 @@ import { Agent, makeUndiciFetch } from '@aztec/foundation/json-rpc/undici';
 import type { LogFn } from '@aztec/foundation/log';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import { ProvingJobConsumerSchema, createProvingJobBrokerClient } from '@aztec/prover-client/broker';
+import {
+  ProvingJobConsumerSchema,
+  createProvingJobBrokerClient,
+  proverBrokerBackoff,
+} from '@aztec/prover-client/broker';
 import { type CliPXEOptions, type PXEConfig, allPxeConfigMappings } from '@aztec/pxe/config';
-import { AztecNodeAdminApiSchema, AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
-import { P2PApiSchema, ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import {
   type TelemetryClientConfig,
   initTelemetryClient,
@@ -22,14 +29,9 @@ import {
 import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import { createAztecNode } from '../../local-network/index.js';
-import {
-  extractNamespacedOptions,
-  extractRelevantOptions,
-  preloadCrsDataForVerifying,
-  setupVersionChecker,
-} from '../util.js';
+import { extractNamespacedOptions, extractRelevantOptions, preloadCrsDataForVerifying } from '../util.js';
 import { getVersions } from '../versioning.js';
-import { computeExpectedGenesisRoot, waitForCompatibleRollup } from './standby.js';
+import { computeExpectedGenesisRoot, setupAutoShutdown, waitForCompatibleRollup } from './standby.js';
 import { startProverBroker } from './start_prover_broker.js';
 
 export async function startNode(
@@ -65,12 +67,8 @@ export async function startNode(
     if (nodeConfig.proverBrokerUrl) {
       // at 1TPS we'd enqueue ~1k chonk verifier proofs and ~1k AVM proofs immediately
       // set a lower connection limit such that we don't overload the server
-      // Keep retrying up to 30s
-      const fetch = makeTracedFetch(
-        [1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3],
-        false,
-        makeUndiciFetch(new Agent({ connections: 100 })),
-      );
+      // Retry indefinitely until the epoch proving times out and the chain reorgs
+      const fetch = makeTracedFetch(proverBrokerBackoff, false, makeUndiciFetch(new Agent({ connections: 100 })));
       broker = createProvingJobBrokerClient(nodeConfig.proverBrokerUrl, getVersions(nodeConfig), fetch);
     } else if (options.proverBroker) {
       ({ broker } = await startProverBroker(options, signalHandlers, services, userLog));
@@ -83,12 +81,12 @@ export async function startNode(
   await preloadCrsDataForVerifying(nodeConfig, userLog);
 
   const genesisConfig = getGenesisStateConfigEnvVars();
-  const { genesisArchiveRoot, prefilledPublicData } = await computeExpectedGenesisRoot(genesisConfig, userLog);
+  const { genesisArchiveRoot, genesis } = await computeExpectedGenesisRoot(genesisConfig, userLog);
 
   const followsCanonicalRollup =
     typeof nodeConfig.rollupVersion !== 'number' || (nodeConfig.rollupVersion as unknown as string) === 'canonical';
 
-  if (!nodeConfig.l1Contracts.registryAddress || nodeConfig.l1Contracts.registryAddress.isZero()) {
+  if (!nodeConfig.registryAddress || nodeConfig.registryAddress.isZero()) {
     throw new Error('L1 registry address is required to start Aztec Node');
   }
 
@@ -102,7 +100,7 @@ export async function startNode(
   );
 
   const { addresses, config } = await getL1Config(
-    nodeConfig.l1Contracts.registryAddress,
+    nodeConfig.registryAddress,
     nodeConfig.l1RpcUrls,
     nodeConfig.l1ChainId,
     nodeConfig.rollupVersion,
@@ -116,13 +114,9 @@ export async function startNode(
     );
   }
 
-  // TODO(#12272): will clean this up.
   nodeConfig = {
     ...nodeConfig,
-    l1Contracts: {
-      ...addresses,
-      slashFactoryAddress: nodeConfig.l1Contracts.slashFactoryAddress,
-    },
+    ...addresses,
     ...config,
   };
 
@@ -158,17 +152,14 @@ export async function startNode(
   const telemetry = await initTelemetryClient(telemetryConfig);
 
   // Create and start Aztec Node
-  const node = await createAztecNode(nodeConfig, { telemetry, proverBroker: broker }, { prefilledPublicData });
+  const node = await createAztecNode(nodeConfig, { telemetry, proverBroker: broker }, { genesis });
 
-  // Add node and p2p to services list
-  services.node = [node, AztecNodeApiSchema];
-  services.p2p = [node.getP2P(), P2PApiSchema];
-  adminServices.nodeAdmin = [node, AztecNodeAdminApiSchema];
+  registerAztecNodeRpcHandlers(node, services, adminServices, { debug: options.nodeDebug });
 
   // Register prover-node services if the prover node subsystem is running
   const proverNode = node.getProverNode();
   if (proverNode) {
-    services.prover = [proverNode, ProverNodeApiSchema];
+    adminServices.prover = [proverNode, ProverNodeApiSchema];
     if (!nodeConfig.proverBrokerUrl) {
       services.provingJobSource = [proverNode.getProver().getProvingJobSource(), ProvingJobConsumerSchema];
     }
@@ -187,15 +178,14 @@ export async function startNode(
     await addBot(options, signalHandlers, services, wallet, node, telemetry, undefined);
   }
 
-  if (nodeConfig.enableVersionCheck && networkName !== 'local') {
-    const cacheDir = process.env.DATA_DIRECTORY ? `${process.env.DATA_DIRECTORY}/cache` : undefined;
+  if (nodeConfig.enableAutoShutdown && networkName !== 'local' && followsCanonicalRollup) {
     try {
-      await setupVersionChecker(
-        networkName,
-        followsCanonicalRollup,
-        getPublicClient(nodeConfig!),
+      await setupAutoShutdown(
+        nodeConfig,
+        nodeConfig.registryAddress,
+        (nodeConfig.rollupVersion as number | 'canonical') ?? 'canonical',
+        { genesisArchiveRoot, vkTreeRoot: getVKTreeRoot(), protocolContractsHash },
         signalHandlers,
-        cacheDir,
       );
     } catch {
       /* no-op */

package/src/cli/cmds/start_prover_agent.ts

@@ -9,6 +9,7 @@ import {
   createProofStore,
   createProvingJobBrokerClient,
   proverAgentConfigMappings,
+  proverBrokerBackoff,
 } from '@aztec/prover-client/broker';
 import { getProverNodeAgentConfigFromEnv } from '@aztec/prover-node';
 import { ProverAgentApiSchema } from '@aztec/stdlib/interfaces/server';
@@ -23,8 +24,8 @@ export async function startProverAgent(
   services: NamespacedApiHandlers,
   userLog: LogFn,
 ) {
-  if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
-    userLog(`Starting a prover agent with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+  if (options.node || options.sequencer || options.p2pBootstrap || options.txe) {
+    userLog(`Starting a prover agent with --node, --sequencer, --p2p-bootstrap, or --txe is not supported.`);
     process.exit(1);
   }
 
@@ -45,12 +46,8 @@ export async function startProverAgent(
 
   await preloadCrsDataForServerSideProving(config, userLog);
 
-  const fetch = makeTracedFetch(
-    // retry connections every 3s, up to 30s before giving up
-    [1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3],
-    false,
-    makeUndiciFetch(new Agent({ connections: 10 })),
-  );
+  // Retry indefinitely until the epoch proving times out and the chain reorgs
+  const fetch = makeTracedFetch(proverBrokerBackoff, false, makeUndiciFetch(new Agent({ connections: 10 })));
   const broker = createProvingJobBrokerClient(config.proverBrokerUrl, getVersions(), fetch);
 
   const telemetry = await initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));

package/src/cli/cmds/start_prover_broker.ts

@@ -24,38 +24,37 @@ export async function startProverBroker(
   services: NamespacedApiHandlers,
   userLog: LogFn,
 ): Promise<{ broker: ProvingJobBroker; config: ProverBrokerConfig }> {
-  if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
-    userLog(`Starting a prover broker with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+  if (options.node || options.sequencer || options.p2pBootstrap || options.txe) {
+    userLog(`Starting a prover broker with --node, --sequencer, --p2p-bootstrap, or --txe is not supported.`);
     process.exit(1);
   }
 
-  const config: ProverBrokerConfig = {
+  const baseConfig: ProverBrokerConfig = {
     ...getProverNodeBrokerConfigFromEnv(), // get default config from env
     ...extractRelevantOptions<ProverBrokerConfig>(options, proverBrokerConfigMappings, 'proverBroker'), // override with command line options
   };
 
-  if (!config.l1Contracts.registryAddress || config.l1Contracts.registryAddress.isZero()) {
+  if (!baseConfig.registryAddress || baseConfig.registryAddress.isZero()) {
     throw new Error('L1 registry address is required to start Aztec Node without --deploy-aztec-contracts option');
   }
 
   const genesisConfig = getGenesisStateConfigEnvVars();
   const { genesisArchiveRoot } = await computeExpectedGenesisRoot(genesisConfig, userLog);
   await waitForCompatibleRollup(
-    config,
+    baseConfig,
     { genesisArchiveRoot, vkTreeRoot: getVKTreeRoot(), protocolContractsHash },
     options.port,
     userLog,
   );
 
   const { addresses, config: rollupConfig } = await getL1Config(
-    config.l1Contracts.registryAddress,
-    config.l1RpcUrls,
-    config.l1ChainId,
-    config.rollupVersion,
+    baseConfig.registryAddress,
+    baseConfig.l1RpcUrls,
+    baseConfig.l1ChainId,
+    baseConfig.rollupVersion,
   );
 
-  config.l1Contracts = addresses;
-  config.rollupVersion = rollupConfig.rollupVersion;
+  const config: ProverBrokerConfig = { ...baseConfig, ...addresses, rollupVersion: rollupConfig.rollupVersion };
 
   const client = await initTelemetryClient(getTelemetryClientConfig());
   const broker = await createAndStartProvingBroker(config, client);

package/src/cli/cmds/start_txe.ts

@@ -1,15 +1,17 @@
 import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
 import type { Logger } from '@aztec/foundation/log';
-import { createTXERpcServer } from '@aztec/txe';
+import { createTXERpcServer } from '@aztec/txe/server';
 
-export async function startTXE(options: any, debugLogger: Logger) {
+export async function startTXE(options: any, signalHandlers: Array<() => Promise<void>>, debugLogger: Logger) {
   debugLogger.info(`Setting up TXE...`);
 
-  const txeServer = createTXERpcServer(debugLogger);
-  const { port } = await startHttpRpcServer(txeServer, {
+  const txeServer = await createTXERpcServer(debugLogger);
+  const httpServer = await startHttpRpcServer(txeServer, {
     port: options.port,
     timeoutMs: 1e3 * 60 * 5,
   });
 
-  debugLogger.info(`TXE listening on port ${port}`);
+  signalHandlers.push(() => new Promise<void>(resolve => httpServer.close(() => resolve())));
+
+  debugLogger.info(`TXE listening on port ${httpServer.port}`);
 }

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

@@ -6,6 +6,11 @@ export interface CompiledArtifact {
   file_map: unknown;
   functions: ContractFunction[];
   bytecode?: string;
+  /**
+   * Set to true by the AVM transpiler (invoked via `bb aztec_process`) once the contract has been transpiled and its
+   * verification keys generated. Absent on raw `nargo compile` output, hence optional.
+   */
+  transpiled?: boolean;
 }
 
 export interface ContractFunction {

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

@@ -1,5 +1,5 @@
 import type { LogFn } from '@aztec/foundation/log';
-import { getPackageVersion } from '@aztec/stdlib/update-checker';
+import { DEV_VERSION, getPackageVersion } from '@aztec/stdlib/update-checker';
 
 import TOML from '@iarna/toml';
 import { readFile } from 'fs/promises';
@@ -7,16 +7,33 @@ import { join } from 'path';
 
 import { collectCrateDirs } from './collect_crate_dirs.js';
 
-/** Warns if the `aztec` dependency tag in any crate's Nargo.toml doesn't match the CLI version. */
+/** 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) {
-    log(`WARNING: aztec CLI version not found. Skipping dependency compatibility check.`);
+  if (version === DEV_VERSION) {
     return;
   }
 
   const expectedTag = `v${version}`;
-  const mismatches: { file: string; tag: string }[] = [];
+  const mismatches: { file: string; depName: string; tag: string }[] = [];
 
   const crateDirs = await collectCrateDirs('.', { skipGitDeps: true });
 
@@ -30,23 +47,28 @@ export async function warnIfAztecVersionMismatch(log: LogFn, cliVersion?: string
     }
 
     const parsed = TOML.parse(content) as Record<string, any>;
-    const aztecDep = (parsed.dependencies as Record<string, any>)?.aztec;
-    if (!aztecDep || typeof aztecDep !== 'object' || typeof aztecDep.tag !== 'string') {
-      // If a dep called "aztec" doesn't exist or it does not get parsed to an object or it doesn't have a tag defined
-      // we skip the check.
-      continue;
-    }
+    const deps = (parsed.dependencies as Record<string, any>) ?? {};
 
-    if (aztecDep.tag !== expectedTag) {
-      mismatches.push({ file: tomlPath, tag: aztecDep.tag });
+    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.tag})`).join('\n');
+    const details = mismatches.map(m => `  ${m.file} — ${m.depName} (${m.tag})`).join('\n');
     log(
       `WARNING: Aztec dependency version mismatch detected.\n` +
-        `The following crates have an aztec dependency that does not match the CLI version (${expectedTag}):\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/util.ts

@@ -1,18 +1,13 @@
 import type { AztecNodeConfig } from '@aztec/aztec-node';
 import type { AccountManager } from '@aztec/aztec.js/wallet';
-import { getNetworkConfig } from '@aztec/cli/config';
-import { RegistryContract } from '@aztec/ethereum/contracts';
-import type { ViemClient } from '@aztec/ethereum/types';
-import type { ConfigMappingsType, NetworkNames } from '@aztec/foundation/config';
+import type { ConfigMappingsType } from '@aztec/foundation/config';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { type LogFn, createLogger } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 import type { ProverConfig } from '@aztec/stdlib/interfaces/server';
-import { type VersionCheck, getPackageVersion } from '@aztec/stdlib/update-checker';
 import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import chalk from 'chalk';
 import type { Command } from 'commander';
-import type { Hex } from 'viem';
 
 import { type AztecStartOption, aztecStartOptions } from './aztec_start_options.js';
 
@@ -51,6 +46,24 @@ 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],
@@ -81,18 +94,18 @@ export async function createAccountLogs(accountManagers: AccountManager[], walle
     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: ${account.getSecretKey().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 nullifier public key: ${completeAddress.publicKeys.masterNullifierPublicKey.toString()}\n`,
+        ` 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 incoming viewing public key: ${completeAddress.publicKeys.masterIncomingViewingPublicKey.toString()}\n\n`,
+        ` Master message-signing public key hash: ${completeAddress.publicKeys.mspkMHash.toString()}\n\n`,
       );
       accountLogStrings.push(
-        ` Master outgoing viewing public key: ${completeAddress.publicKeys.masterOutgoingViewingPublicKey.toString()}\n\n`,
-      );
-      accountLogStrings.push(
-        ` Master tagging public key: ${completeAddress.publicKeys.masterTaggingPublicKey.toString()}\n\n`,
+        ` Master fallback public key hash: ${completeAddress.publicKeys.fbpkMHash.toString()}\n\n`,
       );
     }
   }
@@ -291,60 +304,6 @@ export async function preloadCrsDataForServerSideProving(
   }
 }
 
-export async function setupVersionChecker(
-  network: NetworkNames,
-  followsCanonicalRollup: boolean,
-  publicClient: ViemClient,
-  signalHandlers: Array<() => Promise<void>>,
-  cacheDir?: string,
-): Promise<void> {
-  const networkConfig = await getNetworkConfig(network, cacheDir);
-  if (!networkConfig) {
-    return;
-  }
-
-  const { VersionChecker } = await import('@aztec/stdlib/update-checker');
-
-  const logger = createLogger('version_check');
-  const registry = new RegistryContract(publicClient, networkConfig.registryAddress as Hex);
-
-  const checks: Array<VersionCheck> = [];
-  checks.push({
-    name: 'node',
-    currentVersion: getPackageVersion() ?? 'unknown',
-    getLatestVersion: async () => {
-      const cfg = await getNetworkConfig(network, cacheDir);
-      return cfg?.nodeVersion;
-    },
-  });
-
-  if (followsCanonicalRollup) {
-    const getLatestVersion = async () => {
-      const version = (await registry.getRollupVersions()).at(-1);
-      return version !== undefined ? String(version) : undefined;
-    };
-    const currentVersion = await getLatestVersion();
-    if (currentVersion !== undefined) {
-      checks.push({
-        name: 'rollup',
-        currentVersion,
-        getLatestVersion,
-      });
-    }
-  }
-
-  const checker = new VersionChecker(checks, 600_000, logger);
-  checker.on('newVersion', ({ name, latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
-
-    logger.warn(`New ${name} version available`, { latestVersion, currentVersion });
-  });
-  checker.start();
-  signalHandlers.push(() => checker.stop());
-}
-
 export function stringifyConfig(config: object): string {
   return Object.entries(config)
     .map(([key, value]) => `${key}=${jsonStringify(value)}`)

package/src/examples/token.ts

@@ -21,10 +21,10 @@ async function main() {
 
   const wallet = await EmbeddedWallet.create(node);
 
-  // During local network setup we deploy a few accounts. Below we add them to our wallet.
+  // During local network setup we create a few initializerless accounts. Below we add them to our wallet.
   const [aliceInitialAccountData, bobInitialAccountData] = await getInitialTestAccountsData();
-  await wallet.createSchnorrAccount(aliceInitialAccountData.secret, aliceInitialAccountData.salt);
-  await wallet.createSchnorrAccount(bobInitialAccountData.secret, bobInitialAccountData.salt);
+  await wallet.createSchnorrInitializerlessAccount(aliceInitialAccountData.secret, aliceInitialAccountData.salt);
+  await wallet.createSchnorrInitializerlessAccount(bobInitialAccountData.secret, bobInitialAccountData.salt);
 
   const alice = aliceInitialAccountData.address;
   const bob = bobInitialAccountData.address;

package/src/local-network/auth_registry.ts

@@ -0,0 +1,19 @@
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
+import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { AuthRegistryArtifact, getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
+import type { AztecAddress } from '@aztec/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

@@ -1,4 +1,5 @@
 import { type InitialAccountData, getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn } from '@aztec/foundation/log';
@@ -45,19 +46,22 @@ export async function getBananaFPCAddress(initialAccounts: InitialAccountData[])
   return (await getBananaFPCInstance(initialAccounts)).address;
 }
 
-export async function setupBananaFPC(initialAccounts: InitialAccountData[], wallet: Wallet, log: LogFn) {
+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).send({
-      from: admin,
-      contractAddressSalt: BANANA_COIN_SALT,
+    TokenContract.deploy(wallet, admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal, {
+      salt: BANANA_COIN_SALT,
       universalDeploy: true,
-    }),
-    FPCContract.deploy(wallet, bananaCoinAddress, admin).send({
+    }).send({ from: admin, wait: waitOpts }),
+    FPCContract.deploy(wallet, bananaCoinAddress, admin, { salt: BANANA_FPC_SALT, universalDeploy: true }).send({
       from: admin,
-      contractAddressSalt: BANANA_FPC_SALT,
-      universalDeploy: true,
+      wait: waitOpts,
     }),
   ]);