@aztec/bb-prover 0.0.0-test.0 → 0.0.1-commit.001888fc

package/dest/bb/execute.js

@@ -1,52 +1,79 @@
-import { sha256 } from '@aztec/foundation/crypto';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
 import { Timer } from '@aztec/foundation/timer';
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
 import { basename, dirname, join } from 'path';
-import { CLIENT_IVC_PROOF_FILE_NAME, CLIENT_IVC_VK_FILE_NAME } from '../prover/client_ivc_proof_utils.js';
+import readline from 'readline';
 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 var BB_RESULT = /*#__PURE__*/ function(BB_RESULT) {
     BB_RESULT[BB_RESULT["SUCCESS"] = 0] = "SUCCESS";
     BB_RESULT[BB_RESULT["FAILURE"] = 1] = "FAILURE";
     BB_RESULT[BB_RESULT["ALREADY_PRESENT"] = 2] = "ALREADY_PRESENT";
     return BB_RESULT;
 }({});
+export const DEFAULT_BB_VERIFY_CONCURRENCY = 4;
 /**
  * Invokes the Barretenberg binary with the provided command and args
  * @param pathToBB - The path to the BB binary
  * @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
- */ export function executeBB(pathToBB, command, args, logger, resultParser = (code)=>code === 0) {
+ */ export function executeBB(pathToBB, command, args, logger, concurrency, timeout, resultParser = (code)=>code === 0) {
     return new Promise((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;
+        if (timeout !== undefined) {
+            timeoutId = setTimeout(()=>{
+                logger(`BB execution timed out after ${timeout}ms, killing process`);
+                if (bb.pid) {
+                    bb.kill('SIGKILL');
+                }
+                resolve({
+                    status: 1,
+                    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, signal)=>{
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
             if (resultParser(exitCode)) {
                 resolve({
                     status: 0,
@@ -67,12 +94,11 @@ export var BB_RESULT = /*#__PURE__*/ function(BB_RESULT) {
             signal: undefined
         }));
 }
-// TODO(#7369) comment this etc (really just take inspiration from this and rewrite it all O:))
-export async function executeBbClientIvcProof(pathToBB, workingDirectory, bytecodeStackPath, witnessStackPath, log) {
+export async function executeBbChonkProof(pathToBB, workingDirectory, inputsPath, log, writeVk = false) {
     // Check that the working directory exists
     try {
         await fs.access(workingDirectory);
-    } catch (error) {
+    } catch  {
         return {
             status: 1,
             reason: `Working directory ${workingDirectory} does not exist`
@@ -89,26 +115,23 @@ export async function executeBbClientIvcProof(pathToBB, workingDirectory, byteco
     }
     try {
         // Write the bytecode to the working directory
-        log(`bytecodePath ${bytecodeStackPath}`);
-        log(`outputPath ${outputPath}`);
+        log(`inputsPath ${inputsPath}`);
+        const timer = new Timer();
+        const logFunction = (message)=>{
+            log(`bb - ${message}`);
+        };
         const args = [
             '-o',
             outputPath,
-            '-b',
-            bytecodeStackPath,
-            '-w',
-            witnessStackPath,
+            '--ivc_inputs_path',
+            inputsPath,
             '-v',
             '--scheme',
-            'client_ivc',
-            '--input_type',
-            'runtime_stack',
-            '--write_vk'
+            'chonk'
         ];
-        const timer = new Timer();
-        const logFunction = (message)=>{
-            log(`bb - ${message}`);
-        };
+        if (writeVk) {
+            args.push('--write_vk');
+        }
         const result = await executeBB(pathToBB, 'prove', args, logFunction);
         const durationMs = timer.ms();
         if (result.status == 0) {
@@ -117,7 +140,7 @@ export async function executeBbClientIvcProof(pathToBB, workingDirectory, byteco
                 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
@@ -153,6 +176,15 @@ function getArgs(flavor) {
                     'keccak'
                 ];
             }
+        case 'ultra_starknet_honk':
+            {
+                return [
+                    '--scheme',
+                    'ultra_honk',
+                    '--oracle_hash',
+                    'starknet'
+                ];
+            }
         case 'ultra_rollup_honk':
             {
                 return [
@@ -175,18 +207,19 @@ function getArgs(flavor) {
  * @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 generateProof(pathToBB, workingDirectory, circuitName, bytecode, recursive, inputWitnessFile, flavor, log) {
+ */ export async function generateProof(pathToBB, workingDirectory, circuitName, bytecode, verificationKey, inputWitnessFile, flavor, log) {
     // Check that the working directory exists
     try {
         await fs.access(workingDirectory);
-    } catch (error) {
+    } catch  {
         return {
             status: 1,
             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}`;
     const binaryPresent = await fs.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
@@ -197,26 +230,30 @@ function getArgs(flavor) {
         };
     }
     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)=>{
-            log(`${circuitName} BB out - ${message}`);
+            log.info(`${circuitName} BB out - ${message}`);
         };
         const result = await executeBB(pathToBB, `prove`, args, logFunction);
         const duration = timer.ms();
@@ -226,80 +263,7 @@ function getArgs(flavor) {
                 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: 1,
-            reason: `Failed to generate proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-            retry: !!result.signal
-        };
-    } catch (error) {
-        return {
-            status: 1,
-            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, workingDirectory, log) {
-    // Check that the working directory exists
-    try {
-        await fs.access(workingDirectory);
-    } catch (error) {
-        return {
-            status: 1,
-            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)=>await fs.access(file, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
-    const binaryPresent = await filePresent(pathToBB);
-    if (!binaryPresent) {
-        return {
-            status: 1,
-            reason: `Failed to find bb binary at ${pathToBB}`
-        };
-    }
-    try {
-        if (!await filePresent(vkPath) || !await filePresent(proofPath)) {
-            return {
-                status: 1,
-                reason: `Client IVC input files not present in  ${workingDirectory}`
-            };
-        }
-        const args = [
-            '-o',
-            outputPath,
-            '-v'
-        ];
-        const timer = new Timer();
-        const logFunction = (message)=>{
-            log(`TubeCircuit (prove) BB out - ${message}`);
-        };
-        const result = await executeBB(pathToBB, 'prove_tube', args, logFunction);
-        const durationMs = timer.ms();
-        if (result.status == 0) {
-            return {
-                status: 0,
-                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
@@ -321,13 +285,14 @@ function getArgs(flavor) {
  * @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(pathToBB, workingDirectory, input, logger) {
+ */ export async function generateAvmProof(pathToBB, workingDirectory, input, logger, checkCircuitOnly = false) {
     // Check that the working directory exists
     try {
         await fs.access(workingDirectory);
-    } catch (error) {
+    } catch  {
         return {
             status: 1,
             reason: `Working directory ${workingDirectory} does not exist`
@@ -354,7 +319,10 @@ function getArgs(flavor) {
                 reason: `Could not write avm inputs to ${avmInputsPath}`
             };
         }
-        const args = [
+        const args = checkCircuitOnly ? [
+            '--avm-inputs',
+            avmInputsPath
+        ] : [
             '--avm-inputs',
             avmInputsPath,
             '-o',
@@ -365,93 +333,11 @@ function getArgs(flavor) {
             args.push(loggingArg);
         }
         const timer = new Timer();
-        const logFunction = (message)=>{
-            logger.verbose(`AvmCircuit (prove) BB out - ${message}`);
-        };
-        const result = await executeBB(pathToBB, 'avm2_prove', args, logFunction);
-        const duration = timer.ms();
-        if (result.status == 0) {
-            return {
-                status: 0,
-                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: 1,
-            reason: `Failed to generate proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-            retry: !!result.signal
-        };
-    } catch (error) {
-        return {
-            status: 1,
-            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, workingDirectory, _input, logger, checkCircuitOnly = false) {
-    // Check that the working directory exists
-    try {
-        await fs.access(workingDirectory);
-    } catch (error) {
-        return {
-            status: 1,
-            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)=>await fs.access(file, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
-    const binaryPresent = await filePresent(pathToBB);
-    if (!binaryPresent) {
-        return {
-            status: 1,
-            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)=>{
             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 == 0) {
             return {
@@ -459,14 +345,14 @@ function getArgs(flavor) {
                 durationMs: duration,
                 proofPath: join(outputPath, PROOF_FILENAME),
                 pkPath: undefined,
-                vkPath: outputPath
+                vkDirectoryPath: undefined
             };
         }
         // Not a great error message here but it is difficult to decipher what comes from bb
         return {
             status: 1,
-            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'
         };
     } catch (error) {
         return {
@@ -480,22 +366,31 @@ function getArgs(flavor) {
  * @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 verifyProof(pathToBB, proofFullPath, verificationKeyPath, ultraHonkFlavor, log) {
-    return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, `verify`, log, getArgs(ultraHonkFlavor));
-}
-/**
- * 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
+ * @param logger - A logger
  * @returns An object containing a result indication and duration taken
- */ export async function verifyAvmProof(pathToBB, proofFullPath, verificationKeyPath, logger) {
-    return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', logger);
+ */ export async function verifyProof(pathToBB, proofFullPath, verificationKeyPath, ultraHonkFlavor, logger) {
+    // 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}`);
+    const args = [
+        '-p',
+        proofFullPath,
+        '-k',
+        verificationKeyPath,
+        '-i',
+        publicInputsFullPath,
+        '--disable_zk',
+        ...getArgs(ultraHonkFlavor)
+    ];
+    let concurrency = DEFAULT_BB_VERIFY_CONCURRENCY;
+    if (process.env.VERIFY_HARDWARE_CONCURRENCY) {
+        concurrency = parseInt(process.env.VERIFY_HARDWARE_CONCURRENCY, 10);
+    }
+    return await verifyProofInternal(pathToBB, `verify`, args, logger, concurrency);
 }
-export async function verifyAvmProofV2(pathToBB, workingDirectory, proofFullPath, publicInputs, verificationKeyPath, logger) {
+export async function verifyAvmProof(pathToBB, workingDirectory, proofFullPath, publicInputs, logger) {
     const inputsBuffer = publicInputs.serializeWithMessagePack();
     // Write the inputs to the working directory.
     const filePresent = async (file)=>await fs.access(file, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
@@ -507,19 +402,23 @@ export async function verifyAvmProofV2(pathToBB, workingDirectory, proofFullPath
             reason: `Could not write avm inputs to ${avmInputsPath}`
         };
     }
-    return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm2_verify', logger, [
+    const args = [
+        '-p',
+        proofFullPath,
         '--avm-public-inputs',
         avmInputsPath
-    ]);
+    ];
+    return await verifyProofInternal(pathToBB, 'avm_verify', args, logger);
 }
 /**
- * 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 logger - A logger
+ * @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(pathToBB, proofPath, keyPath, log) {
+ */ export async function verifyChonkProof(pathToBB, proofPath, keyPath, logger, concurrency = 1) {
     const binaryPresent = await fs.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
     if (!binaryPresent) {
         return {
@@ -527,47 +426,26 @@ export async function verifyAvmProofV2(pathToBB, workingDirectory, proofFullPath
             reason: `Failed to find bb binary at ${pathToBB}`
         };
     }
-    try {
-        const args = [
-            '--scheme',
-            'client_ivc',
-            '-p',
-            proofPath,
-            '-k',
-            keyPath
-        ];
-        const timer = new Timer();
-        const command = 'verify';
-        const result = await executeBB(pathToBB, command, args, log);
-        const duration = timer.ms();
-        if (result.status == 0) {
-            return {
-                status: 0,
-                durationMs: duration
-            };
-        }
-        // Not a great error message here but it is difficult to decipher what comes from bb
-        return {
-            status: 1,
-            reason: `Failed to verify proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-            retry: !!result.signal
-        };
-    } catch (error) {
-        return {
-            status: 1,
-            reason: `${error}`
-        };
-    }
+    const args = [
+        '--scheme',
+        'chonk',
+        '-p',
+        proofPath,
+        '-k',
+        keyPath,
+        '-v'
+    ];
+    return await verifyProofInternal(pathToBB, 'verify', args, logger, concurrency);
 }
 /**
  * Used for verifying proofs with BB
  * @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 command - The BB command to execute (verify/avm_verify)
- * @param log - A logging function
+ * @param args - The arguments to pass to the command
+ * @param logger - A logger
+ * @param concurrency - The number of threads to use for the verification
  * @returns An object containing a result indication and duration taken
- */ async function verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, command, logger, extraArgs = []) {
+ */ async function verifyProofInternal(pathToBB, command, args, logger, concurrency) {
     const binaryPresent = await fs.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
     if (!binaryPresent) {
         return {
@@ -579,19 +457,13 @@ export async function verifyAvmProofV2(pathToBB, workingDirectory, proofFullPath
         logger.verbose(`bb-prover (verify) BB out - ${message}`);
     };
     try {
-        const 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 finalArgs = loggingArg !== '' ? [
+            ...args,
+            loggingArg
+        ] : args;
         const timer = new Timer();
-        const result = await executeBB(pathToBB, command, args, logFunction);
+        const result = await executeBB(pathToBB, command, finalArgs, logFunction, concurrency);
         const duration = timer.ms();
         if (result.status == 0) {
             return {
@@ -685,13 +557,13 @@ export async function generateContractForVerificationKey(pathToBB, vkFilePath, c
     // Check that the working directory exists
     try {
         await fs.access(workingDirectory);
-    } catch (error) {
+    } catch  {
         return {
             status: 1,
             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.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
     if (!binaryPresent) {
@@ -712,7 +584,7 @@ export async function generateContractForVerificationKey(pathToBB, vkFilePath, c
         const timer = new Timer();
         const result = await executeBB(pathToBB, 'gates', [
             '--scheme',
-            flavor === 'mega_honk' ? 'client_ivc' : 'ultra_honk',
+            flavor === 'mega_honk' ? 'chonk' : 'ultra_honk',
             '-b',
             bytecodePath,
             '-v'
@@ -772,7 +644,7 @@ async function fsCache(dir, expectedCacheKey, logger, force, action) {
     }
     try {
         await fs.writeFile(cacheFilePath, expectedCacheKey);
-    } catch (err) {
+    } catch  {
         logger(`Couldn't write cache data to ${cacheFilePath}. Skipping cache...`);
     // ignore
     }

package/dest/bb/index.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env -S node --no-warnings
 import 'source-map-support/register.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBR0EsT0FBTyxnQ0FBZ0MsQ0FBQyJ9

package/dest/config.d.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 {
     /** The path to the ACVM binary */
@@ -10,4 +12,4 @@ export interface ACVMConfig {
     /** The working directory to use for simulation/proving */
     acvmWorkingDirectory: string;
 }
-//# sourceMappingURL=config.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sV0FBVyxRQUFRO0lBQ3ZCLFlBQVksRUFBRSxNQUFNLENBQUM7SUFDckIsa0JBQWtCLEVBQUUsTUFBTSxDQUFDO0lBQzNCLDZEQUE2RDtJQUM3RCxhQUFhLEVBQUUsT0FBTyxDQUFDO0lBQ3ZCLHlCQUF5QixFQUFFLE1BQU0sQ0FBQztJQUNsQyxnQkFBZ0IsRUFBRSxNQUFNLENBQUM7Q0FDMUI7QUFFRCxNQUFNLFdBQVcsVUFBVTtJQUN6QixrQ0FBa0M7SUFDbEMsY0FBYyxFQUFFLE1BQU0sQ0FBQztJQUN2QiwwREFBMEQ7SUFDMUQsb0JBQW9CLEVBQUUsTUFBTSxDQUFDO0NBQzlCIn0=