@aztec/aztec 0.0.1-commit.f504929 → 0.0.1-commit.f81dbcf

package/scripts/setup_project.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Get the actual aztec version for the git tag.
+AZTEC_VERSION=$(jq -r '.version' $(dirname $0)/../package.json)
+NARGO_TOML_PATH="Nargo.toml"
+MAIN_NR_PATH="src/main.nr"
+
+if [ ! -f "$NARGO_TOML_PATH" ]; then
+  >&2 echo "Warning: Could not find Nargo.toml at $NARGO_TOML_PATH to add aztec dependency"
+  exit 1
+fi
+
+if [ ! -f "$MAIN_NR_PATH" ]; then
+  >&2 echo "Warning: Could not find main.nr at $MAIN_NR_PATH"
+  exit 1
+fi
+
+# Add aztec dependency to Nargo.toml
+echo "" >> "$NARGO_TOML_PATH"
+echo "aztec = { git=\"https://github.com/AztecProtocol/aztec-nr\", tag=\"v${AZTEC_VERSION}\", directory=\"aztec\" }" >> "$NARGO_TOML_PATH"
+echo "Added aztec dependency (v${AZTEC_VERSION}) to Nargo.toml"
+
+# Replace the contents of main.nr with the Aztec contract template
+cat > "$MAIN_NR_PATH" << 'EOF'
+use aztec::macros::aztec;
+
+#[aztec]
+contract Main {}
+EOF
+echo "Created main.nr with Aztec contract template"

package/src/bin/index.ts

@@ -11,6 +11,7 @@ import { injectCommands as injectMiscCommands } from '@aztec/cli/misc';
 import { injectCommands as injectValidatorKeysCommands } from '@aztec/cli/validator_keys';
 import { getActiveNetworkName } from '@aztec/foundation/config';
 import { createConsoleLogger, createLogger } from '@aztec/foundation/log';
+import { getPackageVersion } from '@aztec/stdlib/update-checker';
 
 import { Command } from 'commander';
 
@@ -18,7 +19,6 @@ import { injectCompileCommand } from '../cli/cmds/compile.js';
 import { injectMigrateCommand } from '../cli/cmds/migrate_ha_db.js';
 import { injectProfileCommand } from '../cli/cmds/profile.js';
 import { injectAztecCommands } from '../cli/index.js';
-import { getCliVersion } from '../cli/release_version.js';
 
 const NETWORK_FLAG = 'network';
 
@@ -47,7 +47,7 @@ async function main() {
   await enrichEnvironmentWithNetworkConfig(networkName);
   enrichEnvironmentWithChainName(networkName);
 
-  const cliVersion = getCliVersion();
+  const cliVersion = getPackageVersion() ?? 'unknown';
   let program = new Command('aztec');
   program.description('Aztec command line interface').version(cliVersion).enablePositionalOptions();
   program = injectAztecCommands(program, userLog, debugLogger);

package/src/cli/aztec_start_action.ts

@@ -1,3 +1,4 @@
+import { getActiveNetworkName } from '@aztec/foundation/config';
 import {
   type NamespacedApiHandlers,
   createNamespacedSafeJsonRpcServer,
@@ -7,13 +8,13 @@ import {
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import { AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
+import { getPackageVersion } from '@aztec/stdlib/update-checker';
 import { getVersioningMiddleware } from '@aztec/stdlib/versioning';
 import { getOtelJsonRpcPropagationMiddleware } from '@aztec/telemetry-client';
 
 import { createLocalNetwork } from '../local-network/index.js';
 import { github, splash } from '../splash.js';
 import { resolveAdminApiKey } from './admin_api_key_store.js';
-import { getCliVersion } from './release_version.js';
 import { extractNamespacedOptions, installSignalHandlers } from './util.js';
 import { getVersions } from './versioning.js';
 
@@ -22,14 +23,14 @@ export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logg
   const signalHandlers: Array<() => Promise<void>> = [];
   const services: NamespacedApiHandlers = {};
   const adminServices: NamespacedApiHandlers = {};
+  const packageVersion = getPackageVersion();
   let config: ChainConfig | undefined = undefined;
 
   if (options.localNetwork) {
-    const cliVersion = getCliVersion();
     const localNetwork = extractNamespacedOptions(options, 'local-network');
     localNetwork.testAccounts = true;
     userLog(`${splash}\n${github}\n\n`);
-    userLog(`Setting up Aztec local network ${cliVersion}, please stand by...`);
+    userLog(`Setting up Aztec local network ${packageVersion ?? 'unknown'}, please stand by...`);
 
     const { node, stop } = await createLocalNetwork(
       {
@@ -57,7 +58,8 @@ export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logg
 
     if (options.node) {
       const { startNode } = await import('./cmds/start_node.js');
-      ({ config } = await startNode(options, signalHandlers, services, adminServices, userLog));
+      const networkName = getActiveNetworkName(options.network);
+      ({ config } = await startNode(options, signalHandlers, services, adminServices, userLog, networkName));
     } else if (options.bot) {
       const { startBot } = await import('./cmds/start_bot.js');
       await startBot(options, signalHandlers, services, userLog);
@@ -87,13 +89,14 @@ export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logg
 
   installSignalHandlers(debugLogger.info, signalHandlers);
   const versions = getVersions(config);
+  const versioningOpts = { packageVersion };
 
   // Start the main JSON-RPC server
   if (Object.entries(services).length > 0) {
     const rpcServer = createNamespacedSafeJsonRpcServer(services, {
       http200OnError: false,
       log: debugLogger,
-      middlewares: [getOtelJsonRpcPropagationMiddleware(), getVersioningMiddleware(versions)],
+      middlewares: [getOtelJsonRpcPropagationMiddleware(), getVersioningMiddleware(versions, versioningOpts)],
       maxBatchSize: options.rpcMaxBatchSize,
       maxBodySizeBytes: options.rpcMaxBodySize,
     });
@@ -103,7 +106,7 @@ export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logg
 
   // If there are any admin services, start a separate JSON-RPC server for them
   if (Object.entries(adminServices).length > 0) {
-    const adminMiddlewares = [getOtelJsonRpcPropagationMiddleware(), getVersioningMiddleware(versions)];
+    const adminMiddlewares = [getOtelJsonRpcPropagationMiddleware(), getVersioningMiddleware(versions, versioningOpts)];
 
     // Resolve the admin API key (auto-generated and persisted, or opt-out)
     const apiKeyResolution = await resolveAdminApiKey(

package/src/cli/aztec_start_options.ts

@@ -105,8 +105,7 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       env: 'NETWORK',
     },
 
-    configToFlag('--auto-update', sharedNodeConfigMappings.autoUpdate),
-    configToFlag('--auto-update-url', sharedNodeConfigMappings.autoUpdateUrl),
+    configToFlag('--enable-version-check', sharedNodeConfigMappings.enableVersionCheck),
 
     configToFlag('--sync-mode', sharedNodeConfigMappings.syncMode),
     configToFlag('--snapshots-urls', sharedNodeConfigMappings.snapshotsUrls),

package/src/cli/cli.ts

@@ -37,9 +37,9 @@ export function injectAztecCommands(program: Command, userLog: LogFn, debugLogge
       `
 Additional commands:
 
-  init               creates a new Aztec Noir workspace in the current directory.
-  new <name>         creates a new Aztec Noir workspace in its own directory (or creates a new contract-test crates pair and adds it to the current workspace if run in workspace).
-  test [options]     starts a TXE and runs "nargo test" using it as the oracle resolver.
+  init [folder] [options]  creates a new Aztec Noir project.
+  new <path> [options]     creates a new Aztec Noir project in a new directory.
+  test [options]           starts a TXE and runs "nargo test" using it as the oracle resolver.
     `,
     );
   }

package/src/cli/cmds/compile.ts

@@ -3,7 +3,6 @@ import type { LogFn } from '@aztec/foundation/log';
 import { execFileSync } from 'child_process';
 import type { Command } from 'commander';
 import { readFile, writeFile } from 'fs/promises';
-import { join } from 'path';
 
 import { readArtifactFiles } from './utils/artifacts.js';
 import { run } from './utils/spawn.js';
@@ -35,106 +34,6 @@ async function stripInternalPrefixes(artifactPaths: string[]): Promise<void> {
   }
 }
 
-/** Returns the set of package names that are contract crates in the current workspace. */
-async function getContractPackageNames(): Promise<Set<string>> {
-  const contractNames = new Set<string>();
-
-  let rootToml: string;
-  try {
-    rootToml = await readFile('Nargo.toml', 'utf-8');
-  } catch {
-    return contractNames;
-  }
-
-  const membersMatch = rootToml.match(/members\s*=\s*\[([^\]]*)\]/);
-  if (membersMatch) {
-    const members = membersMatch[1]
-      .split(',')
-      .map(m => m.trim().replace(/^"|"$/g, ''))
-      .filter(m => m.length > 0);
-
-    for (const member of members) {
-      try {
-        const memberToml = await readFile(join(member, 'Nargo.toml'), 'utf-8');
-        if (/type\s*=\s*"contract"/.test(memberToml)) {
-          const nameMatch = memberToml.match(/name\s*=\s*"([^"]+)"/);
-          if (nameMatch) {
-            contractNames.add(nameMatch[1]);
-          }
-        }
-      } catch {
-        // Member directory might not exist or have no Nargo.toml; skip.
-      }
-    }
-  } else {
-    // Single-crate project (no workspace): check if the root Nargo.toml itself is a contract.
-    if (/type\s*=\s*"contract"/.test(rootToml)) {
-      const nameMatch = rootToml.match(/name\s*=\s*"([^"]+)"/);
-      if (nameMatch) {
-        contractNames.add(nameMatch[1]);
-      }
-    }
-  }
-
-  return contractNames;
-}
-
-/** Checks that no tests exist in contract crates and fails with a helpful message if they do. */
-async function checkNoTestsInContracts(nargo: string, log: LogFn): Promise<void> {
-  const contractPackages = await getContractPackageNames();
-  if (contractPackages.size === 0) {
-    return;
-  }
-
-  let output: string;
-  try {
-    // We list tests for all the crates in the workspace
-    output = execFileSync(nargo, ['test', '--list-tests', '--silence-warnings'], {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'inherit'],
-    });
-  } catch {
-    // If listing tests fails (e.g. test crate has compile errors), skip the check.
-    return;
-  }
-
-  // The output of the `nargo test --list-tests` command is as follows:
-  // ```
-  // crate_name_1 test_name_1
-  // crate_name_2 test_name_2
-  // ...
-  // crate_name_n test_name_n
-  // ```
-  //
-  // We parse the individual lines and then we check if any contract crate appeared in the parsed output.
-  const lines = output
-    .trim()
-    .split('\n')
-    .filter(line => line.length > 0);
-  const testsInContracts: { packageName: string; testName: string }[] = [];
-
-  for (const line of lines) {
-    const spaceIndex = line.indexOf(' ');
-    if (spaceIndex === -1) {
-      continue;
-    }
-    const packageName = line.substring(0, spaceIndex);
-    const testName = line.substring(spaceIndex + 1);
-    if (contractPackages.has(packageName)) {
-      testsInContracts.push({ packageName, testName });
-    }
-  }
-
-  if (testsInContracts.length > 0) {
-    const details = testsInContracts.map(t => `  ${t.packageName}::${t.testName}`).join('\n');
-    log(
-      `WARNING: Found tests in contract crate(s):\n${details}\n\n` +
-        `Tests should be in a dedicated test crate, not in the contract crate.\n` +
-        `Learn more: https://docs.aztec.network/errors/1`,
-    );
-  }
-}
-
 /** Compiles Aztec Noir contracts and postprocesses artifacts. */
 async function compileAztecContract(nargoArgs: string[], log: LogFn): Promise<void> {
   const nargo = process.env.NARGO ?? 'nargo';
@@ -142,9 +41,6 @@ async function compileAztecContract(nargoArgs: string[], log: LogFn): Promise<vo
 
   await run(nargo, ['compile', ...nargoArgs]);
 
-  // Ensure contract crates contain no tests (tests belong in the test crate).
-  await checkNoTestsInContracts(nargo, log);
-
   const artifacts = await collectContractArtifacts();
 
   if (artifacts.length > 0) {

package/src/cli/cmds/standby.ts

@@ -0,0 +1,132 @@
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { Fr } from '@aztec/aztec.js/fields';
+import { getSponsoredFPCAddress } from '@aztec/cli/cli-utils';
+import { getPublicClient } from '@aztec/ethereum/client';
+import type { GenesisStateConfig } from '@aztec/ethereum/config';
+import { RegistryContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import type { LogFn } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import Koa from 'koa';
+
+const ROLLUP_POLL_INTERVAL_S = 60;
+
+/**
+ * Computes the expected genesis archive root from the genesis state config.
+ * Reads test accounts and sponsored FPC addresses as specified, then computes
+ * the genesis values including the archive root and prefilled public data.
+ */
+export async function computeExpectedGenesisRoot(config: GenesisStateConfig, userLog: LogFn) {
+  const testAccounts = config.testAccounts ? (await getInitialTestAccountsData()).map(a => a.address) : [];
+  const sponsoredFPCAccounts = config.sponsoredFPC ? [await getSponsoredFPCAddress()] : [];
+  const prefundAddresses = (config.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const initialFundedAccounts = testAccounts.concat(sponsoredFPCAccounts).concat(prefundAddresses);
+
+  userLog(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
+
+  const { genesisArchiveRoot, prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
+
+  userLog(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+
+  return { genesisArchiveRoot, prefilledPublicData };
+}
+
+async function checkRollupCompatibility(
+  rollup: RollupContract,
+  expected: { genesisArchiveRoot: Fr; vkTreeRoot: Fr; protocolContractsHash: Fr },
+): Promise<string[]> {
+  const mismatches: string[] = [];
+  const [l1Genesis, l1Vk, l1Protocol] = await Promise.all([
+    rollup.getGenesisArchiveTreeRoot(),
+    rollup.getVkTreeRoot(),
+    rollup.getProtocolContractsHash(),
+  ]);
+  if (!l1Genesis.equals(expected.genesisArchiveRoot)) {
+    mismatches.push(`genesis archive root (expected ${expected.genesisArchiveRoot}, got ${l1Genesis})`);
+  }
+  if (!l1Vk.equals(expected.vkTreeRoot)) {
+    mismatches.push(`VK tree root (expected ${expected.vkTreeRoot}, got ${l1Vk})`);
+  }
+  if (!l1Protocol.equals(expected.protocolContractsHash)) {
+    mismatches.push(`protocol contracts hash (expected ${expected.protocolContractsHash}, got ${l1Protocol})`);
+  }
+  return mismatches;
+}
+
+/**
+ * Waits until the canonical rollup's genesis archive root, VK tree root, and protocol contracts hash
+ * all match the expected local values. If the rollup is not yet compatible (e.g. during L1 contract upgrades),
+ * enters standby mode: starts a lightweight HTTP server for K8s liveness probes and polls every 60s
+ * until a compatible rollup appears.
+ */
+export async function waitForCompatibleRollup(
+  config: {
+    l1RpcUrls: string[];
+    l1ChainId: number;
+    l1Contracts: { registryAddress: EthAddress };
+    rollupVersion?: number;
+  },
+  expected: { genesisArchiveRoot: Fr; vkTreeRoot: Fr; protocolContractsHash: Fr },
+  port: number | undefined,
+  userLog: LogFn,
+): Promise<void> {
+  const publicClient = getPublicClient(config);
+  const rollupVersion: number | 'canonical' = config.rollupVersion ?? 'canonical';
+
+  const registry = new RegistryContract(publicClient, config.l1Contracts.registryAddress);
+  const rollupAddress = await registry.getRollupAddress(rollupVersion);
+  const rollup = new RollupContract(publicClient, rollupAddress.toString());
+
+  let mismatches: string[];
+  try {
+    mismatches = await checkRollupCompatibility(rollup, expected);
+  } catch (err: any) {
+    throw new Error(`Could not retrieve rollup config from canonical rollup at ${rollupAddress}: ${err.message}`);
+  }
+
+  if (mismatches.length === 0) {
+    return;
+  }
+
+  userLog(
+    `Rollup at ${rollupAddress} is incompatible: ${mismatches.join('; ')}. ` +
+      `Entering standby mode. Will poll every ${ROLLUP_POLL_INTERVAL_S}s for a compatible rollup...`,
+  );
+
+  const standbyServer = await startHttpRpcServer({ getApp: () => new Koa(), isHealthy: () => true }, { port });
+  userLog(`Standby status server listening on port ${standbyServer.port}`);
+
+  try {
+    await retryUntil(
+      async () => {
+        const currentRollupAddress = await registry.getRollupAddress(rollupVersion);
+        const currentRollup = new RollupContract(publicClient, currentRollupAddress.toString());
+
+        let currentMismatches: string[];
+        try {
+          currentMismatches = await checkRollupCompatibility(currentRollup, expected);
+        } catch {
+          userLog(`Failed to fetch rollup config from rollup at ${currentRollupAddress}. Retrying...`);
+          return undefined;
+        }
+
+        if (currentMismatches.length === 0) {
+          userLog(`Compatible rollup found at ${currentRollupAddress}. Exiting standby mode.`);
+          return true;
+        }
+
+        userLog(`Still waiting. Rollup at ${currentRollupAddress}: ${currentMismatches.join('; ')}.`);
+        return undefined;
+      },
+      'compatible rollup',
+      0,
+      ROLLUP_POLL_INTERVAL_S,
+    );
+  } finally {
+    await new Promise<void>((resolve, reject) => standbyServer.close(err => (err ? reject(err) : resolve())));
+  }
+}

package/src/cli/cmds/start_node.ts

@@ -1,17 +1,14 @@
-import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { type AztecNodeConfig, aztecNodeConfigMappings, getConfigEnvVars } from '@aztec/aztec-node';
 import { Fr } from '@aztec/aztec.js/fields';
-import { getSponsoredFPCAddress } from '@aztec/cli/cli-utils';
 import { getL1Config } from '@aztec/cli/config';
 import { getPublicClient } from '@aztec/ethereum/client';
-import { RegistryContract, RollupContract } from '@aztec/ethereum/contracts';
-import { SecretValue } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
+import { getGenesisStateConfigEnvVars } from '@aztec/ethereum/config';
+import { type NetworkNames, SecretValue } from '@aztec/foundation/config';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
 import { Agent, makeUndiciFetch } from '@aztec/foundation/json-rpc/undici';
 import type { LogFn } from '@aztec/foundation/log';
-import { sleep } from '@aztec/foundation/sleep';
+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 { type CliPXEOptions, type PXEConfig, allPxeConfigMappings } from '@aztec/pxe/config';
 import { AztecNodeAdminApiSchema, AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
@@ -23,92 +20,25 @@ import {
   telemetryClientConfigMappings,
 } from '@aztec/telemetry-client';
 import { EmbeddedWallet } from '@aztec/wallets/embedded';
-import { getGenesisValues } from '@aztec/world-state/testing';
-
-import Koa from 'koa';
 
 import { createAztecNode } from '../../local-network/index.js';
 import {
   extractNamespacedOptions,
   extractRelevantOptions,
   preloadCrsDataForVerifying,
-  setupUpdateMonitor,
+  setupVersionChecker,
 } from '../util.js';
 import { getVersions } from '../versioning.js';
+import { computeExpectedGenesisRoot, waitForCompatibleRollup } from './standby.js';
 import { startProverBroker } from './start_prover_broker.js';
 
-const ROLLUP_POLL_INTERVAL_MS = 600_000;
-
-/**
- * Waits until the canonical rollup's genesis archive root matches the expected local genesis root.
- * If the rollup is not yet compatible (e.g. during L1 contract upgrades), enters standby mode:
- * starts a lightweight HTTP server for K8s liveness probes and polls until a compatible rollup appears.
- */
-async function waitForCompatibleRollup(
-  publicClient: ReturnType<typeof getPublicClient>,
-  registryAddress: EthAddress,
-  rollupVersion: number | 'canonical',
-  expectedGenesisRoot: Fr,
-  port: number | undefined,
-  userLog: LogFn,
-): Promise<void> {
-  const registry = new RegistryContract(publicClient, registryAddress);
-  const rollupAddress = await registry.getRollupAddress(rollupVersion);
-  const rollup = new RollupContract(publicClient, rollupAddress.toString());
-
-  let l1GenesisRoot: Fr;
-  try {
-    l1GenesisRoot = await rollup.getGenesisArchiveTreeRoot();
-  } catch (err: any) {
-    throw new Error(
-      `Could not retrieve genesis archive root from canonical rollup at ${rollupAddress}: ${err.message}`,
-    );
-  }
-
-  if (l1GenesisRoot.equals(expectedGenesisRoot)) {
-    return;
-  }
-
-  userLog(
-    `Genesis root mismatch: expected ${expectedGenesisRoot}, got ${l1GenesisRoot} from rollup at ${rollupAddress}. ` +
-      `Entering standby mode. Will poll every ${ROLLUP_POLL_INTERVAL_MS / 1000}s for a compatible rollup...`,
-  );
-
-  const standbyServer = await startHttpRpcServer({ getApp: () => new Koa(), isHealthy: () => true }, { port });
-  userLog(`Standby status server listening on port ${standbyServer.port}`);
-
-  try {
-    while (true) {
-      await sleep(ROLLUP_POLL_INTERVAL_MS);
-
-      const currentRollupAddress = await registry.getRollupAddress(rollupVersion);
-      const currentRollup = new RollupContract(publicClient, currentRollupAddress.toString());
-
-      try {
-        l1GenesisRoot = await currentRollup.getGenesisArchiveTreeRoot();
-      } catch {
-        userLog(`Failed to fetch genesis root from rollup at ${currentRollupAddress}. Retrying...`);
-        continue;
-      }
-
-      if (l1GenesisRoot.equals(expectedGenesisRoot)) {
-        userLog(`Compatible rollup found at ${currentRollupAddress}. Exiting standby mode.`);
-        return;
-      }
-
-      userLog(`Still waiting. Rollup at ${currentRollupAddress} has genesis root ${l1GenesisRoot}.`);
-    }
-  } finally {
-    await new Promise<void>((resolve, reject) => standbyServer.close(err => (err ? reject(err) : resolve())));
-  }
-}
-
 export async function startNode(
   options: any,
   signalHandlers: (() => Promise<void>)[],
   services: NamespacedApiHandlers,
   adminServices: NamespacedApiHandlers,
   userLog: LogFn,
+  networkName: NetworkNames,
 ): Promise<{ config: AztecNodeConfig }> {
   // All options set from environment variables
   const configFromEnvVars = getConfigEnvVars();
@@ -152,15 +82,8 @@ export async function startNode(
 
   await preloadCrsDataForVerifying(nodeConfig, userLog);
 
-  const testAccounts = nodeConfig.testAccounts ? (await getInitialTestAccountsData()).map(a => a.address) : [];
-  const sponsoredFPCAccounts = nodeConfig.sponsoredFPC ? [await getSponsoredFPCAddress()] : [];
-  const initialFundedAccounts = testAccounts.concat(sponsoredFPCAccounts);
-
-  userLog(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
-
-  const { genesisArchiveRoot, prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
-
-  userLog(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+  const genesisConfig = getGenesisStateConfigEnvVars();
+  const { genesisArchiveRoot, prefilledPublicData } = await computeExpectedGenesisRoot(genesisConfig, userLog);
 
   const followsCanonicalRollup =
     typeof nodeConfig.rollupVersion !== 'number' || (nodeConfig.rollupVersion as unknown as string) === 'canonical';
@@ -171,13 +94,9 @@ export async function startNode(
 
   // Wait for a compatible rollup before proceeding with full L1 config fetch.
   // This prevents crashes when the canonical rollup hasn't been upgraded yet.
-  const publicClient = getPublicClient(nodeConfig);
-  const rollupVersion: number | 'canonical' = nodeConfig.rollupVersion ?? 'canonical';
   await waitForCompatibleRollup(
-    publicClient,
-    nodeConfig.l1Contracts.registryAddress,
-    rollupVersion,
-    genesisArchiveRoot,
+    nodeConfig,
+    { genesisArchiveRoot, vkTreeRoot: getVKTreeRoot(), protocolContractsHash },
     options.port,
     userLog,
   );
@@ -268,16 +187,19 @@ export async function startNode(
     await addBot(options, signalHandlers, services, wallet, node, telemetry, undefined);
   }
 
-  if (nodeConfig.autoUpdate !== 'disabled' && nodeConfig.autoUpdateUrl) {
-    await setupUpdateMonitor(
-      nodeConfig.autoUpdate,
-      new URL(nodeConfig.autoUpdateUrl),
-      followsCanonicalRollup,
-      getPublicClient(nodeConfig!),
-      nodeConfig.l1Contracts.registryAddress,
-      signalHandlers,
-      async config => node.setConfig((await AztecNodeAdminApiSchema.setConfig.parameters().parseAsync([config]))[0]),
-    );
+  if (nodeConfig.enableVersionCheck && networkName !== 'local') {
+    const cacheDir = process.env.DATA_DIRECTORY ? `${process.env.DATA_DIRECTORY}/cache` : undefined;
+    try {
+      await setupVersionChecker(
+        networkName,
+        followsCanonicalRollup,
+        getPublicClient(nodeConfig!),
+        signalHandlers,
+        cacheDir,
+      );
+    } catch {
+      /* no-op */
+    }
   }
 
   return { config: nodeConfig };

package/src/cli/cmds/start_prover_broker.ts

@@ -1,7 +1,9 @@
 import { getL1Config } from '@aztec/cli/config';
-import { getPublicClient } from '@aztec/ethereum/client';
+import { getGenesisStateConfigEnvVars } from '@aztec/ethereum/config';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
 import type { LogFn } from '@aztec/foundation/log';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import {
   type ProverBrokerConfig,
   ProvingJobBrokerSchema,
@@ -13,7 +15,8 @@ import { getProverNodeBrokerConfigFromEnv } from '@aztec/prover-node';
 import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
 
-import { extractRelevantOptions, setupUpdateMonitor } from '../util.js';
+import { extractRelevantOptions } from '../util.js';
+import { computeExpectedGenesisRoot, waitForCompatibleRollup } from './standby.js';
 
 export async function startProverBroker(
   options: any,
@@ -35,7 +38,15 @@ export async function startProverBroker(
     throw new Error('L1 registry address is required to start Aztec Node without --deploy-aztec-contracts option');
   }
 
-  const followsCanonicalRollup = typeof config.rollupVersion !== 'number';
+  const genesisConfig = getGenesisStateConfigEnvVars();
+  const { genesisArchiveRoot } = await computeExpectedGenesisRoot(genesisConfig, userLog);
+  await waitForCompatibleRollup(
+    config,
+    { genesisArchiveRoot, vkTreeRoot: getVKTreeRoot(), protocolContractsHash },
+    options.port,
+    userLog,
+  );
+
   const { addresses, config: rollupConfig } = await getL1Config(
     config.l1Contracts.registryAddress,
     config.l1RpcUrls,
@@ -49,17 +60,6 @@ export async function startProverBroker(
   const client = await initTelemetryClient(getTelemetryClientConfig());
   const broker = await createAndStartProvingBroker(config, client);
 
-  if (options.autoUpdate !== 'disabled' && options.autoUpdateUrl) {
-    await setupUpdateMonitor(
-      options.autoUpdate,
-      new URL(options.autoUpdateUrl),
-      followsCanonicalRollup,
-      getPublicClient(config),
-      config.l1Contracts.registryAddress,
-      signalHandlers,
-    );
-  }
-
   services.proverBroker = [
     broker,
     config.proverBrokerDebugReplayEnabled ? ProvingJobBrokerSchemaWithDebug : ProvingJobBrokerSchema,