@aztec/bb.js 0.0.0-devnet

package/dest/node-cjs/main.js

@@ -0,0 +1,735 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vkAsFieldsUltraHonk = exports.proofAsFieldsUltraHonk = exports.verifyUltraHonk = exports.writeVkUltraHonk = exports.proveUltraHonk = exports.vkAsFields = exports.proofAsFields = exports.writePk = exports.writeVk = exports.contractUltraHonk = exports.contract = exports.verify = exports.gateCountUltra = exports.prove = exports.foldAndVerifyProgram = exports.proveAndVerifyAztecClient = exports.proveAndVerifyMegaHonk = exports.proveAndVerifyUltraHonk = exports.proveAndVerify = void 0;
+const tslib_1 = require("tslib");
+require("source-map-support/register.js");
+const index_js_1 = require("./index.js");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const fs_1 = require("fs");
+const zlib_1 = require("zlib");
+const pako_1 = require("pako");
+const commander_1 = require("commander");
+const msgpack_1 = require("@msgpack/msgpack");
+const index_js_2 = require("./benchmark/index.js");
+const path_1 = tslib_1.__importDefault(require("path"));
+debug_1.default.log = console.error.bind(console);
+const debug = (0, debug_1.default)('bb.js');
+// Maximum circuit size for plonk we support in node and the browser is 2^19.
+// This is because both node and browser use barretenberg.wasm which has a 4GB memory limit.
+//
+// This is not a restriction in the bb binary and one should be
+// aware of this discrepancy, when creating proofs in bb versus
+// creating the same proofs in the node CLI.
+const MAX_ULTRAPLONK_CIRCUIT_SIZE_IN_WASM = 2 ** 19;
+const threads = +process.env.HARDWARE_CONCURRENCY || undefined;
+function getBytecode(bytecodePath) {
+    const extension = bytecodePath.substring(bytecodePath.lastIndexOf('.') + 1);
+    if (extension == 'json') {
+        const encodedCircuit = JSON.parse((0, fs_1.readFileSync)(bytecodePath, 'utf8'));
+        const decompressed = (0, zlib_1.gunzipSync)(Buffer.from(encodedCircuit.bytecode, 'base64'));
+        return decompressed;
+    }
+    const encodedCircuit = (0, fs_1.readFileSync)(bytecodePath);
+    const decompressed = (0, zlib_1.gunzipSync)(encodedCircuit);
+    return decompressed;
+}
+function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+function readStack(bytecodePath, numToDrop = 0) {
+    const encodedPackedZippedBytecodeArray = (0, fs_1.readFileSync)(bytecodePath, 'utf-8');
+    const packedZippedBytecodeArray = base64ToUint8Array(encodedPackedZippedBytecodeArray);
+    const zipped = (0, msgpack_1.decode)(packedZippedBytecodeArray.subarray(0, packedZippedBytecodeArray.length - numToDrop));
+    const bytecodeArray = zipped.map((arr) => (0, pako_1.ungzip)(arr));
+    return bytecodeArray;
+}
+// TODO(https://github.com/AztecProtocol/barretenberg/issues/1126): split this into separate Plonk and Honk functions as their gate count differs
+async function getGatesUltra(bytecodePath, recursive, honkRecursion, api) {
+    const { total } = await computeCircuitSize(bytecodePath, recursive, honkRecursion, api);
+    return total;
+}
+function getWitness(witnessPath) {
+    const data = (0, fs_1.readFileSync)(witnessPath);
+    const decompressed = (0, zlib_1.gunzipSync)(data);
+    return decompressed;
+}
+async function computeCircuitSize(bytecodePath, recursive, honkRecursion, api) {
+    debug(`computing circuit size...`);
+    const bytecode = getBytecode(bytecodePath);
+    const [total, subgroup] = await api.acirGetCircuitSizes(bytecode, recursive, honkRecursion);
+    return { total, subgroup };
+}
+async function initUltraPlonk(bytecodePath, recursive, crsPath, subgroupSizeOverride = -1, honkRecursion = false) {
+    const api = await index_js_1.Barretenberg.new({ threads });
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1126): use specific UltraPlonk function
+    const circuitSize = await getGatesUltra(bytecodePath, recursive, honkRecursion, api);
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/811): remove subgroupSizeOverride hack for goblin
+    const subgroupSize = Math.max(subgroupSizeOverride, Math.pow(2, Math.ceil(Math.log2(circuitSize))));
+    if (subgroupSize > MAX_ULTRAPLONK_CIRCUIT_SIZE_IN_WASM) {
+        throw new Error(`Circuit size of ${subgroupSize} exceeds max supported of ${MAX_ULTRAPLONK_CIRCUIT_SIZE_IN_WASM}`);
+    }
+    debug(`circuit size: ${circuitSize}`);
+    debug(`subgroup size: ${subgroupSize}`);
+    debug('loading crs...');
+    // Plus 1 needed! (Move +1 into Crs?)
+    const crs = await index_js_1.Crs.new(subgroupSize + 1, crsPath);
+    // // Important to init slab allocator as first thing, to ensure maximum memory efficiency for Plonk.
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1129): Do slab allocator initialization?
+    // await api.commonInitSlabAllocator(subgroupSize);
+    // Load CRS into wasm global CRS state.
+    // TODO: Make RawBuffer be default behavior, and have a specific Vector type for when wanting length prefixed.
+    await api.srsInitSrs(new index_js_1.RawBuffer(crs.getG1Data()), crs.numPoints, new index_js_1.RawBuffer(crs.getG2Data()));
+    const acirComposer = await api.acirNewAcirComposer(subgroupSize);
+    return { api, acirComposer, circuitSize, subgroupSize };
+}
+async function initUltraHonk(bytecodePath, recursive, crsPath) {
+    const api = await index_js_1.Barretenberg.new({ threads });
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1126): use specific UltraHonk function
+    const circuitSize = await getGatesUltra(bytecodePath, recursive, /*honkRecursion=*/ true, api);
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/811): remove subgroupSizeOverride hack for goblin
+    const dyadicCircuitSize = Math.pow(2, Math.ceil(Math.log2(circuitSize)));
+    debug(`circuit size: ${circuitSize}`);
+    debug(`dyadic circuit size size: ${dyadicCircuitSize}`);
+    debug('loading crs...');
+    const crs = await index_js_1.Crs.new(dyadicCircuitSize + 1, crsPath);
+    // Load CRS into wasm global CRS state.
+    // TODO: Make RawBuffer be default behavior, and have a specific Vector type for when wanting length prefixed.
+    await api.srsInitSrs(new index_js_1.RawBuffer(crs.getG1Data()), crs.numPoints, new index_js_1.RawBuffer(crs.getG2Data()));
+    return { api, circuitSize, dyadicCircuitSize };
+}
+async function initClientIVC(crsPath) {
+    const api = await index_js_1.Barretenberg.new({ threads });
+    debug('loading BN254 and Grumpkin crs...');
+    const crs = await index_js_1.Crs.new(2 ** 21 + 1, crsPath);
+    const grumpkinCrs = await index_js_1.GrumpkinCrs.new(2 ** 16 + 1, crsPath);
+    // Load CRS into wasm global CRS state.
+    // TODO: Make RawBuffer be default behavior, and have a specific Vector type for when wanting length prefixed.
+    await api.srsInitSrs(new index_js_1.RawBuffer(crs.getG1Data()), crs.numPoints, new index_js_1.RawBuffer(crs.getG2Data()));
+    await api.srsInitGrumpkinSrs(new index_js_1.RawBuffer(grumpkinCrs.getG1Data()), grumpkinCrs.numPoints);
+    return { api };
+}
+async function initLite(crsPath) {
+    const api = await index_js_1.Barretenberg.new({ threads: 1 });
+    // Plus 1 needed! (Move +1 into Crs?)
+    const crs = await index_js_1.Crs.new(1, crsPath);
+    // Load CRS into wasm global CRS state.
+    await api.srsInitSrs(new index_js_1.RawBuffer(crs.getG1Data()), crs.numPoints, new index_js_1.RawBuffer(crs.getG2Data()));
+    const acirComposer = await api.acirNewAcirComposer(0);
+    return { api, acirComposer };
+}
+async function proveAndVerify(bytecodePath, recursive, witnessPath, crsPath) {
+    /* eslint-disable camelcase */
+    const acir_test = path_1.default.basename(process.cwd());
+    const { api, acirComposer, circuitSize, subgroupSize } = await initUltraPlonk(bytecodePath, recursive, crsPath);
+    try {
+        debug(`creating proof...`);
+        const bytecode = getBytecode(bytecodePath);
+        const witness = getWitness(witnessPath);
+        const pkTimer = new index_js_2.Timer();
+        await api.acirInitProvingKey(acirComposer, bytecode, recursive);
+        (0, index_js_2.writeBenchmark)('pk_construction_time', pkTimer.ms(), { acir_test, threads });
+        (0, index_js_2.writeBenchmark)('gate_count', circuitSize, { acir_test, threads });
+        (0, index_js_2.writeBenchmark)('subgroup_size', subgroupSize, { acir_test, threads });
+        const proofTimer = new index_js_2.Timer();
+        const proof = await api.acirCreateProof(acirComposer, bytecode, recursive, witness);
+        (0, index_js_2.writeBenchmark)('proof_construction_time', proofTimer.ms(), { acir_test, threads });
+        debug(`verifying...`);
+        const verified = await api.acirVerifyProof(acirComposer, proof);
+        debug(`verified: ${verified}`);
+        return verified;
+    }
+    finally {
+        await api.destroy();
+    }
+    /* eslint-enable camelcase */
+}
+exports.proveAndVerify = proveAndVerify;
+async function proveAndVerifyUltraHonk(bytecodePath, recursive, witnessPath, crsPath) {
+    /* eslint-disable camelcase */
+    const { api } = await initUltraHonk(bytecodePath, false, crsPath);
+    try {
+        const bytecode = getBytecode(bytecodePath);
+        const witness = getWitness(witnessPath);
+        const verified = await api.acirProveAndVerifyUltraHonk(bytecode, recursive, witness);
+        return verified;
+    }
+    finally {
+        await api.destroy();
+    }
+    /* eslint-enable camelcase */
+}
+exports.proveAndVerifyUltraHonk = proveAndVerifyUltraHonk;
+async function proveAndVerifyMegaHonk(bytecodePath, recursive, witnessPath, crsPath) {
+    /* eslint-disable camelcase */
+    const { api } = await initUltraPlonk(bytecodePath, false, crsPath);
+    try {
+        const bytecode = getBytecode(bytecodePath);
+        const witness = getWitness(witnessPath);
+        const verified = await api.acirProveAndVerifyMegaHonk(bytecode, recursive, witness);
+        return verified;
+    }
+    finally {
+        await api.destroy();
+    }
+    /* eslint-enable camelcase */
+}
+exports.proveAndVerifyMegaHonk = proveAndVerifyMegaHonk;
+async function proveAndVerifyAztecClient(bytecodePath, witnessPath, crsPath) {
+    /* eslint-disable camelcase */
+    const { api } = await initClientIVC(crsPath);
+    try {
+        const bytecode = readStack(bytecodePath);
+        const witness = readStack(witnessPath);
+        const verified = await api.acirProveAndVerifyAztecClient(bytecode, witness);
+        console.log(`verified?: ${verified}`);
+        return verified;
+    }
+    finally {
+        await api.destroy();
+    }
+    /* eslint-enable camelcase */
+}
+exports.proveAndVerifyAztecClient = proveAndVerifyAztecClient;
+async function foldAndVerifyProgram(bytecodePath, recursive, witnessPath, crsPath) {
+    /* eslint-disable camelcase */
+    const { api } = await initClientIVC(crsPath);
+    try {
+        const bytecode = getBytecode(bytecodePath);
+        const witness = getWitness(witnessPath);
+        const verified = await api.acirFoldAndVerifyProgramStack(bytecode, recursive, witness);
+        debug(`verified: ${verified}`);
+        return verified;
+    }
+    finally {
+        await api.destroy();
+    }
+    /* eslint-enable camelcase */
+}
+exports.foldAndVerifyProgram = foldAndVerifyProgram;
+async function prove(bytecodePath, recursive, witnessPath, crsPath, outputPath) {
+    const { api, acirComposer } = await initUltraPlonk(bytecodePath, recursive, crsPath);
+    try {
+        debug(`creating proof...`);
+        const bytecode = getBytecode(bytecodePath);
+        const witness = getWitness(witnessPath);
+        const proof = await api.acirCreateProof(acirComposer, bytecode, recursive, witness);
+        debug(`done.`);
+        if (outputPath === '-') {
+            process.stdout.write(proof);
+            debug(`proof written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(outputPath, proof);
+            debug(`proof written to: ${outputPath}`);
+        }
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.prove = prove;
+async function gateCountUltra(bytecodePath, recursive, honkRecursion) {
+    const api = await index_js_1.Barretenberg.new({ threads: 1 });
+    try {
+        const numberOfGates = await getGatesUltra(bytecodePath, recursive, honkRecursion, api);
+        debug(`number of gates: : ${numberOfGates}`);
+        // Create an 8-byte buffer and write the number into it.
+        // Writing number directly to stdout will result in a variable sized
+        // input depending on the size.
+        const buffer = Buffer.alloc(8);
+        buffer.writeBigInt64LE(BigInt(numberOfGates));
+        process.stdout.write(buffer);
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.gateCountUltra = gateCountUltra;
+async function verify(proofPath, vkPath, crsPath) {
+    const { api, acirComposer } = await initLite(crsPath);
+    try {
+        await api.acirLoadVerificationKey(acirComposer, new index_js_1.RawBuffer((0, fs_1.readFileSync)(vkPath)));
+        const verified = await api.acirVerifyProof(acirComposer, (0, fs_1.readFileSync)(proofPath));
+        debug(`verified: ${verified}`);
+        return verified;
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.verify = verify;
+async function contract(outputPath, vkPath, crsPath) {
+    const { api, acirComposer } = await initLite(crsPath);
+    try {
+        await api.acirLoadVerificationKey(acirComposer, new index_js_1.RawBuffer((0, fs_1.readFileSync)(vkPath)));
+        const contract = await api.acirGetSolidityVerifier(acirComposer);
+        if (outputPath === '-') {
+            process.stdout.write(contract);
+            debug(`contract written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(outputPath, contract);
+            debug(`contract written to: ${outputPath}`);
+        }
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.contract = contract;
+async function contractUltraHonk(bytecodePath, vkPath, crsPath, outputPath) {
+    const { api } = await initUltraHonk(bytecodePath, false, crsPath);
+    try {
+        console.log('bytecodePath', bytecodePath);
+        const bytecode = getBytecode(bytecodePath);
+        console.log('vkPath', vkPath);
+        const vk = new index_js_1.RawBuffer((0, fs_1.readFileSync)(vkPath));
+        const contract = await api.acirHonkSolidityVerifier(bytecode, vk);
+        if (outputPath === '-') {
+            process.stdout.write(contract);
+            debug(`contract written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(outputPath, contract);
+            debug(`contract written to: ${outputPath}`);
+        }
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.contractUltraHonk = contractUltraHonk;
+async function writeVk(bytecodePath, recursive, crsPath, outputPath) {
+    const { api, acirComposer } = await initUltraPlonk(bytecodePath, recursive, crsPath);
+    try {
+        debug('initing proving key...');
+        const bytecode = getBytecode(bytecodePath);
+        await api.acirInitProvingKey(acirComposer, bytecode, recursive);
+        debug('initing verification key...');
+        const vk = await api.acirGetVerificationKey(acirComposer);
+        if (outputPath === '-') {
+            process.stdout.write(vk);
+            debug(`vk written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(outputPath, vk);
+            debug(`vk written to: ${outputPath}`);
+        }
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.writeVk = writeVk;
+async function writePk(bytecodePath, recursive, crsPath, outputPath) {
+    const { api, acirComposer } = await initUltraPlonk(bytecodePath, recursive, crsPath);
+    try {
+        debug('initing proving key...');
+        const bytecode = getBytecode(bytecodePath);
+        const pk = await api.acirGetProvingKey(acirComposer, bytecode, recursive);
+        if (outputPath === '-') {
+            process.stdout.write(pk);
+            debug(`pk written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(outputPath, pk);
+            debug(`pk written to: ${outputPath}`);
+        }
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.writePk = writePk;
+async function proofAsFields(proofPath, vkPath, outputPath, crsPath) {
+    const { api, acirComposer } = await initLite(crsPath);
+    try {
+        debug('serializing proof byte array into field elements');
+        const numPublicInputs = (0, fs_1.readFileSync)(vkPath).readUint32BE(8);
+        const proofAsFields = await api.acirSerializeProofIntoFields(acirComposer, (0, fs_1.readFileSync)(proofPath), numPublicInputs);
+        const jsonProofAsFields = JSON.stringify(proofAsFields.map(f => f.toString()));
+        if (outputPath === '-') {
+            process.stdout.write(jsonProofAsFields);
+            debug(`proofAsFields written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(outputPath, jsonProofAsFields);
+            debug(`proofAsFields written to: ${outputPath}`);
+        }
+        debug('done.');
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.proofAsFields = proofAsFields;
+async function vkAsFields(vkPath, vkeyOutputPath, crsPath) {
+    const { api, acirComposer } = await initLite(crsPath);
+    try {
+        debug('serializing vk byte array into field elements');
+        await api.acirLoadVerificationKey(acirComposer, new index_js_1.RawBuffer((0, fs_1.readFileSync)(vkPath)));
+        const [vkAsFields, vkHash] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
+        const output = [vkHash, ...vkAsFields].map(f => f.toString());
+        const jsonVKAsFields = JSON.stringify(output);
+        if (vkeyOutputPath === '-') {
+            process.stdout.write(jsonVKAsFields);
+            debug(`vkAsFields written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(vkeyOutputPath, jsonVKAsFields);
+            debug(`vkAsFields written to: ${vkeyOutputPath}`);
+        }
+        debug('done.');
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.vkAsFields = vkAsFields;
+async function proveUltraHonk(bytecodePath, recursive, witnessPath, crsPath, outputPath, options) {
+    const { api } = await initUltraHonk(bytecodePath, recursive, crsPath);
+    try {
+        debug(`creating proof...`);
+        const bytecode = getBytecode(bytecodePath);
+        const witness = getWitness(witnessPath);
+        const acirProveUltraHonk = options?.keccak
+            ? api.acirProveUltraKeccakHonk.bind(api)
+            : api.acirProveUltraHonk.bind(api);
+        const proof = await acirProveUltraHonk(bytecode, recursive, witness);
+        debug(`done.`);
+        if (outputPath === '-') {
+            process.stdout.write(proof);
+            debug(`proof written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(outputPath, proof);
+            debug(`proof written to: ${outputPath}`);
+        }
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.proveUltraHonk = proveUltraHonk;
+async function writeVkUltraHonk(bytecodePath, recursive, crsPath, outputPath, options) {
+    const { api } = await initUltraHonk(bytecodePath, recursive, crsPath);
+    try {
+        const bytecode = getBytecode(bytecodePath);
+        debug('initing verification key...');
+        const acirWriteVkUltraHonk = options?.keccak
+            ? api.acirWriteVkUltraKeccakHonk.bind(api)
+            : api.acirWriteVkUltraHonk.bind(api);
+        const vk = await acirWriteVkUltraHonk(bytecode, recursive);
+        if (outputPath === '-') {
+            process.stdout.write(vk);
+            debug(`vk written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(outputPath, vk);
+            debug(`vk written to: ${outputPath}`);
+        }
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.writeVkUltraHonk = writeVkUltraHonk;
+async function verifyUltraHonk(proofPath, vkPath, crsPath, options) {
+    const { api } = await initLite(crsPath);
+    try {
+        const acirVerifyUltraHonk = options?.keccak
+            ? api.acirVerifyUltraKeccakHonk.bind(api)
+            : api.acirVerifyUltraHonk.bind(api);
+        const verified = await acirVerifyUltraHonk((0, fs_1.readFileSync)(proofPath), new index_js_1.RawBuffer((0, fs_1.readFileSync)(vkPath)));
+        debug(`verified: ${verified}`);
+        return verified;
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.verifyUltraHonk = verifyUltraHonk;
+async function proofAsFieldsUltraHonk(proofPath, outputPath, crsPath) {
+    const { api } = await initLite(crsPath);
+    try {
+        debug('outputting proof as vector of fields');
+        const proofAsFields = await api.acirProofAsFieldsUltraHonk((0, fs_1.readFileSync)(proofPath));
+        const jsonProofAsFields = JSON.stringify(proofAsFields.map(f => f.toString()));
+        if (outputPath === '-') {
+            process.stdout.write(jsonProofAsFields);
+            debug(`proofAsFieldsUltraHonk written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(outputPath, jsonProofAsFields);
+            debug(`proofAsFieldsUltraHonk written to: ${outputPath}`);
+        }
+        debug('done.');
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.proofAsFieldsUltraHonk = proofAsFieldsUltraHonk;
+async function vkAsFieldsUltraHonk(vkPath, vkeyOutputPath, crsPath) {
+    const { api } = await initLite(crsPath);
+    try {
+        debug('serializing vk byte array into field elements');
+        const vkAsFields = await api.acirVkAsFieldsUltraHonk(new index_js_1.RawBuffer((0, fs_1.readFileSync)(vkPath)));
+        const jsonVKAsFields = JSON.stringify(vkAsFields.map(f => f.toString()));
+        if (vkeyOutputPath === '-') {
+            process.stdout.write(jsonVKAsFields);
+            debug(`vkAsFieldsUltraHonk written to stdout`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(vkeyOutputPath, jsonVKAsFields);
+            debug(`vkAsFieldsUltraHonk written to: ${vkeyOutputPath}`);
+        }
+        debug('done.');
+    }
+    finally {
+        await api.destroy();
+    }
+}
+exports.vkAsFieldsUltraHonk = vkAsFieldsUltraHonk;
+const program = new commander_1.Command('bb');
+program.option('-v, --verbose', 'enable verbose logging', false);
+program.option('-c, --crs-path <path>', 'set crs path', './crs');
+function handleGlobalOptions() {
+    if (program.opts().verbose) {
+        debug_1.default.enable('bb.js*');
+    }
+    return { crsPath: program.opts().crsPath };
+}
+program
+    .command('prove_and_verify')
+    .description('Generate a proof and verify it. Process exits with success or failure code.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Whether to use a SNARK friendly proof', false)
+    .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+    .action(async ({ bytecodePath, recursive, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    const result = await proveAndVerify(bytecodePath, recursive, witnessPath, crsPath);
+    process.exit(result ? 0 : 1);
+});
+program
+    .command('prove_and_verify_ultra_honk')
+    .description('Generate an UltraHonk proof and verify it. Process exits with success or failure code.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Whether to use a SNARK friendly proof', false)
+    .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+    .action(async ({ bytecodePath, recursive, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    const result = await proveAndVerifyUltraHonk(bytecodePath, recursive, witnessPath, crsPath);
+    process.exit(result ? 0 : 1);
+});
+program
+    .command('prove_and_verify_mega_honk')
+    .description('Generate a MegaHonk proof and verify it. Process exits with success or failure code.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Whether to use a SNARK friendly proof', false)
+    .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+    .action(async ({ bytecodePath, recursive, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    const result = await proveAndVerifyMegaHonk(bytecodePath, recursive, witnessPath, crsPath);
+    process.exit(result ? 0 : 1);
+});
+program
+    .command('client_ivc_prove_and_verify')
+    .description('Generate a ClientIVC proof.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/acir.msgpack.b64')
+    .option('-w, --witness-path <path>', 'Specify the witness path', './target/witnesses.msgpack.b64')
+    .action(async ({ bytecodePath, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    const result = await proveAndVerifyAztecClient(bytecodePath, witnessPath, crsPath);
+    process.exit(result ? 0 : 1);
+});
+program
+    .command('fold_and_verify_program')
+    .description('Accumulate a set of circuits using ClientIvc then verify. Process exits with success or failure code.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Create a SNARK friendly proof', false)
+    .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+    .action(async ({ bytecodePath, recursive, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    const result = await foldAndVerifyProgram(bytecodePath, recursive, witnessPath, crsPath);
+    process.exit(result ? 0 : 1);
+});
+program
+    .command('prove')
+    .description('Generate a proof and write it to a file.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Create a SNARK friendly proof', false)
+    .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+    .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
+    .action(async ({ bytecodePath, recursive, witnessPath, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await prove(bytecodePath, recursive, witnessPath, crsPath, outputPath);
+});
+program
+    .command('gates')
+    .description('Print Ultra Builder gate count to standard output.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Create a SNARK friendly proof', false)
+    .option('-hr, --honk-recursion', 'Specify whether to use UltraHonk recursion', false)
+    .action(async ({ bytecodePath, recursive, honkRecursion: honkRecursion }) => {
+    handleGlobalOptions();
+    await gateCountUltra(bytecodePath, recursive, honkRecursion);
+});
+program
+    .command('verify')
+    .description('Verify a proof. Process exists with success or failure code.')
+    .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
+    .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
+    .action(async ({ proofPath, vk }) => {
+    const { crsPath } = handleGlobalOptions();
+    const result = await verify(proofPath, vk, crsPath);
+    process.exit(result ? 0 : 1);
+});
+program
+    .command('contract')
+    .description('Output solidity verification key contract.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-o, --output-path <path>', 'Specify the path to write the contract', './target/contract.sol')
+    .requiredOption('-k, --vk-path <path>', 'Path to a verification key. avoids recomputation.')
+    .action(async ({ outputPath, vkPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await contract(outputPath, vkPath, crsPath);
+});
+program
+    .command('contract_ultra_honk')
+    .description('Output solidity verification key contract.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-o, --output-path <path>', 'Specify the path to write the contract', './target/contract.sol')
+    .requiredOption('-k, --vk-path <path>', 'Path to a verification key.')
+    .action(async ({ bytecodePath, outputPath, vkPath, crsPath }) => {
+    handleGlobalOptions();
+    await contractUltraHonk(bytecodePath, vkPath, crsPath, outputPath);
+});
+program
+    .command('write_vk')
+    .description('Output verification key.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Create a SNARK friendly proof', false)
+    .option('-o, --output-path <path>', 'Specify the path to write the key')
+    .action(async ({ bytecodePath, recursive, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await writeVk(bytecodePath, recursive, crsPath, outputPath);
+});
+program
+    .command('write_pk')
+    .description('Output proving key.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Create a SNARK friendly proof', false)
+    .requiredOption('-o, --output-path <path>', 'Specify the path to write the key')
+    .action(async ({ bytecodePath, recursive, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await writePk(bytecodePath, recursive, crsPath, outputPath);
+});
+program
+    .command('proof_as_fields')
+    .description('Return the proof as fields elements')
+    .requiredOption('-p, --proof-path <path>', 'Specify the proof path')
+    .requiredOption('-k, --vk-path <path>', 'Path to verification key.')
+    .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the proof fields')
+    .action(async ({ proofPath, vkPath, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await proofAsFields(proofPath, vkPath, outputPath, crsPath);
+});
+program
+    .command('vk_as_fields')
+    .description('Return the verification key represented as fields elements. Also return the verification key hash.')
+    .requiredOption('-k, --vk-path <path>', 'Path to verification key.')
+    .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the verification key fields and key hash')
+    .action(async ({ vkPath, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await vkAsFields(vkPath, outputPath, crsPath);
+});
+program
+    .command('prove_ultra_honk')
+    .description('Generate a proof and write it to a file.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Create a SNARK friendly proof', false)
+    .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+    .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
+    .action(async ({ bytecodePath, recursive, witnessPath, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await proveUltraHonk(bytecodePath, recursive, witnessPath, crsPath, outputPath);
+});
+program
+    .command('prove_ultra_keccak_honk')
+    .description('Generate a proof and write it to a file.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Create a SNARK friendly proof', false)
+    .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+    .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
+    .action(async ({ bytecodePath, recursive, witnessPath, outputPath, crsPath }) => {
+    handleGlobalOptions();
+    await proveUltraHonk(bytecodePath, recursive, witnessPath, crsPath, outputPath, { keccak: true });
+});
+program
+    .command('write_vk_ultra_honk')
+    .description('Output verification key.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Create a SNARK friendly proof', false)
+    .requiredOption('-o, --output-path <path>', 'Specify the path to write the key')
+    .action(async ({ bytecodePath, recursive, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await writeVkUltraHonk(bytecodePath, recursive, crsPath, outputPath);
+});
+program
+    .command('write_vk_ultra_keccak_honk')
+    .description('Output verification key.')
+    .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
+    .option('-r, --recursive', 'Create a SNARK friendly proof', false)
+    .requiredOption('-o, --output-path <path>', 'Specify the path to write the key')
+    .action(async ({ bytecodePath, recursive, outputPath, crsPath }) => {
+    handleGlobalOptions();
+    await writeVkUltraHonk(bytecodePath, recursive, crsPath, outputPath, { keccak: true });
+});
+program
+    .command('verify_ultra_honk')
+    .description('Verify a proof. Process exists with success or failure code.')
+    .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
+    .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
+    .action(async ({ proofPath, vk }) => {
+    const { crsPath } = handleGlobalOptions();
+    const result = await verifyUltraHonk(proofPath, vk, crsPath);
+    process.exit(result ? 0 : 1);
+});
+program
+    .command('verify_ultra_keccak_honk')
+    .description('Verify a proof. Process exists with success or failure code.')
+    .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
+    .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
+    .action(async ({ proofPath, vk }) => {
+    const { crsPath } = handleGlobalOptions();
+    const result = await verifyUltraHonk(proofPath, vk, crsPath, { keccak: true });
+    process.exit(result ? 0 : 1);
+});
+program
+    .command('proof_as_fields_honk')
+    .description('Return the proof as fields elements')
+    .requiredOption('-p, --proof-path <path>', 'Specify the proof path')
+    .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the proof fields')
+    .action(async ({ proofPath, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await proofAsFieldsUltraHonk(proofPath, outputPath, crsPath);
+});
+program
+    .command('vk_as_fields_ultra_honk')
+    .description('Return the verification key represented as fields elements.')
+    .requiredOption('-k, --vk-path <path>', 'Path to verification key.')
+    .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the verification key fields.')
+    .action(async ({ vkPath, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
+    await vkAsFieldsUltraHonk(vkPath, outputPath, crsPath);
+});
+program.name('bb.js').parse(process.argv);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/main.ts"],"names":[],"mappings":"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"}