@aztec/bb.js 0.72.1 → 0.73.0

package/src/barretenberg/index.ts

@@ -22,6 +22,9 @@ export type BackendOptions = {
 
   /** @description Path to download CRS files */
   crsPath?: string;
+
+  /** @description Path to download WASM files */
+  wasmPath?: string;
 };
 
 export type CircuitOptions = {
@@ -50,7 +53,7 @@ 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);
+    const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath);
     await wasm.init(module, threads, proxy(debug), options.memory?.initial, options.memory?.maximum);
     return new Barretenberg(worker, wasm, options);
   }
@@ -89,26 +92,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);
+    const { module, threads } = await fetchModuleAndThreads(1, wasmPath);
     await wasm.init(module, threads);
     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 +127,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/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.ts

@@ -7,14 +7,14 @@ import { fetchCode } from './fetch_code/index.js';
 
 const debug = createDebug('bb.js:wasm');
 
-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);
+  const code = await fetchCode(shared, wasmPath);
   const module = await WebAssembly.compile(code);
   return { module, threads: limitedThreads };
 }
@@ -38,10 +38,10 @@ 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);
+    const { module, threads } = await fetchModuleAndThreads(desiredThreads, wasmPath);
     await wasm.init(module, threads, proxy(debug));
     return { worker, wasm };
   }

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';