@aztec/bb-prover 0.0.0-test.0 → 0.0.1-commit.21caa21

package/src/bb/execute.ts

@@ -6,18 +6,16 @@ import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
 import { basename, dirname, join } from 'path';
+import readline from 'readline';
 
 import type { UltraHonkFlavor } from '../honk.js';
-import { CLIENT_IVC_PROOF_FILE_NAME, CLIENT_IVC_VK_FILE_NAME } from '../prover/client_ivc_proof_utils.js';
 
 export const VK_FILENAME = 'vk';
-export const VK_FIELDS_FILENAME = 'vk_fields.json';
+export const PUBLIC_INPUTS_FILENAME = 'public_inputs';
 export const PROOF_FILENAME = 'proof';
-export const PROOF_FIELDS_FILENAME = 'proof_fields.json';
 export const AVM_INPUTS_FILENAME = 'avm_inputs.bin';
 export const AVM_BYTECODE_FILENAME = 'avm_bytecode.bin';
 export const AVM_PUBLIC_INPUTS_FILENAME = 'avm_public_inputs.bin';
-export const AVM_HINTS_FILENAME = 'avm_hints.bin';
 
 export enum BB_RESULT {
   SUCCESS,
@@ -31,7 +29,7 @@ export type BBSuccess = {
   /** Full path of the public key. */
   pkPath?: string;
   /** Base directory for the VKs (raw, fields). */
-  vkPath?: string;
+  vkDirectoryPath?: string;
   /** Full path of the proof. */
   proofPath?: string;
   /** Full path of the contract. */
@@ -48,8 +46,6 @@ export type BBFailure = {
 
 export type BBResult = BBSuccess | BBFailure;
 
-export type VerificationFunction = typeof verifyProof | typeof verifyAvmProof;
-
 type BBExecResult = {
   status: BB_RESULT;
   exitCode: number;
@@ -62,6 +58,7 @@ type BBExecResult = {
  * @param command - The command to execute
  * @param args - The arguments to pass
  * @param logger - A log function
+ * @param timeout - An optional timeout before killing the BB process
  * @param resultParser - An optional handler for detecting success or failure
  * @returns The completed partial witness outputted from the circuit
  */
@@ -70,25 +67,47 @@ export function executeBB(
   command: string,
   args: string[],
   logger: LogFn,
+  concurrency?: number,
+  timeout?: number,
   resultParser = (code: number) => code === 0,
 ): Promise<BBExecResult> {
   return new Promise<BBExecResult>(resolve => {
     // spawn the bb process
     const { HARDWARE_CONCURRENCY: _, ...envWithoutConcurrency } = process.env;
-    const env = process.env.HARDWARE_CONCURRENCY ? process.env : envWithoutConcurrency;
+
+    const env = envWithoutConcurrency;
+    // We prioritise the concurrency argument if provided and > 0
+    if (concurrency && concurrency > 0) {
+      env.HARDWARE_CONCURRENCY = concurrency.toString();
+    } else if (process.env.HARDWARE_CONCURRENCY) {
+      env.HARDWARE_CONCURRENCY = process.env.HARDWARE_CONCURRENCY;
+    }
+
+    logger(`BB concurrency: ${env.HARDWARE_CONCURRENCY}`);
     logger(`Executing BB with: ${pathToBB} ${command} ${args.join(' ')}`);
     const bb = proc.spawn(pathToBB, [command, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe'],
       env,
     });
-    bb.stdout.on('data', data => {
-      const message = data.toString('utf-8').replace(/\n$/, '');
-      logger(message);
-    });
-    bb.stderr.on('data', data => {
-      const message = data.toString('utf-8').replace(/\n$/, '');
-      logger(message);
-    });
+
+    let timeoutId: NodeJS.Timeout | undefined;
+    if (timeout !== undefined) {
+      timeoutId = setTimeout(() => {
+        logger(`BB execution timed out after ${timeout}ms, killing process`);
+        if (bb.pid) {
+          bb.kill('SIGKILL');
+        }
+        resolve({ status: BB_RESULT.FAILURE, exitCode: -1, signal: 'TIMEOUT' });
+      }, timeout);
+    }
+
+    readline.createInterface({ input: bb.stdout }).on('line', logger);
+    readline.createInterface({ input: bb.stderr }).on('line', logger);
+
     bb.on('close', (exitCode: number, signal?: string) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
       if (resultParser(exitCode)) {
         resolve({ status: BB_RESULT.SUCCESS, exitCode, signal });
       } else {
@@ -98,18 +117,17 @@ export function executeBB(
   }).catch(_ => ({ status: BB_RESULT.FAILURE, exitCode: -1, signal: undefined }));
 }
 
-// TODO(#7369) comment this etc (really just take inspiration from this and rewrite it all O:))
-export async function executeBbClientIvcProof(
+export async function executeBbChonkProof(
   pathToBB: string,
   workingDirectory: string,
-  bytecodeStackPath: string,
-  witnessStackPath: string,
+  inputsPath: string,
   log: LogFn,
+  writeVk = false,
 ): Promise<BBFailure | BBSuccess> {
   // Check that the working directory exists
   try {
     await fs.access(workingDirectory);
-  } catch (error) {
+  } catch {
     return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
@@ -126,28 +144,16 @@ export async function executeBbClientIvcProof(
 
   try {
     // Write the bytecode to the working directory
-    log(`bytecodePath ${bytecodeStackPath}`);
-    log(`outputPath ${outputPath}`);
-    const args = [
-      '-o',
-      outputPath,
-      '-b',
-      bytecodeStackPath,
-      '-w',
-      witnessStackPath,
-      '-v',
-      '--scheme',
-      'client_ivc',
-      '--input_type',
-      'runtime_stack',
-      '--write_vk',
-    ];
-
+    log(`inputsPath ${inputsPath}`);
     const timer = new Timer();
     const logFunction = (message: string) => {
       log(`bb - ${message}`);
     };
 
+    const args = ['-o', outputPath, '--ivc_inputs_path', inputsPath, '-v', '--scheme', 'chonk'];
+    if (writeVk) {
+      args.push('--write_vk');
+    }
     const result = await executeBB(pathToBB, 'prove', args, logFunction);
     const durationMs = timer.ms();
 
@@ -157,7 +163,7 @@ export async function executeBbClientIvcProof(
         durationMs,
         proofPath: `${outputPath}`,
         pkPath: undefined,
-        vkPath: `${outputPath}`,
+        vkDirectoryPath: `${outputPath}`,
       };
     }
     // Not a great error message here but it is difficult to decipher what comes from bb
@@ -179,6 +185,9 @@ function getArgs(flavor: UltraHonkFlavor) {
     case 'ultra_keccak_honk': {
       return ['--scheme', 'ultra_honk', '--oracle_hash', 'keccak'];
     }
+    case 'ultra_starknet_honk': {
+      return ['--scheme', 'ultra_honk', '--oracle_hash', 'starknet'];
+    }
     case 'ultra_rollup_honk': {
       return ['--scheme', 'ultra_honk', '--oracle_hash', 'poseidon2', '--ipa_accumulation'];
     }
@@ -201,20 +210,21 @@ export async function generateProof(
   workingDirectory: string,
   circuitName: string,
   bytecode: Buffer,
-  recursive: boolean,
+  verificationKey: Buffer,
   inputWitnessFile: string,
   flavor: UltraHonkFlavor,
-  log: LogFn,
+  log: Logger,
 ): Promise<BBFailure | BBSuccess> {
   // Check that the working directory exists
   try {
     await fs.access(workingDirectory);
-  } catch (error) {
+  } catch {
     return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
-  // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
+  // The bytecode is written to e.g. /workingDirectory/ParityBaseArtifact-bytecode
   const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
+  const vkPath = `${workingDirectory}/${circuitName}-vk`;
 
   // The proof is written to e.g. /workingDirectory/ultra_honk/proof
   const outputPath = `${workingDirectory}`;
@@ -228,26 +238,28 @@ export async function generateProof(
   }
 
   try {
-    // Write the bytecode to the working directory
-    await fs.writeFile(bytecodePath, bytecode);
+    // Write the bytecode and vk to the working directory
+    await Promise.all([fs.writeFile(bytecodePath, bytecode), fs.writeFile(vkPath, verificationKey)]);
     const args = getArgs(flavor).concat([
-      '--output_format',
-      'bytes_and_fields',
-      '--write_vk',
+      '--disable_zk',
       '-o',
       outputPath,
       '-b',
       bytecodePath,
+      '-k',
+      vkPath,
       '-w',
       inputWitnessFile,
       '-v',
     ]);
-    if (recursive) {
-      args.push('--init_kzg_accumulator');
+    const loggingArg = log.level === 'debug' || log.level === 'trace' ? '-d' : log.level === 'verbose' ? '-v' : '';
+    if (loggingArg !== '') {
+      args.push(loggingArg);
     }
+
     const timer = new Timer();
     const logFunction = (message: string) => {
-      log(`${circuitName} BB out - ${message}`);
+      log.info(`${circuitName} BB out - ${message}`);
     };
     const result = await executeBB(pathToBB, `prove`, args, logFunction);
     const duration = timer.ms();
@@ -258,80 +270,7 @@ export async function generateProof(
         durationMs: duration,
         proofPath: `${outputPath}`,
         pkPath: undefined,
-        vkPath: `${outputPath}`,
-      };
-    }
-    // Not a great error message here but it is difficult to decipher what comes from bb
-    return {
-      status: BB_RESULT.FAILURE,
-      reason: `Failed to generate proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-      retry: !!result.signal,
-    };
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `${error}` };
-  }
-}
-
-/**
- * Used for generating proofs of the tube circuit
- * It is assumed that the working directory is a temporary and/or random directory used solely for generating this proof.
- * @param pathToBB - The full path to the bb binary
- * @param workingDirectory - A working directory for use by bb
- * @param circuitName - An identifier for the circuit
- * @param bytecode - The compiled circuit bytecode
- * @param inputWitnessFile - The circuit input witness
- * @param log - A logging function
- * @returns An object containing a result indication, the location of the proof and the duration taken
- */
-export async function generateTubeProof(
-  pathToBB: string,
-  workingDirectory: string,
-  log: LogFn,
-): Promise<BBFailure | BBSuccess> {
-  // Check that the working directory exists
-  try {
-    await fs.access(workingDirectory);
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
-  }
-
-  // // Paths for the inputs
-  const vkPath = join(workingDirectory, CLIENT_IVC_VK_FILE_NAME);
-  const proofPath = join(workingDirectory, CLIENT_IVC_PROOF_FILE_NAME);
-
-  // The proof is written to e.g. /workingDirectory/proof
-  const outputPath = workingDirectory;
-  const filePresent = async (file: string) =>
-    await fs
-      .access(file, fs.constants.R_OK)
-      .then(_ => true)
-      .catch(_ => false);
-
-  const binaryPresent = await filePresent(pathToBB);
-  if (!binaryPresent) {
-    return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
-  }
-
-  try {
-    if (!(await filePresent(vkPath)) || !(await filePresent(proofPath))) {
-      return { status: BB_RESULT.FAILURE, reason: `Client IVC input files not present in  ${workingDirectory}` };
-    }
-    const args = ['-o', outputPath, '-v'];
-
-    const timer = new Timer();
-    const logFunction = (message: string) => {
-      log(`TubeCircuit (prove) BB out - ${message}`);
-    };
-    const result = await executeBB(pathToBB, 'prove_tube', args, logFunction);
-    const durationMs = timer.ms();
-
-    if (result.status == BB_RESULT.SUCCESS) {
-      return {
-        status: BB_RESULT.SUCCESS,
-        durationMs,
-        proofPath: outputPath,
-        pkPath: undefined,
-        vkPath: outputPath,
+        vkDirectoryPath: `${outputPath}`,
       };
     }
     // Not a great error message here but it is difficult to decipher what comes from bb
@@ -351,19 +290,21 @@ export async function generateTubeProof(
  * @param pathToBB - The full path to the bb binary
  * @param workingDirectory - A working directory for use by bb
  * @param input - The inputs for the public function to be proven
- * @param log - A logging function
+ * @param logger - A logging function
+ * @param checkCircuitOnly - A boolean to toggle a "check-circuit only" operation instead of proving.
  * @returns An object containing a result indication, the location of the proof and the duration taken
  */
-export async function generateAvmProofV2(
+export async function generateAvmProof(
   pathToBB: string,
   workingDirectory: string,
   input: AvmCircuitInputs,
   logger: Logger,
+  checkCircuitOnly: boolean = false,
 ): Promise<BBFailure | BBSuccess> {
   // Check that the working directory exists
   try {
     await fs.access(workingDirectory);
-  } catch (error) {
+  } catch {
     return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
@@ -391,107 +332,19 @@ export async function generateAvmProofV2(
       return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
     }
 
-    const args = ['--avm-inputs', avmInputsPath, '-o', outputPath];
+    const args = checkCircuitOnly ? ['--avm-inputs', avmInputsPath] : ['--avm-inputs', avmInputsPath, '-o', outputPath];
     const loggingArg =
       logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '';
     if (loggingArg !== '') {
       args.push(loggingArg);
     }
     const timer = new Timer();
-    const logFunction = (message: string) => {
-      logger.verbose(`AvmCircuit (prove) BB out - ${message}`);
-    };
-    const result = await executeBB(pathToBB, 'avm2_prove', args, logFunction);
-    const duration = timer.ms();
-
-    if (result.status == BB_RESULT.SUCCESS) {
-      return {
-        status: BB_RESULT.SUCCESS,
-        durationMs: duration,
-        proofPath: join(outputPath, PROOF_FILENAME),
-        pkPath: undefined,
-        vkPath: outputPath,
-      };
-    }
-    // Not a great error message here but it is difficult to decipher what comes from bb
-    return {
-      status: BB_RESULT.FAILURE,
-      reason: `Failed to generate proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-      retry: !!result.signal,
-    };
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `${error}` };
-  }
-}
 
-/**
- * Used for generating AVM proofs (or doing check-circuit).
- * It is assumed that the working directory is a temporary and/or random directory used solely for generating this proof.
- * @param pathToBB - The full path to the bb binary
- * @param workingDirectory - A working directory for use by bb
- * @param bytecode - The AVM bytecode for the public function to be proven (expected to be decompressed)
- * @param log - A logging function
- * @returns An object containing a result indication, the location of the proof and the duration taken
- */
-export async function generateAvmProof(
-  pathToBB: string,
-  workingDirectory: string,
-  _input: AvmCircuitInputs,
-  logger: Logger,
-  checkCircuitOnly: boolean = false,
-): Promise<BBFailure | BBSuccess> {
-  // Check that the working directory exists
-  try {
-    await fs.access(workingDirectory);
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
-  }
-
-  // Paths for the inputs
-  const publicInputsPath = join(workingDirectory, AVM_PUBLIC_INPUTS_FILENAME);
-  const avmHintsPath = join(workingDirectory, AVM_HINTS_FILENAME);
-
-  // The proof is written to e.g. /workingDirectory/proof
-  const outputPath = workingDirectory;
-
-  const filePresent = async (file: string) =>
-    await fs
-      .access(file, fs.constants.R_OK)
-      .then(_ => true)
-      .catch(_ => false);
-
-  const binaryPresent = await filePresent(pathToBB);
-  if (!binaryPresent) {
-    return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
-  }
-
-  try {
-    // Write the inputs to the working directory.
-
-    // WARNING: Not writing the inputs since VM1 is disabled!
-    // await fs.writeFile(publicInputsPath, input.publicInputs.toBuffer());
-    // if (!(await filePresent(publicInputsPath))) {
-    //   return { status: BB_RESULT.FAILURE, reason: `Could not write publicInputs at ${publicInputsPath}` };
-    // }
-
-    // await fs.writeFile(avmHintsPath, input.avmHints.toBuffer());
-    // if (!(await filePresent(avmHintsPath))) {
-    //   return { status: BB_RESULT.FAILURE, reason: `Could not write avmHints at ${avmHintsPath}` };
-    // }
-
-    const args = ['--avm-public-inputs', publicInputsPath, '--avm-hints', avmHintsPath, '-o', outputPath];
-    const loggingArg =
-      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '';
-    if (loggingArg !== '') {
-      args.push(loggingArg);
-    }
-
-    const timer = new Timer();
-    const cmd = checkCircuitOnly ? 'check_circuit' : 'prove';
+    const cmd = checkCircuitOnly ? 'avm_check_circuit' : 'avm_prove';
     const logFunction = (message: string) => {
       logger.verbose(`AvmCircuit (${cmd}) BB out - ${message}`);
     };
-    const result = await executeBB(pathToBB, `avm_${cmd}`, args, logFunction);
+    const result = await executeBB(pathToBB, cmd, args, logFunction);
     const duration = timer.ms();
 
     if (result.status == BB_RESULT.SUCCESS) {
@@ -500,14 +353,14 @@ export async function generateAvmProof(
         durationMs: duration,
         proofPath: join(outputPath, PROOF_FILENAME),
         pkPath: undefined,
-        vkPath: outputPath,
+        vkDirectoryPath: outputPath,
       };
     }
     // Not a great error message here but it is difficult to decipher what comes from bb
     return {
       status: BB_RESULT.FAILURE,
-      reason: `Failed to generate proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-      retry: !!result.signal,
+      reason: `Failed to generate proof. AVM proof for TX hash ${input.hints.tx.hash}. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+      retry: result.signal === 'SIGKILL', // retry on SIGKILL because the oomkiller might have stopped the process
     };
   } catch (error) {
     return { status: BB_RESULT.FAILURE, reason: `${error}` };
@@ -539,24 +392,7 @@ export async function verifyProof(
   );
 }
 
-/**
- * Used for verifying proofs of the AVM
- * @param pathToBB - The full path to the bb binary
- * @param proofFullPath - The full path to the proof to be verified
- * @param verificationKeyPath - The full path to the circuit verification key
- * @param log - A logging function
- * @returns An object containing a result indication and duration taken
- */
 export async function verifyAvmProof(
-  pathToBB: string,
-  proofFullPath: string,
-  verificationKeyPath: string,
-  logger: Logger,
-): Promise<BBFailure | BBSuccess> {
-  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', logger);
-}
-
-export async function verifyAvmProofV2(
   pathToBB: string,
   workingDirectory: string,
   proofFullPath: string,
@@ -578,25 +414,27 @@ export async function verifyAvmProofV2(
     return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
   }
 
-  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm2_verify', logger, [
+  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', logger, [
     '--avm-public-inputs',
     avmInputsPath,
   ]);
 }
 
 /**
- * Verifies a ClientIvcProof
+ * Verifies a ChonkProof
  * TODO(#7370) The verification keys should be supplied separately
  * @param pathToBB - The full path to the bb binary
  * @param targetPath - The path to the folder with the proof, accumulator, and verification keys
  * @param log - A logging function
+ * @param concurrency - The number of threads to use for the verification
  * @returns An object containing a result indication and duration taken
  */
-export async function verifyClientIvcProof(
+export async function verifyChonkProof(
   pathToBB: string,
   proofPath: string,
   keyPath: string,
   log: LogFn,
+  concurrency = 1,
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
     .access(pathToBB, fs.constants.R_OK)
@@ -607,10 +445,11 @@ export async function verifyClientIvcProof(
   }
 
   try {
-    const args = ['--scheme', 'client_ivc', '-p', proofPath, '-k', keyPath];
+    const args = ['--scheme', 'chonk', '-p', proofPath, '-k', keyPath, '-v'];
     const timer = new Timer();
     const command = 'verify';
-    const result = await executeBB(pathToBB, command, args, log);
+
+    const result = await executeBB(pathToBB, command, args, log, concurrency);
     const duration = timer.ms();
     if (result.status == BB_RESULT.SUCCESS) {
       return { status: BB_RESULT.SUCCESS, durationMs: duration };
@@ -639,7 +478,7 @@ async function verifyProofInternal(
   pathToBB: string,
   proofFullPath: string,
   verificationKeyPath: string,
-  command: 'verify' | 'avm_verify' | 'avm2_verify',
+  command: 'verify' | 'avm_verify',
   logger: Logger,
   extraArgs: string[] = [],
 ): Promise<BBFailure | BBSuccess> {
@@ -656,12 +495,26 @@ async function verifyProofInternal(
   };
 
   try {
-    const args = ['-p', proofFullPath, '-k', verificationKeyPath, ...extraArgs];
+    let args;
+
+    if (command == 'verify') {
+      // Specify the public inputs path in the case of UH verification.
+      // Take proofFullPath and remove the suffix past the / to get the directory.
+      const proofDir = proofFullPath.substring(0, proofFullPath.lastIndexOf('/'));
+      const publicInputsFullPath = join(proofDir, '/public_inputs');
+      logger.debug(`public inputs path: ${publicInputsFullPath}`);
+
+      args = ['-p', proofFullPath, '-k', verificationKeyPath, '-i', publicInputsFullPath, '--disable_zk', ...extraArgs];
+    } else {
+      args = ['-p', proofFullPath, '-k', verificationKeyPath, ...extraArgs];
+    }
+
     const loggingArg =
       logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '';
     if (loggingArg !== '') {
       args.push(loggingArg);
     }
+
     const timer = new Timer();
     const result = await executeBB(pathToBB, command, args, logFunction);
     const duration = timer.ms();
@@ -752,11 +605,11 @@ export async function computeGateCountForCircuit(
   // Check that the working directory exists
   try {
     await fs.access(workingDirectory);
-  } catch (error) {
+  } catch {
     return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
-  // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
+  // The bytecode is written to e.g. /workingDirectory/ParityBaseArtifact-bytecode
   const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
 
   const binaryPresent = await fs
@@ -782,7 +635,7 @@ export async function computeGateCountForCircuit(
     const result = await executeBB(
       pathToBB,
       'gates',
-      ['--scheme', flavor === 'mega_honk' ? 'client_ivc' : 'ultra_honk', '-b', bytecodePath, '-v'],
+      ['--scheme', flavor === 'mega_honk' ? 'chonk' : 'ultra_honk', '-b', bytecodePath, '-v'],
       logHandler,
     );
     const duration = timer.ms();
@@ -844,7 +697,7 @@ async function fsCache<T>(
 
   try {
     await fs.writeFile(cacheFilePath, expectedCacheKey);
-  } catch (err) {
+  } catch {
     logger(`Couldn't write cache data to ${cacheFilePath}. Skipping cache...`);
     // ignore
   }

package/src/config.ts

@@ -3,6 +3,8 @@ export interface BBConfig {
   bbWorkingDirectory: string;
   /** Whether to skip tmp dir cleanup for debugging purposes */
   bbSkipCleanup: boolean;
+  numConcurrentIVCVerifiers: number;
+  bbIVCConcurrency: number;
 }
 
 export interface ACVMConfig {

package/src/honk.ts

@@ -1,9 +1,9 @@
 import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
 
-export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_rollup_honk';
+export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_starknet_honk' | 'ultra_rollup_honk';
 
 const UltraKeccakHonkCircuits = ['RootRollupArtifact'] as const satisfies ServerProtocolArtifact[];
-const UltraHonkCircuits = ['BaseParityArtifact', 'RootParityArtifact'] as const satisfies ServerProtocolArtifact[];
+const UltraHonkCircuits = ['ParityBaseArtifact', 'ParityRootArtifact'] as const satisfies ServerProtocolArtifact[];
 
 export type UltraKeccakHonkServerProtocolArtifact = (typeof UltraKeccakHonkCircuits)[number];
 export type UltraHonkServerProtocolArtifact = (typeof UltraHonkCircuits)[number];
@@ -17,6 +17,7 @@ export function getUltraHonkFlavorForCircuit(artifact: UltraHonkServerProtocolAr
 export function getUltraHonkFlavorForCircuit(artifact: UltraRollupHonkServerProtocolArtifact): 'ultra_rollup_honk';
 export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor;
 export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor {
+  // STARKNET: how to allow for the distinction between keccak/starknet? ultra_keccak_honk is returned in both cases
   if (isUltraKeccakHonkCircuit(artifact)) {
     return 'ultra_keccak_honk';
   } else if (UltraHonkCircuits.includes(artifact as UltraHonkServerProtocolArtifact)) {

package/src/index.ts

@@ -4,5 +4,6 @@ export * from './verifier/index.js';
 export * from './config.js';
 export * from './bb/execute.js';
 export * from './honk.js';
+export * from './verification_key/verification_key_data.js';
 
 export { type ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';

package/src/instrumentation.ts

@@ -86,13 +86,12 @@ export class ProverInstrumentation {
    */
   recordDuration(
     metric: 'simulationDuration' | 'witGenDuration' | 'provingDuration',
-    circuitName: CircuitName | 'tubeCircuit',
+    circuitName: CircuitName,
     timerOrMS: Timer | number,
   ) {
     const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
     this[metric].record(s, {
       [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
-      [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
     });
   }
 
@@ -117,12 +116,11 @@ export class ProverInstrumentation {
    */
   recordSize(
     metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
-    circuitName: CircuitName | 'tubeCircuit',
+    circuitName: CircuitName,
     size: number,
   ) {
     this[metric].record(Math.ceil(size), {
       [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
-      [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
     });
   }