@aztec/bb.js 0.12.0 → 0.13.0

package/src/barretenberg_api/pedersen.test.ts

@@ -1,91 +1,29 @@
 import { Barretenberg } from '../barretenberg/index.js';
-import { Fr } from '../types/index.js';
+import { Fr, Point } from '../types/index.js';
 
 describe('pedersen', () => {
   let api: Barretenberg;
 
   beforeAll(async () => {
     api = await Barretenberg.new(1);
-    await api.pedersenHashInit();
   }, 30000);
 
   afterAll(async () => {
     await api.destroy();
   });
 
-  it('pedersenCompressFields', async () => {
-    const result = await api.pedersenCompressFields(new Fr(4n), new Fr(8n));
-    expect(result).toEqual(new Fr(1521373897829389584529155077412196627698249315427143054350987371861781120260n));
-  });
-
-  it('pedersenCompress', async () => {
-    const result = await api.pedersenCompress([new Fr(4n), new Fr(8n), new Fr(12n)]);
-    expect(result).toEqual(new Fr(16354408412011670665169322571938780771784319449166930406648760506154417354381n));
-  });
-
-  it('pedersenCompressWithHashIndex', async () => {
-    const result = await api.pedersenCompressWithHashIndex([new Fr(4n), new Fr(8n)], 7);
+  it('pedersenHashWithHashIndex', async () => {
+    const result = await api.pedersenHashWithHashIndex([new Fr(4n), new Fr(8n)], 7);
     expect(result).toEqual(new Fr(2152386650411553803409271316104075950536496387580531018130718456431861859990n));
   });
 
-  it('pedersenCompressAndHashSame', async () => {
-    const resultCompress = await api.pedersenCompressWithHashIndex([new Fr(4n), new Fr(8n)], 7);
-    const resultHash = await api.pedersenHashWithHashIndex([new Fr(4n), new Fr(8n)], 7);
-    expect(resultCompress).toEqual(resultHash);
-  });
-
-  it('pedersenHashWith0IndexSameAsNoIndex', async () => {
-    const resultHashImplicit0 = await api.pedersenHash([new Fr(4n), new Fr(8n)]);
-    const resultCompressImplicit0 = await api.pedersenCompress([new Fr(4n), new Fr(8n)]);
-    const resultCompressFieldsImplicit0 = await api.pedersenCompressFields(new Fr(4n), new Fr(8n));
-    const resultHashExplicit0 = await api.pedersenHashWithHashIndex([new Fr(4n), new Fr(8n)], 0);
-    expect(resultHashImplicit0).toEqual(resultCompressImplicit0);
-    expect(resultHashImplicit0).toEqual(resultHashExplicit0);
-    expect(resultHashImplicit0).toEqual(resultCompressFieldsImplicit0);
-  });
-
-  it('pedersenHashPairSameAsWith0Index', async () => {
-    const resultHashPair = await api.pedersenHashPair(new Fr(4n), new Fr(8n));
-    const resultHashExplicit0 = await api.pedersenHashWithHashIndex([new Fr(4n), new Fr(8n)], 0);
-    expect(resultHashExplicit0).toEqual(resultHashPair);
-  });
-
-  it('pedersenHashMultipleSameAsWith0Index', async () => {
-    const resultHashPair = await api.pedersenHashMultiple([new Fr(4n), new Fr(8n)]);
-    const resultHashExplicit0 = await api.pedersenHashWithHashIndex([new Fr(4n), new Fr(8n)], 0);
-    expect(resultHashExplicit0).toEqual(resultHashPair);
-  });
-
   it('pedersenCommit', async () => {
     const result = await api.pedersenCommit([new Fr(4n), new Fr(8n), new Fr(12n)]);
-    expect(result).toEqual(new Fr(18374309251862457296563484909553154519357910650678202211610516068880120638872n));
-  });
-
-  it('pedersenHashPair', async () => {
-    const result = await api.pedersenHashPair(new Fr(4n), new Fr(8n));
-    expect(result).toEqual(new Fr(1521373897829389584529155077412196627698249315427143054350987371861781120260n));
-  });
-
-  it('pedersenHashMultiple', async () => {
-    const result = await api.pedersenHashMultiple([new Fr(4n), new Fr(8n), new Fr(12n)]);
-    expect(result).toEqual(new Fr(16354408412011670665169322571938780771784319449166930406648760506154417354381n));
-  });
-
-  it('pedersenHashMultipleWithHashIndex', async () => {
-    const result = await api.pedersenHashMultipleWithHashIndex([new Fr(4n), new Fr(8n)], 7);
-    expect(result).toEqual(new Fr(2152386650411553803409271316104075950536496387580531018130718456431861859990n));
-  });
-
-  it('pedersenHashToTree', async () => {
-    const result = await api.pedersenHashToTree([new Fr(4n), new Fr(8n), new Fr(12n), new Fr(16n)]);
-    expect(result).toEqual([
-      new Fr(4n),
-      new Fr(8n),
-      new Fr(12n),
-      new Fr(16n),
-      new Fr(1521373897829389584529155077412196627698249315427143054350987371861781120260n),
-      new Fr(18350527319045519333962768191016242826584323959670139897255818770108115223653n),
-      new Fr(5972535902427608430534212385621973704186819235181735133037695406667218179357n),
-    ]);
+    expect(result).toEqual(
+      new Point(
+        new Fr(18374309251862457296563484909553154519357910650678202211610516068880120638872n),
+        new Fr(2572141322478528249692953821523229170092797347760799983831061874108357705739n),
+      ),
+    );
   });
 });

package/src/barretenberg_api/schnorr.test.ts

@@ -9,7 +9,6 @@ describe('schnorr', () => {
 
   beforeAll(async () => {
     api = await Barretenberg.new(1);
-    await api.pedersenInit();
   }, 30000);
 
   afterAll(async () => {

package/src/benchmark/index.ts

@@ -0,0 +1,26 @@
+import * as fs from 'fs';
+export * from './timer.js';
+
+const bfd = (() => {
+  const bfdStr = process.env.BENCHMARK_FD;
+  const bfd = bfdStr ? parseInt(bfdStr) : -1;
+  if (bfd >= 0 && !fs.fstatSync(bfd)) {
+    throw new Error('fd is not open. Did you redirect in your shell?');
+  }
+  return bfd;
+})();
+
+export function writeBenchmark<T>(name: string, value: T, labels: Record<string, any> = {}) {
+  if (bfd === -1) {
+    return;
+  }
+  const data = {
+    timestamp: new Date().toISOString(),
+    name,
+    type: typeof value,
+    value,
+    ...labels,
+  };
+  const jsonl = JSON.stringify(data) + '\n';
+  fs.writeSync(bfd, jsonl);
+}

package/src/benchmark/timer.ts

@@ -0,0 +1,41 @@
+/**
+ * Timer class to measure time intervals in milliseconds and seconds.
+ * Upon instantiation, it stores the current timestamp as the starting point.
+ * The 'ms()' method returns the elapsed time in milliseconds,
+ * while the 's()' method returns the elapsed time in seconds.
+ *
+ * @example
+ * const timer = new Timer();
+ * setTimeout(() =\> \{
+ *   console.log(`Elapsed time: ${timer.ms()} ms`);
+ * \}, 1000);
+ */
+export class Timer {
+  private start: number;
+
+  constructor() {
+    this.start = new Date().getTime();
+  }
+
+  /**
+   * Returns the elapsed time in milliseconds since the Timer instance was created.
+   * Provides a simple and convenient way to measure the time duration between two events
+   * or monitor performance of specific code sections.
+   *
+   * @returns The elapsed time in milliseconds.
+   */
+  public ms() {
+    return new Date().getTime() - this.start;
+  }
+
+  /**
+   * Returns the time elapsed since the Timer instance was created, in seconds.
+   * The value is calculated by subtracting the initial start time from the current time
+   * and dividing the result by 1000 to convert milliseconds to seconds.
+   *
+   * @returns The elapsed time in seconds.
+   */
+  public s() {
+    return (new Date().getTime() - this.start) / 1000;
+  }
+}

package/src/main.ts

@@ -5,6 +5,8 @@ import { readFileSync, writeFileSync } from 'fs';
 import { gunzipSync } from 'zlib';
 import { Command } from 'commander';
 import { acvmInfoJson } from './info.js';
+import { Timer, writeBenchmark } from './benchmark/index.js';
+import path from 'path';
 createDebug.log = console.error.bind(console);
 const debug = createDebug('bb.js');
 
@@ -15,6 +17,7 @@ const debug = createDebug('bb.js');
 // aware of this discrepancy, when creating proofs in bb versus
 // creating the same proofs in the node CLI.
 const MAX_CIRCUIT_SIZE = 2 ** 19;
+const threads = +process.env.HARDWARE_CONCURRENCY! || undefined;
 
 function getBytecode(bytecodePath: string) {
   const encodedCircuit = readFileSync(bytecodePath);
@@ -41,7 +44,7 @@ async function computeCircuitSize(bytecodePath: string, api: Barretenberg) {
 }
 
 async function init(bytecodePath: string, crsPath: string) {
-  const api = await Barretenberg.new();
+  const api = await Barretenberg.new(threads);
 
   const circuitSize = await getGates(bytecodePath, api);
   const subgroupSize = Math.pow(2, Math.ceil(Math.log2(circuitSize)));
@@ -63,7 +66,7 @@ async function init(bytecodePath: string, crsPath: string) {
   await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
 
   const acirComposer = await api.acirNewAcirComposer(subgroupSize);
-  return { api, acirComposer, circuitSize: subgroupSize };
+  return { api, acirComposer, circuitSize, subgroupSize };
 }
 
 async function initLite() {
@@ -80,12 +83,24 @@ async function initLite() {
 }
 
 export async function proveAndVerify(bytecodePath: string, witnessPath: string, crsPath: string, isRecursive: boolean) {
-  const { api, acirComposer } = await init(bytecodePath, crsPath);
+  /* eslint-disable camelcase */
+  const acir_test = path.basename(process.cwd());
+
+  const { api, acirComposer, circuitSize, subgroupSize } = await init(bytecodePath, crsPath);
   try {
     debug(`creating proof...`);
     const bytecode = getBytecode(bytecodePath);
     const witness = getWitness(witnessPath);
+
+    const pkTimer = new Timer();
+    await api.acirInitProvingKey(acirComposer, bytecode);
+    writeBenchmark('pk_construction_time', pkTimer.ms(), { acir_test, threads });
+    writeBenchmark('gate_count', circuitSize, { acir_test, threads });
+    writeBenchmark('subgroup_size', subgroupSize, { acir_test, threads });
+
+    const proofTimer = new Timer();
     const proof = await api.acirCreateProof(acirComposer, bytecode, witness, isRecursive);
+    writeBenchmark('proof_construction_time', proofTimer.ms(), { acir_test, threads });
 
     debug(`verifying...`);
     const verified = await api.acirVerifyProof(acirComposer, proof, isRecursive);
@@ -94,6 +109,7 @@ export async function proveAndVerify(bytecodePath: string, witnessPath: string,
   } finally {
     await api.destroy();
   }
+  /* eslint-enable camelcase */
 }
 
 export async function prove(