@aztec/bb.js 0.16.8 → 0.17.0

package/src/crs/node/ignition_files_crs.ts

@@ -14,9 +14,10 @@ function getCurrentDir() {
 }
 
 /**
- * The path to our SRS object, assuming that we are in barretenberg/ts folder.
+ * The path to our SRS object, assuming that we are in e.g. barretenberg/ts/dest/node/crs/node folder.
  */
-export const SRS_DEV_PATH = getCurrentDir() + '/../../../cpp/srs_db/ignition/monomial';
+export const SRS_DEV_PATH = getCurrentDir() + '/../../../../../cpp/srs_db/ignition/monomial';
+export const GRUMPKIN_SRS_DEV_PATH = getCurrentDir() + '/../../../../../cpp/srs_db/grumpkin/monomial';
 
 /**
  * Downloader for CRS from a local file (for Node).
@@ -33,8 +34,8 @@ export class IgnitionFilesCrs {
     private path = SRS_DEV_PATH,
   ) {}
 
-  static defaultExists() {
-    return existsSync(SRS_DEV_PATH);
+  pathExists() {
+    return existsSync(this.path);
   }
 
   /**
@@ -49,7 +50,10 @@ export class IgnitionFilesCrs {
     const data = await readFile(this.path + '/transcript00.dat');
     this.data = data.subarray(g1Start, g1End);
 
-    this.g2Data = await readFile(this.path + '/g2.dat');
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/811): proper abstraction from Grumpkin which does not have g2
+    if (existsSync(this.path + '/g2.dat')) {
+      this.g2Data = await readFile(this.path + '/g2.dat');
+    }
   }
 
   /**

package/src/crs/node/index.ts

@@ -1,8 +1,9 @@
 import { NetCrs } from '../net_crs.js';
-import { IgnitionFilesCrs } from './ignition_files_crs.js';
+import { GRUMPKIN_SRS_DEV_PATH, IgnitionFilesCrs } from './ignition_files_crs.js';
 import { mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { readFile } from 'fs/promises';
+import { readFile, stat } from 'fs/promises';
 import createDebug from 'debug';
+import { homedir } from 'os';
 
 const debug = createDebug('bb.js:crs');
 
@@ -12,7 +13,7 @@ const debug = createDebug('bb.js:crs');
 export class Crs {
   constructor(public readonly numPoints: number, public readonly path: string) {}
 
-  static async new(numPoints: number, crsPath = './crs') {
+  static async new(numPoints: number, crsPath = homedir() + '/.bb-crs') {
     const crs = new Crs(numPoints, crsPath);
     await crs.init();
     return crs;
@@ -20,22 +21,24 @@ export class Crs {
 
   async init() {
     mkdirSync(this.path, { recursive: true });
-    const size = await readFile(this.path + '/size', 'ascii').catch(() => undefined);
-    if (size && +size >= this.numPoints) {
-      debug(`using cached crs of size: ${size}`);
+
+    const g1FileSize = await stat(this.path + '/bn254_g1.dat')
+      .then(stats => stats.size)
+      .catch(() => 0);
+    const g2FileSize = await stat(this.path + '/bn254_g2.dat')
+      .then(stats => stats.size)
+      .catch(() => 0);
+
+    if (g1FileSize >= this.numPoints * 64 && g1FileSize % 64 == 0 && g2FileSize == 128) {
+      debug(`using cached crs of size: ${g1FileSize / 64}`);
       return;
     }
 
-    const crs = IgnitionFilesCrs.defaultExists() ? new IgnitionFilesCrs(this.numPoints) : new NetCrs(this.numPoints);
-    if (crs instanceof NetCrs) {
-      debug(`downloading crs of size: ${this.numPoints}`);
-    } else {
-      debug(`loading igntion file crs of size: ${this.numPoints}`);
-    }
+    debug(`downloading crs of size: ${this.numPoints}`);
+    const crs = new NetCrs(this.numPoints);
     await crs.init();
-    writeFileSync(this.path + '/size', this.numPoints.toString());
-    writeFileSync(this.path + '/g1.dat', crs.getG1Data());
-    writeFileSync(this.path + '/g2.dat', crs.getG2Data());
+    writeFileSync(this.path + '/bn254_g1.dat', crs.getG1Data());
+    writeFileSync(this.path + '/bn254_g2.dat', crs.getG2Data());
   }
 
   /**
@@ -43,7 +46,7 @@ export class Crs {
    * @returns The points data.
    */
   getG1Data(): Uint8Array {
-    return readFileSync(this.path + '/g1.dat');
+    return readFileSync(this.path + '/bn254_g1.dat');
   }
 
   /**
@@ -51,6 +54,61 @@ export class Crs {
    * @returns The points data.
    */
   getG2Data(): Uint8Array {
-    return readFileSync(this.path + '/g2.dat');
+    return readFileSync(this.path + '/bn254_g2.dat');
+  }
+}
+
+/**
+ * Generic Grumpkin CRS finder utility class.
+ */
+export class GrumpkinCrs {
+  constructor(public readonly numPoints: number, public readonly path: string) {}
+
+  static async new(numPoints: number, crsPath = './crs') {
+    const crs = new GrumpkinCrs(numPoints, crsPath);
+    await crs.init();
+    return crs;
+  }
+
+  async downloadG1Data() {
+    const g1Start = 28;
+    const g1End = g1Start + this.numPoints * 64 - 1;
+
+    const response = await fetch('https://aztec-ignition.s3.amazonaws.com/TEST%20GRUMPKIN/monomial/transcript00.dat', {
+      headers: {
+        Range: `bytes=${g1Start}-${g1End}`,
+      },
+      cache: 'force-cache',
+    });
+
+    return new Uint8Array(await response.arrayBuffer());
+  }
+
+  async init() {
+    mkdirSync(this.path, { recursive: true });
+    const size = await readFile(this.path + '/grumpkin_size', 'ascii').catch(() => undefined);
+    if (size && +size >= this.numPoints) {
+      debug(`using cached crs of size: ${size}`);
+      return;
+    }
+
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/813): implement NetCrs for Grumpkin once SRS is uploaded.
+    const ignitionCrs = new IgnitionFilesCrs(this.numPoints, GRUMPKIN_SRS_DEV_PATH);
+    if (ignitionCrs.pathExists()) {
+      await ignitionCrs.init();
+    }
+    const g1Data = ignitionCrs.pathExists() ? ignitionCrs.getG1Data() : await this.downloadG1Data();
+    debug(`loading ignition file crs of size: ${this.numPoints}`);
+    // await crs.init();
+    writeFileSync(this.path + '/grumpkin_size', this.numPoints.toString());
+    writeFileSync(this.path + '/grumpkin_g1.dat', g1Data);
+  }
+
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data(): Uint8Array {
+    return readFileSync(this.path + '/grumpkin_g1.dat');
   }
 }

package/src/info.ts

@@ -15,7 +15,6 @@ export const acvmInfoJson = {
     'schnorr_verify',
     'pedersen',
     'pedersen_hash',
-    'hash_to_field_128_security',
     'ecdsa_secp256k1',
     'ecdsa_secp256r1',
     'fixed_base_scalar_mul',

package/src/main.ts

@@ -7,6 +7,7 @@ import { Command } from 'commander';
 import { acvmInfoJson } from './info.js';
 import { Timer, writeBenchmark } from './benchmark/index.js';
 import path from 'path';
+import { GrumpkinCrs } from './crs/node/index.js';
 createDebug.log = console.error.bind(console);
 const debug = createDebug('bb.js');
 
@@ -43,11 +44,12 @@ async function computeCircuitSize(bytecodePath: string, api: Barretenberg) {
   return { exact, total, subgroup };
 }
 
-async function init(bytecodePath: string, crsPath: string) {
-  const api = await Barretenberg.new(threads);
+async function init(bytecodePath: string, crsPath: string, subgroupSizeOverride = -1) {
+  const api = await Barretenberg.new({ threads });
 
   const circuitSize = await getGates(bytecodePath, api);
-  const subgroupSize = Math.pow(2, Math.ceil(Math.log2(circuitSize)));
+  // 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_CIRCUIT_SIZE) {
     throw new Error(`Circuit size of ${subgroupSize} exceeds max supported of ${MAX_CIRCUIT_SIZE}`);
   }
@@ -69,8 +71,22 @@ async function init(bytecodePath: string, crsPath: string) {
   return { api, acirComposer, circuitSize, subgroupSize };
 }
 
+async function initGoblin(bytecodePath: string, crsPath: string) {
+  // TODO(https://github.com/AztecProtocol/barretenberg/issues/811): remove this subgroup size hack
+  const hardcodedGrumpkinSubgroupSizeHack = 262144;
+  const initData = await init(bytecodePath, crsPath, hardcodedGrumpkinSubgroupSizeHack);
+  const { api } = initData;
+
+  // Plus 1 needed! (Move +1 into Crs?)
+  // Need both grumpkin and bn254 SRS's currently
+  const grumpkinCrs = await GrumpkinCrs.new(hardcodedGrumpkinSubgroupSizeHack + 1, crsPath);
+  await api.srsInitGrumpkinSrs(new RawBuffer(grumpkinCrs.getG1Data()), grumpkinCrs.numPoints);
+
+  return initData;
+}
+
 async function initLite() {
-  const api = await Barretenberg.new(1);
+  const api = await Barretenberg.new({ threads: 1 });
 
   // Plus 1 needed! (Move +1 into Crs?)
   const crs = await Crs.new(1);
@@ -112,6 +128,34 @@ export async function proveAndVerify(bytecodePath: string, witnessPath: string,
   /* eslint-enable camelcase */
 }
 
+export async function proveAndVerifyGoblin(bytecodePath: string, witnessPath: string, crsPath: string) {
+  /* eslint-disable camelcase */
+  const acir_test = path.basename(process.cwd());
+
+  const { api, acirComposer, circuitSize, subgroupSize } = await initGoblin(bytecodePath, crsPath);
+  try {
+    debug(`creating proof...`);
+    const bytecode = getBytecode(bytecodePath);
+    const witness = getWitness(witnessPath);
+
+    writeBenchmark('gate_count', circuitSize, { acir_test, threads });
+    writeBenchmark('subgroup_size', subgroupSize, { acir_test, threads });
+
+    const proofTimer = new Timer();
+    const proof = await api.acirCreateGoblinProof(acirComposer, bytecode, witness);
+    writeBenchmark('proof_construction_time', proofTimer.ms(), { acir_test, threads });
+
+    debug(`verifying...`);
+    const verified = await api.acirVerifyGoblinProof(acirComposer, proof);
+    debug(`verified: ${verified}`);
+    console.log({ verified });
+    return verified;
+  } finally {
+    await api.destroy();
+  }
+  /* eslint-enable camelcase */
+}
+
 export async function prove(
   bytecodePath: string,
   witnessPath: string,
@@ -140,7 +184,7 @@ export async function prove(
 }
 
 export async function gateCount(bytecodePath: string) {
-  const api = await Barretenberg.new(1);
+  const api = await Barretenberg.new({ threads: 1 });
   try {
     const numberOfGates = await getGates(bytecodePath, api);
 
@@ -312,6 +356,17 @@ program
     process.exit(result ? 0 : 1);
   });
 
+program
+  .command('prove_and_verify_goblin')
+  .description('Generate a proof and verify it. Process exits with success or failure code.')
+  .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/acir.gz')
+  .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+  .action(async ({ bytecodePath, witnessPath, crsPath }) => {
+    handleGlobalOptions();
+    const result = await proveAndVerifyGoblin(bytecodePath, witnessPath, crsPath);
+    process.exit(result ? 0 : 1);
+  });
+
 program
   .command('prove')
   .description('Generate a proof and write it to a file.')