@aztec/bb.js 0.72.0 → 0.73.0-commit.117882ca3ed35a6df177e74f0b3d2f3e7c512184

package/dest/node-cjs/retry/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+export declare function backoffGenerator(): Generator<number, void, unknown>;
+/**
+ * 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.
+ */
+export declare function makeBackoff(retries: number[]): Generator<number, void, unknown>;
+/**
+ * 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.
+ */
+export declare function retry<Result>(fn: () => Promise<Result>, backoff?: Generator<number, void, unknown>): Promise<Result>;
+//# sourceMappingURL=index.d.ts.map

package/dest/node-cjs/retry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/retry/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAiB,gBAAgB,qCAMhC;AAED;;;;GAIG;AACH,wBAAiB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,oCAI7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,mCAAqB,mBAa1F"}

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.72.0",
+  "version": "0.73.0-commit.117882ca3ed35a6df177e74f0b3d2f3e7c512184",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/ts",
   "license": "MIT",
   "type": "module",
@@ -13,7 +13,9 @@
       "default": "./dest/node/index.js"
     }
   },
-  "bin": "./dest/node/main.js",
+  "bin": {
+    "bb.js": "dest/node/main.js"
+  },
   "files": [
     "src/",
     "dest/",
@@ -96,7 +98,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": "^4.15.0",

package/src/barretenberg/blake2s.test.ts

@@ -41,7 +41,7 @@ describe('blake2s sync', () => {
   let api: BarretenbergSync;
 
   beforeAll(async () => {
-    api = await BarretenbergSync.new();
+    api = await BarretenbergSync.initSingleton();
   });
 
   it('blake2s', () => {

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;
@@ -22,6 +20,9 @@ export type BackendOptions = {
 
   /** @description Path to download CRS files */
   crsPath?: string;
+
+  /** @description Path to download WASM files */
+  wasmPath?: string;
 };
 
 export type CircuitOptions = {
@@ -50,8 +51,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);
-    await wasm.init(module, threads, proxy(debug), options.memory?.initial, options.memory?.maximum);
+    const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath);
+    await wasm.init(
+      module,
+      threads,
+      proxy(createDebug('bb.js:bb_wasm_async')),
+      options.memory?.initial,
+      options.memory?.maximum,
+    );
     return new Barretenberg(worker, wasm, options);
   }
 
@@ -89,26 +96,28 @@ export class Barretenberg extends BarretenbergApi {
   }
 }
 
+let barrentenbergSyncSingletonPromise: Promise<BarretenbergSync>;
 let barretenbergSyncSingleton: BarretenbergSync;
-let barretenbergSyncSingletonPromise: Promise<BarretenbergSync>;
 
 export class BarretenbergSync extends BarretenbergApiSync {
   private constructor(wasm: BarretenbergWasmMain) {
     super(wasm);
   }
 
-  static async new() {
+  private static async new(wasmPath?: string) {
     const wasm = new BarretenbergWasmMain();
-    const { module, threads } = await fetchModuleAndThreads(1);
-    await wasm.init(module, threads);
+    const { module, threads } = await fetchModuleAndThreads(1, wasmPath);
+    await wasm.init(module, threads, createDebug('bb.js:bb_wasm_sync'));
     return new BarretenbergSync(wasm);
   }
 
-  static initSingleton() {
-    if (!barretenbergSyncSingletonPromise) {
-      barretenbergSyncSingletonPromise = BarretenbergSync.new().then(s => (barretenbergSyncSingleton = s));
+  static async initSingleton(wasmPath?: string) {
+    if (!barrentenbergSyncSingletonPromise) {
+      barrentenbergSyncSingletonPromise = BarretenbergSync.new(wasmPath);
     }
-    return barretenbergSyncSingletonPromise;
+
+    barretenbergSyncSingleton = await barrentenbergSyncSingletonPromise;
+    return barretenbergSyncSingleton;
   }
 
   static getSingleton() {
@@ -122,35 +131,3 @@ export class BarretenbergSync extends BarretenbergApiSync {
     return this.wasm;
   }
 }
-
-let barrentenbergLazySingleton: BarretenbergLazy;
-
-export class BarretenbergLazy extends BarretenbergApi {
-  private constructor(wasm: BarretenbergWasmMain) {
-    super(wasm);
-  }
-
-  private static async new() {
-    const wasm = new BarretenbergWasmMain();
-    const { module, threads } = await fetchModuleAndThreads(1);
-    await wasm.init(module, threads);
-    return new BarretenbergLazy(wasm);
-  }
-
-  static async getSingleton() {
-    if (!barrentenbergLazySingleton) {
-      barrentenbergLazySingleton = await BarretenbergLazy.new();
-    }
-    return barrentenbergLazySingleton;
-  }
-
-  getWasm() {
-    return this.wasm;
-  }
-}
-
-// If we're in ESM environment, use top level await. CJS users need to call it manually.
-// Need to ignore for cjs build.
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-await BarretenbergSync.initSingleton(); // POSTPROCESS ESM ONLY

package/src/barretenberg/pedersen.test.ts

@@ -6,7 +6,7 @@ describe('pedersen sync', () => {
   let api: BarretenbergSync;
 
   beforeAll(async () => {
-    api = await BarretenbergSync.new();
+    api = await BarretenbergSync.initSingleton();
   });
 
   it('pedersenHash', () => {

package/src/barretenberg/poseidon.test.ts

@@ -6,7 +6,7 @@ describe('poseidon sync', () => {
   let api: BarretenbergSync;
 
   beforeAll(async () => {
-    api = await BarretenbergSync.new();
+    api = await BarretenbergSync.initSingleton();
   });
 
   it('poseidonHash', () => {

package/src/barretenberg_api/index.ts

@@ -76,6 +76,18 @@ export class BarretenbergApi {
     return out[0];
   }
 
+  async poseidon2HashAccumulate(inputsBuffer: Fr[]): Promise<Fr> {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes: OutputType[] = [Fr];
+    const result = await this.wasm.callWasmExport(
+      'poseidon2_hash_accumulate',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
   async poseidon2Hashes(inputsBuffer: Fr[]): Promise<Fr> {
     const inArgs = [inputsBuffer].map(serializeBufferable);
     const outTypes: OutputType[] = [Fr];

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -1,7 +1,7 @@
 import createDebug from 'debug';
 import { randomBytes } from '../../random/index.js';
 
-const debug = createDebug('bb.js:wasm');
+const debug = createDebug('bb.js:bb_wasm_base');
 
 /**
  * Base implementation of BarretenbergWasm.
@@ -51,9 +51,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,7 +7,7 @@ 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');
+const debug = createDebug('bb.js:bb_wasm');
 
 /**
  * This is the "main thread" implementation of BarretenbergWasm.

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

@@ -4,9 +4,22 @@ import pako from 'pako';
 
 // Annoyingly the wasm declares if it's memory is shared or not. So now we need two wasms if we want to be
 // able to fallback on "non shared memory" situations.
-export async function fetchCode(multithreaded: boolean) {
-  const res = await fetch(multithreaded ? barretenbergThreadsModule : barretenbergModule);
-  const compressedData = await res.arrayBuffer();
-  const decompressedData = pako.ungzip(new Uint8Array(compressedData));
-  return decompressedData.buffer;
+export async function fetchCode(multithreaded: boolean, wasmPath?: string) {
+  let url = multithreaded ? barretenbergThreadsModule : barretenbergModule;
+  url = wasmPath ? `${wasmPath}/${/[^/]+(?=\/$|$)/.exec(url)?.[0]}` : url;
+  const res = await fetch(url);
+  const maybeCompressedData = await res.arrayBuffer();
+  const buffer = new Uint8Array(maybeCompressedData);
+  const isGzip =
+    // Check magic number
+    buffer[0] === 0x1f &&
+    buffer[1] === 0x8b &&
+    // Check compression method:
+    buffer[2] === 0x08;
+  if (isGzip) {
+    const decompressedData = pako.ungzip(buffer);
+    return decompressedData.buffer;
+  } else {
+    return buffer;
+  }
 }

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

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

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,17 +5,20 @@ 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');
+const fetchDebug = createDebug('bb.js:fetch_mat');
 
-export async function fetchModuleAndThreads(desiredThreads = 32) {
+export async function fetchModuleAndThreads(desiredThreads = 32, wasmPath?: string) {
   const shared = getSharedMemoryAvailable();
 
   const availableThreads = shared ? await getAvailableThreads() : 1;
   // We limit the number of threads to 32 as we do not benefit from greater numbers.
   const limitedThreads = Math.min(desiredThreads, availableThreads, 32);
 
-  const code = await fetchCode(shared);
+  fetchDebug('Fetching wasm...');
+  const code = await fetchCode(shared, wasmPath);
+  fetchDebug(`Compiling wasm of ${code.byteLength} bytes...`);
   const module = await WebAssembly.compile(code);
+  fetchDebug('Done.');
   return { module, threads: limitedThreads };
 }
 
@@ -27,7 +30,7 @@ async function getAvailableThreads(): Promise<number> {
       const os = await import('os');
       return os.cpus().length;
     } catch (e) {
-      debug(`Could not detect environment. Falling back to one thread.: {e}`);
+      fetchDebug(`Could not detect environment. Falling back to one thread.: {e}`);
       return 1;
     }
   }
@@ -38,11 +41,11 @@ 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) {
+  public static async new(desiredThreads?: number, wasmPath?: string) {
     const worker = createMainWorker();
     const wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
-    const { module, threads } = await fetchModuleAndThreads(desiredThreads);
-    await wasm.init(module, threads, proxy(debug));
+    const { module, threads } = await fetchModuleAndThreads(desiredThreads, wasmPath);
+    await wasm.init(module, threads, proxy(createDebug('bb.js:bb_wasm_main')));
     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

@@ -45,7 +45,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);

package/src/index.ts

@@ -3,11 +3,11 @@ export {
   BackendOptions,
   Barretenberg,
   BarretenbergSync,
-  BarretenbergLazy,
   BarretenbergVerifier,
   UltraPlonkBackend,
   UltraHonkBackend,
   AztecClientBackend,
 } from './barretenberg/index.js';
+
 export { RawBuffer, Fr } from './types/index.js';
 export { splitHonkProof, reconstructHonkProof, ProofData } from './proof/index.js';

package/src/main.ts

@@ -22,18 +22,18 @@ const debug = createDebug('bb.js');
 const MAX_ULTRAPLONK_CIRCUIT_SIZE_IN_WASM = 2 ** 19;
 const threads = +process.env.HARDWARE_CONCURRENCY! || undefined;
 
-function getBytecode(bytecodePath: string) {
+function getBytecode(bytecodePath: string): Uint8Array {
   const extension = bytecodePath.substring(bytecodePath.lastIndexOf('.') + 1);
 
   if (extension == 'json') {
     const encodedCircuit = JSON.parse(readFileSync(bytecodePath, 'utf8'));
     const decompressed = gunzipSync(Buffer.from(encodedCircuit.bytecode, 'base64'));
-    return decompressed;
+    return Uint8Array.from(decompressed);
   }
 
   const encodedCircuit = readFileSync(bytecodePath);
   const decompressed = gunzipSync(encodedCircuit);
-  return decompressed;
+  return Uint8Array.from(decompressed);
 }
 
 function base64ToUint8Array(base64: string) {
@@ -62,10 +62,10 @@ async function getGatesUltra(bytecodePath: string, recursive: boolean, honkRecur
   return total;
 }
 
-function getWitness(witnessPath: string) {
+function getWitness(witnessPath: string): Uint8Array {
   const data = readFileSync(witnessPath);
   const decompressed = gunzipSync(data);
-  return decompressed;
+  return Uint8Array.from(decompressed);
 }
 
 async function computeCircuitSize(bytecodePath: string, recursive: boolean, honkRecursion: boolean, api: Barretenberg) {
@@ -300,7 +300,7 @@ export async function gateCountUltra(bytecodePath: string, recursive: boolean, h
     const buffer = Buffer.alloc(8);
     buffer.writeBigInt64LE(BigInt(numberOfGates));
 
-    process.stdout.write(buffer);
+    process.stdout.write(Uint8Array.from(buffer));
   } finally {
     await api.destroy();
   }
@@ -310,7 +310,7 @@ export async function verify(proofPath: string, vkPath: string, crsPath: string)
   const { api, acirComposer } = await initLite(crsPath);
   try {
     await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
-    const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath));
+    const verified = await api.acirVerifyProof(acirComposer, Uint8Array.from(readFileSync(proofPath)));
     debug(`verified: ${verified}`);
     return verified;
   } finally {
@@ -406,7 +406,7 @@ export async function proofAsFields(proofPath: string, vkPath: string, outputPat
     const numPublicInputs = readFileSync(vkPath).readUint32BE(8);
     const proofAsFields = await api.acirSerializeProofIntoFields(
       acirComposer,
-      readFileSync(proofPath),
+      Uint8Array.from(readFileSync(proofPath)),
       numPublicInputs,
     );
     const jsonProofAsFields = JSON.stringify(proofAsFields.map(f => f.toString()));
@@ -521,7 +521,10 @@ export async function verifyUltraHonk(
     const acirVerifyUltraHonk = options?.keccak
       ? api.acirVerifyUltraKeccakHonk.bind(api)
       : api.acirVerifyUltraHonk.bind(api);
-    const verified = await acirVerifyUltraHonk(readFileSync(proofPath), new RawBuffer(readFileSync(vkPath)));
+    const verified = await acirVerifyUltraHonk(
+      Uint8Array.from(readFileSync(proofPath)),
+      new RawBuffer(readFileSync(vkPath)),
+    );
 
     debug(`verified: ${verified}`);
     return verified;
@@ -534,7 +537,7 @@ export async function proofAsFieldsUltraHonk(proofPath: string, outputPath: stri
   const { api } = await initLite(crsPath);
   try {
     debug('outputting proof as vector of fields');
-    const proofAsFields = await api.acirProofAsFieldsUltraHonk(readFileSync(proofPath));
+    const proofAsFields = await api.acirProofAsFieldsUltraHonk(Uint8Array.from(readFileSync(proofPath)));
     const jsonProofAsFields = JSON.stringify(proofAsFields.map(f => f.toString()));
 
     if (outputPath === '-') {

package/src/retry/index.ts

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+export 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)];
+  }
+}
+
+/**
+ * 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.
+ */
+export function* makeBackoff(retries: number[]) {
+  for (const retry of retries) {
+    yield retry;
+  }
+}
+
+/**
+ * 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.
+ */
+export async function retry<Result>(fn: () => Promise<Result>, backoff = backoffGenerator()) {
+  while (true) {
+    try {
+      return await fn();
+    } catch (err: any) {
+      const s = backoff.next().value;
+      if (s === undefined) {
+        throw err;
+      }
+      await new Promise(resolve => setTimeout(resolve, s * 1000));
+      continue;
+    }
+  }
+}