@aztec/bb.js 0.0.1-alpha.6 → 0.0.1-alpha.7

package/src/main.ts

@@ -12,46 +12,53 @@ const debug = createDebug('bb.js');
 // Maximum we support.
 const MAX_CIRCUIT_SIZE = 2 ** 19;
 
-function getBytecode(jsonPath: string) {
+function getJsonData(jsonPath: string) {
   const json = readFileSync(jsonPath, 'utf-8');
   const parsed = JSON.parse(json);
+  return parsed;
+}
+
+function getBytecode(jsonPath: string) {
+  const parsed = getJsonData(jsonPath);
   const buffer = Buffer.from(parsed.bytecode, 'base64');
   const decompressed = gunzipSync(buffer);
   return decompressed;
 }
 
+async function getGates(jsonPath: string, api: BarretenbergApiAsync) {
+  const parsed = getJsonData(jsonPath);
+  if (parsed.gates) {
+    return +parsed.gates;
+  }
+  const { total } = await computeCircuitSize(jsonPath, api);
+  const jsonData = getJsonData(jsonPath);
+  jsonData.gates = total;
+  writeFileSync(jsonPath, JSON.stringify(jsonData));
+  return total;
+}
+
 function getWitness(witnessPath: string) {
   const data = readFileSync(witnessPath);
   return Buffer.concat([numToUInt32BE(data.length / 32), data]);
 }
 
-async function getCircuitSize(jsonPath: string, api: BarretenbergApiAsync) {
+async function computeCircuitSize(jsonPath: string, api: BarretenbergApiAsync) {
+  debug(`computing circuit size...`);
   const bytecode = getBytecode(jsonPath);
   const [exact, total, subgroup] = await api.acirGetCircuitSizes(new RawBuffer(bytecode));
   return { exact, total, subgroup };
 }
 
-async function init(jsonPath: string, sizeHint?: number) {
+async function init(jsonPath: string) {
   const api = await newBarretenbergApiAsync();
 
-  const subgroupSize = await (async () => {
-    if (sizeHint) {
-      // Round to subgroup size.
-      return Math.pow(2, Math.ceil(Math.log2(sizeHint)));
-    }
-
-    // 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;
-  })();
+  const circuitSize = await getGates(jsonPath, api);
+  const subgroupSize = Math.pow(2, Math.ceil(Math.log2(circuitSize)));
+  if (subgroupSize > MAX_CIRCUIT_SIZE) {
+    throw new Error(`Circuit size of ${subgroupSize} exceeds max supported of ${MAX_CIRCUIT_SIZE}`);
+  }
 
+  debug(`circuit size: ${circuitSize}`);
   debug(`subgroup size: ${subgroupSize}`);
   debug('loading crs...');
   // Plus 1 needed! (Move +1 into Crs?)
@@ -81,8 +88,8 @@ async function initLite() {
   return { api, acirComposer };
 }
 
-export async function proveAndVerify(jsonPath: string, witnessPath: string, isRecursive: boolean, sizeHint?: number) {
-  const { api, acirComposer } = await init(jsonPath, sizeHint);
+export async function proveAndVerify(jsonPath: string, witnessPath: string, isRecursive: boolean) {
+  const { api, acirComposer } = await init(jsonPath);
   try {
     debug(`creating proof...`);
     const bytecode = getBytecode(jsonPath);
@@ -98,14 +105,8 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, isRe
   }
 }
 
-export async function prove(
-  jsonPath: string,
-  witnessPath: string,
-  isRecursive: boolean,
-  outputPath: string,
-  sizeHint?: number,
-) {
-  const { api, acirComposer } = await init(jsonPath, sizeHint);
+export async function prove(jsonPath: string, witnessPath: string, isRecursive: boolean, outputPath: string) {
+  const { api, acirComposer } = await init(jsonPath);
   try {
     debug(`creating proof...`);
     const bytecode = getBytecode(jsonPath);
@@ -123,14 +124,13 @@ export async function prove(
 export async function gateCount(jsonPath: string) {
   const api = await newBarretenbergApiAsync(1);
   try {
-    const circuitSizes = await getCircuitSize(jsonPath, api);
-    console.log(`${circuitSizes.exact}`);
+    console.log(`gates: ${await getGates(jsonPath, api)}`);
   } finally {
     await api.destroy();
   }
 }
 
-export async function verify(jsonPath: string, proofPath: string, isRecursive: boolean, vkPath: string) {
+export async function verify(proofPath: string, isRecursive: boolean, vkPath: string) {
   const { api, acirComposer } = await initLite();
   try {
     await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
@@ -158,8 +158,8 @@ export async function contract(outputPath: string, vkPath: string) {
   }
 }
 
-export async function writeVk(jsonPath: string, outputPath: string, sizeHint?: number) {
-  const { api, acirComposer } = await init(jsonPath, sizeHint);
+export async function writeVk(jsonPath: string, outputPath: string) {
+  const { api, acirComposer } = await init(jsonPath);
   try {
     debug('initing proving key...');
     const bytecode = getBytecode(jsonPath);
@@ -211,16 +211,6 @@ export async function vkAsFields(vkPath: string, vkeyOutputPath: string) {
   }
 }
 
-// nargo use bb.js: backend -> bb.js
-// backend prove --data-dir data --witness /foo/bar/witness.tr --json /foo/bar/main.json
-// backend verify ...
-// backend get_total_num_gates --data-dir data --json /foo/bar/main.json
-// backend get_sol_contract --data-dir data --json /foo/bar/main.json --output
-// backend get_features
-// OPTIONAL stateful backend:
-// backend start
-// backend stop
-
 const program = new Command();
 
 program.option('-v, --verbose', 'enable verbose logging', false);
@@ -237,10 +227,9 @@ 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 and verify using recursive prover and verifier', false)
-  .option('-s, --size-hint <gates>', 'provide a circuit size hint to skip calculation phase')
-  .action(async ({ jsonPath, witnessPath, recursive, sizeHint }) => {
+  .action(async ({ jsonPath, witnessPath, recursive }) => {
     handleGlobalOptions();
-    const result = await proveAndVerify(jsonPath, witnessPath, recursive, sizeHint);
+    const result = await proveAndVerify(jsonPath, witnessPath, recursive);
     process.exit(result ? 0 : 1);
   });
 
@@ -251,10 +240,9 @@ program
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
   .option('-r, --recursive', 'prove using recursive prover', false)
   .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 }) => {
+  .action(async ({ jsonPath, witnessPath, recursive, outputPath }) => {
     handleGlobalOptions();
-    await prove(jsonPath, witnessPath, recursive, outputPath, sizeHint);
+    await prove(jsonPath, witnessPath, recursive, outputPath);
   });
 
 program
@@ -269,13 +257,13 @@ program
 program
   .command('verify')
   .description('Verify a proof. Process exists with success or failure code.')
-  .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)
   .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
-  .action(async ({ jsonPath, proofPath, recursive, vk }) => {
+  .action(async ({ proofPath, recursive, vk }) => {
     handleGlobalOptions();
-    await verify(jsonPath, proofPath, recursive, vk);
+    const result = await verify(proofPath, recursive, vk);
+    process.exit(result ? 0 : 1);
   });
 
 program
@@ -294,10 +282,9 @@ 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')
-  .option('-s, --size-hint <gates>', 'provide a circuit size hint to skip calculation phase')
-  .action(async ({ jsonPath, outputPath, sizeHint }) => {
+  .action(async ({ jsonPath, outputPath }) => {
     handleGlobalOptions();
-    await writeVk(jsonPath, outputPath, sizeHint);
+    await writeVk(jsonPath, outputPath);
   });
 
 program

package/dest/crs/node/file_crs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file_crs.d.ts","sourceRoot":"","sources":["../../../src/crs/node/file_crs.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,eAAO,MAAM,YAAY,QAAqF,CAAC;AAE/G;;GAEG;AACH,qBAAa,OAAO;IAKhB;;OAEG;aACa,SAAS,EAAE,MAAM;IACjC,OAAO,CAAC,IAAI;IARd,OAAO,CAAC,IAAI,CAAc;IAC1B,OAAO,CAAC,MAAM,CAAc;;IAG1B;;OAEG;IACa,SAAS,EAAE,MAAM,EACzB,IAAI,SAAe;IAG7B,MAAM,CAAC,aAAa;IAIpB;;OAEG;IACG,IAAI;IAYV;;;OAGG;IACH,SAAS,IAAI,UAAU;IAIvB;;;OAGG;IACH,SAAS,IAAI,UAAU;CAGxB"}

package/dest/crs/node/file_crs.js

@@ -1,51 +0,0 @@
-import { existsSync } from 'fs';
-import { readFile } from 'fs/promises';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-/**
- * The path to our SRS object, assuming that we are in barretenberg/ts folder.
- */
-export const SRS_DEV_PATH = dirname(fileURLToPath(import.meta.url)) + '/../../../cpp/srs_db/ignition/monomial';
-/**
- * Downloader for CRS from a local file (for Node).
- */
-export class FileCrs {
-    constructor(
-    /**
-     * The number of circuit gates.
-     */
-    numPoints, path = SRS_DEV_PATH) {
-        this.numPoints = numPoints;
-        this.path = path;
-    }
-    static defaultExists() {
-        return existsSync(SRS_DEV_PATH);
-    }
-    /**
-     * Read the data file.
-     */
-    async init() {
-        // We need this.numPoints number of g1 points.
-        // numPoints should be circuitSize + 1.
-        const g1Start = 28;
-        const g1End = g1Start + this.numPoints * 64;
-        const data = await readFile(this.path + '/transcript00.dat');
-        this.data = data.subarray(g1Start, g1End);
-        this.g2Data = await readFile(this.path + '/g2.dat');
-    }
-    /**
-     * G1 points data for prover key.
-     * @returns The points data.
-     */
-    getG1Data() {
-        return this.data;
-    }
-    /**
-     * G2 points data for verification key.
-     * @returns The points data.
-     */
-    getG2Data() {
-        return this.g2Data;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZV9jcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY3JzL25vZGUvZmlsZV9jcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLElBQUksQ0FBQztBQUNoQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDL0IsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUVwQzs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyx3Q0FBd0MsQ0FBQztBQUUvRzs7R0FFRztBQUNILE1BQU0sT0FBTyxPQUFPO0lBSWxCO0lBQ0U7O09BRUc7SUFDYSxTQUFpQixFQUN6QixPQUFPLFlBQVk7UUFEWCxjQUFTLEdBQVQsU0FBUyxDQUFRO1FBQ3pCLFNBQUksR0FBSixJQUFJLENBQWU7SUFDMUIsQ0FBQztJQUVKLE1BQU0sQ0FBQyxhQUFhO1FBQ2xCLE9BQU8sVUFBVSxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFRDs7T0FFRztJQUNILEtBQUssQ0FBQyxJQUFJO1FBQ1IsOENBQThDO1FBQzlDLHVDQUF1QztRQUN2QyxNQUFNLE9BQU8sR0FBRyxFQUFFLENBQUM7UUFDbkIsTUFBTSxLQUFLLEdBQUcsT0FBTyxHQUFHLElBQUksQ0FBQyxTQUFTLEdBQUcsRUFBRSxDQUFDO1FBRTVDLE1BQU0sSUFBSSxHQUFHLE1BQU0sUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLEdBQUcsbUJBQW1CLENBQUMsQ0FBQztRQUM3RCxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBRTFDLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksR0FBRyxTQUFTLENBQUMsQ0FBQztJQUN0RCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsU0FBUztRQUNQLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztJQUNuQixDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsU0FBUztRQUNQLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztJQUNyQixDQUFDO0NBQ0YifQ==