@aztec/bb.js 0.76.4-devnet-test-rc3 → 0.77.0-testnet-ignition.4

package/dest/node-cjs/retry/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retry = exports.makeBackoff = exports.backoffGenerator = void 0;
+/**
+ * Generates a backoff sequence for retrying operations with an increasing delay.
+ * The backoff sequence follows this pattern: 1, 1, 1, 2, 4, 8, 16, 32, 64, ...
+ * This generator can be used in combination with the `retry` function to perform
+ * retries with exponential backoff and capped at 64 seconds between attempts.
+ *
+ * @returns A generator that yields the next backoff value in seconds as an integer.
+ */
+function* backoffGenerator() {
+    const v = [1, 1, 1, 2, 4, 8, 16, 32, 64];
+    let i = 0;
+    while (true) {
+        yield v[Math.min(i++, v.length - 1)];
+    }
+}
+exports.backoffGenerator = backoffGenerator;
+/**
+ * Generates a backoff sequence based on the array of retry intervals to use with the `retry` function.
+ * @param retries - Intervals to retry (in seconds).
+ * @returns A generator sequence.
+ */
+function* makeBackoff(retries) {
+    for (const retry of retries) {
+        yield retry;
+    }
+}
+exports.makeBackoff = makeBackoff;
+/**
+ * Retry a given asynchronous function with a specific backoff strategy, until it succeeds or backoff generator ends.
+ * It logs the error and retry interval in case an error is caught. The function can be named for better log output.
+ *
+ * @param fn - The asynchronous function to be retried.
+ * @param backoff - The optional backoff generator providing the intervals in seconds between retries. Defaults to a predefined series.
+ * @returns A Promise that resolves with the successful result of the provided function, or rejects if backoff generator ends.
+ * @throws If `NoRetryError` is thrown by the `fn`, it is rethrown.
+ */
+async function retry(fn, backoff = backoffGenerator()) {
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            const s = backoff.next().value;
+            if (s === undefined) {
+                throw err;
+            }
+            await new Promise(resolve => setTimeout(resolve, s * 1000));
+            continue;
+        }
+    }
+}
+exports.retry = retry;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmV0cnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7Ozs7R0FPRztBQUNILFFBQWUsQ0FBQyxDQUFDLGdCQUFnQjtJQUMvQixNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDekMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ1YsT0FBTyxJQUFJLEVBQUUsQ0FBQztRQUNaLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7QUFDSCxDQUFDO0FBTkQsNENBTUM7QUFFRDs7OztHQUlHO0FBQ0gsUUFBZSxDQUFDLENBQUMsV0FBVyxDQUFDLE9BQWlCO0lBQzVDLEtBQUssTUFBTSxLQUFLLElBQUksT0FBTyxFQUFFLENBQUM7UUFDNUIsTUFBTSxLQUFLLENBQUM7SUFDZCxDQUFDO0FBQ0gsQ0FBQztBQUpELGtDQUlDO0FBRUQ7Ozs7Ozs7O0dBUUc7QUFDSSxLQUFLLFVBQVUsS0FBSyxDQUFTLEVBQXlCLEVBQUUsT0FBTyxHQUFHLGdCQUFnQixFQUFFO0lBQ3pGLE9BQU8sSUFBSSxFQUFFLENBQUM7UUFDWixJQUFJLENBQUM7WUFDSCxPQUFPLE1BQU0sRUFBRSxFQUFFLENBQUM7UUFDcEIsQ0FBQztRQUFDLE9BQU8sR0FBUSxFQUFFLENBQUM7WUFDbEIsTUFBTSxDQUFDLEdBQUcsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDLEtBQUssQ0FBQztZQUMvQixJQUFJLENBQUMsS0FBSyxTQUFTLEVBQUUsQ0FBQztnQkFDcEIsTUFBTSxHQUFHLENBQUM7WUFDWixDQUFDO1lBQ0QsTUFBTSxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUM7WUFDNUQsU0FBUztRQUNYLENBQUM7SUFDSCxDQUFDO0FBQ0gsQ0FBQztBQWJELHNCQWFDIn0=

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aztec/bb.js",
   "packageManager": "yarn@4.5.2",
-  "version": "0.76.4-devnet-test-rc3",
+  "version": "0.77.0-testnet-ignition.4",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/ts",
   "license": "MIT",
   "type": "module",
@@ -13,7 +13,7 @@
       "default": "./dest/node/index.js"
     }
   },
-  "bin": "./dest/node/main.js",
+  "bin": "dest/node/main.js",
   "files": [
     "src/",
     "dest/",
@@ -96,7 +96,7 @@
     "ts-jest": "^29.1.0",
     "ts-loader": "^9.4.2",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4",
+    "typescript": "5.4.5",
     "webpack": "^5.82.1",
     "webpack-cli": "^5.1.1",
     "webpack-dev-server": "^5.2.0",

package/src/barretenberg/backend.ts

@@ -10,6 +10,12 @@ import {
   reconstructUltraPlonkProof,
 } from '../proof/index.js';
 
+export class AztecClientBackendError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
 export class UltraPlonkBackend {
   // These type assertions are used so that we don't
   // have to initialize `api` and `acirComposer` in the constructor.
@@ -302,9 +308,11 @@ export class UltraHonkBackend {
     return await verifyUltraHonk(proof, new RawBuffer(vkBuf));
   }
 
-  async getVerificationKey(): Promise<Uint8Array> {
+  async getVerificationKey(options?: UltraHonkBackendOptions): Promise<Uint8Array> {
     await this.instantiate();
-    return await this.api.acirWriteVkUltraHonk(this.acirUncompressedBytecode, this.circuitOptions.recursive);
+    return options?.keccak
+      ? await this.api.acirWriteVkUltraKeccakHonk(this.acirUncompressedBytecode, this.circuitOptions.recursive)
+      : await this.api.acirWriteVkUltraHonk(this.acirUncompressedBytecode, this.circuitOptions.recursive);
   }
 
   /** @description Returns a solidity verifier */
@@ -376,7 +384,12 @@ export class AztecClientBackend {
 
   async prove(witnessMsgpack: Uint8Array[]): Promise<[Uint8Array, Uint8Array]> {
     await this.instantiate();
-    return this.api.acirProveAztecClient(this.acirMsgpack, witnessMsgpack);
+    const proofAndVk = await this.api.acirProveAztecClient(this.acirMsgpack, witnessMsgpack);
+    const [proof, vk] = proofAndVk;
+    if (!await this.verify(proof, vk)) {
+      throw new AztecClientBackendError("Failed to verify the private (ClientIVC) transaction proof!");
+    }
+    return proofAndVk;
   }
 
   async verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean> {
@@ -389,6 +402,12 @@ export class AztecClientBackend {
     return this.api.acirProveAndVerifyAztecClient(this.acirMsgpack, witnessMsgpack);
   }
 
+  async gates(): Promise<number[]> {
+    // call function on API
+    await this.instantiate();
+    return this.api.acirGatesAztecClient(this.acirMsgpack);
+  }
+
   async destroy(): Promise<void> {
     if (!this.api) {
       return;

package/src/barretenberg/index.ts

@@ -11,8 +11,6 @@ import { RawBuffer } from '../types/raw_buffer.js';
 export { BarretenbergVerifier } from './verifier.js';
 export { UltraPlonkBackend, UltraHonkBackend, AztecClientBackend } from './backend.js';
 
-const debug = createDebug('bb.js:wasm');
-
 export type BackendOptions = {
   /** @description Number of threads to run the backend worker on */
   threads?: number;
@@ -25,6 +23,9 @@ export type BackendOptions = {
 
   /** @description Path to download WASM files */
   wasmPath?: string;
+
+  /** @description Logging function */
+  logger?: (msg: string) => void;
 };
 
 export type CircuitOptions = {
@@ -53,8 +54,14 @@ export class Barretenberg extends BarretenbergApi {
   static async new(options: BackendOptions = {}) {
     const worker = createMainWorker();
     const wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
-    const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath);
-    await wasm.init(module, threads, proxy(debug), options.memory?.initial, options.memory?.maximum);
+    const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath, options.logger);
+    await wasm.init(
+      module,
+      threads,
+      proxy(options.logger ?? createDebug('bb.js:bb_wasm_async')),
+      options.memory?.initial,
+      options.memory?.maximum,
+    );
     return new Barretenberg(worker, wasm, options);
   }
 
@@ -63,7 +70,7 @@ export class Barretenberg extends BarretenbergApi {
   }
 
   async initSRSForCircuitSize(circuitSize: number): Promise<void> {
-    const crs = await Crs.new(circuitSize + 1, this.options.crsPath);
+    const crs = await Crs.new(circuitSize + 1, this.options.crsPath, this.options.logger);
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/1129): Do slab allocator initialization?
     // await this.commonInitSlabAllocator(circuitSize);
     await this.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
@@ -71,8 +78,8 @@ export class Barretenberg extends BarretenbergApi {
 
   async initSRSClientIVC(): Promise<void> {
     // crsPath can be undefined
-    const crs = await Crs.new(2 ** 20 + 1, this.options.crsPath);
-    const grumpkinCrs = await GrumpkinCrs.new(2 ** 16 + 1, this.options.crsPath);
+    const crs = await Crs.new(2 ** 20 + 1, this.options.crsPath, this.options.logger);
+    const grumpkinCrs = await GrumpkinCrs.new(2 ** 16 + 1, this.options.crsPath, this.options.logger);
 
     // Load CRS into wasm global CRS state.
     // TODO: Make RawBuffer be default behavior, and have a specific Vector type for when wanting length prefixed.
@@ -100,16 +107,16 @@ export class BarretenbergSync extends BarretenbergApiSync {
     super(wasm);
   }
 
-  private static async new(wasmPath?: string) {
+  private static async new(wasmPath?: string, logger: (msg: string) => void = createDebug('bb.js:bb_wasm_sync')) {
     const wasm = new BarretenbergWasmMain();
-    const { module, threads } = await fetchModuleAndThreads(1, wasmPath);
-    await wasm.init(module, threads);
+    const { module, threads } = await fetchModuleAndThreads(1, wasmPath, logger);
+    await wasm.init(module, threads, logger);
     return new BarretenbergSync(wasm);
   }
 
-  static async initSingleton(wasmPath?: string) {
+  static async initSingleton(wasmPath?: string, logger: (msg: string) => void = createDebug('bb.js:bb_wasm_sync')) {
     if (!barrentenbergSyncSingletonPromise) {
-      barrentenbergSyncSingletonPromise = BarretenbergSync.new(wasmPath);
+      barrentenbergSyncSingletonPromise = BarretenbergSync.new(wasmPath, logger);
     }
 
     barretenbergSyncSingleton = await barrentenbergSyncSingletonPromise;

package/src/barretenberg_api/index.ts

@@ -12,6 +12,26 @@ import {
   OutputType,
 } from '../serialize/index.js';
 import { Fr, Fq, Point, Buffer32, Buffer128, Ptr } from '../types/index.js';
+function parseBigEndianU32Array(buffer: Uint8Array, hasSizePrefix = false): number[] {
+  const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+
+  let offset = 0;
+  let count = buffer.byteLength >>> 2; // default is entire buffer length / 4
+
+  if (hasSizePrefix) {
+    // Read the first 4 bytes as the size (big-endian).
+    count = dv.getUint32(0, /* littleEndian= */ false);
+    offset = 4;
+  }
+
+  const out: number[] = new Array(count);
+  for (let i = 0; i < count; i++) {
+    out[i] = dv.getUint32(offset, false);
+    offset += 4;
+  }
+
+  return out;
+}
 
 export class BarretenbergApi {
   constructor(protected wasm: BarretenbergWasmWorker | BarretenbergWasmMain) {}
@@ -357,6 +377,21 @@ export class BarretenbergApi {
     return out as [number, number];
   }
 
+  async acirGatesAztecClient(
+    // cf acirProveAztecClient
+    acirVec: Uint8Array[],
+  ): Promise<number[]> {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const resultBuffer = await this.wasm.callWasmExport(
+      'acir_gates_aztec_client',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+
+    return parseBigEndianU32Array(resultBuffer[0], /*hasSizePrefix=*/ true);
+  }
+
   async acirNewAcirComposer(sizeHint: number): Promise<Ptr> {
     const inArgs = [sizeHint].map(serializeBufferable);
     const outTypes: OutputType[] = [Ptr];

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -1,8 +1,6 @@
 import createDebug from 'debug';
 import { randomBytes } from '../../random/index.js';
 
-const debug = createDebug('bb.js:wasm');
-
 /**
  * Base implementation of BarretenbergWasm.
  * Contains code that is common to the "main thread" implementation and the "child thread" implementation.
@@ -11,7 +9,7 @@ export class BarretenbergWasmBase {
   protected memStore: { [key: string]: Uint8Array } = {};
   protected memory!: WebAssembly.Memory;
   protected instance!: WebAssembly.Instance;
-  protected logger: (msg: string) => void = debug;
+  protected logger: (msg: string) => void = createDebug('bb.js:bb_wasm_base');
 
   protected getImportObj(memory: WebAssembly.Memory) {
     /* eslint-disable camelcase */
@@ -51,9 +49,9 @@ export class BarretenbergWasmBase {
           const m = this.getMemory();
           const str2 = `${str} (mem: ${(m.length / (1024 * 1024)).toFixed(2)}MiB)`;
           this.logger(str2);
-          if (str2.startsWith('WARNING:')) {
-            this.logger(new Error().stack!);
-          }
+          // if (str2.startsWith('WARNING:')) {
+          //   this.logger(new Error().stack!);
+          // }
         },
 
         get_data: (keyAddr: number, outBufAddr: number) => {

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -7,8 +7,6 @@ import { type BarretenbergWasmThreadWorker } from '../barretenberg_wasm_thread/i
 import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
 import { HeapAllocator } from './heap_allocator.js';
 
-const debug = createDebug('bb.js:wasm');
-
 /**
  * This is the "main thread" implementation of BarretenbergWasm.
  * It spawns a bunch of "child thread" implementations.
@@ -31,7 +29,7 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   public async init(
     module: WebAssembly.Module,
     threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS),
-    logger: (msg: string) => void = debug,
+    logger: (msg: string) => void = createDebug('bb.js:bb_wasm'),
     initial = 32,
     maximum = 2 ** 16,
   ) {
@@ -42,9 +40,9 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     const shared = getSharedMemoryAvailable();
 
     this.logger(
-      `initial mem: ${initial} pages, ${initialMb}MiB. ` +
-        `max mem: ${maximum} pages, ${maxMb}MiB. ` +
-        `threads: ${threads}, shared: ${shared}`,
+      `Initializing bb wasm: initial memory ${initial} pages ${initialMb}MiB; ` +
+        `max memory: ${maximum} pages, ${maxMb}MiB; ` +
+        `threads: ${threads}; shared memory: ${shared}`,
     );
 
     this.memory = new WebAssembly.Memory({ initial, maximum, shared });
@@ -58,7 +56,7 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
 
     // Create worker threads. Create 1 less than requested, as main thread counts as a thread.
     if (threads > 1) {
-      this.logger(`creating ${threads} worker threads...`);
+      this.logger(`Creating ${threads} worker threads`);
       this.workers = await Promise.all(Array.from({ length: threads - 1 }).map(createThreadWorker));
       this.remoteWasms = await Promise.all(this.workers.map(getRemoteBarretenbergWasm<BarretenbergWasmThreadWorker>));
       await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory)));

package/src/barretenberg_wasm/fetch_code/browser/index.ts

@@ -6,7 +6,10 @@ export async function fetchCode(multithreaded: boolean, wasmPath?: string) {
   let url: string;
   if (wasmPath) {
     const suffix = multithreaded ? '-threads' : '';
-    url = `${wasmPath}/barretenberg${suffix}.wasm.gz`;
+    const filePath = wasmPath.split('/').slice(0, -1).join('/');
+    const fileNameWithExtensions = wasmPath.split('/').pop();
+    const [fileName, ...extensions] = fileNameWithExtensions!.split('.');
+    url = `${filePath}/${fileName}${suffix}.${extensions.join('.')}`;
   } else {
     url = multithreaded
       ? (await import(/* webpackIgnore: true */ './barretenberg-threads.js')).default

package/src/barretenberg_wasm/fetch_code/node/index.ts

@@ -15,7 +15,7 @@ function getCurrentDir() {
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function fetchCode(multithreaded: boolean, wasmPath?: string) {
-  const path = getCurrentDir() + '/../../barretenberg-threads.wasm.gz';
+  const path = wasmPath ?? getCurrentDir() + '/../../barretenberg-threads.wasm.gz';
   const compressedData = await readFile(path);
   const decompressedData = pako.ungzip(new Uint8Array(compressedData));
   return decompressedData.buffer;

package/src/barretenberg_wasm/index.test.ts

@@ -18,7 +18,7 @@ describe('barretenberg wasm', () => {
     const length = 1024;
     const ptr = await wasm.call('bbmalloc', length);
     const buf = Buffer.alloc(length, 128);
-    await wasm.writeMemory(ptr, buf);
+    await wasm.writeMemory(ptr, Uint8Array.from(buf));
     const result = Buffer.from(await wasm.getMemorySlice(ptr, ptr + length));
     await wasm.call('bbfree', ptr);
     expect(result).toStrictEqual(buf);
@@ -37,7 +37,7 @@ describe('barretenberg wasm', () => {
     const length = 1024;
     const ptr = await wasm.call('bbmalloc', length);
     const buf = Buffer.alloc(length, 128);
-    await wasm.writeMemory(ptr, buf);
+    await wasm.writeMemory(ptr, Uint8Array.from(buf));
     const result = Buffer.from(await wasm.getMemorySlice(ptr, ptr + length));
     await wasm.call('bbfree', ptr);
     expect(result).toStrictEqual(buf);

package/src/barretenberg_wasm/index.ts

@@ -5,29 +5,36 @@ import { getRemoteBarretenbergWasm, getSharedMemoryAvailable } from './helpers/n
 import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from './barretenberg_wasm_main/index.js';
 import { fetchCode } from './fetch_code/index.js';
 
-const debug = createDebug('bb.js:wasm');
-
-export async function fetchModuleAndThreads(desiredThreads = 32, wasmPath?: string) {
+export async function fetchModuleAndThreads(
+  desiredThreads = 32,
+  wasmPath?: string,
+  logger: (msg: string) => void = createDebug('bb.js:fetch_mat'),
+) {
   const shared = getSharedMemoryAvailable();
 
-  const availableThreads = shared ? await getAvailableThreads() : 1;
+  const availableThreads = shared ? await getAvailableThreads(logger) : 1;
   // We limit the number of threads to 32 as we do not benefit from greater numbers.
   const limitedThreads = Math.min(desiredThreads, availableThreads, 32);
 
+  logger(`Fetching bb wasm from ${wasmPath ?? 'default location'}`);
   const code = await fetchCode(shared, wasmPath);
+  logger(`Compiling bb wasm of ${code.byteLength} bytes`);
   const module = await WebAssembly.compile(code);
+  logger('Compilation of bb wasm complete');
   return { module, threads: limitedThreads };
 }
 
-async function getAvailableThreads(): Promise<number> {
+async function getAvailableThreads(logger: (msg: string) => void): Promise<number> {
   if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
     return navigator.hardwareConcurrency;
   } else {
     try {
       const os = await import('os');
       return os.cpus().length;
-    } catch (e) {
-      debug(`Could not detect environment. Falling back to one thread.: {e}`);
+    } catch (e: any) {
+      logger(
+        `Could not detect environment to query number of threads. Falling back to one thread. Error: ${e.message ?? e}`,
+      );
       return 1;
     }
   }
@@ -38,11 +45,15 @@ export class BarretenbergWasm extends BarretenbergWasmMain {
    * Construct and initialize BarretenbergWasm within a Worker. Return both the worker and the wasm proxy.
    * Used when running in the browser, because we can't block the main thread.
    */
-  public static async new(desiredThreads?: number, wasmPath?: string) {
+  public static async new(
+    desiredThreads?: number,
+    wasmPath?: string,
+    logger: (msg: string) => void = createDebug('bb.js:bb_wasm_main'),
+  ) {
     const worker = createMainWorker();
     const wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
-    const { module, threads } = await fetchModuleAndThreads(desiredThreads, wasmPath);
-    await wasm.init(module, threads, proxy(debug));
+    const { module, threads } = await fetchModuleAndThreads(desiredThreads, wasmPath, logger);
+    await wasm.init(module, threads, proxy(logger));
     return { worker, wasm };
   }
 }

package/src/crs/net_crs.ts

@@ -1,3 +1,4 @@
+import { retry, makeBackoff } from '../retry/index.js';
 /**
  * Downloader for CRS from the web or local.
  */
@@ -28,12 +29,16 @@ export class NetCrs {
 
     const g1End = this.numPoints * 64 - 1;
 
-    const response = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g1.dat', {
-      headers: {
-        Range: `bytes=0-${g1End}`,
-      },
-      cache: 'force-cache',
-    });
+    const response = await retry(
+      () =>
+        fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g1.dat', {
+          headers: {
+            Range: `bytes=0-${g1End}`,
+          },
+          cache: 'force-cache',
+        }),
+      makeBackoff([5, 5, 5]),
+    );
 
     return (this.data = new Uint8Array(await response.arrayBuffer()));
   }
@@ -42,9 +47,13 @@ export class NetCrs {
    * Download the G2 points data.
    */
   async downloadG2Data() {
-    const response2 = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g2.dat', {
-      cache: 'force-cache',
-    });
+    const response2 = await retry(
+      () =>
+        fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g2.dat', {
+          cache: 'force-cache',
+        }),
+      makeBackoff([5, 5, 5]),
+    );
 
     return (this.g2Data = new Uint8Array(await response2.arrayBuffer()));
   }

package/src/crs/node/index.ts

@@ -4,16 +4,22 @@ import { stat } from 'fs/promises';
 import createDebug from 'debug';
 import { homedir } from 'os';
 
-const debug = createDebug('bb.js:crs');
-
 /**
  * Generic CRS finder utility class.
  */
 export class Crs {
-  constructor(public readonly numPoints: number, public readonly path: string) {}
-
-  static async new(numPoints: number, crsPath = homedir() + '/.bb-crs') {
-    const crs = new Crs(numPoints, crsPath);
+  constructor(
+    public readonly numPoints: number,
+    public readonly path: string,
+    private readonly logger: (msg: string) => void = createDebug('bb.js:crs'),
+  ) {}
+
+  static async new(
+    numPoints: number,
+    crsPath = homedir() + '/.bb-crs',
+    logger: (msg: string) => void = createDebug('bb.js:crs'),
+  ) {
+    const crs = new Crs(numPoints, crsPath, logger);
     await crs.init();
     return crs;
   }
@@ -29,11 +35,11 @@ export class Crs {
       .catch(() => 0);
 
     if (g1FileSize >= this.numPoints * 64 && g1FileSize % 64 == 0 && g2FileSize == 128) {
-      debug(`using cached crs of size: ${g1FileSize / 64}`);
+      this.logger(`Using cached CRS of size ${g1FileSize / 64}`);
       return;
     }
 
-    debug(`downloading crs of size: ${this.numPoints}`);
+    this.logger(`Downloading CRS of size ${this.numPoints} into ${this.path}`);
     const crs = new NetCrs(this.numPoints);
     await crs.init();
     writeFileSync(this.path + '/bn254_g1.dat', crs.getG1Data());
@@ -45,7 +51,9 @@ export class Crs {
    * @returns The points data.
    */
   getG1Data(): Uint8Array {
-    const length = this.numPoints * 64;
+    // Ensure length > 0, otherwise we might read a huge file.
+    // This is a backup.
+    const length = Math.max(this.numPoints, 1) * 64;
     const fd = openSync(this.path + '/bn254_g1.dat', 'r');
     const buffer = new Uint8Array(length);
     readSync(fd, buffer, 0, length, 0);
@@ -66,10 +74,18 @@ export class Crs {
  * Generic Grumpkin CRS finder utility class.
  */
 export class GrumpkinCrs {
-  constructor(public readonly numPoints: number, public readonly path: string) {}
-
-  static async new(numPoints: number, crsPath = homedir() + '/.bb-crs') {
-    const crs = new GrumpkinCrs(numPoints, crsPath);
+  constructor(
+    public readonly numPoints: number,
+    public readonly path: string,
+    private readonly logger: (msg: string) => void = createDebug('bb.js:crs'),
+  ) {}
+
+  static async new(
+    numPoints: number,
+    crsPath = homedir() + '/.bb-crs',
+    logger: (msg: string) => void = createDebug('bb.js:crs'),
+  ) {
+    const crs = new GrumpkinCrs(numPoints, crsPath, logger);
     await crs.init();
     return crs;
   }
@@ -82,11 +98,11 @@ export class GrumpkinCrs {
       .catch(() => 0);
 
     if (g1FileSize >= this.numPoints * 64 && g1FileSize % 64 == 0) {
-      debug(`using cached crs of size: ${g1FileSize / 64}`);
+      this.logger(`Using cached Grumpkin CRS of size ${g1FileSize / 64}`);
       return;
     }
 
-    debug(`downloading crs of size: ${this.numPoints}`);
+    this.logger(`Downloading Grumpkin CRS of size ${this.numPoints} into ${this.path}`);
     const crs = new NetGrumpkinCrs(this.numPoints);
     await crs.init();
     writeFileSync(this.path + '/grumpkin_g1.dat', crs.getG1Data());

package/src/examples/simple.test.ts

@@ -19,7 +19,7 @@ describe('simple', () => {
 
   afterAll(async () => {
     await api.destroy();
-  });
+  }, 10000);
 
   it('should construct 512k gate proof', async () => {
     const valid = await api.examplesSimpleCreateAndVerifyProof();