@aztec/bb-prover 0.39.0

package/dest/bb/cli.d.ts

@@ -0,0 +1,9 @@
+import { type LogFn } from '@aztec/foundation/log';
+import { Command } from 'commander';
+/**
+ * Returns commander program that defines the CLI.
+ * @param log - Console logger.
+ * @returns The CLI.
+ */
+export declare function getProgram(log: LogFn): Command;
+//# sourceMappingURL=cli.d.ts.map

package/dest/bb/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/bb/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,CA4E9C"}

package/dest/bb/cli.js

@@ -0,0 +1,64 @@
+import { ProtocolCircuitArtifacts } from '@aztec/noir-protocol-circuits-types';
+import { Command } from 'commander';
+import * as fs from 'fs/promises';
+import { generateKeyForNoirCircuit } from './execute.js';
+const { BB_WORKING_DIRECTORY, BB_BINARY_PATH } = process.env;
+/**
+ * Returns commander program that defines the CLI.
+ * @param log - Console logger.
+ * @returns The CLI.
+ */
+export function getProgram(log) {
+    const program = new Command();
+    program.name('bb-cli').description('CLI for interacting with Barretenberg.');
+    program
+        .command('protocol-circuits')
+        .description('Lists the available protocol circuit artifacts')
+        .action(() => {
+        log(Object.keys(ProtocolCircuitArtifacts).reduce((prev, x) => prev.concat(`\n${x}`)));
+    });
+    program
+        .command('write-pk')
+        .description('Generates the proving key for the specified circuit')
+        .requiredOption('-w, --working-directory <string>', 'A directory to use for storing input/output files', BB_WORKING_DIRECTORY)
+        .requiredOption('-b, --bb-path <string>', 'The path to the BB binary', BB_BINARY_PATH)
+        .requiredOption('-c, --circuit <string>', 'The name of a protocol circuit')
+        .action(async (options) => {
+        const compiledCircuit = ProtocolCircuitArtifacts[options.circuit];
+        if (!compiledCircuit) {
+            log(`Failed to find circuit ${options.circuit}`);
+            return;
+        }
+        try {
+            await fs.access(options.workingDirectory, fs.constants.W_OK);
+        }
+        catch (error) {
+            log(`Working directory does not exist`);
+            return;
+        }
+        await generateKeyForNoirCircuit(options.bbPath, options.workingDirectory, options.circuit, compiledCircuit, 'pk', log);
+    });
+    program
+        .command('write-vk')
+        .description('Generates the verification key for the specified circuit')
+        .requiredOption('-w, --working-directory <string>', 'A directory to use for storing input/output files', BB_WORKING_DIRECTORY)
+        .requiredOption('-b, --bb-path <string>', 'The path to the BB binary', BB_BINARY_PATH)
+        .requiredOption('-c, --circuit <string>', 'The name of a protocol circuit')
+        .action(async (options) => {
+        const compiledCircuit = ProtocolCircuitArtifacts[options.circuit];
+        if (!compiledCircuit) {
+            log(`Failed to find circuit ${options.circuit}`);
+            return;
+        }
+        try {
+            await fs.access(options.workingDirectory, fs.constants.W_OK);
+        }
+        catch (error) {
+            log(`Working directory does not exist`);
+            return;
+        }
+        await generateKeyForNoirCircuit(options.bbPath, options.workingDirectory, options.circuit, compiledCircuit, 'vk', log);
+    });
+    return program;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/bb/execute.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type LogFn } from '@aztec/foundation/log';
+import { type NoirCompiledCircuit } from '@aztec/types/noir';
+export declare const VK_FILENAME = "vk";
+export declare const VK_FIELDS_FILENAME = "vk_fields.json";
+export declare const PROOF_FILENAME = "proof";
+export declare const PROOF_FIELDS_FILENAME = "proof_fields.json";
+export declare enum BB_RESULT {
+    SUCCESS = 0,
+    FAILURE = 1,
+    ALREADY_PRESENT = 2
+}
+export type BBSuccess = {
+    status: BB_RESULT.SUCCESS | BB_RESULT.ALREADY_PRESENT;
+    duration: number;
+    pkPath?: string;
+    vkPath?: string;
+    proofPath?: string;
+};
+export type BBFailure = {
+    status: BB_RESULT.FAILURE;
+    reason: string;
+};
+export type BBResult = BBSuccess | BBFailure;
+/**
+ * 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 resultParser - An optional handler for detecting success or failure
+ * @returns The completed partial witness outputted from the circuit
+ */
+export declare function executeBB(pathToBB: string, command: string, args: string[], logger: LogFn, resultParser?: (code: number) => boolean): Promise<BB_RESULT>;
+/**
+ * Used for generating either a proving or verification key, will exit early if the key already exists
+ * It assumes the provided working directory is one where the caller wishes to maintain a permanent set of keys
+ * It is not considered a temporary directory
+ * @param pathToBB - The full path to the bb binary
+ * @param workingDirectory - The directory into which the key should be created
+ * @param circuitName - An identifier for the circuit
+ * @param compiledCircuit - The compiled circuit
+ * @param key - The type of key, either 'pk' or 'vk'
+ * @param log - A logging function
+ * @param force - Force the key to be regenerated even if it already exists
+ * @returns An instance of BBResult
+ */
+export declare function generateKeyForNoirCircuit(pathToBB: string, workingDirectory: string, circuitName: string, compiledCircuit: NoirCompiledCircuit, key: 'vk' | 'pk', log: LogFn, force?: boolean): Promise<BBSuccess | BBFailure>;
+/**
+ * Used for generating proofs of noir circuits.
+ * 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 declare function generateProof(pathToBB: string, workingDirectory: string, circuitName: string, bytecode: Buffer, inputWitnessFile: string, log: LogFn): Promise<BBFailure | BBSuccess>;
+/**
+ * Used for verifying proofs of noir circuits
+ * @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 declare function verifyProof(pathToBB: string, proofFullPath: string, verificationKeyPath: string, log: LogFn): Promise<BBFailure | BBSuccess>;
+/**
+ * Used for verifying proofs of noir circuits
+ * @param pathToBB - The full path to the bb binary
+ * @param verificationKeyPath - The directory containing the binary verification key
+ * @param verificationKeyFilename - The filename of the verification key
+ * @param log - A logging function
+ * @returns An object containing a result indication and duration taken
+ */
+export declare function writeVkAsFields(pathToBB: string, verificationKeyPath: string, verificationKeyFilename: string, log: LogFn): Promise<BBFailure | BBSuccess>;
+/**
+ * Used for verifying proofs of noir circuits
+ * @param pathToBB - The full path to the bb binary
+ * @param proofPath - The directory containing the binary proof
+ * @param proofFileName - The filename of the proof
+ * @param log - A logging function
+ * @returns An object containing a result indication and duration taken
+ */
+export declare function writeProofAsFields(pathToBB: string, proofPath: string, proofFileName: string, log: LogFn): Promise<BBFailure | BBSuccess>;
+//# sourceMappingURL=execute.d.ts.map

package/dest/bb/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/bb/execute.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAK7D,eAAO,MAAM,WAAW,OAAO,CAAC;AAChC,eAAO,MAAM,kBAAkB,mBAAmB,CAAC;AACnD,eAAO,MAAM,cAAc,UAAU,CAAC;AACtC,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AAEzD,oBAAY,SAAS;IACnB,OAAO,IAAA;IACP,OAAO,IAAA;IACP,eAAe,IAAA;CAChB;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,SAAS,CAAC,OAAO,GAAG,SAAS,CAAC,eAAe,CAAC;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;AAE7C;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,KAAK,EACb,YAAY,UAAU,MAAM,YAAe,sBAqB5C;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,mBAAmB,EACpC,GAAG,EAAE,IAAI,GAAG,IAAI,EAChB,GAAG,EAAE,KAAK,EACV,KAAK,UAAQ,GACZ,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAoFhC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,GAAG,EAAE,KAAK,GACT,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAgDhC;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,mBAAmB,EAAE,MAAM,EAC3B,GAAG,EAAE,KAAK,GACT,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAsBhC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,mBAAmB,EAAE,MAAM,EAC3B,uBAAuB,EAAE,MAAM,EAC/B,GAAG,EAAE,KAAK,GACT,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAsBhC;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,KAAK,GACT,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAsBhC"}

package/dest/bb/execute.js

@@ -0,0 +1,288 @@
+import { sha256 } from '@aztec/foundation/crypto';
+import { Timer } from '@aztec/foundation/timer';
+import * as proc from 'child_process';
+import * as fs from 'fs/promises';
+export const VK_FILENAME = 'vk';
+export const VK_FIELDS_FILENAME = 'vk_fields.json';
+export const PROOF_FILENAME = 'proof';
+export const PROOF_FIELDS_FILENAME = 'proof_fields.json';
+export var BB_RESULT;
+(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";
+})(BB_RESULT || (BB_RESULT = {}));
+/**
+ * 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 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) {
+    return new Promise((resolve, reject) => {
+        // spawn the bb process
+        const bb = proc.spawn(pathToBB, [command, ...args]);
+        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);
+        });
+        bb.on('close', (code) => {
+            if (resultParser(code)) {
+                resolve(BB_RESULT.SUCCESS);
+            }
+            else {
+                reject();
+            }
+        });
+    }).catch(_ => BB_RESULT.FAILURE);
+}
+const bytecodeHashFilename = 'bytecode_hash';
+const bytecodeFilename = 'bytecode';
+/**
+ * Used for generating either a proving or verification key, will exit early if the key already exists
+ * It assumes the provided working directory is one where the caller wishes to maintain a permanent set of keys
+ * It is not considered a temporary directory
+ * @param pathToBB - The full path to the bb binary
+ * @param workingDirectory - The directory into which the key should be created
+ * @param circuitName - An identifier for the circuit
+ * @param compiledCircuit - The compiled circuit
+ * @param key - The type of key, either 'pk' or 'vk'
+ * @param log - A logging function
+ * @param force - Force the key to be regenerated even if it already exists
+ * @returns An instance of BBResult
+ */
+export async function generateKeyForNoirCircuit(pathToBB, workingDirectory, circuitName, compiledCircuit, key, log, force = false) {
+    const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+    // The key generation is written to e.g. /workingDirectory/pk/BaseParityArtifact/pk
+    // The bytecode hash file is also written here as /workingDirectory/pk/BaseParityArtifact/bytecode-hash
+    // The bytecode is written to e.g. /workingDirectory/pk/BaseParityArtifact/bytecode
+    // The bytecode is removed after the key is generated, leaving just the hash file
+    const circuitOutputDirectory = `${workingDirectory}/${key}/${circuitName}`;
+    const bytecodeHashPath = `${circuitOutputDirectory}/${bytecodeHashFilename}`;
+    const bytecodePath = `${circuitOutputDirectory}/${bytecodeFilename}`;
+    const bytecodeHash = sha256(bytecode);
+    const outputPath = `${circuitOutputDirectory}`;
+    // ensure the directory exists
+    await fs.mkdir(circuitOutputDirectory, { recursive: true });
+    // Generate the key if we have been told to, or there is no bytecode hash
+    let mustRegenerate = force ||
+        (await fs
+            .access(bytecodeHashPath, fs.constants.R_OK)
+            .then(_ => false)
+            .catch(_ => true));
+    if (!mustRegenerate) {
+        // Check to see if the bytecode hash has changed from the stored value
+        const data = await fs.readFile(bytecodeHashPath).catch(_ => Buffer.alloc(0));
+        mustRegenerate = data.length == 0 || !data.equals(bytecodeHash);
+    }
+    if (!mustRegenerate) {
+        // No need to generate, early out
+        return {
+            status: BB_RESULT.ALREADY_PRESENT,
+            duration: 0,
+            pkPath: key === 'pk' ? outputPath : undefined,
+            vkPath: key === 'vk' ? outputPath : undefined,
+            proofPath: undefined,
+        };
+    }
+    // Check we have access to bb
+    const binaryPresent = await fs
+        .access(pathToBB, fs.constants.R_OK)
+        .then(_ => true)
+        .catch(_ => false);
+    if (!binaryPresent) {
+        return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
+    }
+    // We are now going to generate the key
+    try {
+        // Write the bytecode to the working directory
+        await fs.writeFile(bytecodePath, bytecode);
+        // args are the output path and the input bytecode path
+        const args = ['-o', outputPath, '-b', bytecodePath];
+        const timer = new Timer();
+        let result = await executeBB(pathToBB, `write_${key}`, args, log);
+        // If we succeeded and the type of key if verification, have bb write the 'fields' version too
+        if (result == BB_RESULT.SUCCESS && key === 'vk') {
+            const asFieldsArgs = ['-k', `${outputPath}/${VK_FILENAME}`, '-o', `${outputPath}/${VK_FIELDS_FILENAME}`, '-v'];
+            result = await executeBB(pathToBB, `vk_as_fields`, asFieldsArgs, log);
+        }
+        const duration = timer.ms();
+        // Cleanup the bytecode file
+        await fs.rm(bytecodePath, { force: true });
+        if (result == BB_RESULT.SUCCESS) {
+            // Store the bytecode hash so we don't need to regenerate at a later time
+            await fs.writeFile(bytecodeHashPath, bytecodeHash);
+            return {
+                status: BB_RESULT.SUCCESS,
+                duration,
+                pkPath: key === 'pk' ? outputPath : undefined,
+                vkPath: key === 'vk' ? outputPath : undefined,
+                proofPath: undefined,
+            };
+        }
+        // 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 key` };
+    }
+    catch (error) {
+        return { status: BB_RESULT.FAILURE, reason: `${error}` };
+    }
+}
+/**
+ * Used for generating proofs of noir circuits.
+ * 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 generateProof(pathToBB, workingDirectory, circuitName, bytecode, inputWitnessFile, log) {
+    // 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` };
+    }
+    // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
+    const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
+    // The proof is written to e.g. /workingDirectory/proof
+    const outputPath = `${workingDirectory}`;
+    const binaryPresent = await fs
+        .access(pathToBB, fs.constants.R_OK)
+        .then(_ => true)
+        .catch(_ => false);
+    if (!binaryPresent) {
+        return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
+    }
+    try {
+        // Write the bytecode to the working directory
+        await fs.writeFile(bytecodePath, bytecode);
+        const args = ['-o', outputPath, '-b', bytecodePath, '-w', inputWitnessFile, '-v'];
+        const timer = new Timer();
+        const logFunction = (message) => {
+            log(`${circuitName} BB out - ${message}`);
+        };
+        const result = await executeBB(pathToBB, 'prove_output_all', args, logFunction);
+        const duration = timer.ms();
+        // cleanup the bytecode
+        await fs.rm(bytecodePath, { force: true });
+        if (result == BB_RESULT.SUCCESS) {
+            return {
+                status: BB_RESULT.SUCCESS,
+                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` };
+    }
+    catch (error) {
+        return { status: BB_RESULT.FAILURE, reason: `${error}` };
+    }
+}
+/**
+ * Used for verifying proofs of noir circuits
+ * @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, log) {
+    const binaryPresent = await fs
+        .access(pathToBB, fs.constants.R_OK)
+        .then(_ => true)
+        .catch(_ => false);
+    if (!binaryPresent) {
+        return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
+    }
+    try {
+        const args = ['-p', proofFullPath, '-k', verificationKeyPath];
+        const timer = new Timer();
+        const result = await executeBB(pathToBB, 'verify', args, log);
+        const duration = timer.ms();
+        if (result == BB_RESULT.SUCCESS) {
+            return { status: BB_RESULT.SUCCESS, duration };
+        }
+        // Not a great error message here but it is difficult to decipher what comes from bb
+        return { status: BB_RESULT.FAILURE, reason: `Failed to verify proof` };
+    }
+    catch (error) {
+        return { status: BB_RESULT.FAILURE, reason: `${error}` };
+    }
+}
+/**
+ * Used for verifying proofs of noir circuits
+ * @param pathToBB - The full path to the bb binary
+ * @param verificationKeyPath - The directory containing the binary verification key
+ * @param verificationKeyFilename - The filename of the verification key
+ * @param log - A logging function
+ * @returns An object containing a result indication and duration taken
+ */
+export async function writeVkAsFields(pathToBB, verificationKeyPath, verificationKeyFilename, log) {
+    const binaryPresent = await fs
+        .access(pathToBB, fs.constants.R_OK)
+        .then(_ => true)
+        .catch(_ => false);
+    if (!binaryPresent) {
+        return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
+    }
+    try {
+        const args = ['-k', `${verificationKeyPath}/${verificationKeyFilename}`, '-v'];
+        const timer = new Timer();
+        const result = await executeBB(pathToBB, 'vk_as_fields', args, log);
+        const duration = timer.ms();
+        if (result == BB_RESULT.SUCCESS) {
+            return { status: BB_RESULT.SUCCESS, duration, vkPath: verificationKeyPath };
+        }
+        // Not a great error message here but it is difficult to decipher what comes from bb
+        return { status: BB_RESULT.FAILURE, reason: `Failed to create vk as fields` };
+    }
+    catch (error) {
+        return { status: BB_RESULT.FAILURE, reason: `${error}` };
+    }
+}
+/**
+ * Used for verifying proofs of noir circuits
+ * @param pathToBB - The full path to the bb binary
+ * @param proofPath - The directory containing the binary proof
+ * @param proofFileName - The filename of the proof
+ * @param log - A logging function
+ * @returns An object containing a result indication and duration taken
+ */
+export async function writeProofAsFields(pathToBB, proofPath, proofFileName, log) {
+    const binaryPresent = await fs
+        .access(pathToBB, fs.constants.R_OK)
+        .then(_ => true)
+        .catch(_ => false);
+    if (!binaryPresent) {
+        return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
+    }
+    try {
+        const args = ['-p', `${proofPath}/${proofFileName}`, '-v'];
+        const timer = new Timer();
+        const result = await executeBB(pathToBB, 'proof_as_fields', args, log);
+        const duration = timer.ms();
+        if (result == BB_RESULT.SUCCESS) {
+            return { status: BB_RESULT.SUCCESS, duration, proofPath: proofPath };
+        }
+        // Not a great error message here but it is difficult to decipher what comes from bb
+        return { status: BB_RESULT.FAILURE, reason: `Failed to create proof as fields` };
+    }
+    catch (error) {
+        return { status: BB_RESULT.FAILURE, reason: `${error}` };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"execute.js","sourceRoot":"","sources":["../../src/bb/execute.ts"],"names":[],"mappings":"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"}

package/dest/bb/index.d.ts

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

package/dest/bb/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bb/index.ts"],"names":[],"mappings":";AAGA,OAAO,gCAAgC,CAAC"}

package/dest/bb/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env -S node --no-warnings
+import { createConsoleLogger } from '@aztec/foundation/log';
+import 'source-map-support/register.js';
+import { getProgram } from './cli.js';
+const log = createConsoleLogger();
+/** CLI main entrypoint */
+async function main() {
+    process.once('SIGINT', () => process.exit(0));
+    process.once('SIGTERM', () => process.exit(0));
+    const program = getProgram(log);
+    await program.parseAsync(process.argv);
+}
+main().catch(err => {
+    log(`Error in command execution`);
+    log(err);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYmIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRTVELE9BQU8sZ0NBQWdDLENBQUM7QUFFeEMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUV0QyxNQUFNLEdBQUcsR0FBRyxtQkFBbUIsRUFBRSxDQUFDO0FBRWxDLDBCQUEwQjtBQUMxQixLQUFLLFVBQVUsSUFBSTtJQUNqQixPQUFPLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxHQUFHLEVBQUUsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDOUMsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRS9DLE1BQU0sT0FBTyxHQUFHLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNoQyxNQUFNLE9BQU8sQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ3pDLENBQUM7QUFFRCxJQUFJLEVBQUUsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLEVBQUU7SUFDakIsR0FBRyxDQUFDLDRCQUE0QixDQUFDLENBQUM7SUFDbEMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ1QsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNsQixDQUFDLENBQUMsQ0FBQyJ9

package/dest/index.d.ts

@@ -0,0 +1,3 @@
+export * from './prover/index.js';
+export * from './test/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}

package/dest/index.js

@@ -0,0 +1,3 @@
+export * from './prover/index.js';
+export * from './test/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGlCQUFpQixDQUFDIn0=

package/dest/mappings/mappings.d.ts

@@ -0,0 +1,12 @@
+import { PublicKernelType } from '@aztec/circuit-types';
+import { type PublicKernelCircuitPrivateInputs, type PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
+import { type WitnessMap } from '@noir-lang/types';
+export type PublicKernelProvingOps = {
+    artifact: ServerProtocolArtifact;
+    convertInputs: (inputs: PublicKernelCircuitPrivateInputs) => WitnessMap;
+    convertOutputs: (outputs: WitnessMap) => PublicKernelCircuitPublicInputs;
+};
+export type KernelTypeToArtifact = Record<PublicKernelType, PublicKernelProvingOps | undefined>;
+export declare const PublicKernelArtifactMapping: KernelTypeToArtifact;
+//# sourceMappingURL=mappings.d.ts.map

package/dest/mappings/mappings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappings.d.ts","sourceRoot":"","sources":["../../src/mappings/mappings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,KAAK,gCAAgC,EAAE,KAAK,+BAA+B,EAAE,MAAM,oBAAoB,CAAC;AACjH,OAAO,EACL,KAAK,sBAAsB,EAO5B,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,sBAAsB,CAAC;IACjC,aAAa,EAAE,CAAC,MAAM,EAAE,gCAAgC,KAAK,UAAU,CAAC;IACxE,cAAc,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,+BAA+B,CAAC;CAC1E,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,gBAAgB,EAAE,sBAAsB,GAAG,SAAS,CAAC,CAAC;AAEhG,eAAO,MAAM,2BAA2B,EAAE,oBAkBzC,CAAC"}

package/dest/mappings/mappings.js

@@ -0,0 +1,22 @@
+import { PublicKernelType } from '@aztec/circuit-types';
+import { convertPublicInnerRollupInputsToWitnessMap, convertPublicInnerRollupOutputFromWitnessMap, convertPublicSetupRollupInputsToWitnessMap, convertPublicSetupRollupOutputFromWitnessMap, convertPublicTeardownRollupInputsToWitnessMap, convertPublicTeardownRollupOutputFromWitnessMap, } from '@aztec/noir-protocol-circuits-types';
+export const PublicKernelArtifactMapping = {
+    [PublicKernelType.NON_PUBLIC]: undefined,
+    [PublicKernelType.APP_LOGIC]: {
+        artifact: 'PublicKernelAppLogicArtifact',
+        convertInputs: convertPublicInnerRollupInputsToWitnessMap,
+        convertOutputs: convertPublicInnerRollupOutputFromWitnessMap,
+    },
+    [PublicKernelType.SETUP]: {
+        artifact: 'PublicKernelSetupArtifact',
+        convertInputs: convertPublicSetupRollupInputsToWitnessMap,
+        convertOutputs: convertPublicSetupRollupOutputFromWitnessMap,
+    },
+    [PublicKernelType.TEARDOWN]: {
+        artifact: 'PublicKernelTeardownArtifact',
+        convertInputs: convertPublicTeardownRollupInputsToWitnessMap,
+        convertOutputs: convertPublicTeardownRollupOutputFromWitnessMap,
+    },
+    [PublicKernelType.TAIL]: undefined,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwcGluZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWFwcGluZ3MvbWFwcGluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFeEQsT0FBTyxFQUVMLDBDQUEwQyxFQUMxQyw0Q0FBNEMsRUFDNUMsMENBQTBDLEVBQzFDLDRDQUE0QyxFQUM1Qyw2Q0FBNkMsRUFDN0MsK0NBQStDLEdBQ2hELE1BQU0scUNBQXFDLENBQUM7QUFZN0MsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQXlCO0lBQy9ELENBQUMsZ0JBQWdCLENBQUMsVUFBVSxDQUFDLEVBQUUsU0FBUztJQUN4QyxDQUFDLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxFQUFFO1FBQzVCLFFBQVEsRUFBRSw4QkFBOEI7UUFDeEMsYUFBYSxFQUFFLDBDQUEwQztRQUN6RCxjQUFjLEVBQUUsNENBQTRDO0tBQzdEO0lBQ0QsQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsRUFBRTtRQUN4QixRQUFRLEVBQUUsMkJBQTJCO1FBQ3JDLGFBQWEsRUFBRSwwQ0FBMEM7UUFDekQsY0FBYyxFQUFFLDRDQUE0QztLQUM3RDtJQUNELENBQUMsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLEVBQUU7UUFDM0IsUUFBUSxFQUFFLDhCQUE4QjtRQUN4QyxhQUFhLEVBQUUsNkNBQTZDO1FBQzVELGNBQWMsRUFBRSwrQ0FBK0M7S0FDaEU7SUFDRCxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxFQUFFLFNBQVM7Q0FDbkMsQ0FBQyJ9

package/dest/prover/bb_native_proof_creator.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type AppCircuitProofOutput, type KernelProofOutput, type ProofCreator } from '@aztec/circuit-types';
+import { Fr, type PrivateCircuitPublicInputs, type PrivateKernelCircuitPublicInputs, type PrivateKernelInitCircuitPrivateInputs, type PrivateKernelInnerCircuitPrivateInputs, type PrivateKernelTailCircuitPrivateInputs, type PrivateKernelTailCircuitPublicInputs, Proof } from '@aztec/circuits.js';
+import { type ClientProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
+import { type ACVMField } from '@aztec/simulator';
+/**
+ * This proof creator implementation uses the native bb binary.
+ * This is a temporary implementation until we make the WASM version work.
+ */
+export declare class BBNativeProofCreator implements ProofCreator {
+    private bbBinaryPath;
+    private bbWorkingDirectory;
+    private log;
+    private simulator;
+    private verificationKeys;
+    constructor(bbBinaryPath: string, bbWorkingDirectory: string, log?: import("@aztec/foundation/log").Logger);
+    getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs): Promise<Fr[]>;
+    createProofInit(inputs: PrivateKernelInitCircuitPrivateInputs): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>>;
+    createProofInner(inputs: PrivateKernelInnerCircuitPrivateInputs): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>>;
+    createProofTail(inputs: PrivateKernelTailCircuitPrivateInputs): Promise<KernelProofOutput<PrivateKernelTailCircuitPublicInputs>>;
+    createAppCircuitProof(partialWitness: Map<number, ACVMField>, bytecode: Buffer): Promise<AppCircuitProofOutput>;
+    /**
+     * Verifies a proof, will generate the verification key if one is not cached internally
+     * @param circuitType - The type of circuit whose proof is to be verified
+     * @param proof - The proof to be verified
+     */
+    verifyProofForProtocolCircuit(circuitType: ClientProtocolArtifact, proof: Proof): Promise<void>;
+    private verifyProofFromKey;
+    /**
+     * Returns the verification key data for a circuit, will generate and cache it if not cached internally
+     * @param circuitType - The type of circuit for which the verification key is required
+     * @returns The verification key data
+     */
+    private getVerificationKeyDataForCircuit;
+    /**
+     * Reads the verification key data stored at the specified location and parses into a VerificationKeyData
+     * @param filePath - The directory containing the verification key data files
+     * @returns The verification key data
+     */
+    private convertVk;
+    /**
+     * Ensures our verification key cache includes the key data located at the specified directory
+     * @param filePath - The directory containing the verification key data files
+     * @param circuitType - The type of circuit to which the verification key corresponds
+     */
+    private updateVerificationKeyAfterProof;
+    private createSafeProof;
+    private generateWitnessAndCreateProof;
+    private createProof;
+    /**
+     * Parses and returns the proof data stored at the specified directory
+     * @param filePath - The directory containing the proof data
+     * @param circuitType - The type of circuit proven
+     * @returns The proof
+     */
+    private readProofAsFields;
+}
+//# sourceMappingURL=bb_native_proof_creator.d.ts.map

package/dest/prover/bb_native_proof_creator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bb_native_proof_creator.d.ts","sourceRoot":"","sources":["../../src/prover/bb_native_proof_creator.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAC7G,OAAO,EACL,EAAE,EAEF,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,qCAAqC,EAC1C,KAAK,sCAAsC,EAC3C,KAAK,qCAAqC,EAC1C,KAAK,oCAAoC,EACzC,KAAK,EAKN,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EAEL,KAAK,sBAAsB,EAS5B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,KAAK,SAAS,EAAiB,MAAM,kBAAkB,CAAC;AA4CjE;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IASrD,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,GAAG;IAVb,OAAO,CAAC,SAAS,CAAuB;IAExC,OAAO,CAAC,gBAAgB,CAGpB;gBAGM,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,yCAA8C;IAGpD,oBAAoB,CAAC,YAAY,EAAE,0BAA0B;IAQvD,eAAe,CAC1B,MAAM,EAAE,qCAAqC,GAC5C,OAAO,CAAC,iBAAiB,CAAC,gCAAgC,CAAC,CAAC;IAKlD,gBAAgB,CAC3B,MAAM,EAAE,sCAAsC,GAC7C,OAAO,CAAC,iBAAiB,CAAC,gCAAgC,CAAC,CAAC;IAKlD,eAAe,CAC1B,MAAM,EAAE,qCAAqC,GAC5C,OAAO,CAAC,iBAAiB,CAAC,oCAAoC,CAAC,CAAC;IAStD,qBAAqB,CAChC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EACtC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,CAAC;IAsBjC;;;;OAIG;IACU,6BAA6B,CAAC,WAAW,EAAE,sBAAsB,EAAE,KAAK,EAAE,KAAK;YAmB9E,kBAAkB;IAsBhC;;;;OAIG;YACW,gCAAgC;IAqB9C;;;;OAIG;YACW,SAAS;IAqBvB;;;;OAIG;YACW,+BAA+B;YAU/B,eAAe;YAef,6BAA6B;YAiC7B,WAAW;IA0CzB;;;;;OAKG;YACW,iBAAiB;CAoBhC"}