@aztec/bb-prover 0.0.0-test.0

package/dest/bb/execute.js

@@ -0,0 +1,780 @@
+import { sha256 } from '@aztec/foundation/crypto';
+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';
+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 const AVM_INPUTS_FILENAME = 'avm_inputs.bin';
+export const AVM_BYTECODE_FILENAME = 'avm_bytecode.bin';
+export const AVM_PUBLIC_INPUTS_FILENAME = 'avm_public_inputs.bin';
+export const AVM_HINTS_FILENAME = 'avm_hints.bin';
+export var BB_RESULT = /*#__PURE__*/ function(BB_RESULT) {
+    BB_RESULT[BB_RESULT["SUCCESS"] = 0] = "SUCCESS";
+    BB_RESULT[BB_RESULT["FAILURE"] = 1] = "FAILURE";
+    BB_RESULT[BB_RESULT["ALREADY_PRESENT"] = 2] = "ALREADY_PRESENT";
+    return BB_RESULT;
+}({});
+/**
+ * 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)=>{
+        // spawn the bb process
+        const { HARDWARE_CONCURRENCY: _, ...envWithoutConcurrency } = process.env;
+        const env = process.env.HARDWARE_CONCURRENCY ? process.env : envWithoutConcurrency;
+        logger(`Executing BB with: ${pathToBB} ${command} ${args.join(' ')}`);
+        const bb = proc.spawn(pathToBB, [
+            command,
+            ...args
+        ], {
+            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);
+        });
+        bb.on('close', (exitCode, signal)=>{
+            if (resultParser(exitCode)) {
+                resolve({
+                    status: 0,
+                    exitCode,
+                    signal
+                });
+            } else {
+                resolve({
+                    status: 1,
+                    exitCode,
+                    signal
+                });
+            }
+        });
+    }).catch((_)=>({
+            status: 1,
+            exitCode: -1,
+            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) {
+    // Check that the working directory exists
+    try {
+        await fs.access(workingDirectory);
+    } catch (error) {
+        return {
+            status: 1,
+            reason: `Working directory ${workingDirectory} does not exist`
+        };
+    }
+    // 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: 1,
+            reason: `Failed to find bb binary at ${pathToBB}`
+        };
+    }
+    try {
+        // Write the bytecode to the working directory
+        log(`bytecodePath ${bytecodeStackPath}`);
+        log(`outputPath ${outputPath}`);
+        const args = [
+            '-o',
+            outputPath,
+            '-b',
+            bytecodeStackPath,
+            '-w',
+            witnessStackPath,
+            '-v',
+            '--scheme',
+            'client_ivc',
+            '--input_type',
+            'runtime_stack',
+            '--write_vk'
+        ];
+        const timer = new Timer();
+        const logFunction = (message)=>{
+            log(`bb - ${message}`);
+        };
+        const result = await executeBB(pathToBB, 'prove', args, logFunction);
+        const durationMs = timer.ms();
+        if (result.status == 0) {
+            return {
+                status: 0,
+                durationMs,
+                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}`
+        };
+    }
+}
+function getArgs(flavor) {
+    switch(flavor){
+        case 'ultra_honk':
+            {
+                return [
+                    '--scheme',
+                    'ultra_honk',
+                    '--oracle_hash',
+                    'poseidon2'
+                ];
+            }
+        case 'ultra_keccak_honk':
+            {
+                return [
+                    '--scheme',
+                    'ultra_honk',
+                    '--oracle_hash',
+                    'keccak'
+                ];
+            }
+        case 'ultra_rollup_honk':
+            {
+                return [
+                    '--scheme',
+                    'ultra_honk',
+                    '--oracle_hash',
+                    'poseidon2',
+                    '--ipa_accumulation'
+                ];
+            }
+    }
+}
+/**
+ * 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, recursive, inputWitnessFile, flavor, log) {
+    // Check that the working directory exists
+    try {
+        await fs.access(workingDirectory);
+    } catch (error) {
+        return {
+            status: 1,
+            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/ultra_honk/proof
+    const outputPath = `${workingDirectory}`;
+    const binaryPresent = await fs.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
+    if (!binaryPresent) {
+        return {
+            status: 1,
+            reason: `Failed to find bb binary at ${pathToBB}`
+        };
+    }
+    try {
+        // Write the bytecode to the working directory
+        await fs.writeFile(bytecodePath, bytecode);
+        const args = getArgs(flavor).concat([
+            '--output_format',
+            'bytes_and_fields',
+            '--write_vk',
+            '-o',
+            outputPath,
+            '-b',
+            bytecodePath,
+            '-w',
+            inputWitnessFile,
+            '-v'
+        ]);
+        if (recursive) {
+            args.push('--init_kzg_accumulator');
+        }
+        const timer = new Timer();
+        const logFunction = (message)=>{
+            log(`${circuitName} BB out - ${message}`);
+        };
+        const result = await executeBB(pathToBB, `prove`, args, logFunction);
+        const duration = timer.ms();
+        if (result.status == 0) {
+            return {
+                status: 0,
+                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
+            };
+        }
+        // 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.
+ * 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 input - The inputs for the public function to be proven
+ * @param log - A logging function
+ * @returns An object containing a result indication, the location of the proof and the duration taken
+ */ export async function generateAvmProofV2(pathToBB, workingDirectory, input, logger) {
+    // Check that the working directory exists
+    try {
+        await fs.access(workingDirectory);
+    } catch (error) {
+        return {
+            status: 1,
+            reason: `Working directory ${workingDirectory} does not exist`
+        };
+    }
+    // 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}`
+        };
+    }
+    const inputsBuffer = input.serializeWithMessagePack();
+    try {
+        // Write the inputs to the working directory.
+        const avmInputsPath = join(workingDirectory, AVM_INPUTS_FILENAME);
+        await fs.writeFile(avmInputsPath, inputsBuffer);
+        if (!await filePresent(avmInputsPath)) {
+            return {
+                status: 1,
+                reason: `Could not write avm inputs to ${avmInputsPath}`
+            };
+        }
+        const args = [
+            '--avm-inputs',
+            avmInputsPath,
+            '-o',
+            outputPath
+        ];
+        const loggingArg = logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '';
+        if (loggingArg !== '') {
+            args.push(loggingArg);
+        }
+        const timer = new Timer();
+        const logFunction = (message)=>{
+            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 logFunction = (message)=>{
+            logger.verbose(`AvmCircuit (${cmd}) BB out - ${message}`);
+        };
+        const result = await executeBB(pathToBB, `avm_${cmd}`, 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 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, 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) {
+    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);
+    const avmInputsPath = join(workingDirectory, 'avm_public_inputs.bin');
+    await fs.writeFile(avmInputsPath, inputsBuffer);
+    if (!await filePresent(avmInputsPath)) {
+        return {
+            status: 1,
+            reason: `Could not write avm inputs to ${avmInputsPath}`
+        };
+    }
+    return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm2_verify', logger, [
+        '--avm-public-inputs',
+        avmInputsPath
+    ]);
+}
+/**
+ * Verifies a ClientIvcProof
+ * 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
+ * @returns An object containing a result indication and duration taken
+ */ export async function verifyClientIvcProof(pathToBB, proofPath, keyPath, log) {
+    const binaryPresent = await fs.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
+    if (!binaryPresent) {
+        return {
+            status: 1,
+            reason: `Failed to find bb binary at ${pathToBB}`
+        };
+    }
+    try {
+        const args = [
+            '--scheme',
+            'client_ivc',
+            '-p',
+            proofPath,
+            '-k',
+            keyPath
+        ];
+        const timer = new Timer();
+        const command = 'verify';
+        const result = await executeBB(pathToBB, command, args, log);
+        const duration = timer.ms();
+        if (result.status == 0) {
+            return {
+                status: 0,
+                durationMs: duration
+            };
+        }
+        // Not a great error message here but it is difficult to decipher what comes from bb
+        return {
+            status: 1,
+            reason: `Failed to verify proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+            retry: !!result.signal
+        };
+    } catch (error) {
+        return {
+            status: 1,
+            reason: `${error}`
+        };
+    }
+}
+/**
+ * Used for verifying proofs with BB
+ * @param pathToBB - The full path to the bb binary
+ * @param proofFullPath - The full path to the proof to be verified
+ * @param verificationKeyPath - The full path to the circuit verification key
+ * @param command - The BB command to execute (verify/avm_verify)
+ * @param log - A logging function
+ * @returns An object containing a result indication and duration taken
+ */ async function verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, command, logger, extraArgs = []) {
+    const binaryPresent = await fs.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
+    if (!binaryPresent) {
+        return {
+            status: 1,
+            reason: `Failed to find bb binary at ${pathToBB}`
+        };
+    }
+    const logFunction = (message)=>{
+        logger.verbose(`bb-prover (verify) BB out - ${message}`);
+    };
+    try {
+        const args = [
+            '-p',
+            proofFullPath,
+            '-k',
+            verificationKeyPath,
+            ...extraArgs
+        ];
+        const loggingArg = logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '';
+        if (loggingArg !== '') {
+            args.push(loggingArg);
+        }
+        const timer = new Timer();
+        const result = await executeBB(pathToBB, command, args, logFunction);
+        const duration = timer.ms();
+        if (result.status == 0) {
+            return {
+                status: 0,
+                durationMs: duration
+            };
+        }
+        // Not a great error message here but it is difficult to decipher what comes from bb
+        return {
+            status: 1,
+            reason: `Failed to verify proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+            retry: !!result.signal
+        };
+    } catch (error) {
+        return {
+            status: 1,
+            reason: `${error}`
+        };
+    }
+}
+export async function generateContractForVerificationKey(pathToBB, vkFilePath, contractPath, log) {
+    const binaryPresent = await fs.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
+    if (!binaryPresent) {
+        return {
+            status: 1,
+            reason: `Failed to find bb binary at ${pathToBB}`
+        };
+    }
+    const outputDir = dirname(contractPath);
+    const contractName = basename(contractPath);
+    // cache contract generation based on vk file and contract name
+    const cacheKey = sha256(Buffer.concat([
+        Buffer.from(contractName),
+        await fs.readFile(vkFilePath)
+    ]));
+    await fs.mkdir(outputDir, {
+        recursive: true
+    });
+    const res = await fsCache(outputDir, cacheKey, log, false, async ()=>{
+        try {
+            const args = [
+                '--scheme',
+                'ultra_honk',
+                '-k',
+                vkFilePath,
+                '-o',
+                contractPath,
+                '-v'
+            ];
+            const timer = new Timer();
+            const result = await executeBB(pathToBB, 'contract', args, log);
+            const duration = timer.ms();
+            if (result.status == 0) {
+                return {
+                    status: 0,
+                    durationMs: duration,
+                    contractPath
+                };
+            }
+            // Not a great error message here but it is difficult to decipher what comes from bb
+            return {
+                status: 1,
+                reason: `Failed to write verifier contract. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+                retry: !!result.signal
+            };
+        } catch (error) {
+            return {
+                status: 1,
+                reason: `${error}`
+            };
+        }
+    });
+    if (!res) {
+        return {
+            status: 2,
+            durationMs: 0,
+            contractPath
+        };
+    }
+    return res;
+}
+/**
+ * Compute bb gate count for a given circuit
+ * @param pathToBB - The full path to the bb binary
+ * @param workingDirectory - A temporary directory for writing the bytecode
+ * @param circuitName - The name of the circuit
+ * @param bytecode - The bytecode of the circuit
+ * @param flavor - The flavor of the backend - mega_honk or ultra_honk variants
+ * @returns An object containing the status, gate count, and time taken
+ */ export async function computeGateCountForCircuit(pathToBB, workingDirectory, circuitName, bytecode, flavor, log) {
+    // Check that the working directory exists
+    try {
+        await fs.access(workingDirectory);
+    } catch (error) {
+        return {
+            status: 1,
+            reason: `Working directory ${workingDirectory} does not exist`
+        };
+    }
+    // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
+    const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
+    const binaryPresent = await fs.access(pathToBB, fs.constants.R_OK).then((_)=>true).catch((_)=>false);
+    if (!binaryPresent) {
+        return {
+            status: 1,
+            reason: `Failed to find bb binary at ${pathToBB}`
+        };
+    }
+    // Accumulate the stdout from bb
+    let stdout = '';
+    const logHandler = (message)=>{
+        stdout += message;
+        log(message);
+    };
+    try {
+        // Write the bytecode to the working directory
+        await fs.writeFile(bytecodePath, bytecode);
+        const timer = new Timer();
+        const result = await executeBB(pathToBB, 'gates', [
+            '--scheme',
+            flavor === 'mega_honk' ? 'client_ivc' : 'ultra_honk',
+            '-b',
+            bytecodePath,
+            '-v'
+        ], logHandler);
+        const duration = timer.ms();
+        if (result.status == 0) {
+            // Look for "circuit_size" in the stdout and parse the number
+            const circuitSizeMatch = stdout.match(/circuit_size": (\d+)/);
+            if (!circuitSizeMatch) {
+                return {
+                    status: 1,
+                    reason: 'Failed to parse circuit_size from bb gates stdout.'
+                };
+            }
+            const circuitSize = parseInt(circuitSizeMatch[1]);
+            return {
+                status: 0,
+                durationMs: duration,
+                circuitSize: circuitSize
+            };
+        }
+        return {
+            status: 1,
+            reason: 'Failed getting the gate count.'
+        };
+    } catch (error) {
+        return {
+            status: 1,
+            reason: `${error}`
+        };
+    }
+}
+const CACHE_FILENAME = '.cache';
+async function fsCache(dir, expectedCacheKey, logger, force, action) {
+    const cacheFilePath = join(dir, CACHE_FILENAME);
+    let run;
+    if (force) {
+        run = true;
+    } else {
+        try {
+            run = !expectedCacheKey.equals(await fs.readFile(cacheFilePath));
+        } catch (err) {
+            if (err && 'code' in err && err.code === 'ENOENT') {
+                // cache file doesn't exist, swallow error and run
+                run = true;
+            } else {
+                throw err;
+            }
+        }
+    }
+    let res;
+    if (run) {
+        logger(`Cache miss or forced run. Running operation in ${dir}...`);
+        res = await action();
+    } else {
+        logger(`Cache hit. Skipping operation in ${dir}...`);
+    }
+    try {
+        await fs.writeFile(cacheFilePath, expectedCacheKey);
+    } catch (err) {
+        logger(`Couldn't write cache data to ${cacheFilePath}. Skipping cache...`);
+    // ignore
+    }
+    return res;
+}