@aztec/bb-prover 0.39.0

package/dest/test/test_circuit_prover.js

@@ -0,0 +1,128 @@
+import { PublicKernelType, makePublicInputsAndProof, } from '@aztec/circuit-types';
+import { NESTED_RECURSIVE_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, RootParityInput, VerificationKeyAsFields, makeEmptyProof, makeRecursiveProof, } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { BaseParityArtifact, MergeRollupArtifact, RootParityArtifact, RootRollupArtifact, ServerCircuitArtifacts, SimulatedBaseRollupArtifact, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertPublicTailInputsToWitnessMap, convertPublicTailOutputFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertSimulatedBaseRollupInputsToWitnessMap, convertSimulatedBaseRollupOutputsFromWitnessMap, } from '@aztec/noir-protocol-circuits-types';
+import { WASMSimulator, emitCircuitSimulationStats } from '@aztec/simulator';
+import { PublicKernelArtifactMapping } from '../mappings/mappings.js';
+import { mapPublicKernelToCircuitName } from '../stats.js';
+const VERIFICATION_KEYS = {
+    BaseParityArtifact: VerificationKeyAsFields.makeFake(),
+    RootParityArtifact: VerificationKeyAsFields.makeFake(),
+    PublicKernelAppLogicArtifact: VerificationKeyAsFields.makeFake(),
+    PublicKernelSetupArtifact: VerificationKeyAsFields.makeFake(),
+    PublicKernelTailArtifact: VerificationKeyAsFields.makeFake(),
+    PublicKernelTeardownArtifact: VerificationKeyAsFields.makeFake(),
+    BaseRollupArtifact: VerificationKeyAsFields.makeFake(),
+    MergeRollupArtifact: VerificationKeyAsFields.makeFake(),
+    RootRollupArtifact: VerificationKeyAsFields.makeFake(),
+};
+/**
+ * A class for use in testing situations (e2e, unit test etc)
+ * Simulates circuits using the most efficient method and performs no proving
+ */
+export class TestCircuitProver {
+    constructor(simulationProvider, logger = createDebugLogger('aztec:test-prover')) {
+        this.simulationProvider = simulationProvider;
+        this.logger = logger;
+        this.wasmSimulator = new WASMSimulator();
+    }
+    /**
+     * Simulates the base parity circuit from its inputs.
+     * @param inputs - Inputs to the circuit.
+     * @returns The public inputs of the parity circuit.
+     */
+    async getBaseParityProof(inputs) {
+        const timer = new Timer();
+        const witnessMap = convertBaseParityInputsToWitnessMap(inputs);
+        // use WASM here as it is faster for small circuits
+        const witness = await this.wasmSimulator.simulateCircuit(witnessMap, BaseParityArtifact);
+        const result = convertBaseParityOutputsFromWitnessMap(witness);
+        const rootParityInput = new RootParityInput(makeRecursiveProof(RECURSIVE_PROOF_LENGTH), VERIFICATION_KEYS['BaseParityArtifact'], result);
+        emitCircuitSimulationStats('base-parity', timer.ms(), inputs.toBuffer().length, result.toBuffer().length, this.logger);
+        return Promise.resolve(rootParityInput);
+    }
+    /**
+     * Simulates the root parity circuit from its inputs.
+     * @param inputs - Inputs to the circuit.
+     * @returns The public inputs of the parity circuit.
+     */
+    async getRootParityProof(inputs) {
+        const timer = new Timer();
+        const witnessMap = convertRootParityInputsToWitnessMap(inputs);
+        // use WASM here as it is faster for small circuits
+        const witness = await this.wasmSimulator.simulateCircuit(witnessMap, RootParityArtifact);
+        const result = convertRootParityOutputsFromWitnessMap(witness);
+        const rootParityInput = new RootParityInput(makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH), VERIFICATION_KEYS['RootParityArtifact'], result);
+        emitCircuitSimulationStats('root-parity', timer.ms(), inputs.toBuffer().length, result.toBuffer().length, this.logger);
+        return Promise.resolve(rootParityInput);
+    }
+    /**
+     * Simulates the base rollup circuit from its inputs.
+     * @param input - Inputs to the circuit.
+     * @returns The public inputs as outputs of the simulation.
+     */
+    async getBaseRollupProof(input) {
+        const timer = new Timer();
+        const witnessMap = convertSimulatedBaseRollupInputsToWitnessMap(input);
+        const simulationProvider = this.simulationProvider ?? this.wasmSimulator;
+        const witness = await simulationProvider.simulateCircuit(witnessMap, SimulatedBaseRollupArtifact);
+        const result = convertSimulatedBaseRollupOutputsFromWitnessMap(witness);
+        emitCircuitSimulationStats('base-rollup', timer.ms(), input.toBuffer().length, result.toBuffer().length, this.logger);
+        return makePublicInputsAndProof(result, makeEmptyProof());
+    }
+    /**
+     * Simulates the merge rollup circuit from its inputs.
+     * @param input - Inputs to the circuit.
+     * @returns The public inputs as outputs of the simulation.
+     */
+    async getMergeRollupProof(input) {
+        const timer = new Timer();
+        const witnessMap = convertMergeRollupInputsToWitnessMap(input);
+        // use WASM here as it is faster for small circuits
+        const witness = await this.wasmSimulator.simulateCircuit(witnessMap, MergeRollupArtifact);
+        const result = convertMergeRollupOutputsFromWitnessMap(witness);
+        emitCircuitSimulationStats('merge-rollup', timer.ms(), input.toBuffer().length, result.toBuffer().length, this.logger);
+        return makePublicInputsAndProof(result, makeEmptyProof());
+    }
+    /**
+     * Simulates the root rollup circuit from its inputs.
+     * @param input - Inputs to the circuit.
+     * @returns The public inputs as outputs of the simulation.
+     */
+    async getRootRollupProof(input) {
+        const timer = new Timer();
+        const witnessMap = convertRootRollupInputsToWitnessMap(input);
+        // use WASM here as it is faster for small circuits
+        const witness = await this.wasmSimulator.simulateCircuit(witnessMap, RootRollupArtifact);
+        const result = convertRootRollupOutputsFromWitnessMap(witness);
+        emitCircuitSimulationStats('root-rollup', timer.ms(), input.toBuffer().length, result.toBuffer().length, this.logger);
+        return makePublicInputsAndProof(result, makeEmptyProof());
+    }
+    async getPublicKernelProof(kernelRequest) {
+        const timer = new Timer();
+        const kernelOps = PublicKernelArtifactMapping[kernelRequest.type];
+        if (kernelOps === undefined) {
+            throw new Error(`Unable to prove for kernel type ${PublicKernelType[kernelRequest.type]}`);
+        }
+        const witnessMap = kernelOps.convertInputs(kernelRequest.inputs);
+        const witness = await this.wasmSimulator.simulateCircuit(witnessMap, ServerCircuitArtifacts[kernelOps.artifact]);
+        const result = kernelOps.convertOutputs(witness);
+        emitCircuitSimulationStats(mapPublicKernelToCircuitName(kernelRequest.type), timer.ms(), kernelRequest.inputs.toBuffer().length, result.toBuffer().length, this.logger);
+        return makePublicInputsAndProof(result, makeEmptyProof());
+    }
+    async getPublicTailProof(kernelRequest) {
+        const timer = new Timer();
+        const witnessMap = convertPublicTailInputsToWitnessMap(kernelRequest.inputs);
+        // use WASM here as it is faster for small circuits
+        const witness = await this.wasmSimulator.simulateCircuit(witnessMap, ServerCircuitArtifacts['PublicKernelTailArtifact']);
+        const result = convertPublicTailOutputFromWitnessMap(witness);
+        emitCircuitSimulationStats('public-kernel-tail', timer.ms(), kernelRequest.inputs.toBuffer().length, result.toBuffer().length, this.logger);
+        return makePublicInputsAndProof(result, makeEmptyProof());
+    }
+    // Not implemented for test circuits
+    verifyProof(_1, _2) {
+        return Promise.reject(new Error('Method not implemented.'));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@aztec/bb-prover",
+  "version": "0.39.0",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js"
+  },
+  "bin": {
+    "bb-cli": "./dest/bb/index.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "BB Prover",
+    "tsconfig": "./tsconfig.json"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "bb": "node --no-warnings ./dest/bb/index.js",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest"
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      [
+        "default",
+        {
+          "summaryThreshold": 9999
+        }
+      ]
+    ]
+  },
+  "dependencies": {
+    "@aztec/circuit-types": "0.39.0",
+    "@aztec/circuits.js": "0.39.0",
+    "@aztec/foundation": "0.39.0",
+    "@aztec/noir-protocol-circuits-types": "0.39.0",
+    "@aztec/simulator": "0.39.0",
+    "@noir-lang/noirc_abi": "portal:../../noir/packages/noirc_abi",
+    "@noir-lang/types": "portal:../../noir/packages/types",
+    "commander": "^9.0.0",
+    "source-map-support": "^0.5.21",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/memdown": "^3.0.0",
+    "@types/node": "^18.7.23",
+    "@types/source-map-support": "^0.5.10",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/bb/cli.ts

@@ -0,0 +1,92 @@
+import { type LogFn } from '@aztec/foundation/log';
+import { type ProtocolArtifact, 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: LogFn): Command {
+  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: string, x: string) => 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 as ProtocolArtifact];
+      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 as ProtocolArtifact];
+      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;
+}

package/src/bb/execute.ts

@@ -0,0 +1,359 @@
+import { sha256 } from '@aztec/foundation/crypto';
+import { type LogFn } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { type NoirCompiledCircuit } from '@aztec/types/noir';
+
+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 enum BB_RESULT {
+  SUCCESS,
+  FAILURE,
+  ALREADY_PRESENT,
+}
+
+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 function executeBB(
+  pathToBB: string,
+  command: string,
+  args: string[],
+  logger: LogFn,
+  resultParser = (code: number) => code === 0,
+) {
+  return new Promise<BB_RESULT.SUCCESS | BB_RESULT.FAILURE>((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: number) => {
+      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: string,
+  workingDirectory: string,
+  circuitName: string,
+  compiledCircuit: NoirCompiledCircuit,
+  key: 'vk' | 'pk',
+  log: LogFn,
+  force = false,
+): Promise<BBSuccess | BBFailure> {
+  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: Buffer = 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: string,
+  workingDirectory: string,
+  circuitName: string,
+  bytecode: Buffer,
+  inputWitnessFile: string,
+  log: LogFn,
+): Promise<BBFailure | BBSuccess> {
+  // 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: string) => {
+      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: string,
+  proofFullPath: string,
+  verificationKeyPath: string,
+  log: LogFn,
+): Promise<BBFailure | BBSuccess> {
+  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: string,
+  verificationKeyPath: string,
+  verificationKeyFilename: string,
+  log: LogFn,
+): Promise<BBFailure | BBSuccess> {
+  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: string,
+  proofPath: string,
+  proofFileName: string,
+  log: LogFn,
+): Promise<BBFailure | BBSuccess> {
+  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}` };
+  }
+}