@aztec/aztec 0.0.1-commit.e2b2873ed → 0.0.1-commit.e304674f1

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

@@ -0,0 +1,118 @@
+import TOML from '@iarna/toml';
+import { existsSync } from 'fs';
+import { mkdir, readFile, stat } from 'fs/promises';
+import { homedir } from 'os';
+import { dirname, join, resolve } from 'path';
+
+import { run } from './spawn.js';
+
+/**
+ * Recursively collects crate directories starting from startCrateDir by following dependencies declared in Nargo.toml
+ * files.
+ *
+ * When `skipGitDeps` is false (default), git-based deps are followed and fetched into the nargo cache
+ * (`$HOME/nargo/<domain>/<repo-path>/<tag>`) if not already present.
+ *
+ * When `skipGitDeps` is true, git-based deps are ignored entirely.
+ */
+export async function collectCrateDirs(startCrateDir: string, opts?: { skipGitDeps?: boolean }): Promise<string[]> {
+  const { skipGitDeps = false } = opts ?? {};
+  const visited = new Set<string>();
+
+  async function visit(crateDir: string): Promise<void> {
+    const absDir = resolve(crateDir);
+    if (visited.has(absDir)) {
+      return;
+    }
+    visited.add(absDir);
+
+    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) {
+        await visit(resolve(absDir, member));
+      }
+    } else {
+      // Single crate — follow its deps
+      const deps = (parsed.dependencies as Record<string, any>) ?? {};
+      for (const dep of Object.values(deps)) {
+        if (!dep || typeof dep !== 'object') {
+          continue;
+        }
+        if (typeof dep.path === 'string') {
+          // Dependency contains "path" hence it's a local dependency. We just check it's a real directory and then we
+          // recursively search through it
+          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);
+        } else if (!skipGitDeps && typeof dep.git === 'string' && typeof dep.tag === 'string') {
+          // Dependency contains "git" hence it's a git dependency. We ensure it has been fetched and fetch it if
+          // it's not the case and then we recursively search through it.
+          await fetchAndVisit(dep.git, dep.tag, dep.directory);
+        }
+      }
+    }
+  }
+
+  async function fetchAndVisit(gitUrl: string, tag: string, directory?: string): Promise<void> {
+    // `directory` is set when the dep lives in a subdirectory of a repository, e.g.:
+    //   aztec = { git = "https://github.com/AztecProtocol/aztec-packages", tag = "v0.82.0",
+    //             directory = "noir-projects/aztec-nr/aztec" }
+    // In that case nargo clones the whole repo and the crate root is <cachePath>/<directory>.
+    const cachePath = nargoGitDepPath(gitUrl, tag);
+    const crateDir = directory ? join(cachePath, directory) : cachePath;
+    await ensureGitDepCached(gitUrl, tag, cachePath);
+    await visit(crateDir);
+  }
+
+  await visit(startCrateDir);
+  return [...visited];
+}
+
+/**
+ * Computes the local nargo cache path for a git dependency, mirroring nargo's own `git_dep_location` function.
+ * Path format: `$HOME/nargo/<domain>/<repo-path>/<tag>`
+ * e.g. `~/nargo/github.com/AztecProtocol/aztec-packages/v0.82.0`
+ *
+ * Source: noir/noir-repo/tooling/nargo_toml/src/git.rs
+ */
+export function nargoGitDepPath(gitUrl: string, tag: string): string {
+  const url = new URL(gitUrl);
+  const domain = url.hostname;
+  const repoPath = url.pathname.replace(/^\//, '');
+  return join(process.env.HOME ?? homedir(), 'nargo', domain, repoPath, tag);
+}
+
+/**
+ * Ensures a git dep is present in the nargo cache, cloning it if it isn't. Mirrors nargo's `clone_git_repo`.
+ * If cloning fails (e.g. no network), throws with a message suggesting `nargo check` to prime the cache.
+ *
+ * Source: noir/noir-repo/tooling/nargo_toml/src/git.rs
+ */
+async function ensureGitDepCached(gitUrl: string, tag: string, cachePath: string): Promise<void> {
+  if (existsSync(cachePath)) {
+    return;
+  }
+  await mkdir(dirname(cachePath), { recursive: true });
+  try {
+    await run('git', ['-c', 'advice.detachedHead=false', 'clone', '--depth', '1', '--branch', tag, gitUrl, cachePath]);
+  } catch (err: any) {
+    throw new Error(
+      `Failed to fetch git dependency ${gitUrl}@${tag}: ${err?.message ?? err}.\n` +
+        `Try running \`nargo check\` first to prime the dependency cache.`,
+    );
+  }
+}

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

@@ -0,0 +1,98 @@
+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
+ * (including path-based dependencies) is newer than the oldest artifact. We compare against the oldest artifact so
+ * that a source change between the oldest and newest compilation (e.g. in a multi-contract workspace) still triggers
+ * a recompile.
+ *
+ * Note: The above implies that if there is a random json file in the target dir we would be always recompiling.
+ */
+export async function needsRecompile(): Promise<boolean> {
+  const oldestArtifactMs = await getOldestArtifactModificationTime('target');
+  if (oldestArtifactMs === undefined) {
+    return true;
+  }
+
+  // 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);
+}
+
+/**
+ * Returns the last modification time (timestamp in ms) of the oldest .json artifact in targetDir, or undefined if
+ * none exist.
+ */
+async function getOldestArtifactModificationTime(targetDir: string): Promise<number | undefined> {
+  let entries: string[];
+  try {
+    entries = (await readdir(targetDir)).filter(f => f.endsWith('.json'));
+  } catch (err: any) {
+    if (err?.code === 'ENOENT') {
+      return undefined;
+    }
+    throw err;
+  }
+
+  if (entries.length === 0) {
+    return undefined;
+  }
+
+  let oldest = Infinity;
+  for (const entry of entries) {
+    const s = await stat(join(targetDir, entry));
+    if (s.mtimeMs < oldest) {
+      oldest = s.mtimeMs;
+    }
+  }
+  return oldest;
+}
+
+/**
+ * Walks crate dirs looking for .nr and Nargo.toml files newer than thresholdMs. Short-circuits on the first match.
+ */
+async function hasNewerSourceFile(crateDirs: string[], thresholdMs: number): Promise<boolean> {
+  // Returns true if it find a new file than thresholdMs, false otherwise
+  async function walkForNewer(dir: string): Promise<boolean> {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+
+    // We iterate over the entries in the dir
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        // If the entry is a dir and it's not called `target` we recursively enter it
+        if (entry.name === 'target') {
+          continue;
+        }
+        if (await walkForNewer(fullPath)) {
+          return true;
+        }
+      } else if (entry.name === 'Nargo.toml' || entry.name.endsWith('.nr')) {
+        // The entry is a Nargo.toml file or *.nr file so we check the timestamp
+        const s = await stat(fullPath);
+        if (s.mtimeMs > thresholdMs) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  // We search through the crate dirs
+  for (const dir of crateDirs) {
+    if (await walkForNewer(dir)) {
+      return true;
+    }
+  }
+  return false;
+}

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

@@ -0,0 +1,16 @@
+import { spawn } from 'child_process';
+
+/** Spawns a command with inherited stdio and rejects on non-zero exit. */
+export function run(cmd: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit' });
+    child.on('error', reject);
+    child.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(`${cmd} exited with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}

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

@@ -0,0 +1,54 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { 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';
+
+/** Warns if the `aztec` dependency tag in any crate's Nargo.toml 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.`);
+    return;
+  }
+
+  const expectedTag = `v${version}`;
+  const mismatches: { file: 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 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;
+    }
+
+    if (aztecDep.tag !== expectedTag) {
+      mismatches.push({ file: tomlPath, tag: aztecDep.tag });
+    }
+  }
+
+  if (mismatches.length > 0) {
+    const details = mismatches.map(m => `  ${m.file} (${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` +
+        `${details}\n\n` +
+        `See https://docs.aztec.network/errors/9 for how to update your dependencies.`,
+    );
+  }
+}

package/src/cli/util.ts

@@ -1,16 +1,18 @@
 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 } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ConfigMappingsType, NetworkNames } from '@aztec/foundation/config';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { type LogFn, createLogger } from '@aztec/foundation/log';
-import type { SharedNodeConfig } from '@aztec/node-lib/config';
 import type { ProverConfig } from '@aztec/stdlib/interfaces/server';
-import { getTelemetryClient } from '@aztec/telemetry-client/start';
+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';
 
@@ -270,7 +272,7 @@ export async function preloadCrsDataForVerifying(
 ): 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 + 1, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 1, undefined, log), GrumpkinCrs.new(2 ** 16, undefined, log)]);
   }
 }
 
@@ -285,94 +287,66 @@ export async function preloadCrsDataForServerSideProving(
 ): Promise<void> {
   if (realProofs) {
     const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
-    await Promise.all([Crs.new(2 ** 25 + 1, undefined, log), GrumpkinCrs.new(2 ** 18 + 1, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 25, undefined, log), GrumpkinCrs.new(2 ** 18, undefined, log)]);
   }
 }
 
-export async function setupUpdateMonitor(
-  autoUpdateMode: SharedNodeConfig['autoUpdate'],
-  updatesLocation: URL,
+export async function setupVersionChecker(
+  network: NetworkNames,
   followsCanonicalRollup: boolean,
   publicClient: ViemClient,
-  registryContractAddress: EthAddress,
   signalHandlers: Array<() => Promise<void>>,
-  updateNodeConfig?: (config: object) => Promise<void>,
-) {
-  const logger = createLogger('update-check');
-  const { UpdateChecker } = await import('@aztec/stdlib/update-checker');
-  const checker = await UpdateChecker.new({
-    baseURL: updatesLocation,
-    publicClient,
-    registryContractAddress,
-  });
+  cacheDir?: string,
+): Promise<void> {
+  const networkConfig = await getNetworkConfig(network, cacheDir);
+  if (!networkConfig) {
+    return;
+  }
 
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('newRollupVersion', async ({ latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
+  const { VersionChecker } = await import('@aztec/stdlib/update-checker');
 
-    // if node follows canonical rollup then this is equivalent to a config update
-    if (!followsCanonicalRollup) {
-      return;
-    }
+  const logger = createLogger('version_check');
+  const registry = new RegistryContract(publicClient, networkConfig.registryAddress as Hex);
 
-    if (autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') {
-      logger.info(`New rollup version detected. Please restart the node`, { latestVersion, currentVersion });
-      await shutdown(logger.info, ExitCode.ROLLUP_UPGRADE, signalHandlers);
-    } else if (autoUpdateMode === 'notify') {
-      logger.warn(`New rollup detected. Please restart the node`, { latestVersion, currentVersion });
-    }
+  const checks: Array<VersionCheck> = [];
+  checks.push({
+    name: 'node',
+    currentVersion: getPackageVersion() ?? 'unknown',
+    getLatestVersion: async () => {
+      const cfg = await getNetworkConfig(network, cacheDir);
+      return cfg?.nodeVersion;
+    },
   });
 
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('newNodeVersion', async ({ latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
-    if (autoUpdateMode === 'config-and-version') {
-      logger.info(`New node version detected. Please update and restart the node`, { latestVersion, currentVersion });
-      await shutdown(logger.info, ExitCode.VERSION_UPGRADE, signalHandlers);
-    } else if (autoUpdateMode === 'notify') {
-      logger.info(`New node version detected. Please update and restart the node`, { latestVersion, currentVersion });
+  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,
+      });
     }
-  });
+  }
 
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('updateNodeConfig', async config => {
+  const checker = new VersionChecker(checks, 600_000, logger);
+  checker.on('newVersion', ({ name, latestVersion, currentVersion }) => {
     if (isShuttingDown()) {
       return;
     }
 
-    if ((autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') && updateNodeConfig) {
-      logger.warn(`Config change detected. Updating node`, config);
-      try {
-        await updateNodeConfig(config);
-      } catch (err) {
-        logger.warn('Failed to update config', { err });
-      }
-    }
-    // don't notify on these config changes
+    logger.warn(`New ${name} version available`, { latestVersion, currentVersion });
   });
-
-  checker.on('updatePublicTelemetryConfig', config => {
-    if (autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') {
-      logger.warn(`Public telemetry config change detected. Updating telemetry client`, config);
-      try {
-        const publicIncludeMetrics: unknown = (config as any).publicIncludeMetrics;
-        if (Array.isArray(publicIncludeMetrics) && publicIncludeMetrics.every(m => typeof m === 'string')) {
-          getTelemetryClient().setExportedPublicTelemetry(publicIncludeMetrics);
-        }
-        const publicMetricsCollectFrom: unknown = (config as any).publicMetricsCollectFrom;
-        if (Array.isArray(publicMetricsCollectFrom) && publicMetricsCollectFrom.every(m => typeof m === 'string')) {
-          getTelemetryClient().setPublicTelemetryCollectFrom(publicMetricsCollectFrom);
-        }
-      } catch (err) {
-        logger.warn('Failed to update config', { err });
-      }
-    }
-    // don't notify on these config changes
-  });
-
   checker.start();
+  signalHandlers.push(() => checker.stop());
+}
+
+export function stringifyConfig(config: object): string {
+  return Object.entries(config)
+    .map(([key, value]) => `${key}=${jsonStringify(value)}`)
+    .join(' ');
 }

package/src/examples/token.ts

@@ -32,7 +32,9 @@ async function main() {
   logger.info(`Fetched Alice and Bob accounts: ${alice.toString()}, ${bob.toString()}`);
 
   logger.info('Deploying Token...');
-  const token = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18).send({ from: alice });
+  const { contract: token } = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18).send({
+    from: alice,
+  });
   logger.info('Token deployed');
 
   // Mint tokens to Alice
@@ -41,7 +43,7 @@ async function main() {
 
   logger.info(`${ALICE_MINT_BALANCE} tokens were successfully minted by Alice and transferred to private`);
 
-  const balanceAfterMint = await token.methods.balance_of_private(alice).simulate({ from: alice });
+  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
@@ -49,10 +51,10 @@ async function main() {
   await token.methods.transfer(bob, TRANSFER_AMOUNT).send({ from: alice });
 
   // Check the new balances
-  const aliceBalance = await token.methods.balance_of_private(alice).simulate({ from: alice });
+  const { result: aliceBalance } = await token.methods.balance_of_private(alice).simulate({ from: alice });
   logger.info(`Alice's balance ${aliceBalance}`);
 
-  const bobBalance = await token.methods.balance_of_private(bob).simulate({ from: bob });
+  const { result: bobBalance } = await token.methods.balance_of_private(bob).simulate({ from: bob });
   logger.info(`Bob's balance ${bobBalance}`);
 }
 

package/src/local-network/banana_fpc.ts

@@ -48,7 +48,7 @@ export async function getBananaFPCAddress(initialAccounts: InitialAccountData[])
 export async function setupBananaFPC(initialAccounts: InitialAccountData[], wallet: Wallet, log: LogFn) {
   const bananaCoinAddress = await getBananaCoinAddress(initialAccounts);
   const admin = getBananaAdmin(initialAccounts);
-  const [bananaCoin, fpc] = await Promise.all([
+  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,

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

@@ -18,7 +18,10 @@ 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 type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { SequencerState } from '@aztec/sequencer-client';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import {
   type TelemetryClient,
   getConfigEnvVars as getTelemetryClientConfig,
@@ -36,6 +39,7 @@ 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 { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
 import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 
@@ -66,7 +70,7 @@ 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,
   });
 
@@ -99,18 +103,25 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
     logger.warn(`Multiple L1 RPC URLs provided. Local networks will only use the first one: ${l1RpcUrl}`);
   }
 
+  // The local network deploys a banana FPC with Token contracts, so include Token entries
+  // in the setup allowlist so FPC-based fee payments work out of the box.
+  const tokenAllowList = await getTokenAllowedSetupFunctions();
+
   const aztecNodeConfig: AztecNodeConfig = {
     ...getConfigEnvVars(),
     ...config,
+    txPublicSetupAllowListExtend: [...tokenAllowList, ...(config.txPublicSetupAllowListExtend ?? [])],
   };
   const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
   if (
-    aztecNodeConfig.publisherPrivateKeys == undefined ||
-    !aztecNodeConfig.publisherPrivateKeys.length ||
-    aztecNodeConfig.publisherPrivateKeys[0].getValue() === NULL_KEY
+    aztecNodeConfig.sequencerPublisherPrivateKeys == undefined ||
+    !aztecNodeConfig.sequencerPublisherPrivateKeys.length ||
+    aztecNodeConfig.sequencerPublisherPrivateKeys[0].getValue() === NULL_KEY
   ) {
     const privKey = hdAccount.getHdKey().privateKey;
-    aztecNodeConfig.publisherPrivateKeys = [new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const)];
+    aztecNodeConfig.sequencerPublisherPrivateKeys = [
+      new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const),
+    ];
   }
   if (!aztecNodeConfig.validatorPrivateKeys?.getValue().length) {
     const privKey = hdAccount.getHdKey().privateKey;
@@ -134,10 +145,13 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
 
   const bananaFPC = await getBananaFPCAddress(initialAccounts);
   const sponsoredFPC = await getSponsoredFPCAddress();
-  const fundedAddresses = initialAccounts.length
-    ? [...initialAccounts.map(a => a.address), bananaFPC, sponsoredFPC]
-    : [];
-  const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(fundedAddresses);
+  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const fundedAddresses = [
+    ...initialAccounts.map(a => a.address),
+    ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
+    ...prefundAddresses,
+  ];
+  const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(fundedAddresses);
 
   const dateProvider = new TestDateProvider();
 
@@ -176,7 +190,22 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   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 });
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { genesis });
+
+  // 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) {
@@ -191,7 +220,10 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   }
 
   if (initialAccounts.length) {
-    const wallet = await EmbeddedWallet.create(node, { pxeConfig: { proverEnabled: aztecNodeConfig.realProofs } });
+    const wallet = await EmbeddedWallet.create(node, {
+      pxeConfig: { proverEnabled: aztecNodeConfig.realProofs },
+      ephemeral: true,
+    });
 
     userLog('Setting up funded test accounts...');
     const accountManagers = await deployFundedSchnorrAccounts(wallet, initialAccounts);
@@ -221,8 +253,13 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
  */
 export async function createAztecNode(
   config: Partial<AztecNodeConfig> = {},
-  deps: { telemetry?: TelemetryClient; blobClient?: BlobClientInterface; dateProvider?: DateProvider } = {},
-  options: { prefilledPublicData?: PublicDataTreeLeaf[] } = {},
+  deps: {
+    telemetry?: TelemetryClient;
+    blobClient?: BlobClientInterface;
+    dateProvider?: DateProvider;
+    proverBroker?: ProvingJobBroker;
+  } = {},
+  options: { genesis?: GenesisData } = {},
 ) {
   // TODO(#12272): will clean this up. This is criminal.
   const { l1Contracts, ...rest } = getConfigEnvVars();
@@ -231,6 +268,10 @@ export async function createAztecNode(
     ...config,
     l1Contracts: { ...l1Contracts, ...config.l1Contracts },
   };
-  const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps, options);
+  const node = await AztecNodeService.createAndSync(
+    aztecNodeConfig,
+    { ...deps, proverNodeDeps: { broker: deps.proverBroker } },
+    options,
+  );
   return node;
 }