@aztec/aztec 0.0.1-commit.d431d1c → 0.0.1-commit.dbf9cec

package/src/cli/cmds/compile.ts

@@ -0,0 +1,184 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import { execFileSync } from 'child_process';
+import type { Command } from 'commander';
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+
+import { readArtifactFiles } from './utils/artifacts.js';
+import { run } from './utils/spawn.js';
+
+/** Returns paths to contract artifacts in the target directory. */
+async function collectContractArtifacts(): Promise<string[]> {
+  let files;
+  try {
+    files = await readArtifactFiles('target');
+  } catch (err: any) {
+    if (err?.message?.includes('does not exist')) {
+      return [];
+    }
+    throw err;
+  }
+  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> {
+  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__/, '');
+      }
+    }
+    await writeFile(path, JSON.stringify(artifact, null, 2) + '\n');
+  }
+}
+
+/** Returns the set of package names that are contract crates in the current workspace. */
+async function getContractPackageNames(): Promise<Set<string>> {
+  const contractNames = new Set<string>();
+
+  let rootToml: string;
+  try {
+    rootToml = await readFile('Nargo.toml', 'utf-8');
+  } catch {
+    return contractNames;
+  }
+
+  const membersMatch = rootToml.match(/members\s*=\s*\[([^\]]*)\]/);
+  if (membersMatch) {
+    const members = membersMatch[1]
+      .split(',')
+      .map(m => m.trim().replace(/^"|"$/g, ''))
+      .filter(m => m.length > 0);
+
+    for (const member of members) {
+      try {
+        const memberToml = await readFile(join(member, 'Nargo.toml'), 'utf-8');
+        if (/type\s*=\s*"contract"/.test(memberToml)) {
+          const nameMatch = memberToml.match(/name\s*=\s*"([^"]+)"/);
+          if (nameMatch) {
+            contractNames.add(nameMatch[1]);
+          }
+        }
+      } catch {
+        // Member directory might not exist or have no Nargo.toml; skip.
+      }
+    }
+  } else {
+    // Single-crate project (no workspace): check if the root Nargo.toml itself is a contract.
+    if (/type\s*=\s*"contract"/.test(rootToml)) {
+      const nameMatch = rootToml.match(/name\s*=\s*"([^"]+)"/);
+      if (nameMatch) {
+        contractNames.add(nameMatch[1]);
+      }
+    }
+  }
+
+  return contractNames;
+}
+
+/** Checks that no tests exist in contract crates and fails with a helpful message if they do. */
+async function checkNoTestsInContracts(nargo: string, log: LogFn): Promise<void> {
+  const contractPackages = await getContractPackageNames();
+  if (contractPackages.size === 0) {
+    return;
+  }
+
+  let output: string;
+  try {
+    // We list tests for all the crates in the workspace
+    output = execFileSync(nargo, ['test', '--list-tests', '--silence-warnings'], {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'inherit'],
+    });
+  } catch {
+    // If listing tests fails (e.g. test crate has compile errors), skip the check.
+    return;
+  }
+
+  // The output of the `nargo test --list-tests` command is as follows:
+  // ```
+  // crate_name_1 test_name_1
+  // crate_name_2 test_name_2
+  // ...
+  // crate_name_n test_name_n
+  // ```
+  //
+  // We parse the individual lines and then we check if any contract crate appeared in the parsed output.
+  const lines = output
+    .trim()
+    .split('\n')
+    .filter(line => line.length > 0);
+  const testsInContracts: { packageName: string; testName: string }[] = [];
+
+  for (const line of lines) {
+    const spaceIndex = line.indexOf(' ');
+    if (spaceIndex === -1) {
+      continue;
+    }
+    const packageName = line.substring(0, spaceIndex);
+    const testName = line.substring(spaceIndex + 1);
+    if (contractPackages.has(packageName)) {
+      testsInContracts.push({ packageName, testName });
+    }
+  }
+
+  if (testsInContracts.length > 0) {
+    const details = testsInContracts.map(t => `  ${t.packageName}::${t.testName}`).join('\n');
+    log(
+      `WARNING: Found tests in contract crate(s):\n${details}\n\n` +
+        `Tests should be in a dedicated test crate, not in the contract crate.\n` +
+        `Learn more: https://docs.aztec.network/errors/1`,
+    );
+  }
+}
+
+/** Compiles Aztec Noir contracts and postprocesses artifacts. */
+async function compileAztecContract(nargoArgs: string[], log: LogFn): Promise<void> {
+  const nargo = process.env.NARGO ?? 'nargo';
+  const bb = process.env.BB ?? 'bb';
+
+  await run(nargo, ['compile', ...nargoArgs]);
+
+  // Ensure contract crates contain no tests (tests belong in the test crate).
+  await checkNoTestsInContracts(nargo, log);
+
+  const artifacts = await collectContractArtifacts();
+
+  if (artifacts.length > 0) {
+    log('Postprocessing contracts...');
+    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);
+  }
+
+  log('Compilation complete!');
+}
+
+export function injectCompileCommand(program: Command, log: LogFn): Command {
+  program
+    .command('compile')
+    .argument('[nargo-args...]')
+    .passThroughOptions()
+    .allowUnknownOption()
+    .description(
+      'Compile Aztec Noir contracts using nargo and postprocess them to generate transpiled artifacts and verification keys. All options are forwarded to nargo compile.',
+    )
+    .addHelpText('after', () => {
+      // Show nargo's own compile options so users see all available flags in one place.
+      const nargo = process.env.NARGO ?? 'nargo';
+      try {
+        const output = execFileSync(nargo, ['compile', '--help'], { encoding: 'utf-8' });
+        return `\nUnderlying nargo compile options:\n\n${output}`;
+      } catch {
+        return '\n(Run "nargo compile --help" to see available nargo options)';
+      }
+    })
+    .action((nargoArgs: string[]) => compileAztecContract(nargoArgs, log));
+
+  return program;
+}

package/src/cli/cmds/profile.ts

@@ -0,0 +1,25 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import type { Command } from 'commander';
+
+import { profileFlamegraph } from './profile_flamegraph.js';
+import { profileGates } from './profile_gates.js';
+
+export function injectProfileCommand(program: Command, log: LogFn): Command {
+  const profile = program.command('profile').description('Profile compiled Aztec artifacts.');
+
+  profile
+    .command('gates')
+    .argument('[target-dir]', 'Path to the compiled artifacts directory', './target')
+    .description('Display gate counts for all compiled Aztec artifacts in a target directory.')
+    .action((targetDir: string) => profileGates(targetDir, log));
+
+  profile
+    .command('flamegraph')
+    .argument('<contract-artifact>', 'Path to the compiled contract artifact JSON')
+    .argument('<function>', 'Name of the contract function to profile')
+    .description('Generate a gate count flamegraph SVG for a contract function.')
+    .action((artifactPath: string, functionName: string) => profileFlamegraph(artifactPath, functionName, log));
+
+  return program;
+}

package/src/cli/cmds/profile_flamegraph.ts

@@ -0,0 +1,63 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import { readFile, rename, rm, writeFile } from 'fs/promises';
+import { basename, dirname, join } from 'path';
+
+import { makeFunctionArtifact } from './profile_utils.js';
+import type { CompiledArtifact } from './utils/artifacts.js';
+import { run } from './utils/spawn.js';
+
+/** Generates a gate count flamegraph SVG for a single contract function. */
+export async function profileFlamegraph(artifactPath: string, functionName: string, log: LogFn): Promise<void> {
+  const raw = await readFile(artifactPath, 'utf-8');
+  const artifact: CompiledArtifact = JSON.parse(raw);
+
+  if (!Array.isArray(artifact.functions)) {
+    throw new Error(`${artifactPath} does not appear to be a contract artifact (no functions array)`);
+  }
+
+  const func = artifact.functions.find(f => f.name === functionName);
+  if (!func) {
+    const available = artifact.functions.map(f => f.name).join(', ');
+    throw new Error(`Function "${functionName}" not found in artifact. Available: ${available}`);
+  }
+  if (func.is_unconstrained) {
+    throw new Error(`Function "${functionName}" is unconstrained and cannot be profiled`);
+  }
+
+  const outputDir = dirname(artifactPath);
+  const contractName = basename(artifactPath, '.json');
+  const functionArtifact = join(outputDir, `${contractName}-${functionName}.json`);
+
+  try {
+    await writeFile(functionArtifact, makeFunctionArtifact(artifact, func));
+
+    const profiler = process.env.PROFILER_PATH ?? 'noir-profiler';
+    const bb = process.env.BB ?? 'bb';
+
+    await run(profiler, [
+      'gates',
+      '--artifact-path',
+      functionArtifact,
+      '--backend-path',
+      bb,
+      '--backend-gates-command',
+      'gates',
+      '--output',
+      outputDir,
+      '--scheme',
+      'chonk',
+      '--include_gates_per_opcode',
+    ]);
+
+    // noir-profiler names the SVG using the internal function name which
+    // retains the __aztec_nr_internals__ prefix in the bytecode metadata.
+    const srcSvg = join(outputDir, `__aztec_nr_internals__${functionName}_gates.svg`);
+    const destSvg = join(outputDir, `${contractName}-${functionName}-flamegraph.svg`);
+    await rename(srcSvg, destSvg);
+
+    log(`Flamegraph written to ${destSvg}`);
+  } finally {
+    await rm(functionArtifact, { force: true });
+  }
+}

package/src/cli/cmds/profile_gates.ts

@@ -0,0 +1,67 @@
+import { asyncPool } from '@aztec/foundation/async-pool';
+import type { LogFn } from '@aztec/foundation/log';
+
+import { execFile as execFileCb } from 'child_process';
+import { rm } from 'fs/promises';
+import { promisify } from 'util';
+
+import { MAX_CONCURRENT, discoverArtifacts } from './profile_utils.js';
+
+const execFile = promisify(execFileCb);
+
+interface GateCountResult {
+  name: string;
+  gateCount: number;
+}
+
+/** Parses circuit_size from bb gates JSON output: { "functions": [{ "circuit_size": N }] } */
+function parseGateCount(stdout: string): number {
+  const parsed = JSON.parse(stdout);
+  const size = parsed?.functions?.[0]?.circuit_size;
+  if (typeof size !== 'number') {
+    throw new Error('Failed to parse circuit_size from bb gates output');
+  }
+  return size;
+}
+
+/** Runs bb gates on a single artifact file and returns the gate count. */
+async function getGateCount(bb: string, artifactPath: string): Promise<number> {
+  const { stdout } = await execFile(bb, ['gates', '--scheme', 'chonk', '-b', artifactPath]);
+  return parseGateCount(stdout);
+}
+
+/** 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';
+  const { artifacts, tmpDir } = await discoverArtifacts(targetDir);
+
+  if (artifacts.length === 0) {
+    log('No artifacts found in target directory.');
+    return;
+  }
+
+  try {
+    const results: GateCountResult[] = await asyncPool(MAX_CONCURRENT, artifacts, async artifact => ({
+      name: artifact.name,
+      gateCount: await getGateCount(bb, artifact.filePath),
+    }));
+    results.sort((a, b) => a.name.localeCompare(b.name));
+
+    if (results.length === 0) {
+      log('No constrained circuits found.');
+      return;
+    }
+
+    const maxNameLen = Math.max(...results.map(r => r.name.length));
+    log('');
+    log('Gate counts:');
+    log('-'.repeat(maxNameLen + 16));
+    for (const { name, gateCount } of results) {
+      log(`${name.padEnd(maxNameLen)}  ${gateCount.toLocaleString().padStart(12)}`);
+    }
+    log('-'.repeat(maxNameLen + 16));
+    log(`Total: ${results.length} circuit(s)`);
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+}

package/src/cli/cmds/profile_utils.ts

@@ -0,0 +1,58 @@
+import { mkdtemp, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import type { CompiledArtifact, ContractFunction } from './utils/artifacts.js';
+import { readArtifactFiles } from './utils/artifacts.js';
+
+export const MAX_CONCURRENT = 4;
+
+export interface DiscoveredArtifact {
+  name: string;
+  filePath: string;
+  type: 'contract-function' | 'program';
+}
+
+/**
+ * Reads a target directory and returns a list of discovered artifacts with temp files
+ * created for contract functions. Caller must clean up tmpDir when done.
+ */
+export async function discoverArtifacts(
+  targetDir: string,
+): Promise<{ artifacts: DiscoveredArtifact[]; tmpDir: string }> {
+  const files = await readArtifactFiles(targetDir);
+  const tmpDir = await mkdtemp(join(tmpdir(), 'aztec-profile-'));
+  const artifacts: DiscoveredArtifact[] = [];
+
+  for (const file of files) {
+    if (Array.isArray(file.content.functions)) {
+      for (const func of file.content.functions) {
+        if (!func.bytecode || func.is_unconstrained) {
+          continue;
+        }
+        const name = `${file.name}::${func.name}`;
+        const tmpPath = join(tmpDir, `${file.name}-${func.name}.json`);
+        await writeFile(tmpPath, makeFunctionArtifact(file.content, func));
+        artifacts.push({ name, filePath: tmpPath, type: 'contract-function' });
+      }
+    } else if (file.content.bytecode) {
+      artifacts.push({ name: file.name, filePath: file.filePath, type: 'program' });
+    }
+  }
+
+  return { artifacts, tmpDir };
+}
+
+/** Extracts a contract function as a standalone program artifact JSON string. */
+export function makeFunctionArtifact(artifact: CompiledArtifact, func: ContractFunction) {
+  /* eslint-disable camelcase */
+  return JSON.stringify({
+    noir_version: artifact.noir_version,
+    hash: 0,
+    abi: func.abi,
+    bytecode: func.bytecode,
+    debug_symbols: func.debug_symbols,
+    file_map: artifact.file_map,
+  });
+  /* eslint-enable camelcase */
+}

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(
@@ -38,22 +38,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

@@ -6,16 +6,19 @@ import { getL1Config } from '@aztec/cli/config';
 import { getPublicClient } from '@aztec/ethereum/client';
 import { 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 { 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 { EmbeddedWallet } from '@aztec/wallets/embedded';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { createAztecNode } from '../../local-network/index.js';
@@ -25,6 +28,8 @@ import {
   preloadCrsDataForVerifying,
   setupUpdateMonitor,
 } from '../util.js';
+import { getVersions } from '../versioning.js';
+import { startProverBroker } from './start_prover_broker.js';
 
 export async function startNode(
   options: any,
@@ -45,9 +50,32 @@ 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
+      // 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(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);
@@ -101,12 +129,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 +153,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 }, { prefilledPublicData });
 
   // 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,7 +177,7 @@ 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);
   }

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,9 +4,9 @@ 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,
 } from '@aztec/prover-client/broker';
@@ -55,7 +55,7 @@ export async function startProverAgent(
 
   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

@@ -5,6 +5,7 @@ import type { LogFn } from '@aztec/foundation/log';
 import {
   type ProverBrokerConfig,
   ProvingJobBrokerSchema,
+  ProvingJobBrokerSchemaWithDebug,
   createAndStartProvingBroker,
   proverBrokerConfigMappings,
 } from '@aztec/prover-client/broker';
@@ -59,7 +60,10 @@ export async function startProverBroker(
     );
   }
 
-  services.proverBroker = [broker, ProvingJobBrokerSchema];
+  services.proverBroker = [
+    broker,
+    config.proverBrokerDebugReplayEnabled ? ProvingJobBrokerSchemaWithDebug : ProvingJobBrokerSchema,
+  ];
   signalHandlers.push(() => broker.stop());
 
   return { broker, config };

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;
+}

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

@@ -0,0 +1,16 @@
+import { spawn } from 'child_process';
+
+/** Spawns a command with inherited stdio and rejects on non-zero exit. */
+export function run(cmd: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit' });
+    child.on('error', reject);
+    child.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(`${cmd} exited with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}