@aztec/aztec 0.0.1-commit.b6e433891 → 0.0.1-commit.b8a057fa

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

@@ -1,6 +1,7 @@
-import TOML from '@iarna/toml';
-import { readFile, readdir, stat } from 'fs/promises';
-import { join, resolve } from 'path';
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+
+import { collectCrateDirs } from './collect_crate_dirs.js';
 
 /**
  * Returns true if recompilation is needed: either no artifacts exist in target/ or any .nr or Nargo.toml source file
@@ -16,7 +17,10 @@ export async function needsRecompile(): Promise<boolean> {
     return true;
   }
 
-  const crateDirs = await collectCrateDirs('.');
+  // Git deps are pinned to a specific tag in Nargo.toml and nargo always fetches an exact tag, so their contents never
+  // change without Nargo.toml itself changing — and Nargo.toml is already tracked as a source file. Hence we can
+  // safely ignore checking source files of git deps.
+  const crateDirs = await collectCrateDirs('.', { skipGitDeps: true });
   return hasNewerSourceFile(crateDirs, oldestArtifactMs);
 }
 
@@ -49,63 +53,6 @@ async function getOldestArtifactModificationTime(targetDir: string): Promise<num
   return oldest;
 }
 
-/**
- * Recursively collects crate directories starting from startCrateDir by following path-based dependencies declared in
- * Nargo.toml files. Git-based deps are ignored (they only change when Nargo.toml itself is modified since the deps are
- * tagged).
- */
-async function collectCrateDirs(startCrateDir: string): Promise<string[]> {
-  // We have a set of visited dirs we check against when entering a new dir because we could stumble upon a directory
-  // multiple times in case multiple deps shared a dep (e.g. dep A and dep B both sharing dep C).
-  const visited = new Set<string>();
-
-  async function visit(crateDir: string): Promise<void> {
-    const absDir = resolve(crateDir);
-    if (visited.has(absDir)) {
-      return;
-    }
-    visited.add(absDir);
-
-    // Every dep is its own crate and every crate needs to have Nargo.toml defined in the root so we try to load it and
-    // error out if it's not the case.
-    const tomlPath = join(absDir, 'Nargo.toml');
-    const content = await readFile(tomlPath, 'utf-8').catch(() => {
-      throw new Error(`Incorrectly defined dependency. Nargo.toml not found in ${absDir}`);
-    });
-
-    const parsed = TOML.parse(content) as Record<string, any>;
-
-    const members = (parsed.workspace as Record<string, any>)?.members as string[] | undefined;
-
-    // A Nargo.toml is either a workspace root (has workspace.members) or a single crate (has dependencies).
-    if (Array.isArray(members)) {
-      // The crate is a workspace root and has members defined so we visit the members
-      for (const member of members) {
-        const memberPath = resolve(absDir, member);
-        await visit(memberPath);
-      }
-    } else {
-      // The crate is not a workspace root so we check for dependencies
-      const deps = (parsed.dependencies as Record<string, any>) ?? {};
-      for (const dep of Object.values(deps)) {
-        if (dep && typeof dep === 'object' && typeof dep.path === 'string') {
-          const depPath = resolve(absDir, dep.path);
-          const s = await stat(depPath);
-          if (!s.isDirectory()) {
-            throw new Error(
-              `Dependency path "${dep.path}" in ${tomlPath} resolves to ${depPath} which is not a directory`,
-            );
-          }
-          await visit(depPath);
-        }
-      }
-    }
-  }
-
-  await visit(startCrateDir);
-  return [...visited];
-}
-
 /**
  * Walks crate dirs looking for .nr and Nargo.toml files newer than thresholdMs. Short-circuits on the first match.
  */

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

@@ -0,0 +1,76 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { DEV_VERSION, getPackageVersion } from '@aztec/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/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,
     }),
   ]);
 

package/src/local-network/local-network.ts

@@ -1,51 +1,53 @@
 #!/usr/bin/env -S node --no-warnings
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { AztecNodeService } from '@aztec/aztec-node';
+import { createAztecNodeService } from '@aztec/aztec-node';
 import { type AztecNodeConfig, getConfigEnvVars } from '@aztec/aztec-node/config';
 import { Fr } from '@aztec/aztec.js/fields';
 import { createLogger } from '@aztec/aztec.js/log';
 import { type BlobClientInterface, createBlobClient } from '@aztec/blob-client/client';
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import { createEthereumChain } from '@aztec/ethereum/chain';
 import { waitForPublicClient } from '@aztec/ethereum/client';
 import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
 import { NULL_KEY } from '@aztec/ethereum/constants';
 import { deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
-import { EthCheatCodes } from '@aztec/ethereum/test';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { SecretValue } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn } from '@aztec/foundation/log';
 import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import { SequencerState } from '@aztec/sequencer-client';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { TxStatus } from '@aztec/stdlib/tx';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import {
   type TelemetryClient,
   getConfigEnvVars as getTelemetryClientConfig,
   initTelemetryClient,
 } from '@aztec/telemetry-client';
 import { EmbeddedWallet } from '@aztec/wallets/embedded';
-import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
+import { createFundedInitializerlessAccounts } from '@aztec/wallets/testing';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import { type Hex, createPublicClient, fallback, http as httpViemTransport } from 'viem';
+import type { Hex } from 'viem';
 import { mnemonicToAccount, privateKeyToAddress } from 'viem/accounts';
 import { foundry } from 'viem/chains';
 
 import { createAccountLogs } from '../cli/util.js';
 import { DefaultMnemonic } from '../mnemonic.js';
-import { AnvilTestWatcher } from '../testing/anvil_test_watcher.js';
-import { EpochTestSettler } from '../testing/epoch_test_settler.js';
 import { getTokenAllowedSetupFunctions } from '../testing/token_allowed_setup.js';
+import { publishStandardAuthRegistry } from './auth_registry.js';
 import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
 import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 
 const logger = createLogger('local-network');
 
-const localAnvil = foundry;
+// The embedded wallet defaults to waiting for PROPOSED, which returns as soon as a tx lands in a
+// proposed L2 block. That is flaky for the serial sandbox setup below: a proposed block can be
+// pruned before its checkpoint is published, dropping a tx we already moved on from ("Tx dropped by
+// P2P node"). Wait for the checkpoint so each setup tx is durably included before the next is sent.
+const setupWaitOpts = { waitForStatus: TxStatus.CHECKPOINTED };
 
 /**
  * Function to deploy our L1 contracts to the local network L1
@@ -59,7 +61,7 @@ export async function deployContractsToL1(
     genesisArchiveRoot?: Fr;
     feeJuicePortalInitialBalance?: bigint;
   } = {},
-) {
+): Promise<L1ContractAddresses> {
   await waitForPublicClient(aztecNodeConfig);
 
   const l1Contracts = await deployAztecL1Contracts(aztecNodeConfig.l1RpcUrls[0], privateKey, foundry.id, {
@@ -70,14 +72,14 @@ export async function deployContractsToL1(
     genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
     feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
     aztecTargetCommitteeSize: 0, // no committee in local network
-    slasherFlavor: 'none', // no slashing in local network
+    slasherEnabled: false, // no slashing in local network
     realVerifier: false,
   });
 
-  aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
+  Object.assign(aztecNodeConfig, l1Contracts.l1ContractAddresses);
   aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
 
-  return aztecNodeConfig.l1Contracts;
+  return l1Contracts.l1ContractAddresses;
 }
 
 /** Local network settings. */
@@ -107,10 +109,33 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   // in the setup allowlist so FPC-based fee payments work out of the box.
   const tokenAllowList = await getTokenAllowedSetupFunctions();
 
+  const envConfig = getConfigEnvVars();
   const aztecNodeConfig: AztecNodeConfig = {
-    ...getConfigEnvVars(),
+    ...envConfig,
     ...config,
+    skipOrphanProposedBlockPruning: true,
+    // The local network builds node config from env without a DATA_DIRECTORY, so the validator's
+    // local signing protection runs against an ephemeral store. That is acceptable for this dev
+    // network; production validators must persist it and fail-fast when the data directory is unset.
+    allowEphemeralSigningProtection: config.allowEphemeralSigningProtection ?? true,
     txPublicSetupAllowListExtend: [...tokenAllowList, ...(config.txPublicSetupAllowListExtend ?? [])],
+    // The local network runs against anvil with no committee, so it defaults to the deterministic
+    // AutomineSequencer, which owns L1 time control (warps the dateProvider and L1 timestamps to slot
+    // boundaries as it builds), replacing the deleted AnvilTestWatcher. This remains true when p2p is
+    // enabled for local peer testing; local-network is not a mode for connecting to an existing network.
+    useAutomineSequencer: config.useAutomineSequencer ?? true,
+    // The AutomineSequencer owns epoch proving in the local network — it writes epoch out hashes to
+    // the L1 Outbox and advances the proven tip as checkpoints land, through the same serial queue as
+    // its builds — replacing the standalone EpochTestSettler that used to race the build loop.
+    automineEnableProveEpoch: config.automineEnableProveEpoch ?? true,
+    // Defaults for the local network / sandbox; callers (e.g. the CLI) may override. No real proving
+    // happens here — the AutomineSequencer synthetically settles epochs. Short epochs let it write out
+    // hashes quickly (so users can consume L2-to-L1 messages without a long wait), with a wider
+    // proof-submission window so the synthetic settler has headroom before the rollup would prune an
+    // unproven checkpoint.
+    realProofs: config.realProofs ?? false,
+    aztecEpochDuration: config.aztecEpochDuration ?? 4,
+    aztecProofSubmissionEpochs: config.aztecProofSubmissionEpochs ?? 2,
   };
   const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
   if (
@@ -134,7 +159,7 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   const initialAccounts = await (async () => {
     if (config.testAccounts === true || config.testAccounts === undefined) {
       if (aztecNodeConfig.p2pEnabled) {
-        userLog(`Not setting up test accounts as we are connecting to a network`);
+        userLog(`Not setting up test accounts when p2p is enabled`);
       } else {
         userLog(`Setting up test accounts`);
         return await getInitialTestAccountsData();
@@ -145,79 +170,27 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
 
   const bananaFPC = await getBananaFPCAddress(initialAccounts);
   const sponsoredFPC = await getSponsoredFPCAddress();
-  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromStringUnsafe(a));
   const fundedAddresses = [
     ...initialAccounts.map(a => a.address),
     ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
     ...prefundAddresses,
   ];
-  const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(fundedAddresses);
+  const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(fundedAddresses);
 
   const dateProvider = new TestDateProvider();
 
-  let cheatcodes: EthCheatCodes | undefined;
-  let rollupAddress: EthAddress | undefined;
-  let watcher: AnvilTestWatcher | undefined;
   if (!aztecNodeConfig.p2pEnabled) {
-    ({ rollupAddress } = await deployContractsToL1(
-      aztecNodeConfig,
-      aztecNodeConfig.validatorPrivateKeys.getValue()[0],
-      {
-        genesisArchiveRoot,
-        feeJuicePortalInitialBalance: fundingNeeded,
-      },
-    ));
-
-    const chain =
-      aztecNodeConfig.l1RpcUrls.length > 0
-        ? createEthereumChain([l1RpcUrl], aztecNodeConfig.l1ChainId)
-        : { chainInfo: localAnvil };
-
-    const publicClient = createPublicClient({
-      chain: chain.chainInfo,
-      transport: fallback([httpViemTransport(l1RpcUrl)]) as any,
+    await deployContractsToL1(aztecNodeConfig, aztecNodeConfig.validatorPrivateKeys.getValue()[0], {
+      genesisArchiveRoot,
+      feeJuicePortalInitialBalance: fundingNeeded,
     });
-
-    cheatcodes = new EthCheatCodes([l1RpcUrl], dateProvider);
-
-    watcher = new AnvilTestWatcher(cheatcodes, rollupAddress, publicClient, dateProvider);
-    watcher.setisLocalNetwork(true);
-    watcher.setIsMarkingAsProven(false); // Do not mark as proven in the watcher. It's marked in the epochTestSettler after the out hash is set.
-
-    await watcher.start();
   }
 
   const telemetry = await initTelemetryClient(getTelemetryClientConfig());
   // Create a local blob client client inside the local network, no http connectivity
   const blobClient = createBlobClient();
-  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { prefilledPublicData });
-
-  // Now that the node is up, let the watcher check for pending txs so it can skip unfilled slots faster when
-  // transactions are waiting in the mempool. Also let it check if the sequencer is actively building, to avoid
-  // warping time out from under an in-progress block.
-  watcher?.setGetPendingTxCount(() => node.getPendingTxCount());
-  const sequencer = node.getSequencer()?.getSequencer();
-  if (sequencer) {
-    const idleStates: Set<string> = new Set([
-      SequencerState.STOPPED,
-      SequencerState.STOPPING,
-      SequencerState.IDLE,
-      SequencerState.SYNCHRONIZING,
-    ]);
-    watcher?.setIsSequencerBuilding(() => !idleStates.has(sequencer.getState()));
-  }
-
-  let epochTestSettler: EpochTestSettler | undefined;
-  if (!aztecNodeConfig.p2pEnabled) {
-    epochTestSettler = new EpochTestSettler(
-      cheatcodes!,
-      rollupAddress!,
-      node.getBlockSource(),
-      logger.createChild('epoch-settler'),
-      { pollingIntervalMs: 200 },
-    );
-    await epochTestSettler.start();
-  }
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { genesis });
 
   if (initialAccounts.length) {
     const wallet = await EmbeddedWallet.create(node, {
@@ -226,11 +199,14 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
     });
 
     userLog('Setting up funded test accounts...');
-    const accountManagers = await deployFundedSchnorrAccounts(wallet, initialAccounts);
+    const accountManagers = await createFundedInitializerlessAccounts(wallet, initialAccounts);
     const accLogs = await createAccountLogs(accountManagers, wallet);
     userLog(accLogs.join(''));
 
-    await setupBananaFPC(initialAccounts, wallet, userLog);
+    userLog('Publishing standard AuthRegistry contract...');
+    await publishStandardAuthRegistry(wallet, initialAccounts[0].address, setupWaitOpts);
+
+    await setupBananaFPC(initialAccounts, wallet, userLog, setupWaitOpts);
 
     userLog(`SponsoredFPC: ${await getSponsoredFPCAddress()}`);
 
@@ -240,8 +216,6 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
 
   const stop = async () => {
     await node.stop();
-    await watcher?.stop();
-    await epochTestSettler?.stop();
   };
 
   return { node, stop };
@@ -259,16 +233,15 @@ export async function createAztecNode(
     dateProvider?: DateProvider;
     proverBroker?: ProvingJobBroker;
   } = {},
-  options: { prefilledPublicData?: PublicDataTreeLeaf[] } = {},
+  options: { genesis?: GenesisData } = {},
 ) {
   // TODO(#12272): will clean this up. This is criminal.
-  const { l1Contracts, ...rest } = getConfigEnvVars();
+  // Not sure why this was ever done. Will be fixed in A-989, A-991, A-990.
   const aztecNodeConfig: AztecNodeConfig = {
-    ...rest,
+    ...getConfigEnvVars(),
     ...config,
-    l1Contracts: { ...l1Contracts, ...config.l1Contracts },
   };
-  const node = await AztecNodeService.createAndSync(
+  const node = await createAztecNodeService(
     aztecNodeConfig,
     { ...deps, proverNodeDeps: { broker: deps.proverBroker } },
     options,