@aztec/bb.js 0.0.1-alpha.0

package/src/barretenberg_api/schnorr.test.ts

@@ -0,0 +1,169 @@
+import { TextEncoder } from 'util';
+import { Buffer128, Buffer32, Fr, Point } from '../types/index.js';
+import { BarretenbergApiSync } from './index.js';
+import { newBarretenbergApiSync } from '../factory/index.js';
+
+describe('schnorr', () => {
+  const msg = Buffer.from(new TextEncoder().encode('The quick brown dog jumped over the lazy fox.'));
+  let api: BarretenbergApiSync;
+
+  beforeAll(async () => {
+    api = await newBarretenbergApiSync();
+    api.pedersenInit();
+  });
+
+  afterAll(async () => {
+    await api.destroy();
+  });
+
+  it('should verify signature', () => {
+    const pk = Fr.fromBuffer(
+      new Uint8Array([
+        0x0b, 0x9b, 0x3a, 0xde, 0xe6, 0xb3, 0xd8, 0x1b, 0x28, 0xa0, 0x88, 0x6b, 0x2a, 0x84, 0x15, 0xc7, 0xda, 0x31,
+        0x29, 0x1a, 0x5e, 0x96, 0xbb, 0x7a, 0x56, 0x63, 0x9e, 0x17, 0x7d, 0x30, 0x1b, 0xeb,
+      ]),
+    );
+    const pubKey = api.schnorrComputePublicKey(pk);
+    const [s, e] = api.schnorrConstructSignature(msg, pk);
+    const verified = api.schnorrVerifySignature(msg, pubKey, s, e);
+
+    expect(verified).toBe(true);
+  });
+
+  it('public key negation should work', () => {
+    const publicKeyStr =
+      '0x164f01b1011a1b292217acf53eef4d74f625f6e9bd5edfdb74c56fd81aafeebb21912735f9266a3719f61c1eb747ddee0cac9917f5c807485d356709b529b62c';
+    const publicKey = Point.fromString(publicKeyStr);
+    // hardcoded expected negated public key
+    const expectedInvertedStr =
+      '0x164f01b1011a1b292217acf53eef4d74f625f6e9bd5edfdb74c56fd81aafeebb0ed3273ce80b35f29e5a2997ca397a6f1b874f3083f16948e6ac8e8a3ad649d5';
+    const expectedInverted = Point.fromString(expectedInvertedStr);
+
+    // negate - should match expected negated key
+    const negatedPublicKey = api.schnorrNegatePublicKey(publicKey);
+    expect(negatedPublicKey.equals(expectedInverted)).toEqual(true);
+    // negate again - should be original public key now
+    expect(api.schnorrNegatePublicKey(negatedPublicKey).equals(publicKey)).toEqual(true);
+  });
+
+  it('should create + verify multi signature', () => {
+    // set up multisig accounts
+    const numSigners = 7;
+    const pks = [...Array(numSigners)].map(() => Fr.random());
+    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
+
+    // round one
+    const roundOnePublicOutputs: Buffer128[] = [];
+    const roundOnePrivateOutputs: Buffer128[] = [];
+    for (let i = 0; i < numSigners; ++i) {
+      const [publicOutput, privateOutput] = api.schnorrMultisigConstructSignatureRound1();
+      roundOnePublicOutputs.push(publicOutput);
+      roundOnePrivateOutputs.push(privateOutput);
+    }
+
+    // round two
+    const roundTwoOutputs = pks.map(
+      (pk, i) =>
+        api.schnorrMultisigConstructSignatureRound2(
+          msg,
+          pk,
+          roundOnePrivateOutputs[i],
+          pubKeys,
+          roundOnePublicOutputs,
+        )[0],
+    );
+
+    // generate signature
+    const [s, e] = api.schnorrMultisigCombineSignatures(msg, pubKeys, roundOnePublicOutputs, roundTwoOutputs)!;
+    const [combinedKey] = api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys);
+    expect(combinedKey).not.toEqual(Buffer.alloc(64));
+    const verified = api.schnorrVerifySignature(msg, combinedKey, s, e);
+    expect(verified).toBe(true);
+  });
+
+  it('should identify invalid multi signature', () => {
+    const pks = [...Array(3)].map(() => Fr.random());
+    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
+    const [combinedKey] = api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys);
+
+    const verified = api.schnorrVerifySignature(msg, combinedKey, Buffer32.random(), Buffer32.random());
+    expect(verified).toBe(false);
+  });
+
+  it('should not construct invalid multi signature', () => {
+    // set up multisig accounts
+    const numSigners = 7;
+    const pks = [...Array(numSigners)].map(() => Fr.random());
+    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
+
+    // round one
+    const roundOnePublicOutputs: Buffer128[] = [];
+    const roundOnePrivateOutputs: Buffer128[] = [];
+    for (let i = 0; i < numSigners; ++i) {
+      const [publicOutput, privateOutput] = api.schnorrMultisigConstructSignatureRound1();
+      roundOnePublicOutputs.push(publicOutput);
+      roundOnePrivateOutputs.push(privateOutput);
+    }
+
+    // round two
+    const roundTwoOutputs = pks.map(
+      (pk, i) =>
+        api.schnorrMultisigConstructSignatureRound2(
+          msg,
+          pk,
+          roundOnePrivateOutputs[i],
+          pubKeys,
+          roundOnePublicOutputs,
+        )[0],
+    );
+
+    // wrong number of data
+    {
+      expect(
+        api.schnorrMultisigCombineSignatures(
+          msg,
+          pubKeys.slice(0, -1),
+          roundOnePublicOutputs.slice(0, -1),
+          roundTwoOutputs.slice(0, -1),
+        )[2],
+      ).toBe(false);
+    }
+
+    // invalid round two output
+    {
+      const invalidOutputs = [...roundTwoOutputs];
+      invalidOutputs[1] = api.schnorrMultisigConstructSignatureRound2(
+        msg,
+        pks[2], // <- Wrong private key.
+        roundOnePrivateOutputs[1],
+        pubKeys,
+        roundOnePublicOutputs,
+      )[0];
+      expect(api.schnorrMultisigCombineSignatures(msg, pubKeys, roundOnePublicOutputs, invalidOutputs)[2]).toBe(false);
+    }
+
+    // contains duplicates
+    {
+      const invalidOutputs = [...roundTwoOutputs];
+      invalidOutputs[1] = roundTwoOutputs[2];
+      expect(api.schnorrMultisigCombineSignatures(msg, pubKeys, roundOnePublicOutputs, invalidOutputs)[2]).toBe(false);
+    }
+  });
+
+  it('should not create combined key from public keys containing invalid key', () => {
+    const pks = [...Array(5)].map(() => Fr.random());
+    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
+
+    // not a valid point
+    {
+      pubKeys[1] = new Buffer128(Buffer.alloc(128));
+      expect(api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys)[1]).toBe(false);
+    }
+
+    // contains duplicates
+    {
+      pubKeys[1] = pubKeys[2];
+      expect(api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys)[1]).toBe(false);
+    }
+  });
+});

package/src/barretenberg_binder/heap_allocator.ts

@@ -0,0 +1,62 @@
+import { Bufferable, serializeBufferable, OutputType } from '../serialize/index.js';
+import { BarretenbergWasm, BarretenbergWasmWorker } from '../barretenberg_wasm/barretenberg_wasm.js';
+import { asyncMap } from '../async_map/index.js';
+
+/**
+ * Keeps track of heap allocations so they can be easily freed.
+ * The WASM memory layout has 1024 bytes of unused "scratch" space at the start (addresses 0-1023).
+ * We can leverage this for IO rather than making expensive bb_malloc bb_free calls.
+ * Heap allocations will be created for input/output args that don't fit into the scratch space.
+ * 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 HeapAllocator {
+  private allocs: number[] = [];
+  private inScratchRemaining = 1024;
+  private outScratchRemaining = 1024;
+
+  constructor(private wasm: BarretenbergWasm | BarretenbergWasmWorker) {}
+
+  async copyToMemory(bufferable: Bufferable[]) {
+    return await asyncMap(bufferable.map(serializeBufferable), async buf => {
+      if (buf.length <= this.inScratchRemaining) {
+        const ptr = (this.inScratchRemaining -= buf.length);
+        await this.wasm.writeMemory(ptr, buf);
+        return ptr;
+      } else {
+        const ptr = await this.wasm.call('bbmalloc', buf.length);
+        await this.wasm.writeMemory(ptr, buf);
+        this.allocs.push(ptr);
+        return ptr;
+      }
+    });
+  }
+
+  async getOutputPtrs(objs: OutputType[]) {
+    return await asyncMap(objs, async obj => {
+      // 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;
+
+      if (size <= this.outScratchRemaining) {
+        return (this.outScratchRemaining -= size);
+      } else {
+        const ptr = await this.wasm.call('bbmalloc', size);
+        this.allocs.push(ptr);
+        return ptr;
+      }
+    });
+  }
+
+  addOutputPtr(ptr: number) {
+    if (ptr >= 1024) {
+      this.allocs.push(ptr);
+    }
+  }
+
+  async freeAll() {
+    for (const ptr of this.allocs) {
+      await this.wasm.call('bbfree', ptr);
+    }
+  }
+}

package/src/barretenberg_binder/heap_allocator_sync.ts

@@ -0,0 +1,61 @@
+import { Bufferable, serializeBufferable, OutputType } from '../serialize/index.js';
+import { BarretenbergWasm } from '../barretenberg_wasm/barretenberg_wasm.js';
+
+/**
+ * Keeps track of heap allocations so they can be easily freed.
+ * The WASM memory layout has 1024 bytes of unused "scratch" space at the start (addresses 0-1023).
+ * We can leverage this for IO rather than making expensive bb_malloc bb_free calls.
+ * Heap allocations will be created for input/output args that don't fit into the scratch space.
+ * 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 {
+  private allocs: number[] = [];
+  private inScratchRemaining = 1024;
+  private outScratchRemaining = 1024;
+
+  constructor(private wasm: BarretenbergWasm) {}
+
+  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;
+      } else {
+        const ptr = this.wasm.call('bbmalloc', buf.length);
+        this.wasm.writeMemory(ptr, buf);
+        this.allocs.push(ptr);
+        return ptr;
+      }
+    });
+  }
+
+  getOutputPtrs(objs: OutputType[]) {
+    return objs.map(obj => {
+      // 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;
+
+      if (size <= this.outScratchRemaining) {
+        return (this.outScratchRemaining -= size);
+      } else {
+        const ptr = this.wasm.call('bbmalloc', size);
+        this.allocs.push(ptr);
+        return ptr;
+      }
+    });
+  }
+
+  addOutputPtr(ptr: number) {
+    if (ptr >= 1024) {
+      this.allocs.push(ptr);
+    }
+  }
+
+  freeAll() {
+    for (const ptr of this.allocs) {
+      this.wasm.call('bbfree', ptr);
+    }
+  }
+}

package/src/barretenberg_binder/index.ts

@@ -0,0 +1,76 @@
+import { BarretenbergWasm, BarretenbergWasmWorker } from '../barretenberg_wasm/barretenberg_wasm.js';
+import { HeapAllocator } from './heap_allocator.js';
+import { Bufferable, OutputType } from '../serialize/index.js';
+import { asyncMap } from '../async_map/index.js';
+import { HeapAllocatorSync } from './heap_allocator_sync.js';
+
+/**
+ * Calls a WASM export function, handles allocating/freeing of memory, and serializing/deserializing to types.
+ *
+ * Notes on function binding ABI:
+ * All functions can have an arbitrary number of input and output args.
+ * All arguments must be pointers.
+ * Input args are determined by being const or pointer to const.
+ * Output args must come after input args.
+ * All input data is big-endian.
+ * All output data is big-endian, except output heap alloc pointers.
+ * As integer types are converted to/from big-endian form, we shouldn't have to worry about memory alignment. (SURE?)
+ * All functions should return void.
+ * This binding function is responsible for allocating argument memory (including output memory).
+ * Variable length output args are allocated on the heap, and the resulting pointer is written to the output arg ptr,
+ * hence the above statement remains true.
+ * Binding will free any variable length output args that were allocated on the heap.
+ */
+export class BarretenbergBinder {
+  constructor(public wasm: BarretenbergWasm | BarretenbergWasmWorker) {}
+
+  async callWasmExport(funcName: string, inArgs: Bufferable[], outTypes: OutputType[]) {
+    const alloc = new HeapAllocator(this.wasm);
+    const inPtrs = await alloc.copyToMemory(inArgs);
+    const outPtrs = await alloc.getOutputPtrs(outTypes);
+    await this.wasm.call(funcName, ...inPtrs, ...outPtrs);
+    const outArgs = this.deserializeOutputArgs(outTypes, outPtrs, alloc);
+    await alloc.freeAll();
+    return outArgs;
+  }
+
+  private deserializeOutputArgs(outTypes: OutputType[], outPtrs: number[], alloc: HeapAllocator) {
+    return asyncMap(outTypes, async (t, i) => {
+      if (t.SIZE_IN_BYTES) {
+        const slice = await this.wasm.getMemorySlice(outPtrs[i], outPtrs[i] + t.SIZE_IN_BYTES);
+        return t.fromBuffer(slice);
+      }
+      const slice = await this.wasm.getMemorySlice(outPtrs[i], outPtrs[i] + 4);
+      const ptr = new DataView(slice.buffer, slice.byteOffset, slice.byteLength).getUint32(0, true);
+      alloc.addOutputPtr(ptr);
+      return t.fromBuffer(await this.wasm.getMemorySlice(ptr));
+    });
+  }
+}
+
+export class BarretenbergBinderSync {
+  constructor(public wasm: BarretenbergWasm) {}
+
+  callWasmExport(funcName: string, inArgs: Bufferable[], outTypes: OutputType[]) {
+    const alloc = new HeapAllocatorSync(this.wasm);
+    const inPtrs = alloc.copyToMemory(inArgs);
+    const outPtrs = alloc.getOutputPtrs(outTypes);
+    this.wasm.call(funcName, ...inPtrs, ...outPtrs);
+    const outArgs = this.deserializeOutputArgs(outTypes, outPtrs, alloc);
+    alloc.freeAll();
+    return outArgs;
+  }
+
+  private deserializeOutputArgs(outTypes: OutputType[], outPtrs: number[], alloc: HeapAllocatorSync) {
+    return outTypes.map((t, i) => {
+      if (t.SIZE_IN_BYTES) {
+        const slice = this.wasm.getMemorySlice(outPtrs[i], outPtrs[i] + t.SIZE_IN_BYTES);
+        return t.fromBuffer(slice);
+      }
+      const slice = this.wasm.getMemorySlice(outPtrs[i], outPtrs[i] + 4);
+      const ptr = new DataView(slice.buffer, slice.byteOffset, slice.byteLength).getUint32(0, true);
+      alloc.addOutputPtr(ptr);
+      return t.fromBuffer(this.wasm.getMemorySlice(ptr));
+    });
+  }
+}

package/src/barretenberg_wasm/barretenberg_wasm.test.ts

@@ -0,0 +1,52 @@
+import { type Worker } from 'worker_threads';
+import { BarretenbergWasm, BarretenbergWasmWorker } from './barretenberg_wasm.js';
+
+describe('barretenberg wasm', () => {
+  let wasm!: BarretenbergWasm;
+
+  beforeAll(async () => {
+    wasm = await BarretenbergWasm.new();
+  });
+
+  afterAll(async () => {
+    await wasm.destroy();
+  });
+
+  it('should new malloc, transfer and slice mem', () => {
+    const length = 1024;
+    const ptr = wasm.call('bbmalloc', length);
+    const buf = Buffer.alloc(length, 128);
+    wasm.writeMemory(ptr, buf);
+    const result = Buffer.from(wasm.getMemorySlice(ptr, ptr + length));
+    wasm.call('bbfree', ptr);
+    expect(result).toStrictEqual(buf);
+  });
+
+  it('test abort', () => {
+    expect(() => wasm.call('test_abort')).toThrow();
+  });
+});
+
+describe('barretenberg wasm worker', () => {
+  let worker!: Worker;
+  let wasm!: BarretenbergWasmWorker;
+
+  beforeAll(async () => {
+    ({ wasm, worker } = await BarretenbergWasm.newWorker(2));
+  });
+
+  afterAll(async () => {
+    await wasm.destroy();
+    await worker.terminate();
+  });
+
+  it('should new malloc, transfer and slice mem', async () => {
+    const length = 1024;
+    const ptr = await wasm.call('bbmalloc', length);
+    const buf = Buffer.alloc(length, 128);
+    await wasm.writeMemory(ptr, buf);
+    const result = Buffer.from(await wasm.getMemorySlice(ptr, ptr + length));
+    await wasm.call('bbfree', ptr);
+    expect(result).toStrictEqual(buf);
+  });
+});

package/src/barretenberg_wasm/barretenberg_wasm.ts

@@ -0,0 +1,222 @@
+import { type Worker } from 'worker_threads';
+import { EventEmitter } from 'events';
+import createDebug from 'debug';
+import { Remote, proxy } from 'comlink';
+import { randomBytes } from '../random/index.js';
+// Webpack config swaps this import with ./browser/index.js
+// You can toggle between these two imports to sanity check the type-safety.
+import { fetchCode, getNumCpu, createWorker, getRemoteBarretenbergWasm, threadLogger, killSelf } from './node/index.js';
+// import { fetchCode, getNumCpu, createWorker, randomBytes } from './browser/index.js';
+
+const debug = createDebug('bb.js:wasm');
+
+EventEmitter.defaultMaxListeners = 30;
+
+export class BarretenbergWasm {
+  static MAX_THREADS = 16;
+  private memory!: WebAssembly.Memory;
+  private instance!: WebAssembly.Instance;
+  private workers: Worker[] = [];
+  private remoteWasms: BarretenbergWasmWorker[] = [];
+  private nextWorker = 0;
+  private nextThreadId = 1;
+  private isThread = false;
+  private logger: (msg: string) => void = debug;
+
+  public static async new() {
+    const barretenberg = new BarretenbergWasm();
+    await barretenberg.init(1);
+    return barretenberg;
+  }
+
+  /**
+   * Construct and initialise 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 newWorker(threads?: number) {
+    const worker = createWorker();
+    const wasm = getRemoteBarretenbergWasm(worker);
+    await wasm.init(threads, proxy(debug));
+    return { worker, wasm };
+  }
+
+  public getNumThreads() {
+    return this.workers.length + 1;
+  }
+
+  /**
+   * Init as main thread. Spawn child threads.
+   */
+  public async init(
+    threads = Math.min(getNumCpu(), BarretenbergWasm.MAX_THREADS),
+    logger: (msg: string) => void = debug,
+    initial = 25,
+    maximum = 2 ** 16,
+  ) {
+    this.logger = logger;
+
+    const initialMb = (initial * 2 ** 16) / (1024 * 1024);
+    const maxMb = (maximum * 2 ** 16) / (1024 * 1024);
+    this.logger(
+      `initial mem: ${initial} pages, ${initialMb}MiB. ` +
+        `max mem: ${maximum} pages, ${maxMb}MiB. ` +
+        `threads: ${threads}`,
+    );
+
+    this.memory = new WebAssembly.Memory({ initial, maximum, shared: threads > 1 });
+
+    // 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.
+    const code = await fetchCode(threads > 1 ? 'barretenberg-threads.wasm' : 'barretenberg.wasm');
+    const { instance, module } = await WebAssembly.instantiate(code, 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.
+    this.logger('creating worker threads...');
+    this.workers = await Promise.all(Array.from({ length: threads - 1 }).map(createWorker));
+    this.remoteWasms = await Promise.all(this.workers.map(getRemoteBarretenbergWasm));
+    await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory)));
+    this.logger('init complete.');
+  }
+
+  /**
+   * Init as worker thread.
+   */
+  public async initThread(module: WebAssembly.Module, memory: WebAssembly.Memory) {
+    this.isThread = true;
+    this.logger = threadLogger() || this.logger;
+    this.memory = memory;
+    this.instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
+  }
+
+  /**
+   * Called on main thread. Signals child threads to gracefully exit.
+   */
+  public async destroy() {
+    await Promise.all(this.workers.map(w => w.terminate()));
+  }
+
+  private 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('HUNG: proc_exit was called. This is caused by unstable experimental wasi pthreads. Try again.');
+          this.logger(new Error().stack!);
+          killSelf();
+        },
+      },
+      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;
+        },
+      },
+
+      // 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: {
+        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;
+        },
+        /**
+         * 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);
+        },
+
+        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);
+      if (this.isThread) {
+        killSelf();
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  public memSize() {
+    return this.getMemory().length;
+  }
+
+  public getMemorySlice(start: number, end?: number) {
+    return this.getMemory().subarray(start, end);
+  }
+
+  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));
+  }
+}
+
+export type BarretenbergWasmWorker = Remote<BarretenbergWasm>;

package/src/barretenberg_wasm/browser/index.ts

@@ -0,0 +1,32 @@
+import { wrap } from 'comlink';
+import { BarretenbergWasmWorker, type BarretenbergWasm } from '../barretenberg_wasm.js';
+import debug from 'debug';
+
+export async function fetchCode(name: string) {
+  const res = await fetch('/' + name);
+  return await res.arrayBuffer();
+}
+
+export function createWorker() {
+  const worker = new Worker('barretenberg_wasm.js');
+  const debugStr = debug.disable();
+  debug.enable(debugStr);
+  worker.postMessage({ debug: debugStr });
+  return worker;
+}
+
+export function getRemoteBarretenbergWasm(worker: Worker): BarretenbergWasmWorker {
+  return wrap<BarretenbergWasm>(worker);
+}
+
+export function getNumCpu() {
+  return navigator.hardwareConcurrency;
+}
+
+export function threadLogger(): ((msg: string) => void) | undefined {
+  return undefined;
+}
+
+export function killSelf() {
+  self.close();
+}

package/src/barretenberg_wasm/browser/worker.ts

@@ -0,0 +1,13 @@
+import { expose } from 'comlink';
+import { BarretenbergWasm } from '../index.js';
+import debug from 'debug';
+
+self.onmessage = function (e) {
+  if (e.data.debug) {
+    debug.enable(e.data.debug);
+  }
+};
+
+expose(new BarretenbergWasm());
+
+self.postMessage({ ready: true });

package/src/barretenberg_wasm/index.ts

@@ -0,0 +1 @@
+export * from "./barretenberg_wasm.js";