@aztec/aztec 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/cli/cmds/start_bot.ts

@@ -1,11 +1,19 @@
-import { type BotConfig, BotRunner, botConfigMappings, getBotRunnerApiHandler } from '@aztec/bot';
+import { type BotConfig, BotRunner, BotStore, botConfigMappings, getBotRunnerApiHandler } from '@aztec/bot';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
 import type { LogFn } from '@aztec/foundation/log';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+import { createStore, openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import { type CliPXEOptions, type PXEConfig, allPxeConfigMappings } from '@aztec/pxe/config';
+import { type AztecNode, type AztecNodeAdmin, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
 import type { TelemetryClient } from '@aztec/telemetry-client';
-import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+import {
+  getConfigEnvVars as getTelemetryClientConfig,
+  initTelemetryClient,
+  makeTracedFetch,
+} from '@aztec/telemetry-client';
+import { TestWallet } from '@aztec/test-wallet/server';
 
 import { extractRelevantOptions } from '../util.js';
+import { getVersions } from '../versioning.js';
 
 export async function startBot(
   options: any,
@@ -20,26 +28,41 @@ export async function startBot(
     );
     process.exit(1);
   }
-  // Start a PXE client that is used by the bot if required
-  let pxe: PXE | undefined;
-  if (options.pxe) {
-    const { addPXE } = await import('./start_pxe.js');
-    ({ pxe } = await addPXE(options, signalHandlers, services, userLog));
+
+  const fetch = makeTracedFetch([1, 2, 3], true);
+  const config = extractRelevantOptions<BotConfig>(options, botConfigMappings, 'bot');
+  if (!config.nodeUrl) {
+    throw new Error('The bot requires access to a Node');
   }
 
+  const aztecNode = createAztecNodeClient(config.nodeUrl, getVersions(), fetch);
+
+  const pxeConfig = extractRelevantOptions<PXEConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
+  const wallet = await TestWallet.create(aztecNode, pxeConfig);
+
   const telemetry = initTelemetryClient(getTelemetryClientConfig());
-  await addBot(options, signalHandlers, services, { pxe, telemetry });
+  await addBot(options, signalHandlers, services, wallet, aztecNode, telemetry, undefined);
 }
 
-export function addBot(
+export async function addBot(
   options: any,
   signalHandlers: (() => Promise<void>)[],
   services: NamespacedApiHandlers,
-  deps: { pxe?: PXE; node?: AztecNode; telemetry: TelemetryClient },
+  wallet: TestWallet,
+  aztecNode: AztecNode,
+  telemetry: TelemetryClient,
+  aztecNodeAdmin?: AztecNodeAdmin,
 ) {
   const config = extractRelevantOptions<BotConfig>(options, botConfigMappings, 'bot');
 
-  const botRunner = new BotRunner(config, deps);
+  const db = await (config.dataDirectory
+    ? createStore('bot', BotStore.SCHEMA_VERSION, config)
+    : openTmpStore('bot', true, config.dataStoreMapSizeKb));
+
+  const store = new BotStore(db);
+  await store.cleanupOldClaims();
+
+  const botRunner = new BotRunner(config, wallet, aztecNode, telemetry, aztecNodeAdmin, store);
   if (!config.noStart) {
     void botRunner.start(); // Do not block since bot setup takes time
   }

package/src/cli/cmds/start_node.ts

@@ -1,35 +1,48 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { type AztecNodeConfig, aztecNodeConfigMappings, getConfigEnvVars } from '@aztec/aztec-node';
-import { NULL_KEY } from '@aztec/ethereum';
+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';
+import { SecretValue } from '@aztec/foundation/config';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
 import type { LogFn } from '@aztec/foundation/log';
-import { AztecNodeApiSchema, type PXE } from '@aztec/stdlib/interfaces/client';
+import { type CliPXEOptions, type PXEConfig, allPxeConfigMappings } from '@aztec/pxe/config';
+import { AztecNodeAdminApiSchema, AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
 import { P2PApiSchema } from '@aztec/stdlib/interfaces/server';
 import {
   type TelemetryClientConfig,
   initTelemetryClient,
   telemetryClientConfigMappings,
 } from '@aztec/telemetry-client';
+import { TestWallet } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
-
-import { createAztecNode, deployContractsToL1 } from '../../sandbox/index.js';
-import { getL1Config } from '../get_l1_config.js';
-import { extractNamespacedOptions, extractRelevantOptions } from '../util.js';
+import { createAztecNode } from '../../sandbox/index.js';
+import {
+  extractNamespacedOptions,
+  extractRelevantOptions,
+  preloadCrsDataForVerifying,
+  setupUpdateMonitor,
+} from '../util.js';
 
 export async function startNode(
   options: any,
   signalHandlers: (() => Promise<void>)[],
   services: NamespacedApiHandlers,
+  adminServices: NamespacedApiHandlers,
   userLog: LogFn,
 ): Promise<{ config: AztecNodeConfig }> {
-  // options specifically namespaced with --node.<option>
-  const nodeSpecificOptions = extractNamespacedOptions(options, 'node');
+  // All options set from environment variables
+  const configFromEnvVars = getConfigEnvVars();
+
+  // Extract relevant options from command line arguments
+  const relevantOptions = extractRelevantOptions(options, aztecNodeConfigMappings, 'node');
+
   // All options that are relevant to the Aztec Node
   let nodeConfig: AztecNodeConfig = {
-    ...getConfigEnvVars(),
-    ...extractRelevantOptions(options, aztecNodeConfigMappings, 'node'),
+    ...configFromEnvVars,
+    ...relevantOptions,
   };
 
   if (options.proverNode) {
@@ -37,81 +50,63 @@ export async function startNode(
     process.exit(1);
   }
 
-  const initialFundedAccounts = nodeConfig.testAccounts ? await getInitialTestAccounts() : [];
-  const { genesisBlockHash, genesisArchiveRoot, prefilledPublicData } = await getGenesisValues(
-    initialFundedAccounts.map(a => a.address),
-  );
+  await preloadCrsDataForVerifying(nodeConfig, userLog);
 
-  // Deploy contracts if needed
-  if (nodeSpecificOptions.deployAztecContracts || nodeSpecificOptions.deployAztecContractsSalt) {
-    let account;
-    if (nodeSpecificOptions.publisherPrivateKey) {
-      account = privateKeyToAccount(nodeSpecificOptions.publisherPrivateKey);
-    } else if (options.l1Mnemonic) {
-      account = mnemonicToAccount(options.l1Mnemonic);
-    } else {
-      throw new Error('--node.publisherPrivateKey or --l1-mnemonic is required to deploy L1 contracts');
-    }
-    // REFACTOR: We should not be calling a method from sandbox on the prod start flow
-    await deployContractsToL1(nodeConfig, account!, undefined, {
-      assumeProvenThroughBlockNumber: nodeSpecificOptions.assumeProvenThroughBlockNumber,
-      salt: nodeSpecificOptions.deployAztecContractsSalt,
-      genesisBlockHash,
-      genesisArchiveRoot,
-    });
-  }
-  // If not deploying, validate that any addresses and config provided are correct.
-  else {
-    if (!nodeConfig.l1Contracts.registryAddress || nodeConfig.l1Contracts.registryAddress.isZero()) {
-      throw new Error('L1 registry address is required to start Aztec Node without --deploy-aztec-contracts option');
-    }
-    const { addresses, config } = await getL1Config(
-      nodeConfig.l1Contracts.registryAddress,
-      nodeConfig.l1RpcUrls,
-      nodeConfig.l1ChainId,
-    );
+  const testAccounts = nodeConfig.testAccounts ? (await getInitialTestAccountsData()).map(a => a.address) : [];
+  const sponsoredFPCAccounts = nodeConfig.sponsoredFPC ? [await getSponsoredFPCAddress()] : [];
+  const initialFundedAccounts = testAccounts.concat(sponsoredFPCAccounts);
 
-    // TODO(#12272): will clean this up.
-    nodeConfig = {
-      ...nodeConfig,
-      l1Contracts: {
-        ...addresses,
-        slashFactoryAddress: nodeConfig.l1Contracts.slashFactoryAddress,
-      },
-      ...config,
-    };
+  userLog(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
+
+  const { genesisArchiveRoot, prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
+
+  userLog(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+
+  const followsCanonicalRollup =
+    typeof nodeConfig.rollupVersion !== 'number' || (nodeConfig.rollupVersion as unknown as string) === 'canonical';
+
+  if (!nodeConfig.l1Contracts.registryAddress || nodeConfig.l1Contracts.registryAddress.isZero()) {
+    throw new Error('L1 registry address is required to start Aztec Node');
   }
+  const { addresses, config } = await getL1Config(
+    nodeConfig.l1Contracts.registryAddress,
+    nodeConfig.l1RpcUrls,
+    nodeConfig.l1ChainId,
+    nodeConfig.rollupVersion,
+  );
 
-  // if no publisher private key, then use l1Mnemonic
-  if (!options.archiver) {
-    // expect archiver url in node config
-    const archiverUrl = nodeConfig.archiverUrl;
-    if (!archiverUrl) {
-      userLog('Archiver Service URL is required to start Aztec Node without --archiver option');
-      throw new Error('Archiver Service URL is required to start Aztec Node without --archiver option');
-    }
-    nodeConfig.archiverUrl = archiverUrl;
+  process.env.ROLLUP_CONTRACT_ADDRESS ??= addresses.rollupAddress.toString();
+
+  if (!Fr.fromHexString(config.genesisArchiveTreeRoot).equals(genesisArchiveRoot)) {
+    throw new Error(
+      `The computed genesis archive tree root ${genesisArchiveRoot} does not match the expected genesis archive tree root ${config.genesisArchiveTreeRoot} for the rollup deployed at ${addresses.rollupAddress}`,
+    );
   }
 
+  // TODO(#12272): will clean this up.
+  nodeConfig = {
+    ...nodeConfig,
+    l1Contracts: {
+      ...addresses,
+      slashFactoryAddress: nodeConfig.l1Contracts.slashFactoryAddress,
+    },
+    ...config,
+  };
+
   if (!options.sequencer) {
     nodeConfig.disableValidator = true;
   } else {
-    const sequencerConfig = extractNamespacedOptions(options, 'sequencer');
-    let account;
-    if (!sequencerConfig.publisherPrivateKey || sequencerConfig.publisherPrivateKey === NULL_KEY) {
-      if (!options.l1Mnemonic) {
-        userLog(
-          '--sequencer.publisherPrivateKey or --l1-mnemonic is required to start Aztec Node with --sequencer option',
-        );
-        throw new Error('Private key or Mnemonic is required to start Aztec Node with --sequencer option');
-      } else {
-        account = mnemonicToAccount(options.l1Mnemonic);
-        const privKey = account.getHdKey().privateKey;
-        nodeConfig.publisherPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
+    const sequencerConfig = {
+      ...configFromEnvVars,
+      ...extractNamespacedOptions(options, 'sequencer'),
+    };
+    // If no publisher private keys have been given, use the first validator key
+    if (sequencerConfig.publisherPrivateKeys === undefined || !sequencerConfig.publisherPrivateKeys.length) {
+      if (sequencerConfig.validatorPrivateKeys?.getValue().length) {
+        sequencerConfig.publisherPrivateKeys = [new SecretValue(sequencerConfig.validatorPrivateKeys.getValue()[0])];
       }
-    } else {
-      nodeConfig.publisherPrivateKey = sequencerConfig.publisherPrivateKey;
     }
+    nodeConfig.publisherPrivateKeys = sequencerConfig.publisherPrivateKeys;
   }
 
   if (nodeConfig.p2pEnabled) {
@@ -130,21 +125,31 @@ export async function startNode(
   // Add node and p2p to services list
   services.node = [node, AztecNodeApiSchema];
   services.p2p = [node.getP2P(), P2PApiSchema];
+  adminServices.nodeAdmin = [node, AztecNodeAdminApiSchema];
 
   // Add node stop function to signal handlers
   signalHandlers.push(node.stop.bind(node));
 
-  // Add a PXE client that connects to this node if requested
-  let pxe: PXE | undefined;
-  if (options.pxe) {
-    const { addPXE } = await import('./start_pxe.js');
-    ({ pxe } = await addPXE(options, signalHandlers, services, userLog, { node }));
-  }
-
   // Add a txs bot if requested
   if (options.bot) {
     const { addBot } = await import('./start_bot.js');
-    await addBot(options, signalHandlers, services, { pxe, node, telemetry });
+
+    const pxeConfig = extractRelevantOptions<PXEConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
+    const wallet = await TestWallet.create(node, pxeConfig);
+
+    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]),
+    );
   }
 
   return { config: nodeConfig };

package/src/cli/cmds/start_p2p_bootstrap.ts

@@ -5,7 +5,11 @@ import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { type BootnodeConfig, BootstrapNode, bootnodeConfigMappings } from '@aztec/p2p';
 import { emptyChainConfig } from '@aztec/stdlib/config';
 import { P2PBootstrapApiSchema } from '@aztec/stdlib/interfaces/server';
-import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+import {
+  type TelemetryClientConfig,
+  initTelemetryClient,
+  telemetryClientConfigMappings,
+} from '@aztec/telemetry-client';
 
 import { extractRelevantOptions } from '../util.js';
 
@@ -17,13 +21,17 @@ export async function startP2PBootstrap(
 ) {
   // Start a P2P bootstrap node.
   const config = extractRelevantOptions<BootnodeConfig>(options, bootnodeConfigMappings, 'p2p');
-  userLog(`Starting P2P bootstrap node with config: ${jsonStringify(config)}`);
-  const telemetryClient = initTelemetryClient(getTelemetryClientConfig());
+  const safeConfig = { ...config, peerIdPrivateKey: '<redacted>' };
+  userLog(`Starting P2P bootstrap node with config: ${jsonStringify(safeConfig)}`);
+
+  const telemetryConfig = extractRelevantOptions<TelemetryClientConfig>(options, telemetryClientConfigMappings, 'tel');
+  const telemetryClient = initTelemetryClient(telemetryConfig);
+
   const store = await createStore('p2p-bootstrap', 1, config, createLogger('p2p:bootstrap:store'));
   const node = new BootstrapNode(store, telemetryClient);
   await node.start(config);
   signalHandlers.push(() => node.stop());
   services.bootstrap = [node, P2PBootstrapApiSchema];
-  userLog(`P2P bootstrap node started on ${config.udpListenAddress}`);
+  userLog(`P2P bootstrap node started on ${config.p2pIp}:${config.p2pPort}`);
   return { config: emptyChainConfig };
 }

package/src/cli/cmds/start_prover_agent.ts

@@ -11,9 +11,10 @@ import {
   proverAgentConfigMappings,
 } from '@aztec/prover-client/broker';
 import { getProverNodeAgentConfigFromEnv } from '@aztec/prover-node';
+import { ProverAgentApiSchema } from '@aztec/stdlib/interfaces/server';
 import { initTelemetryClient, makeTracedFetch, telemetryClientConfigMappings } from '@aztec/telemetry-client';
 
-import { extractRelevantOptions } from '../util.js';
+import { extractRelevantOptions, preloadCrsDataForServerSideProving } from '../util.js';
 import { getVersions } from '../versioning.js';
 
 export async function startProverAgent(
@@ -33,14 +34,23 @@ export async function startProverAgent(
   };
 
   if (config.realProofs && (!config.bbBinaryPath || !config.acvmBinaryPath)) {
+    userLog(`Requested real proving but no path to bb or acvm binaries provided`);
     process.exit(1);
   }
 
   if (!config.proverBrokerUrl) {
+    userLog(`Missing prover broker URL. Pass --proverAgent.proverBrokerUrl <value>`);
     process.exit(1);
   }
 
-  const fetch = makeTracedFetch([1, 2, 3], false, makeUndiciFetch(new Agent({ connections: 10 })));
+  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 })),
+  );
   const broker = createProvingJobBrokerClient(config.proverBrokerUrl, getVersions(), fetch);
 
   const telemetry = initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
@@ -59,6 +69,16 @@ export async function startProverAgent(
       ),
   );
 
+  // expose all agents as individual services
+  for (let i = 0; i < agents.length; i++) {
+    services[`agent${i}`] = [agents[i], ProverAgentApiSchema, () => agents[i].getStatus().status !== 'stopped'];
+  }
+
+  // shortcut in the most common case of having a single running agent
+  if (agents.length === 1) {
+    services[`agent`] = [agents[0], ProverAgentApiSchema, () => agents[0].getStatus().status !== 'stopped'];
+  }
+
   await Promise.all(agents.map(agent => agent.start()));
 
   signalHandlers.push(async () => {

package/src/cli/cmds/start_prover_broker.ts

@@ -1,3 +1,5 @@
+import { getL1Config } from '@aztec/cli/config';
+import { getPublicClient } from '@aztec/ethereum';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
 import type { LogFn } from '@aztec/foundation/log';
 import {
@@ -10,8 +12,7 @@ import { getProverNodeBrokerConfigFromEnv } from '@aztec/prover-node';
 import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
 
-import { getL1Config } from '../get_l1_config.js';
-import { extractRelevantOptions } from '../util.js';
+import { extractRelevantOptions, setupUpdateMonitor } from '../util.js';
 
 export async function startProverBroker(
   options: any,
@@ -33,12 +34,31 @@ export async function startProverBroker(
     throw new Error('L1 registry address is required to start Aztec Node without --deploy-aztec-contracts option');
   }
 
-  const { addresses } = await getL1Config(config.l1Contracts.registryAddress, config.l1RpcUrls, config.l1ChainId);
+  const followsCanonicalRollup = typeof config.rollupVersion !== 'number';
+  const { addresses, config: rollupConfig } = await getL1Config(
+    config.l1Contracts.registryAddress,
+    config.l1RpcUrls,
+    config.l1ChainId,
+    config.rollupVersion,
+  );
 
   config.l1Contracts = addresses;
+  config.rollupVersion = rollupConfig.rollupVersion;
 
   const client = 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, ProvingJobBrokerSchema];
   signalHandlers.push(() => broker.stop());
 

package/src/cli/cmds/start_prover_node.ts

@@ -1,5 +1,8 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
-import { NULL_KEY } from '@aztec/ethereum';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+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';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
 import { Agent, makeUndiciFetch } from '@aztec/foundation/json-rpc/undici';
 import type { LogFn } from '@aztec/foundation/log';
@@ -10,15 +13,11 @@ import {
   getProverNodeConfigFromEnv,
   proverNodeConfigMappings,
 } from '@aztec/prover-node';
-import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
 import { P2PApiSchema, ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import { initTelemetryClient, makeTracedFetch, telemetryClientConfigMappings } from '@aztec/telemetry-client';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import { mnemonicToAccount } from 'viem/accounts';
-
-import { getL1Config } from '../get_l1_config.js';
-import { extractRelevantOptions } from '../util.js';
+import { extractRelevantOptions, preloadCrsDataForVerifying, setupUpdateMonitor } from '../util.js';
 import { getVersions } from '../versioning.js';
 import { startProverBroker } from './start_prover_broker.js';
 
@@ -38,53 +37,48 @@ export async function startProverNode(
     ...extractRelevantOptions<ProverNodeConfig>(options, proverNodeConfigMappings, 'proverNode'), // override with command line options
   };
 
-  if (!options.archiver && !proverConfig.archiverUrl) {
-    userLog('--archiver.archiverUrl is required to start a Prover Node without --archiver option');
-    process.exit(1);
-  }
-
-  if (!proverConfig.publisherPrivateKey || proverConfig.publisherPrivateKey === NULL_KEY) {
-    if (!options.l1Mnemonic) {
-      userLog(`--l1-mnemonic is required to start a Prover Node without --node.publisherPrivateKey`);
-      process.exit(1);
-    }
-    const hdAccount = mnemonicToAccount(options.l1Mnemonic);
-    const privKey = hdAccount.getHdKey().privateKey;
-    proverConfig.publisherPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
-  }
-
-  // TODO(palla/prover-node) L1 contract addresses should not silently default to zero,
-  // they should be undefined if not set and fail loudly.
-  // Load l1 contract addresses from aztec node if not set.
-  const isRollupAddressSet =
-    proverConfig.l1Contracts?.rollupAddress && !proverConfig.l1Contracts.rollupAddress.isZero();
-  const nodeUrl = proverConfig.nodeUrl ?? proverConfig.proverCoordinationNodeUrl;
-  if (nodeUrl && !isRollupAddressSet) {
-    userLog(`Loading L1 contract addresses from aztec node at ${nodeUrl}`);
-    proverConfig.l1Contracts = await createAztecNodeClient(nodeUrl).getL1ContractAddresses();
+  if (!proverConfig.l1Contracts.registryAddress || proverConfig.l1Contracts.registryAddress.isZero()) {
+    throw new Error('L1 registry address is required to start a Prover Node');
   }
 
-  // If we create an archiver here, validate the L1 config
-  if (options.archiver) {
-    if (!proverConfig.l1Contracts.registryAddress || proverConfig.l1Contracts.registryAddress.isZero()) {
-      throw new Error('L1 registry address is required to start a Prover Node with --archiver option');
-    }
-    const { addresses, config } = await getL1Config(
-      proverConfig.l1Contracts.registryAddress,
-      proverConfig.l1RpcUrls,
-      proverConfig.l1ChainId,
+  const followsCanonicalRollup = typeof proverConfig.rollupVersion !== 'number';
+  const { addresses, config } = await getL1Config(
+    proverConfig.l1Contracts.registryAddress,
+    proverConfig.l1RpcUrls,
+    proverConfig.l1ChainId,
+    proverConfig.rollupVersion,
+  );
+  process.env.ROLLUP_CONTRACT_ADDRESS ??= addresses.rollupAddress.toString();
+  proverConfig.l1Contracts = addresses;
+  proverConfig = { ...proverConfig, ...config };
+
+  const testAccounts = proverConfig.testAccounts ? (await getInitialTestAccountsData()).map(a => a.address) : [];
+  const sponsoredFPCAccounts = proverConfig.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()}`);
+
+  if (!Fr.fromHexString(config.genesisArchiveTreeRoot).equals(genesisArchiveRoot)) {
+    throw new Error(
+      `The computed genesis archive tree root ${genesisArchiveRoot} does not match the expected genesis archive tree root ${config.genesisArchiveTreeRoot} for the rollup deployed at ${addresses.rollupAddress}`,
     );
-    proverConfig.l1Contracts = addresses;
-    proverConfig = { ...proverConfig, ...config };
   }
 
   const telemetry = initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
 
   let broker: ProvingJobBroker;
   if (proverConfig.proverBrokerUrl) {
-    // at 1TPS we'd enqueue ~1k tube proofs and ~1k AVM proofs immediately
-    // set a lower connectio  limit such that we don't overload the server
-    const fetch = makeTracedFetch([1, 2, 3], false, makeUndiciFetch(new Agent({ connections: 100 })));
+    // 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 })),
+    );
     broker = createProvingJobBrokerClient(proverConfig.proverBrokerUrl, getVersions(proverConfig), fetch);
   } else if (options.proverBroker) {
     ({ broker } = await startProverBroker(options, signalHandlers, services, userLog));
@@ -99,14 +93,12 @@ export async function startProverNode(
     );
   }
 
-  const initialFundedAccounts = proverConfig.testAccounts ? await getInitialTestAccounts() : [];
-  const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts.map(a => a.address));
+  await preloadCrsDataForVerifying(proverConfig, userLog);
 
   const proverNode = await createProverNode(proverConfig, { telemetry, broker }, { prefilledPublicData });
   services.proverNode = [proverNode, ProverNodeApiSchema];
 
-  const p2p = proverNode.getP2P();
-  if (p2p) {
+  if (proverNode.getP2P()) {
     services.p2p = [proverNode.getP2P(), P2PApiSchema];
   }
 
@@ -116,6 +108,17 @@ export async function startProverNode(
 
   signalHandlers.push(proverNode.stop.bind(proverNode));
 
-  proverNode.start();
+  await proverNode.start();
+
+  if (proverConfig.autoUpdate !== 'disabled' && proverConfig.autoUpdateUrl) {
+    await setupUpdateMonitor(
+      proverConfig.autoUpdate,
+      new URL(proverConfig.autoUpdateUrl),
+      followsCanonicalRollup,
+      getPublicClient(proverConfig),
+      proverConfig.l1Contracts.registryAddress,
+      signalHandlers,
+    );
+  }
   return { config: proverConfig };
 }

package/src/cli/preload_crs.ts

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

package/src/cli/release_version.ts

@@ -0,0 +1,21 @@
+import { fileURLToPath } from '@aztec/foundation/url';
+
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+
+export const getCliVersion = () => {
+  const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+  const cliVersion: string = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+
+  // If the version is 0.1.0, this is a placeholder version and we are in a docker container; query release please for the latest version
+  if (cliVersion === '0.1.0') {
+    const releasePleasePath = resolve(
+      dirname(fileURLToPath(import.meta.url)),
+      '../../../../.release-please-manifest.json',
+    );
+    const releaseVersion = JSON.parse(readFileSync(releasePleasePath).toString())['.'];
+    return releaseVersion;
+  }
+
+  return cliVersion;
+};