@aztec/bb-prover 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/dest/bb/execute.js

@@ -1,17 +1,15 @@
-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";
@@ -24,29 +22,57 @@ export var BB_RESULT = /*#__PURE__*/ function(BB_RESULT) {
  * @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 +93,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 +114,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 +139,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 +175,15 @@ function getArgs(flavor) {
                     'keccak'
                 ];
             }
+        case 'ultra_starknet_honk':
+            {
+                return [
+                    '--scheme',
+                    'ultra_honk',
+                    '--oracle_hash',
+                    'starknet'
+                ];
+            }
         case 'ultra_rollup_honk':
             {
                 return [
@@ -175,18 +206,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 +229,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 +262,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 +284,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 +318,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 +332,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 +344,14 @@ function getArgs(flavor) {
                 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: 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 {
@@ -485,17 +370,7 @@ function getArgs(flavor) {
  */ 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
- * @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 verifyAvmProofV2(pathToBB, workingDirectory, proofFullPath, publicInputs, verificationKeyPath, logger) {
+export async function verifyAvmProof(pathToBB, workingDirectory, proofFullPath, publicInputs, verificationKeyPath, 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 +382,20 @@ export async function verifyAvmProofV2(pathToBB, workingDirectory, proofFullPath
             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(pathToBB, proofPath, keyPath, log) {
+ */ export async function verifyChonkProof(pathToBB, proofPath, keyPath, log, concurrency = 1) {
     const binaryPresent = await fs.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
     if (!binaryPresent) {
         return {
@@ -530,15 +406,16 @@ export async function verifyAvmProofV2(pathToBB, workingDirectory, proofFullPath
     try {
         const args = [
             '--scheme',
-            'client_ivc',
+            'chonk',
             '-p',
             proofPath,
             '-k',
-            keyPath
+            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 == 0) {
             return {
@@ -579,13 +456,32 @@ export async function verifyAvmProofV2(pathToBB, workingDirectory, proofFullPath
         logger.verbose(`bb-prover (verify) BB out - ${message}`);
     };
     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);
@@ -685,13 +581,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 +608,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 +668,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=

package/dest/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,kCAAkC;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,oBAAoB,EAAE,MAAM,CAAC;CAC9B"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,aAAa,EAAE,OAAO,CAAC;IACvB,yBAAyB,EAAE,MAAM,CAAC;IAClC,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,kCAAkC;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,oBAAoB,EAAE,MAAM,CAAC;CAC9B"}

package/dest/honk.d.ts

@@ -1,7 +1,7 @@
 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';
 declare const UltraKeccakHonkCircuits: ["RootRollupArtifact"];
-declare const UltraHonkCircuits: ["BaseParityArtifact", "RootParityArtifact"];
+declare const UltraHonkCircuits: ["ParityBaseArtifact", "ParityRootArtifact"];
 export type UltraKeccakHonkServerProtocolArtifact = (typeof UltraKeccakHonkCircuits)[number];
 export type UltraHonkServerProtocolArtifact = (typeof UltraHonkCircuits)[number];
 export type UltraRollupHonkServerProtocolArtifact = Exclude<Exclude<ServerProtocolArtifact, UltraKeccakHonkServerProtocolArtifact>, UltraHonkServerProtocolArtifact>;
@@ -10,4 +10,4 @@ export declare function getUltraHonkFlavorForCircuit(artifact: UltraHonkServerPr
 export declare function getUltraHonkFlavorForCircuit(artifact: UltraRollupHonkServerProtocolArtifact): 'ultra_rollup_honk';
 export declare function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor;
 export {};
-//# sourceMappingURL=honk.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9uay5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2hvbmsudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUV6RixNQUFNLE1BQU0sZUFBZSxHQUFHLFlBQVksR0FBRyxtQkFBbUIsR0FBRyxxQkFBcUIsR0FBRyxtQkFBbUIsQ0FBQztBQUUvRyxRQUFBLE1BQU0sdUJBQXVCLHdCQUFxRSxDQUFDO0FBQ25HLFFBQUEsTUFBTSxpQkFBaUIsOENBQTJGLENBQUM7QUFFbkgsTUFBTSxNQUFNLHFDQUFxQyxHQUFHLENBQUMsT0FBTyx1QkFBdUIsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQzdGLE1BQU0sTUFBTSwrQkFBK0IsR0FBRyxDQUFDLE9BQU8saUJBQWlCLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUNqRixNQUFNLE1BQU0scUNBQXFDLEdBQUcsT0FBTyxDQUN6RCxPQUFPLENBQUMsc0JBQXNCLEVBQUUscUNBQXFDLENBQUMsRUFDdEUsK0JBQStCLENBQ2hDLENBQUM7QUFFRix3QkFBZ0IsNEJBQTRCLENBQUMsUUFBUSxFQUFFLHFDQUFxQyxHQUFHLG1CQUFtQixDQUFDO0FBQ25ILHdCQUFnQiw0QkFBNEIsQ0FBQyxRQUFRLEVBQUUsK0JBQStCLEdBQUcsWUFBWSxDQUFDO0FBQ3RHLHdCQUFnQiw0QkFBNEIsQ0FBQyxRQUFRLEVBQUUscUNBQXFDLEdBQUcsbUJBQW1CLENBQUM7QUFDbkgsd0JBQWdCLDRCQUE0QixDQUFDLFFBQVEsRUFBRSxzQkFBc0IsR0FBRyxlQUFlLENBQUMifQ==

package/dest/honk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"honk.d.ts","sourceRoot":"","sources":["../src/honk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AAEzF,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,mBAAmB,GAAG,mBAAmB,CAAC;AAEvF,QAAA,MAAM,uBAAuB,wBAAqE,CAAC;AACnG,QAAA,MAAM,iBAAiB,8CAA2F,CAAC;AAEnH,MAAM,MAAM,qCAAqC,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAC7F,MAAM,MAAM,+BAA+B,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AACjF,MAAM,MAAM,qCAAqC,GAAG,OAAO,CACzD,OAAO,CAAC,sBAAsB,EAAE,qCAAqC,CAAC,EACtE,+BAA+B,CAChC,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,qCAAqC,GAAG,mBAAmB,CAAC;AACnH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,+BAA+B,GAAG,YAAY,CAAC;AACtG,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,qCAAqC,GAAG,mBAAmB,CAAC;AACnH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,eAAe,CAAC"}
+{"version":3,"file":"honk.d.ts","sourceRoot":"","sources":["../src/honk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AAEzF,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,mBAAmB,GAAG,qBAAqB,GAAG,mBAAmB,CAAC;AAE/G,QAAA,MAAM,uBAAuB,wBAAqE,CAAC;AACnG,QAAA,MAAM,iBAAiB,8CAA2F,CAAC;AAEnH,MAAM,MAAM,qCAAqC,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAC7F,MAAM,MAAM,+BAA+B,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AACjF,MAAM,MAAM,qCAAqC,GAAG,OAAO,CACzD,OAAO,CAAC,sBAAsB,EAAE,qCAAqC,CAAC,EACtE,+BAA+B,CAChC,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,qCAAqC,GAAG,mBAAmB,CAAC;AACnH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,+BAA+B,GAAG,YAAY,CAAC;AACtG,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,qCAAqC,GAAG,mBAAmB,CAAC;AACnH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,eAAe,CAAC"}

package/dest/honk.js

@@ -2,10 +2,11 @@ const UltraKeccakHonkCircuits = [
     'RootRollupArtifact'
 ];
 const UltraHonkCircuits = [
-    'BaseParityArtifact',
-    'RootParityArtifact'
+    'ParityBaseArtifact',
+    'ParityRootArtifact'
 ];
 export function getUltraHonkFlavorForCircuit(artifact) {
+    // 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)) {

package/dest/index.d.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';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsNkNBQTZDLENBQUM7QUFFNUQsT0FBTyxFQUFFLEtBQUssNkJBQTZCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQyJ9