@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-fake-ceab37513c

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -0,0 +1,138 @@
+import { createDebugLogger } from '../../log/index.js';
+import { randomBytes } from '../../random/index.js';
+
+/**
+ * Base implementation of BarretenbergWasm.
+ * Contains code that is common to the "main thread" implementation and the "child thread" implementation.
+ */
+export class BarretenbergWasmBase {
+  protected memStore: { [key: string]: Uint8Array } = {};
+  protected memory!: WebAssembly.Memory;
+  protected instance!: WebAssembly.Instance;
+  protected logger: (msg: string) => void = createDebugLogger('bb_wasm_base');
+
+  protected getImportObj(memory: WebAssembly.Memory) {
+    /* eslint-disable camelcase */
+    const importObj = {
+      // We need to implement a part of the wasi api:
+      // https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
+      // We literally only need to support random_get, everything else is noop implementated in barretenberg.wasm.
+      wasi_snapshot_preview1: {
+        random_get: (out: any, length: number) => {
+          out = out >>> 0;
+          const randomData = randomBytes(length);
+          const mem = this.getMemory();
+          mem.set(randomData, out);
+        },
+        clock_time_get: (a1: number, a2: number, out: number) => {
+          out = out >>> 0;
+          const ts = BigInt(new Date().getTime()) * 1000000n;
+          const view = new DataView(this.getMemory().buffer);
+          view.setBigUint64(out, ts, true);
+        },
+        proc_exit: () => {
+          this.logger('PANIC: proc_exit was called.');
+          throw new Error();
+        },
+      },
+
+      // These are functions implementations for imports we've defined are needed.
+      // The native C++ build defines these in a module called "env". We must implement TypeScript versions here.
+      env: {
+        /**
+         * The 'info' call we use for logging in C++, calls this under the hood.
+         * The native code will just print to std:err (to avoid std::cout which is used for IPC).
+         * Here we just emit the log line for the client to decide what to do with.
+         */
+        logstr: (addr: number) => {
+          const str = this.stringFromAddress(addr);
+          const m = this.getMemory();
+          const str2 = `${str} (mem: ${(m.length / (1024 * 1024)).toFixed(2)}MiB)`;
+          this.logger(str2);
+        },
+
+        throw_or_abort_impl: (addr: number) => {
+          const str = this.stringFromAddress(addr);
+          throw new Error(str);
+        },
+
+        get_data: (keyAddr: number, outBufAddr: number) => {
+          const key = this.stringFromAddress(keyAddr);
+          outBufAddr = outBufAddr >>> 0;
+          const data = this.memStore[key];
+          if (!data) {
+            this.logger(`get_data miss ${key}`);
+            return;
+          }
+          // this.logger(`get_data hit ${key} size: ${data.length} dest: ${outBufAddr}`);
+          // this.logger(Buffer.from(data.slice(0, 64)).toString('hex'));
+          this.writeMemory(outBufAddr, data);
+        },
+
+        set_data: (keyAddr: number, dataAddr: number, dataLength: number) => {
+          const key = this.stringFromAddress(keyAddr);
+          dataAddr = dataAddr >>> 0;
+          this.memStore[key] = this.getMemorySlice(dataAddr, dataAddr + dataLength);
+          // this.logger(`set_data: ${key} length: ${dataLength}`);
+        },
+
+        memory,
+      },
+    };
+    /* eslint-enable camelcase */
+
+    return importObj;
+  }
+
+  public exports(): any {
+    return this.instance.exports;
+  }
+
+  /**
+   * When returning values from the WASM, use >>> operator to convert signed representation to unsigned representation.
+   */
+  public call(name: string, ...args: any) {
+    if (!this.exports()[name]) {
+      throw new Error(`WASM function ${name} not found.`);
+    }
+    try {
+      return this.exports()[name](...args) >>> 0;
+    } catch (err: any) {
+      const message = `WASM function ${name} aborted, error: ${err}`;
+      this.logger(message);
+      this.logger(err.stack);
+      throw err;
+    }
+  }
+
+  public memSize() {
+    return this.getMemory().length;
+  }
+
+  /**
+   * Returns a copy of the data, not a view.
+   */
+  public getMemorySlice(start: number, end: number) {
+    return this.getMemory().subarray(start, end).slice();
+  }
+
+  public writeMemory(offset: number, arr: Uint8Array) {
+    const mem = this.getMemory();
+    mem.set(arr, offset);
+  }
+
+  // PRIVATE METHODS
+
+  private getMemory() {
+    return new Uint8Array(this.memory.buffer);
+  }
+
+  private stringFromAddress(addr: number) {
+    addr = addr >>> 0;
+    const m = this.getMemory();
+    let i = addr;
+    for (; m[i] !== 0; ++i);
+    const textDecoder = new TextDecoder('ascii');
+    return textDecoder.decode(m.slice(addr, i));
+  }
+}

package/src/barretenberg_wasm/barretenberg_wasm_main/factory/browser/index.ts

@@ -0,0 +1,11 @@
+import { logOptions } from '../../../../log/index.js';
+import { readinessListener } from '../../../helpers/browser/index.js';
+
+export async function createMainWorker() {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  const worker = new Worker(new URL('./main.worker.js', import.meta.url), { type: 'module' });
+  worker.postMessage({ log: logOptions });
+  await new Promise<void>(resolve => readinessListener(worker, resolve));
+  return worker;
+}

package/src/barretenberg_wasm/barretenberg_wasm_main/factory/browser/main.worker.ts

@@ -0,0 +1,13 @@
+import { expose } from 'comlink';
+import { BarretenbergWasmMain } from '../../index.js';
+import { Ready } from '../../../helpers/browser/index.js';
+import { initLogger } from '../../../../log/browser/index.js';
+
+addEventListener('message', e => {
+  if (e.data.log) {
+    initLogger(e.data.log);
+  }
+});
+
+expose(new BarretenbergWasmMain());
+postMessage(Ready);

package/src/barretenberg_wasm/barretenberg_wasm_main/factory/node/index.ts

@@ -0,0 +1,21 @@
+import { Worker } from 'worker_threads';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { logOptions } from '../../../../log/index.js';
+
+function getCurrentDir() {
+  if (typeof __dirname !== 'undefined') {
+    return __dirname;
+  } else {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return dirname(fileURLToPath(import.meta.url));
+  }
+}
+
+export function createMainWorker() {
+  const __dirname = getCurrentDir();
+  const worker = new Worker(__dirname + `/main.worker.js`);
+  worker.postMessage({ log: logOptions });
+  return Promise.resolve(worker);
+}

package/src/barretenberg_wasm/barretenberg_wasm_main/factory/node/main.worker.ts

@@ -0,0 +1,19 @@
+import { parentPort } from 'worker_threads';
+import { expose } from 'comlink';
+import { BarretenbergWasmMain } from '../../index.js';
+import { nodeEndpoint } from '../../../helpers/node/node_endpoint.js';
+import { initLogger } from '../../../../log/node/index.js';
+
+if (!parentPort) {
+  throw new Error('No parentPort');
+}
+
+const endpoint = nodeEndpoint(parentPort);
+
+endpoint.addEventListener('message', (e: any) => {
+  if (e.data.log) {
+    initLogger(e.data.log);
+  }
+});
+
+expose(new BarretenbergWasmMain(), nodeEndpoint(parentPort));

package/src/{barretenberg_binder/heap_allocator_sync.ts → barretenberg_wasm/barretenberg_wasm_main/heap_allocator.ts}

@@ -1,5 +1,4 @@
-import { Bufferable, serializeBufferable, OutputType } from '../serialize/index.js';
-import { BarretenbergWasm } from '../barretenberg_wasm/barretenberg_wasm.js';
+import { type BarretenbergWasmMain } from './index.js';
 
 /**
  * Keeps track of heap allocations so they can be easily freed.
@@ -9,33 +8,37 @@ import { BarretenbergWasm } from '../barretenberg_wasm/barretenberg_wasm.js';
  * Input and output args can use the same scratch space as it's assume all input reads will be performed before any
  * output writes are performed.
  */
-export class HeapAllocatorSync {
+export class HeapAllocator {
   private allocs: number[] = [];
   private inScratchRemaining = 1024;
   private outScratchRemaining = 1024;
 
-  constructor(private wasm: BarretenbergWasm) {}
+  constructor(private wasm: BarretenbergWasmMain) {}
 
-  copyToMemory(bufferable: Bufferable[]) {
-    return bufferable.map(serializeBufferable).map(buf => {
-      if (buf.length <= this.inScratchRemaining) {
-        const ptr = (this.inScratchRemaining -= buf.length);
-        this.wasm.writeMemory(ptr, buf);
-        return ptr;
+  getInputs(buffers: (Uint8Array | number)[]) {
+    return buffers.map(bufOrNum => {
+      if (typeof bufOrNum === 'object') {
+        if (bufOrNum.length <= this.inScratchRemaining) {
+          const ptr = (this.inScratchRemaining -= bufOrNum.length);
+          this.wasm.writeMemory(ptr, bufOrNum);
+          return ptr;
+        } else {
+          const ptr = this.wasm.call('bbmalloc', bufOrNum.length);
+          this.wasm.writeMemory(ptr, bufOrNum);
+          this.allocs.push(ptr);
+          return ptr;
+        }
       } else {
-        const ptr = this.wasm.call('bbmalloc', buf.length);
-        this.wasm.writeMemory(ptr, buf);
-        this.allocs.push(ptr);
-        return ptr;
+        return bufOrNum;
       }
     });
   }
 
-  getOutputPtrs(objs: OutputType[]) {
-    return objs.map(obj => {
+  getOutputPtrs(outLens: (number | undefined)[]) {
+    return outLens.map(len => {
       // If the obj is variable length, we need a 4 byte ptr to write the serialized data address to.
       // WARNING: 4 only works with WASM as it has 32 bit memory.
-      const size = obj.SIZE_IN_BYTES || 4;
+      const size = len || 4;
 
       if (size <= this.outScratchRemaining) {
         return (this.outScratchRemaining -= size);

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -0,0 +1,167 @@
+import { type Worker } from 'worker_threads';
+import { Remote } from 'comlink';
+import { getNumCpu, getRemoteBarretenbergWasm, getSharedMemoryAvailable } from '../helpers/index.js';
+import { createThreadWorker } from '../barretenberg_wasm_thread/factory/node/index.js';
+import { type BarretenbergWasmThreadWorker } from '../barretenberg_wasm_thread/index.js';
+import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
+import { HeapAllocator } from './heap_allocator.js';
+import { createDebugLogger } from '../../log/index.js';
+
+/**
+ * This is the "main thread" implementation of BarretenbergWasm.
+ * It spawns a bunch of "child thread" implementations.
+ * In a browser context, this still runs on a worker, as it will block waiting on child threads.
+ */
+export class BarretenbergWasmMain extends BarretenbergWasmBase {
+  static MAX_THREADS = 32;
+  private workers: Worker[] = [];
+  private remoteWasms: BarretenbergWasmThreadWorker[] = [];
+  private nextWorker = 0;
+  private nextThreadId = 1;
+
+  public getNumThreads() {
+    return this.workers.length + 1;
+  }
+
+  /**
+   * Init as main thread. Spawn child threads.
+   */
+  public async init(
+    module: WebAssembly.Module,
+    threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS),
+    logger: (msg: string) => void = createDebugLogger('bb_wasm'),
+    initial = 32,
+    maximum = this.getDefaultMaximumMemoryPages(),
+  ) {
+    this.logger = logger;
+
+    const initialMb = (initial * 2 ** 16) / (1024 * 1024);
+    const maxMb = (maximum * 2 ** 16) / (1024 * 1024);
+    const shared = getSharedMemoryAvailable();
+
+    this.logger(
+      `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 });
+
+    const instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
+
+    this.instance = instance;
+
+    // Init all global/static data.
+    this.call('_initialize');
+
+    // 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.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)));
+    }
+  }
+
+  private getDefaultMaximumMemoryPages(): number {
+    // iOS browser is very aggressive with memory. Check if running in browser and on iOS
+    // We at any rate expect the mobile iOS browser to kill us >=1GB, so we don't set a maximum higher than that.
+    if (typeof window !== 'undefined' && /iPad|iPhone/.test(navigator.userAgent)) {
+      return 2 ** 14;
+    }
+    return 2 ** 16;
+  }
+
+  /**
+   * Called on main thread. Signals child threads to gracefully exit.
+   */
+  public async destroy() {
+    await Promise.all(this.workers.map(w => w.terminate()));
+  }
+
+  protected getImportObj(memory: WebAssembly.Memory) {
+    const baseImports = super.getImportObj(memory);
+
+    /* eslint-disable camelcase */
+    return {
+      ...baseImports,
+      wasi: {
+        'thread-spawn': (arg: number) => {
+          arg = arg >>> 0;
+          const id = this.nextThreadId++;
+          const worker = this.nextWorker++ % this.remoteWasms.length;
+          // this.logger(`spawning thread ${id} on worker ${worker} with arg ${arg >>> 0}`);
+          this.remoteWasms[worker].call('wasi_thread_start', id, arg).catch(this.logger);
+          // this.remoteWasms[worker].postMessage({ msg: 'thread', data: { id, arg } });
+          return id;
+        },
+      },
+      env: {
+        ...baseImports.env,
+        env_hardware_concurrency: () => {
+          // If there are no workers (we're already running as a worker, or the main thread requested no workers)
+          // then we return 1, which should cause any algos using threading to just not create a thread.
+          return this.remoteWasms.length + 1;
+        },
+      },
+    };
+    /* eslint-enable camelcase */
+  }
+
+  callWasmExport(funcName: string, inArgs: (Uint8Array | number)[], outLens: (number | undefined)[]) {
+    const alloc = new HeapAllocator(this);
+    const inPtrs = alloc.getInputs(inArgs);
+    const outPtrs = alloc.getOutputPtrs(outLens);
+    this.call(funcName, ...inPtrs, ...outPtrs);
+    const outArgs = this.getOutputArgs(outLens, outPtrs, alloc);
+    alloc.freeAll();
+    return outArgs;
+  }
+
+  private getOutputArgs(outLens: (number | undefined)[], outPtrs: number[], alloc: HeapAllocator) {
+    return outLens.map((len, i) => {
+      if (len) {
+        return this.getMemorySlice(outPtrs[i], outPtrs[i] + len);
+      }
+      const slice = this.getMemorySlice(outPtrs[i], outPtrs[i] + 4);
+      const ptr = new DataView(slice.buffer, slice.byteOffset, slice.byteLength).getUint32(0, true);
+
+      // Add our heap buffer to the dealloc list.
+      alloc.addOutputPtr(ptr);
+
+      // The length will be found in the first 4 bytes of the buffer, big endian. See to_heap_buffer.
+      const lslice = this.getMemorySlice(ptr, ptr + 4);
+      const length = new DataView(lslice.buffer, lslice.byteOffset, lslice.byteLength).getUint32(0, false);
+
+      return this.getMemorySlice(ptr + 4, ptr + 4 + length);
+    });
+  }
+
+  cbindCall(cbind: string, inputBuffer: Uint8Array): any {
+    const outputSizePtr = this.call('bbmalloc', 4);
+    const outputMsgpackPtr = this.call('bbmalloc', 4);
+
+    const inputPtr = this.call('bbmalloc', inputBuffer.length);
+    this.writeMemory(inputPtr, inputBuffer);
+    this.call(cbind, inputPtr, inputBuffer.length, outputMsgpackPtr, outputSizePtr);
+
+    const readPtr32 = (ptr32: number) => {
+      const dataView = new DataView(this.getMemorySlice(ptr32, ptr32 + 4).buffer);
+      return dataView.getUint32(0, true);
+    };
+
+    const encodedResult = this.getMemorySlice(
+      readPtr32(outputMsgpackPtr),
+      readPtr32(outputMsgpackPtr) + readPtr32(outputSizePtr),
+    );
+    this.call('bbfree', inputPtr);
+    this.call('bbfree', outputSizePtr);
+    this.call('bbfree', outputMsgpackPtr);
+    return encodedResult;
+  }
+}
+
+/**
+ * The comlink type that asyncifies the BarretenbergWasmMain api.
+ */
+export type BarretenbergWasmMainWorker = Remote<BarretenbergWasmMain>;

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/index.ts

@@ -0,0 +1,11 @@
+import { logOptions } from '../../../../log/index.js';
+import { readinessListener } from '../../../helpers/browser/index.js';
+
+export async function createThreadWorker() {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  const worker = new Worker(new URL('./thread.worker.js', import.meta.url), { type: 'module' });
+  worker.postMessage({ log: logOptions });
+  await new Promise<void>(resolve => readinessListener(worker, resolve));
+  return worker;
+}

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/thread.worker.ts

@@ -0,0 +1,13 @@
+import { expose } from 'comlink';
+import { BarretenbergWasmThread } from '../../index.js';
+import { Ready } from '../../../helpers/browser/index.js';
+import { initLogger } from '../../../../log/browser/index.js';
+
+addEventListener('message', e => {
+  if (e.data.log) {
+    initLogger(e.data.log);
+  }
+});
+
+expose(new BarretenbergWasmThread());
+postMessage(Ready);

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/node/index.ts

@@ -0,0 +1,21 @@
+import { Worker } from 'worker_threads';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { logOptions } from '../../../../log/index.js';
+
+function getCurrentDir() {
+  if (typeof __dirname !== 'undefined') {
+    return __dirname;
+  } else {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return dirname(fileURLToPath(import.meta.url));
+  }
+}
+
+export function createThreadWorker() {
+  const __dirname = getCurrentDir();
+  const worker = new Worker(__dirname + `/thread.worker.js`);
+  worker.postMessage({ log: logOptions });
+  return Promise.resolve(worker);
+}

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/node/thread.worker.ts

@@ -0,0 +1,19 @@
+import { parentPort } from 'worker_threads';
+import { expose } from 'comlink';
+import { BarretenbergWasmThread } from '../../index.js';
+import { nodeEndpoint } from '../../../helpers/node/node_endpoint.js';
+import { initLogger } from '../../../../log/node/index.js';
+
+if (!parentPort) {
+  throw new Error('No parentPort');
+}
+
+const endpoint = nodeEndpoint(parentPort);
+
+endpoint.addEventListener('message', (e: any) => {
+  if (e.data.log) {
+    initLogger(e.data.log);
+  }
+});
+
+expose(new BarretenbergWasmThread(), endpoint);

package/src/barretenberg_wasm/barretenberg_wasm_thread/index.ts

@@ -0,0 +1,47 @@
+import { Remote } from 'comlink';
+import { killSelf, threadLogger } from '../helpers/index.js';
+import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
+
+export class BarretenbergWasmThread extends BarretenbergWasmBase {
+  /**
+   * Init as worker thread.
+   */
+  public async initThread(module: WebAssembly.Module, memory: WebAssembly.Memory) {
+    this.logger = threadLogger() || this.logger;
+    this.memory = memory;
+    this.instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
+  }
+
+  public destroy() {
+    killSelf();
+  }
+
+  protected getImportObj(memory: WebAssembly.Memory) {
+    const baseImports = super.getImportObj(memory);
+
+    /* eslint-disable camelcase */
+    return {
+      ...baseImports,
+      wasi: {
+        'thread-spawn': () => {
+          this.logger('PANIC: threads cannot spawn threads!');
+          this.logger(new Error().stack!);
+          killSelf();
+        },
+      },
+
+      // These are functions implementations for imports we've defined are needed.
+      // The native C++ build defines these in a module called "env". We must implement TypeScript versions here.
+      env: {
+        ...baseImports.env,
+        env_hardware_concurrency: () => {
+          // We return 1, which should cause any algos using threading to just not create a thread.
+          return 1;
+        },
+      },
+    };
+    /* eslint-enable camelcase */
+  }
+}
+
+export type BarretenbergWasmThreadWorker = Remote<BarretenbergWasmThread>;

package/src/barretenberg_wasm/fetch_code/browser/barretenberg-threads.ts

@@ -0,0 +1,3 @@
+import barretenbergThreadsModule from '../../barretenberg-threads.wasm.gz';
+
+export default barretenbergThreadsModule;

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

@@ -0,0 +1,3 @@
+import barretenbergModule from '../../barretenberg.wasm.gz';
+
+export default barretenbergModule;

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

@@ -0,0 +1,34 @@
+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, wasmPath?: string) {
+  let url: string;
+  if (wasmPath) {
+    const suffix = multithreaded ? '-threads' : '';
+    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('./barretenberg-threads.js')).default
+      : (await import('./barretenberg.js')).default;
+  }
+  const res = await fetch(url);
+  // Default bb wasm is compressed, but user could point it to a non-compressed version
+  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 as unknown as Uint8Array<ArrayBuffer>;
+  } else {
+    return buffer;
+  }
+}

package/src/barretenberg_wasm/fetch_code/index.ts

@@ -0,0 +1 @@
+export * from './node/index.js';

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

@@ -0,0 +1,34 @@
+import { readFile } from 'fs/promises';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import pako from 'pako';
+
+function getCurrentDir() {
+  if (typeof __dirname !== 'undefined') {
+    return __dirname;
+  } else {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return dirname(fileURLToPath(import.meta.url));
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function fetchCode(multithreaded: boolean, wasmPath?: string) {
+  const path = wasmPath ?? getCurrentDir() + '/../../barretenberg-threads.wasm.gz';
+  // Default bb wasm is compressed, but user could point it to a non-compressed version
+  const maybeCompressedData = await readFile(path);
+  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 as unknown as Uint8Array<ArrayBuffer>;
+  } else {
+    return buffer;
+  }
+}

package/src/barretenberg_wasm/fetch_code/wasm-module.d.ts

@@ -0,0 +1,4 @@
+declare module '*.wasm.gz' {
+  const content: string;
+  export default content;
+}