@aztec/aztec 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

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, genesis } = await getGenesisValues(initialFundedAccounts);
+
+  userLog(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+
+  return { genesisArchiveRoot, genesis };
+}
+
+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;
+    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.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_bot.ts

@@ -10,9 +10,9 @@ import {
   initTelemetryClient,
   makeTracedFetch,
 } from '@aztec/telemetry-client';
-import { TestWallet } from '@aztec/test-wallet/server';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
-import { extractRelevantOptions } from '../util.js';
+import { extractRelevantOptions, stringifyConfig } from '../util.js';
 import { getVersions } from '../versioning.js';
 
 export async function startBot(
@@ -21,11 +21,9 @@ export async function startBot(
   services: NamespacedApiHandlers,
   userLog: LogFn,
 ) {
-  const { proverNode, archiver, sequencer, p2pBootstrap, txe, prover } = options;
-  if (proverNode || archiver || sequencer || p2pBootstrap || txe || prover) {
-    userLog(
-      `Starting a bot with --prover-node, --prover, --archiver, --sequencer, --p2p-bootstrap, or --txe is not supported.`,
-    );
+  const { proverNode, sequencer, p2pBootstrap, txe, prover } = options;
+  if (proverNode || sequencer || p2pBootstrap || txe || prover) {
+    userLog(`Starting a bot with --prover-node, --prover, --sequencer, --p2p-bootstrap, or --txe is not supported.`);
     process.exit(1);
   }
 
@@ -38,22 +36,25 @@ export async function startBot(
   const aztecNode = createAztecNodeClient(config.nodeUrl, getVersions(), fetch);
 
   const pxeConfig = extractRelevantOptions<PXEConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
-  const wallet = await TestWallet.create(aztecNode, pxeConfig);
+  userLog(`Creating bot wallet with config ${stringifyConfig(pxeConfig)}`);
+  const wallet = await EmbeddedWallet.create(aztecNode, { pxeConfig });
 
   const telemetry = await initTelemetryClient(getTelemetryClientConfig());
-  await addBot(options, signalHandlers, services, wallet, aztecNode, telemetry, undefined);
+  await addBot(options, signalHandlers, services, wallet, aztecNode, telemetry, undefined, userLog);
 }
 
 export async function addBot(
   options: any,
   signalHandlers: (() => Promise<void>)[],
   services: NamespacedApiHandlers,
-  wallet: TestWallet,
+  wallet: EmbeddedWallet,
   aztecNode: AztecNode,
   telemetry: TelemetryClient,
   aztecNodeAdmin?: AztecNodeAdmin,
+  userLog?: LogFn,
 ) {
   const config = extractRelevantOptions<BotConfig>(options, botConfigMappings, 'bot');
+  userLog?.(`Starting bot with config ${stringifyConfig(config)}`);
 
   const db = await (config.dataDirectory
     ? createStore('bot', BotStore.SCHEMA_VERSION, config)

package/src/cli/cmds/start_node.ts

@@ -1,30 +1,40 @@
-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 { SecretValue } from '@aztec/foundation/config';
+import { getGenesisStateConfigEnvVars } from '@aztec/ethereum/config';
+import { type NetworkNames, SecretValue } from '@aztec/foundation/config';
 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';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import {
+  ProvingJobConsumerSchema,
+  createProvingJobBrokerClient,
+  proverBrokerBackoff,
+} from '@aztec/prover-client/broker';
 import { type CliPXEOptions, type PXEConfig, allPxeConfigMappings } from '@aztec/pxe/config';
 import { AztecNodeAdminApiSchema, AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
-import { P2PApiSchema } from '@aztec/stdlib/interfaces/server';
+import { P2PApiSchema, ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import {
   type TelemetryClientConfig,
   initTelemetryClient,
+  makeTracedFetch,
   telemetryClientConfigMappings,
 } from '@aztec/telemetry-client';
-import { TestWallet } from '@aztec/test-wallet/server';
-import { getGenesisValues } from '@aztec/world-state/testing';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 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';
 
 export async function startNode(
   options: any,
@@ -32,6 +42,7 @@ export async function startNode(
   services: NamespacedApiHandlers,
   adminServices: NamespacedApiHandlers,
   userLog: LogFn,
+  networkName: NetworkNames,
 ): Promise<{ config: AztecNodeConfig }> {
   // All options set from environment variables
   const configFromEnvVars = getConfigEnvVars();
@@ -45,31 +56,53 @@ export async function startNode(
     ...relevantOptions,
   };
 
+  // Prover node configuration and broker setup
+  // REFACTOR: Move the broker setup out of here and into the prover-node factory
+  let broker: ProvingJobBroker | undefined = undefined;
   if (options.proverNode) {
-    userLog(`Running a Prover Node within a Node is not yet supported`);
-    process.exit(1);
+    nodeConfig.enableProverNode = true;
+    if (nodeConfig.proverAgentCount === 0) {
+      userLog(
+        `Running prover node without local prover agent. Connect prover agents or pass --proverAgent.proverAgentCount`,
+      );
+    }
+    if (nodeConfig.proverBrokerUrl) {
+      // at 1TPS we'd enqueue ~1k chonk verifier proofs and ~1k AVM proofs immediately
+      // set a lower connection limit such that we don't overload the server
+      // Retry indefinitely until the epoch proving times out and the chain reorgs
+      const fetch = makeTracedFetch(proverBrokerBackoff, false, makeUndiciFetch(new Agent({ connections: 100 })));
+      broker = createProvingJobBrokerClient(nodeConfig.proverBrokerUrl, getVersions(nodeConfig), fetch);
+    } else if (options.proverBroker) {
+      ({ broker } = await startProverBroker(options, signalHandlers, services, userLog));
+    } else {
+      userLog(`--prover-broker-url or --prover-broker is required to start a Prover Node`);
+      process.exit(1);
+    }
   }
 
   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, genesis } = await computeExpectedGenesisRoot(genesisConfig, userLog);
 
   const followsCanonicalRollup =
     typeof nodeConfig.rollupVersion !== 'number' || (nodeConfig.rollupVersion as unknown as string) === 'canonical';
 
-  if (!nodeConfig.l1Contracts.registryAddress || nodeConfig.l1Contracts.registryAddress.isZero()) {
+  if (!nodeConfig.registryAddress || nodeConfig.registryAddress.isZero()) {
     throw new Error('L1 registry address is required to start Aztec Node');
   }
+
+  // Wait for a compatible rollup before proceeding with full L1 config fetch.
+  // This prevents crashes when the canonical rollup hasn't been upgraded yet.
+  await waitForCompatibleRollup(
+    nodeConfig,
+    { genesisArchiveRoot, vkTreeRoot: getVKTreeRoot(), protocolContractsHash },
+    options.port,
+    userLog,
+  );
+
   const { addresses, config } = await getL1Config(
-    nodeConfig.l1Contracts.registryAddress,
+    nodeConfig.registryAddress,
     nodeConfig.l1RpcUrls,
     nodeConfig.l1ChainId,
     nodeConfig.rollupVersion,
@@ -83,13 +116,9 @@ export async function startNode(
     );
   }
 
-  // TODO(#12272): will clean this up.
   nodeConfig = {
     ...nodeConfig,
-    l1Contracts: {
-      ...addresses,
-      slashFactoryAddress: nodeConfig.l1Contracts.slashFactoryAddress,
-    },
+    ...addresses,
     ...config,
   };
 
@@ -101,12 +130,17 @@ export async function startNode(
       ...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.sequencerPublisherPrivateKeys === undefined ||
+      !sequencerConfig.sequencerPublisherPrivateKeys.length
+    ) {
       if (sequencerConfig.validatorPrivateKeys?.getValue().length) {
-        sequencerConfig.publisherPrivateKeys = [new SecretValue(sequencerConfig.validatorPrivateKeys.getValue()[0])];
+        sequencerConfig.sequencerPublisherPrivateKeys = [
+          new SecretValue(sequencerConfig.validatorPrivateKeys.getValue()[0]),
+        ];
       }
     }
-    nodeConfig.publisherPrivateKeys = sequencerConfig.publisherPrivateKeys;
+    nodeConfig.sequencerPublisherPrivateKeys = sequencerConfig.sequencerPublisherPrivateKeys;
   }
 
   if (nodeConfig.p2pEnabled) {
@@ -120,13 +154,22 @@ export async function startNode(
   const telemetry = await initTelemetryClient(telemetryConfig);
 
   // Create and start Aztec Node
-  const node = await createAztecNode(nodeConfig, { telemetry }, { prefilledPublicData });
+  const node = await createAztecNode(nodeConfig, { telemetry, proverBroker: broker }, { genesis });
 
   // Add node and p2p to services list
   services.node = [node, AztecNodeApiSchema];
   services.p2p = [node.getP2P(), P2PApiSchema];
   adminServices.nodeAdmin = [node, AztecNodeAdminApiSchema];
 
+  // Register prover-node services if the prover node subsystem is running
+  const proverNode = node.getProverNode();
+  if (proverNode) {
+    services.prover = [proverNode, ProverNodeApiSchema];
+    if (!nodeConfig.proverBrokerUrl) {
+      services.provingJobSource = [proverNode.getProver().getProvingJobSource(), ProvingJobConsumerSchema];
+    }
+  }
+
   // Add node stop function to signal handlers
   signalHandlers.push(node.stop.bind(node));
 
@@ -135,21 +178,24 @@ export async function startNode(
     const { addBot } = await import('./start_bot.js');
 
     const pxeConfig = extractRelevantOptions<PXEConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
-    const wallet = await TestWallet.create(node, pxeConfig);
+    const wallet = await EmbeddedWallet.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]),
-    );
+  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_p2p_bootstrap.ts

@@ -1,6 +1,6 @@
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import { type LogFn, createLogger } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { type BootnodeConfig, BootstrapNode, bootnodeConfigMappings } from '@aztec/p2p';
 import { emptyChainConfig } from '@aztec/stdlib/config';
@@ -27,7 +27,7 @@ export async function startP2PBootstrap(
   const telemetryConfig = extractRelevantOptions<TelemetryClientConfig>(options, telemetryClientConfigMappings, 'tel');
   const telemetryClient = await initTelemetryClient(telemetryConfig);
 
-  const store = await createStore('p2p-bootstrap', 1, config, createLogger('p2p:bootstrap:store'));
+  const store = await createStore('p2p-bootstrap', 1, config);
   const node = new BootstrapNode(store, telemetryClient);
   await node.start(config);
   signalHandlers.push(() => node.stop());

package/src/cli/cmds/start_prover_agent.ts

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

package/src/cli/cmds/start_prover_broker.ts

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

package/src/cli/cmds/start_txe.ts

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

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

@@ -0,0 +1,44 @@
+import { readFile, readdir } from 'fs/promises';
+import { join } from 'path';
+
+export interface CompiledArtifact {
+  noir_version: string;
+  file_map: unknown;
+  functions: ContractFunction[];
+  bytecode?: string;
+}
+
+export interface ContractFunction {
+  name: string;
+  abi: unknown;
+  bytecode: string;
+  debug_symbols: unknown;
+  is_unconstrained?: boolean;
+}
+
+export interface ArtifactFile {
+  name: string;
+  filePath: string;
+  content: CompiledArtifact;
+}
+
+/** Reads all JSON artifact files from a target directory and returns their parsed contents. */
+export async function readArtifactFiles(targetDir: string): Promise<ArtifactFile[]> {
+  let entries: string[];
+  try {
+    entries = (await readdir(targetDir)).filter(f => f.endsWith('.json'));
+  } catch (err: any) {
+    if (err?.code === 'ENOENT') {
+      throw new Error(`Target directory '${targetDir}' does not exist. Compile first with 'aztec compile'.`);
+    }
+    throw err;
+  }
+
+  const artifacts: ArtifactFile[] = [];
+  for (const file of entries) {
+    const filePath = join(targetDir, file);
+    const content = JSON.parse(await readFile(filePath, 'utf-8')) as CompiledArtifact;
+    artifacts.push({ name: file.replace('.json', ''), filePath, content });
+  }
+  return artifacts;
+}