@aztec/aztec 0.0.1-commit.c2eed6949 → 0.0.1-commit.c52d6e7

package/src/cli/cmds/compile.ts

@@ -1,5 +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';
@@ -9,9 +10,10 @@ 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[]> {
+/** Returns contract artifacts in the target directory along with whether each has already been postprocessed. */
+async function collectContractArtifacts(): Promise<ContractArtifactInfo[]> {
   let files;
   try {
     files = await readArtifactFiles('target');
@@ -21,18 +23,18 @@ async function collectContractArtifacts(): Promise<string[]> {
     }
     throw err;
   }
-  return files.filter(f => Array.isArray(f.content.functions)).map(f => f.filePath);
+  return files
+    .filter(f => Array.isArray(f.content.functions))
+    .map(f => ({ filePath: f.filePath, transpiled: f.content.transpiled === true }));
 }
 
-/** 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');
   }
 }
@@ -139,31 +141,36 @@ 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> {
-  if (!(await needsRecompile())) {
-    log('No source changes detected, skipping compilation.');
-    return;
-  }
+  await warnIfAztecVersionMismatch(log);
 
   const nargo = process.env.NARGO ?? 'nargo';
   const bb = process.env.BB ?? findBbBinary() ?? 'bb';
 
-  await run(nargo, ['compile', ...nargoArgs]);
+  const shouldRecompile = await needsRecompile();
+  if (shouldRecompile) {
+    await run(nargo, ['compile', ...nargoArgs]);
 
-  // Ensure contract crates contain no tests (tests belong in the test crate).
-  await checkNoTestsInContracts(nargo, log);
+    // Ensure contract crates contain no tests (tests belong in the test crate).
+    await checkNoTestsInContracts(nargo, log);
+  }
 
-  const artifacts = await collectContractArtifacts();
+  // Postprocess any untranspiled artifacts: those just produced by nargo above, and any left behind by a bare
+  // `nargo compile` run outside `aztec compile`.
+  const unprocessed = (await collectContractArtifacts()).filter(a => !a.transpiled).map(a => a.filePath);
 
-  if (artifacts.length > 0) {
+  if (unprocessed.length > 0) {
     log('Postprocessing contracts...');
-    const bbArgs = artifacts.flatMap(a => ['-i', a]);
+    const bbArgs = unprocessed.flatMap(a => ['-i', a]);
     await run(bb, ['aztec_process', ...bbArgs]);
 
-    // TODO: This should be part of bb aztec_process!
-    await stripInternalPrefixes(artifacts);
+    await stampAztecVersion(unprocessed);
   }
 
-  log('Compilation complete!');
+  if (shouldRecompile || unprocessed.length > 0) {
+    log('Compilation complete!');
+  } else {
+    log('No source changes detected, skipping compilation.');
+  }
 }
 
 export function injectCompileCommand(program: Command, log: LogFn): Command {
@@ -189,3 +196,10 @@ export function injectCompileCommand(program: Command, log: LogFn): Command {
 
   return program;
 }
+
+interface ContractArtifactInfo {
+  /** Path to the artifact JSON in the target directory. */
+  filePath: string;
+  /** Whether the artifact has already been transpiled and had its verification keys generated. */
+  transpiled: boolean;
+}

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_gates.ts

@@ -6,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;
 }
 
@@ -32,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> {
+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/prover.ts

@@ -0,0 +1,42 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import type { LogFn } from '@aztec/foundation/log';
+import { createProverNodeAdminClient } from '@aztec/stdlib/interfaces/server';
+
+import { type Command, InvalidArgumentError } from 'commander';
+
+function parseEpoch(value: string): number {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new InvalidArgumentError('Epoch must be a non-negative integer.');
+  }
+  return parsed;
+}
+
+export function injectProverCommand(program: Command, log: LogFn): Command {
+  const proverCommand = program.command('prover').description('Operate a prover node via its admin JSON-RPC endpoint');
+
+  proverCommand
+    .command('start-proof')
+    .description('Schedules proving for the given epoch')
+    .requiredOption('--epoch <n>', 'Epoch number to prove', parseEpoch)
+    .requiredOption('--admin-url <url>', 'URL of the prover node admin JSON-RPC endpoint')
+    .option('--api-key <key>', 'Admin API key', process.env.AZTEC_ADMIN_API_KEY)
+    .action(async options => {
+      const client = createProverNodeAdminClient(options.adminUrl, {}, undefined, options.apiKey);
+      const jobId = await client.startProof(options.epoch);
+      log(`Started proving job ${jobId} for epoch ${options.epoch}`);
+    });
+
+  proverCommand
+    .command('get-jobs')
+    .description('Lists the prover node proving jobs')
+    .requiredOption('--admin-url <url>', 'URL of the prover node admin JSON-RPC endpoint')
+    .option('--api-key <key>', 'Admin API key', process.env.AZTEC_ADMIN_API_KEY)
+    .action(async options => {
+      const client = createProverNodeAdminClient(options.adminUrl, {}, undefined, options.apiKey);
+      const jobs = await client.getJobs();
+      log(jsonStringify(jobs, true));
+    });
+
+  return program;
+}

package/src/cli/cmds/standby.ts

@@ -6,13 +6,16 @@ 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 { type LogFn, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { VersionCheck } from '@aztec/stdlib/update-checker';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import Koa from 'koa';
 
+import { isShuttingDown, softShutdown } from '../util.js';
+
 const ROLLUP_POLL_INTERVAL_S = 60;
 
 /**
@@ -23,19 +26,24 @@ const ROLLUP_POLL_INTERVAL_S = 60;
 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 prefundAddresses = (config.prefundAddresses ?? []).map(a => AztecAddress.fromStringUnsafe(a));
   const initialFundedAccounts = testAccounts.concat(sponsoredFPCAccounts).concat(prefundAddresses);
 
   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(
+/**
+ * Compares the rollup's on-chain protocol constants (genesis archive root, VK tree root, protocol
+ * contracts hash) against the node's expected local values. Returns a list of human-readable mismatch
+ * descriptions, empty if the rollup is compatible.
+ */
+export async function checkRollupCompatibility(
   rollup: RollupContract,
   expected: { genesisArchiveRoot: Fr; vkTreeRoot: Fr; protocolContractsHash: Fr },
 ): Promise<string[]> {
@@ -67,7 +75,7 @@ export async function waitForCompatibleRollup(
   config: {
     l1RpcUrls: string[];
     l1ChainId: number;
-    l1Contracts: { registryAddress: EthAddress };
+    registryAddress: EthAddress;
     rollupVersion?: number;
   },
   expected: { genesisArchiveRoot: Fr; vkTreeRoot: Fr; protocolContractsHash: Fr },
@@ -77,7 +85,7 @@ export async function waitForCompatibleRollup(
   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());
 
@@ -130,3 +138,47 @@ export async function waitForCompatibleRollup(
     await new Promise<void>((resolve, reject) => standbyServer.close(err => (err ? reject(err) : resolve())));
   }
 }
+
+/**
+ * Polls the canonical rollup's protocol constants every 10 minutes and soft-shuts-down the node once they
+ * diverge from the node's expected local values (i.e. an incompatible rollup has become canonical on L1).
+ * The HTTP health server is left running so K8s probes keep passing on the wound-down pod. This is the
+ * inverse of {@link waitForCompatibleRollup}; it should only be set up for nodes following the canonical
+ * rollup. Reuses the {@link checkRollupCompatibility} diff and the generic VersionChecker poll primitive.
+ */
+export async function setupAutoShutdown(
+  config: { l1RpcUrls: string[]; l1ChainId: number },
+  registryAddress: EthAddress,
+  rollupVersion: number | 'canonical',
+  expected: { genesisArchiveRoot: Fr; vkTreeRoot: Fr; protocolContractsHash: Fr },
+  signalHandlers: Array<() => Promise<void>>,
+): Promise<void> {
+  const { VersionChecker } = await import('@aztec/stdlib/update-checker');
+
+  const logger = createLogger('auto_shutdown');
+  const publicClient = getPublicClient(config);
+  const registry = new RegistryContract(publicClient, registryAddress);
+
+  const check: VersionCheck = {
+    name: 'rollup',
+    currentVersion: 'compatible',
+    getLatestVersion: async () => {
+      const rollupAddress = await registry.getRollupAddress(rollupVersion);
+      const rollup = new RollupContract(publicClient, rollupAddress.toString());
+      const mismatches = await checkRollupCompatibility(rollup, expected);
+      return mismatches.length === 0 ? 'compatible' : `incompatible: ${mismatches.join('; ')}`;
+    },
+  };
+
+  const checker = new VersionChecker([check], 600_000, logger);
+  checker.on('newVersion', ({ latestVersion }) => {
+    if (isShuttingDown()) {
+      return;
+    }
+    logger.warn('Canonical rollup is no longer compatible; auto-shutting down node', { latestVersion });
+    // softShutdown never rejects (it awaits handlers via allSettled); fire-and-forget from the listener.
+    void softShutdown(logger.info.bind(logger), signalHandlers);
+  });
+  checker.start();
+  signalHandlers.push(() => checker.stop());
+}

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);
   }
 
@@ -58,6 +56,11 @@ export async function addBot(
   const config = extractRelevantOptions<BotConfig>(options, botConfigMappings, 'bot');
   userLog?.(`Starting bot with config ${stringifyConfig(config)}`);
 
+  // The bot wallet's embedded PXE syncs to this tip (see start_bot.ts/start_node.ts which build the wallet from the
+  // same options). L1-to-L2 readiness checks must be evaluated at this tip rather than at 'latest', or the bot can
+  // consider a message ready while the PXE simulation anchors to an older block that cannot prove its membership yet.
+  const { syncChainTip } = extractRelevantOptions<PXEConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
+
   const db = await (config.dataDirectory
     ? createStore('bot', BotStore.SCHEMA_VERSION, config)
     : openTmpStore('bot', true, config.dataStoreMapSizeKb));
@@ -65,7 +68,7 @@ export async function addBot(
   const store = new BotStore(db);
   await store.cleanupOldClaims();
 
-  const botRunner = new BotRunner(config, wallet, aztecNode, telemetry, aztecNodeAdmin, store);
+  const botRunner = new BotRunner(config, wallet, aztecNode, telemetry, aztecNodeAdmin, store, syncChainTip);
   if (!config.noStart) {
     void botRunner.start(); // Do not block since bot setup takes time
   }

package/src/cli/cmds/start_node.ts

@@ -1,7 +1,11 @@
-import { type AztecNodeConfig, aztecNodeConfigMappings, getConfigEnvVars } from '@aztec/aztec-node';
+import {
+  type AztecNodeConfig,
+  aztecNodeConfigMappings,
+  getConfigEnvVars,
+  registerAztecNodeRpcHandlers,
+} from '@aztec/aztec-node';
 import { Fr } from '@aztec/aztec.js/fields';
 import { getL1Config } from '@aztec/cli/config';
-import { getPublicClient } from '@aztec/ethereum/client';
 import { getGenesisStateConfigEnvVars } from '@aztec/ethereum/config';
 import { type NetworkNames, SecretValue } from '@aztec/foundation/config';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
@@ -9,10 +13,13 @@ 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 } from '@aztec/prover-client/broker';
+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';
+import { ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import {
   type TelemetryClientConfig,
   initTelemetryClient,
@@ -22,14 +29,9 @@ import {
 import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import { createAztecNode } from '../../local-network/index.js';
-import {
-  extractNamespacedOptions,
-  extractRelevantOptions,
-  preloadCrsDataForVerifying,
-  setupVersionChecker,
-} from '../util.js';
+import { extractNamespacedOptions, extractRelevantOptions, preloadCrsDataForVerifying } from '../util.js';
 import { getVersions } from '../versioning.js';
-import { computeExpectedGenesisRoot, waitForCompatibleRollup } from './standby.js';
+import { computeExpectedGenesisRoot, setupAutoShutdown, waitForCompatibleRollup } from './standby.js';
 import { startProverBroker } from './start_prover_broker.js';
 
 export async function startNode(
@@ -65,12 +67,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));
@@ -83,12 +81,12 @@ 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');
   }
 
@@ -102,7 +100,7 @@ export async function startNode(
   );
 
   const { addresses, config } = await getL1Config(
-    nodeConfig.l1Contracts.registryAddress,
+    nodeConfig.registryAddress,
     nodeConfig.l1RpcUrls,
     nodeConfig.l1ChainId,
     nodeConfig.rollupVersion,
@@ -116,13 +114,9 @@ export async function startNode(
     );
   }
 
-  // TODO(#12272): will clean this up.
   nodeConfig = {
     ...nodeConfig,
-    l1Contracts: {
-      ...addresses,
-      slashFactoryAddress: nodeConfig.l1Contracts.slashFactoryAddress,
-    },
+    ...addresses,
     ...config,
   };
 
@@ -158,17 +152,14 @@ 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];
-  services.p2p = [node.getP2P(), P2PApiSchema];
-  adminServices.nodeAdmin = [node, AztecNodeAdminApiSchema];
+  registerAztecNodeRpcHandlers(node, services, adminServices, { debug: options.nodeDebug });
 
   // Register prover-node services if the prover node subsystem is running
   const proverNode = node.getProverNode();
   if (proverNode) {
-    services.prover = [proverNode, ProverNodeApiSchema];
+    adminServices.prover = [proverNode, ProverNodeApiSchema];
     if (!nodeConfig.proverBrokerUrl) {
       services.provingJobSource = [proverNode.getProver().getProvingJobSource(), ProvingJobConsumerSchema];
     }
@@ -187,15 +178,14 @@ export async function startNode(
     await addBot(options, signalHandlers, services, wallet, node, telemetry, undefined);
   }
 
-  if (nodeConfig.enableVersionCheck && networkName !== 'local') {
-    const cacheDir = process.env.DATA_DIRECTORY ? `${process.env.DATA_DIRECTORY}/cache` : undefined;
+  if (nodeConfig.enableAutoShutdown && networkName !== 'local' && followsCanonicalRollup) {
     try {
-      await setupVersionChecker(
-        networkName,
-        followsCanonicalRollup,
-        getPublicClient(nodeConfig!),
+      await setupAutoShutdown(
+        nodeConfig,
+        nodeConfig.registryAddress,
+        (nodeConfig.rollupVersion as number | 'canonical') ?? 'canonical',
+        { genesisArchiveRoot, vkTreeRoot: getVKTreeRoot(), protocolContractsHash },
         signalHandlers,
-        cacheDir,
       );
     } catch {
       /* no-op */

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

@@ -24,38 +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,
+    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}`);
 }

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

@@ -6,6 +6,11 @@ export interface CompiledArtifact {
   file_map: unknown;
   functions: ContractFunction[];
   bytecode?: string;
+  /**
+   * Set to true by the AVM transpiler (invoked via `bb aztec_process`) once the contract has been transpiled and its
+   * verification keys generated. Absent on raw `nargo compile` output, hence optional.
+   */
+  transpiled?: boolean;
 }
 
 export interface ContractFunction {