@aztec/aztec 0.0.1-commit.04852196a → 0.0.1-commit.04d373f

package/src/cli/aztec_start_options.ts

@@ -36,7 +36,7 @@ export interface AztecStartOption {
   parseVal?: (val: string) => any;
 }
 
-export const getOptions = (namespace: string, configMappings: Record<string, ConfigMapping>) => {
+export const getOptions = (namespace: string, configMappings: Record<string, ConfigMapping<unknown>>) => {
   const options: AztecStartOption[] = [];
   for (const [key, { env, defaultValue: def, parseEnv, description, printDefault, fallback }] of Object.entries(
     configMappings,
@@ -58,7 +58,11 @@ export const getOptions = (namespace: string, configMappings: Record<string, Con
   return options;
 };
 
-const configToFlag = (flag: string, configMapping: ConfigMapping, overrideDefaultValue?: any): AztecStartOption => {
+const configToFlag = (
+  flag: string,
+  configMapping: ConfigMapping<unknown>,
+  overrideDefaultValue?: any,
+): AztecStartOption => {
   if (!configMapping.isBoolean) {
     flag += ' <value>';
   }
@@ -125,6 +129,12 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       defaultValue: DefaultMnemonic,
       env: 'MNEMONIC',
     },
+    {
+      flag: '--local-network.testAccounts',
+      description: 'Deploy test accounts on local network start',
+      env: 'TEST_ACCOUNTS',
+      ...booleanConfigHelper(true),
+    },
   ],
   API: [
     {
@@ -165,6 +175,13 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       env: 'AZTEC_RESET_ADMIN_API_KEY',
       parseVal: val => val === 'true' || val === '1',
     },
+    {
+      flag: '--node-debug',
+      description: 'Expose debug endpoints (e.g. mineBlock) on the main RPC port',
+      defaultValue: false,
+      env: 'AZTEC_NODE_DEBUG',
+      parseVal: val => val === undefined || val === 'true' || val === '1',
+    },
     {
       flag: '--api-prefix <value>',
       description: 'Prefix for API routes on any service that is started',
@@ -205,12 +222,6 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
     },
   ],
   ARCHIVER: [
-    {
-      flag: '--archiver',
-      description: 'Starts Aztec Archiver with options',
-      defaultValue: undefined,
-      env: undefined,
-    },
     ...getOptions(
       'archiver',
       omitConfigMappings(archiverConfigMappings, Object.keys(l1ContractsConfigMappings) as (keyof ArchiverConfig)[]),
@@ -257,11 +268,7 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       defaultValue: undefined,
       env: undefined,
     },
-    ...getOptions(
-      'proverBroker',
-      // filter out archiver options from prover node options as they're passed separately in --archiver
-      proverBrokerConfigMappings,
-    ),
+    ...getOptions('proverBroker', proverBrokerConfigMappings),
   ],
   'PROVER AGENT': [
     {
@@ -309,15 +316,7 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
     },
     ...getOptions('bot', botConfigMappings),
   ],
-  PXE: [
-    {
-      flag: '--pxe',
-      description: 'Starts Aztec PXE with options',
-      defaultValue: undefined,
-      env: undefined,
-    },
-    ...getOptions('pxe', allPxeConfigMappings),
-  ],
+  PXE: [...getOptions('pxe', allPxeConfigMappings)],
   TXE: [
     {
       flag: '--txe',

package/src/cli/cmds/compile.ts

@@ -1,4 +1,6 @@
+import { findBbBinary } from '@aztec/bb.js';
 import type { LogFn } from '@aztec/foundation/log';
+import { getPackageVersion } from '@aztec/stdlib/update-checker';
 
 import { execFileSync } from 'child_process';
 import type { Command } from 'commander';
@@ -8,6 +10,7 @@ import { join } from 'path';
 import { readArtifactFiles } from './utils/artifacts.js';
 import { needsRecompile } from './utils/needs_recompile.js';
 import { run } from './utils/spawn.js';
+import { warnIfAztecVersionMismatch } from './utils/warn_if_aztec_version_mismatch.js';
 
 /** Returns paths to contract artifacts in the target directory. */
 async function collectContractArtifacts(): Promise<string[]> {
@@ -23,15 +26,13 @@ async function collectContractArtifacts(): Promise<string[]> {
   return files.filter(f => Array.isArray(f.content.functions)).map(f => f.filePath);
 }
 
-/** Strips the `__aztec_nr_internals__` prefix from function names in contract artifacts. */
-async function stripInternalPrefixes(artifactPaths: string[]): Promise<void> {
+/** Stamps the Aztec stack version into the contract artifacts. */
+async function stampAztecVersion(artifactPaths: string[]): Promise<void> {
+  const version = getPackageVersion();
   for (const path of artifactPaths) {
     const artifact = JSON.parse(await readFile(path, 'utf-8'));
-    for (const fn of artifact.functions) {
-      if (typeof fn.name === 'string') {
-        fn.name = fn.name.replace(/^__aztec_nr_internals__/, '');
-      }
-    }
+    // eslint-disable-next-line camelcase
+    artifact.aztec_version = version;
     await writeFile(path, JSON.stringify(artifact, null, 2) + '\n');
   }
 }
@@ -138,13 +139,15 @@ async function checkNoTestsInContracts(nargo: string, log: LogFn): Promise<void>
 
 /** Compiles Aztec Noir contracts and postprocesses artifacts. */
 async function compileAztecContract(nargoArgs: string[], log: LogFn): Promise<void> {
+  await warnIfAztecVersionMismatch(log);
+
   if (!(await needsRecompile())) {
     log('No source changes detected, skipping compilation.');
     return;
   }
 
   const nargo = process.env.NARGO ?? 'nargo';
-  const bb = process.env.BB ?? 'bb';
+  const bb = process.env.BB ?? findBbBinary() ?? 'bb';
 
   await run(nargo, ['compile', ...nargoArgs]);
 
@@ -158,8 +161,7 @@ async function compileAztecContract(nargoArgs: string[], log: LogFn): Promise<vo
     const bbArgs = artifacts.flatMap(a => ['-i', a]);
     await run(bb, ['aztec_process', ...bbArgs]);
 
-    // TODO: This should be part of bb aztec_process!
-    await stripInternalPrefixes(artifacts);
+    await stampAztecVersion(artifacts);
   }
 
   log('Compilation complete!');

package/src/cli/cmds/profile.ts

@@ -11,8 +11,9 @@ export function injectProfileCommand(program: Command, log: LogFn): Command {
   profile
     .command('gates')
     .argument('[target-dir]', 'Path to the compiled artifacts directory', './target')
+    .option('--json', 'Output gate counts as JSON instead of a table', false)
     .description('Display gate counts for all compiled Aztec artifacts in a target directory.')
-    .action((targetDir: string) => profileGates(targetDir, log));
+    .action((targetDir: string, options: { json: boolean }) => profileGates(targetDir, options.json, log));
 
   profile
     .command('flamegraph')

package/src/cli/cmds/profile_flamegraph.ts

@@ -1,3 +1,4 @@
+import { findBbBinary } from '@aztec/bb.js';
 import type { LogFn } from '@aztec/foundation/log';
 
 import { readFile, rename, rm, writeFile } from 'fs/promises';
@@ -33,7 +34,7 @@ export async function profileFlamegraph(artifactPath: string, functionName: stri
     await writeFile(functionArtifact, makeFunctionArtifact(artifact, func));
 
     const profiler = process.env.PROFILER_PATH ?? 'noir-profiler';
-    const bb = process.env.BB ?? 'bb';
+    const bb = process.env.BB ?? findBbBinary() ?? 'bb';
 
     await run(profiler, [
       'gates',

package/src/cli/cmds/profile_gates.ts

@@ -1,3 +1,4 @@
+import { findBbBinary } from '@aztec/bb.js';
 import { asyncPool } from '@aztec/foundation/async-pool';
 import type { LogFn } from '@aztec/foundation/log';
 
@@ -5,12 +6,13 @@ import { execFile as execFileCb } from 'child_process';
 import { rm } from 'fs/promises';
 import { promisify } from 'util';
 
-import { MAX_CONCURRENT, discoverArtifacts } from './profile_utils.js';
+import { type DiscoveredArtifact, MAX_CONCURRENT, discoverArtifacts } from './profile_utils.js';
 
 const execFile = promisify(execFileCb);
 
 interface GateCountResult {
   name: string;
+  type: DiscoveredArtifact['type'];
   gateCount: number;
 }
 
@@ -31,24 +33,39 @@ async function getGateCount(bb: string, artifactPath: string): Promise<number> {
 }
 
 /** Profiles all compiled artifacts in a target directory and prints gate counts. */
-export async function profileGates(targetDir: string, log: LogFn): Promise<void> {
-  const bb = process.env.BB ?? 'bb';
+export async function profileGates(targetDir: string, json: boolean, log: LogFn): Promise<void> {
+  const bb = process.env.BB ?? findBbBinary() ?? 'bb';
   const { artifacts, tmpDir } = await discoverArtifacts(targetDir);
 
   if (artifacts.length === 0) {
-    log('No artifacts found in target directory.');
+    if (json) {
+      log('[]');
+    } else {
+      log('No artifacts found in target directory.');
+    }
     return;
   }
 
   try {
     const results: GateCountResult[] = await asyncPool(MAX_CONCURRENT, artifacts, async artifact => ({
       name: artifact.name,
+      type: artifact.type,
       gateCount: await getGateCount(bb, artifact.filePath),
     }));
     results.sort((a, b) => a.name.localeCompare(b.name));
 
     if (results.length === 0) {
-      log('No constrained circuits found.');
+      if (json) {
+        log('[]');
+      } else {
+        log('No constrained circuits found.');
+      }
+      return;
+    }
+
+    if (json) {
+      const entries = results.map(r => ({ name: r.name, type: r.type, gates: r.gateCount }));
+      log(JSON.stringify(entries, null, 2));
       return;
     }
 

package/src/cli/cmds/standby.ts

@@ -28,51 +28,72 @@ export async function computeExpectedGenesisRoot(config: GenesisStateConfig, use
 
   userLog(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
 
-  const { genesisArchiveRoot, prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
+  const { genesisArchiveRoot, genesis } = await getGenesisValues(initialFundedAccounts);
 
   userLog(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
 
-  return { genesisArchiveRoot, prefilledPublicData };
+  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 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 every 60s until a compatible rollup appears.
+ * 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 };
+    registryAddress: EthAddress;
     rollupVersion?: number;
   },
-  expectedGenesisRoot: Fr,
+  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 registry = new RegistryContract(publicClient, config.registryAddress);
   const rollupAddress = await registry.getRollupAddress(rollupVersion);
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
 
-  let l1GenesisRoot: Fr;
+  let mismatches: string[];
   try {
-    l1GenesisRoot = await rollup.getGenesisArchiveTreeRoot();
+    mismatches = await checkRollupCompatibility(rollup, expected);
   } catch (err: any) {
-    throw new Error(
-      `Could not retrieve genesis archive root from canonical rollup at ${rollupAddress}: ${err.message}`,
-    );
+    throw new Error(`Could not retrieve rollup config from canonical rollup at ${rollupAddress}: ${err.message}`);
   }
 
-  if (l1GenesisRoot.equals(expectedGenesisRoot)) {
+  if (mismatches.length === 0) {
     return;
   }
 
   userLog(
-    `Genesis root mismatch: expected ${expectedGenesisRoot}, got ${l1GenesisRoot} from rollup at ${rollupAddress}. ` +
+    `Rollup at ${rollupAddress} is incompatible: ${mismatches.join('; ')}. ` +
       `Entering standby mode. Will poll every ${ROLLUP_POLL_INTERVAL_S}s for a compatible rollup...`,
   );
 
@@ -85,20 +106,20 @@ export async function waitForCompatibleRollup(
         const currentRollupAddress = await registry.getRollupAddress(rollupVersion);
         const currentRollup = new RollupContract(publicClient, currentRollupAddress.toString());
 
-        let currentGenesisRoot: Fr;
+        let currentMismatches: string[];
         try {
-          currentGenesisRoot = await currentRollup.getGenesisArchiveTreeRoot();
+          currentMismatches = await checkRollupCompatibility(currentRollup, expected);
         } catch {
-          userLog(`Failed to fetch genesis root from rollup at ${currentRollupAddress}. Retrying...`);
+          userLog(`Failed to fetch rollup config from rollup at ${currentRollupAddress}. Retrying...`);
           return undefined;
         }
 
-        if (currentGenesisRoot.equals(expectedGenesisRoot)) {
+        if (currentMismatches.length === 0) {
           userLog(`Compatible rollup found at ${currentRollupAddress}. Exiting standby mode.`);
           return true;
         }
 
-        userLog(`Still waiting. Rollup at ${currentRollupAddress} has genesis root ${currentGenesisRoot}.`);
+        userLog(`Still waiting. Rollup at ${currentRollupAddress}: ${currentMismatches.join('; ')}.`);
         return undefined;
       },
       'compatible rollup',

package/src/cli/cmds/start_bot.ts

@@ -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);
   }
 

package/src/cli/cmds/start_node.ts

@@ -7,7 +7,13 @@ 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 { ProvingJobConsumerSchema, createProvingJobBrokerClient } from '@aztec/prover-client/broker';
+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, ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
@@ -63,12 +69,8 @@ export async function startNode(
     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
-      // 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 })),
-      );
+      // 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));
@@ -81,21 +83,26 @@ export async function startNode(
   await preloadCrsDataForVerifying(nodeConfig, userLog);
 
   const genesisConfig = getGenesisStateConfigEnvVars();
-  const { genesisArchiveRoot, prefilledPublicData } = await computeExpectedGenesisRoot(genesisConfig, userLog);
+  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, options.port, userLog);
+  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,
@@ -109,13 +116,9 @@ export async function startNode(
     );
   }
 
-  // TODO(#12272): will clean this up.
   nodeConfig = {
     ...nodeConfig,
-    l1Contracts: {
-      ...addresses,
-      slashFactoryAddress: nodeConfig.l1Contracts.slashFactoryAddress,
-    },
+    ...addresses,
     ...config,
   };
 
@@ -151,7 +154,7 @@ export async function startNode(
   const telemetry = await initTelemetryClient(telemetryConfig);
 
   // Create and start Aztec Node
-  const node = await createAztecNode(nodeConfig, { telemetry, proverBroker: broker }, { prefilledPublicData });
+  const node = await createAztecNode(nodeConfig, { telemetry, proverBroker: broker }, { genesis });
 
   // Add node and p2p to services list
   services.node = [node, AztecNodeApiSchema];

package/src/cli/cmds/start_prover_agent.ts

@@ -9,6 +9,7 @@ import {
   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,12 +46,8 @@ 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'));

package/src/cli/cmds/start_prover_broker.ts

@@ -2,6 +2,8 @@ import { getL1Config } from '@aztec/cli/config';
 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,
@@ -22,33 +24,37 @@ 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 genesisConfig = getGenesisStateConfigEnvVars();
   const { genesisArchiveRoot } = await computeExpectedGenesisRoot(genesisConfig, userLog);
-  await waitForCompatibleRollup(config, genesisArchiveRoot, options.port, 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);

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}`);
 }