@aztec/bb.js 0.0.1-alpha.0 → 0.0.1-alpha.2

package/src/main.ts

@@ -1,16 +1,13 @@
 #!/usr/bin/env -S node --no-warnings
-import { Crs } from './crs/index.js';
+import { Crs, BarretenbergApiAsync, newBarretenbergApiAsync, RawBuffer } from './index.js';
 import createDebug from 'debug';
-import { BarretenbergApiAsync, newBarretenbergApiAsync } from './factory/index.js';
 import { readFileSync, writeFileSync } from 'fs';
 import { gunzipSync } from 'zlib';
-import { RawBuffer } from './types/index.js';
 import { numToUInt32BE } from './serialize/serialize.js';
 import { Command } from 'commander';
 
 createDebug.log = console.error.bind(console);
 const debug = createDebug('bb.js');
-// createDebug.enable('*');
 
 // Maximum we support.
 const MAX_CIRCUIT_SIZE = 2 ** 19;
@@ -34,29 +31,41 @@ async function getCircuitSize(jsonPath: string, api: BarretenbergApiAsync) {
   return { exact, total, subgroup };
 }
 
-async function init(jsonPath: string) {
+async function init(jsonPath: string, sizeHint?: number) {
   const api = await newBarretenbergApiAsync();
 
-  // First compute circuit size.
-  const circuitSizes = await getCircuitSize(jsonPath, api);
-  debug(`circuit size: ${circuitSizes.total}`);
+  const subgroupSize = await (async () => {
+    if (sizeHint) {
+      // Round to subgroup size.
+      return Math.pow(2, Math.ceil(Math.log2(sizeHint)));
+    }
 
-  if (circuitSizes.subgroup > MAX_CIRCUIT_SIZE) {
-    throw new Error(`Circuit size of ${circuitSizes.subgroup} exceeds max supported of ${MAX_CIRCUIT_SIZE}`);
-  }
+    // First compute circuit size.
+    debug(`computing circuit size (use size hint to skip)...`);
+    const circuitSizes = await getCircuitSize(jsonPath, api);
+    debug(`circuit size: ${circuitSizes.total}`);
+
+    if (circuitSizes.subgroup > MAX_CIRCUIT_SIZE) {
+      throw new Error(`Circuit size of ${circuitSizes.subgroup} exceeds max supported of ${MAX_CIRCUIT_SIZE}`);
+    }
 
+    return circuitSizes.subgroup;
+  })();
+
+  debug(`subgroup size: ${subgroupSize}`);
+  debug('loading crs...');
   // Plus 1 needed! (Move +1 into Crs?)
-  const crs = await Crs.new(circuitSizes.subgroup + 1);
+  const crs = await Crs.new(subgroupSize + 1);
 
   // Important to init slab allocator as first thing, to ensure maximum memory efficiency.
-  await api.commonInitSlabAllocator(circuitSizes.subgroup);
+  await api.commonInitSlabAllocator(subgroupSize);
 
   // Load CRS into wasm global CRS state.
   // TODO: Make RawBuffer be default behaviour, and have a specific Vector type for when wanting length prefixed.
   await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
 
   const acirComposer = await api.acirNewAcirComposer();
-  return { api, acirComposer, circuitSize: circuitSizes.subgroup };
+  return { api, acirComposer, circuitSize: subgroupSize };
 }
 
 async function initLite() {
@@ -72,24 +81,24 @@ async function initLite() {
   return { api, acirComposer };
 }
 
-export async function proveAndVerify(jsonPath: string, witnessPath: string, isRecursive: boolean) {
-  const { api, acirComposer, circuitSize } = await init(jsonPath);
+export async function proveAndVerify(jsonPath: string, witnessPath: string, isRecursive: boolean, sizeHint?: number) {
+  const { api, acirComposer } = await init(jsonPath, sizeHint);
   try {
-    debug('initing proving key...');
+    // debug('initing proving key...');
     const bytecode = getBytecode(jsonPath);
-    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
+    // await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
 
     // const circuitSize = await api.acirGetExactCircuitSize(acirComposer);
     // debug(`circuit size: ${circuitSize}`);
 
-    debug('initing verification key...');
-    await api.acirInitVerificationKey(acirComposer);
+    // debug('initing verification key...');
+    // await api.acirInitVerificationKey(acirComposer);
 
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
     const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), isRecursive);
-    debug(`done.`);
 
+    debug(`verifying...`);
     const verified = await api.acirVerifyProof(acirComposer, proof, isRecursive);
     console.log(`verified: ${verified}`);
     return verified;
@@ -98,12 +107,18 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, isRe
   }
 }
 
-export async function prove(jsonPath: string, witnessPath: string, isRecursive: boolean, outputPath: string) {
-  const { api, acirComposer, circuitSize } = await init(jsonPath);
+export async function prove(
+  jsonPath: string,
+  witnessPath: string,
+  isRecursive: boolean,
+  outputPath: string,
+  sizeHint?: number,
+) {
+  const { api, acirComposer } = await init(jsonPath, sizeHint);
   try {
-    debug('initing proving key...');
+    // debug('initing proving key...');
     const bytecode = getBytecode(jsonPath);
-    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
+    // await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
 
     // const circuitSize = await api.acirGetExactCircuitSize(acirComposer);
     // debug(`circuit size: ${circuitSize}`);
@@ -130,46 +145,22 @@ export async function gateCount(jsonPath: string) {
   }
 }
 
-export async function verify(jsonPath: string, proofPath: string, isRecursive: boolean, vkPath?: string) {
-  if (vkPath) {
-    const { api, acirComposer } = await initLite();
-    try {
-      await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
-      const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), isRecursive);
-      console.log(`verified: ${verified}`);
-      return verified;
-    } finally {
-      await api.destroy();
-    }
-  } else {
-    const { api, acirComposer, circuitSize } = await init(jsonPath);
-    try {
-      debug('initing proving key...');
-      const bytecode = getBytecode(jsonPath);
-      await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
-
-      debug('initing verification key...');
-      await api.acirInitVerificationKey(acirComposer);
-
-      const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), isRecursive);
-      console.log(`verified: ${verified}`);
-      return verified;
-    } finally {
-      await api.destroy();
-    }
+export async function verify(jsonPath: string, proofPath: string, isRecursive: boolean, vkPath: string) {
+  const { api, acirComposer } = await initLite();
+  try {
+    await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
+    const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), isRecursive);
+    console.log(`verified: ${verified}`);
+    return verified;
+  } finally {
+    await api.destroy();
   }
 }
 
-export async function contract(jsonPath: string, outputPath: string) {
-  const { api, acirComposer, circuitSize } = await init(jsonPath);
+export async function contract(outputPath: string, vkPath: string) {
+  const { api, acirComposer } = await initLite();
   try {
-    debug('initing proving key...');
-    const bytecode = getBytecode(jsonPath);
-    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
-
-    debug('initing verification key...');
-    await api.acirInitVerificationKey(acirComposer);
-
+    await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
     const contract = await api.acirGetSolidityVerifier(acirComposer);
     if (outputPath === '-') {
       console.log(contract);
@@ -182,8 +173,8 @@ export async function contract(jsonPath: string, outputPath: string) {
   }
 }
 
-export async function writeVk(jsonPath: string, outputPath: string) {
-  const { api, acirComposer, circuitSize } = await init(jsonPath);
+export async function writeVk(jsonPath: string, outputPath: string, sizeHint?: number) {
+  const { api, acirComposer, circuitSize } = await init(jsonPath, sizeHint);
   try {
     debug('initing proving key...');
     const bytecode = getBytecode(jsonPath);
@@ -247,14 +238,24 @@ export async function vkAsFields(vkPath: string, vkeyOutputPath: string) {
 
 const program = new Command();
 
+program.option('-v, --verbose', 'enable verbose logging', false);
+
+function handleGlobalOptions() {
+  if (program.opts().verbose) {
+    createDebug.enable('bb.js*');
+  }
+}
+
 program
   .command('prove_and_verify')
   .description('Generate a proof and verify it. Process exits with success or failure code.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
   .option('-r, --recursive', 'prove and verify using recursive prover and verifier', false)
-  .action(async ({ jsonPath, witnessPath, recursive }) => {
-    const result = await proveAndVerify(jsonPath, witnessPath, recursive);
+  .option('-s, --size-hint <gates>', 'provide a circuit size hint to skip calculation phase')
+  .action(async ({ jsonPath, witnessPath, recursive, sizeHint }) => {
+    handleGlobalOptions();
+    const result = await proveAndVerify(jsonPath, witnessPath, recursive, sizeHint);
     process.exit(result ? 0 : 1);
   });
 
@@ -264,10 +265,11 @@ program
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
   .option('-r, --recursive', 'prove using recursive prover', false)
-  .option('-o, --output-dir <path>', 'Specify the proof output dir', './proofs')
-  .requiredOption('-n, --name <filename>', 'Output file name.')
-  .action(async ({ jsonPath, witnessPath, recursive, outputDir, name }) => {
-    await prove(jsonPath, witnessPath, recursive, outputDir + '/' + name);
+  .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
+  .option('-s, --size-hint <gates>', 'provide a circuit size hint to skip calculation phase')
+  .action(async ({ jsonPath, witnessPath, recursive, outputPath, sizeHint }) => {
+    handleGlobalOptions();
+    await prove(jsonPath, witnessPath, recursive, outputPath, sizeHint);
   });
 
 program
@@ -275,6 +277,7 @@ program
   .description('Print gate count to standard output.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .action(async ({ jsonPath }) => {
+    handleGlobalOptions();
     await gateCount(jsonPath);
   });
 
@@ -284,8 +287,9 @@ program
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
   .option('-r, --recursive', 'prove using recursive prover', false)
-  .option('-v, --vk <path>', 'path to a verification key. avoids recomputation.')
+  .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
   .action(async ({ jsonPath, proofPath, recursive, vk }) => {
+    handleGlobalOptions();
     await verify(jsonPath, proofPath, recursive, vk);
   });
 
@@ -294,8 +298,10 @@ program
   .description('Output solidity verification key contract.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .option('-o, --output-path <path>', 'Specify the path to write the contract', '-')
-  .action(async ({ jsonPath, outputPath }) => {
-    await contract(jsonPath, outputPath);
+  .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
+  .action(async ({ outputPath, vk }) => {
+    handleGlobalOptions();
+    await contract(outputPath, vk);
   });
 
 program
@@ -303,8 +309,10 @@ program
   .description('Output verification key.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .requiredOption('-o, --output-path <path>', 'Specify the path to write the key')
-  .action(async ({ jsonPath, outputPath }) => {
-    await writeVk(jsonPath, outputPath);
+  .option('-s, --size-hint <gates>', 'provide a circuit size hint to skip calculation phase')
+  .action(async ({ jsonPath, outputPath, sizeHint }) => {
+    handleGlobalOptions();
+    await writeVk(jsonPath, outputPath, sizeHint);
   });
 
 program
@@ -314,6 +322,7 @@ program
   .requiredOption('-n, --num-public-inputs <number>', 'Specify the number of public inputs')
   .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the proof fields')
   .action(async ({ proofPath, numPublicInputs, outputPath }) => {
+    handleGlobalOptions();
     await proofAsFields(proofPath, numPublicInputs, outputPath);
   });
 
@@ -323,6 +332,7 @@ program
   .requiredOption('-i, --input-path <path>', 'Specifies the vk path (output from write_vk)')
   .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the verification key fields and key hash')
   .action(async ({ inputPath, outputPath }) => {
+    handleGlobalOptions();
     await vkAsFields(inputPath, outputPath);
   });
 

package/dest/main-dev.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env -S node --loader ts-node/esm --no-warnings
-import './main.js';
-//# sourceMappingURL=main-dev.d.ts.map

package/dest/main-dev.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"main-dev.d.ts","sourceRoot":"","sources":["../src/main-dev.ts"],"names":[],"mappings":";AACA,OAAO,WAAW,CAAC"}

package/dest/main-dev.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env -S node --loader ts-node/esm --no-warnings
-import './main.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFpbi1kZXYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbWFpbi1kZXYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLE9BQU8sV0FBVyxDQUFDIn0=

package/src/main-dev.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env -S node --loader ts-node/esm --no-warnings
-import './main.js';