@aztec/bb.js 0.5.0 → 0.5.1

package/src/barretenberg_api/pedersen.test.ts

@@ -1,76 +1,77 @@
-import { newBarretenbergApiSync } from '../factory/index.js';
+import { Barretenberg } from '../barretenberg/index.js';
 import { Fr } from '../types/index.js';
-import { BarretenbergApiSync } from './index.js';
 
 describe('pedersen', () => {
-  let api: BarretenbergApiSync;
+  let api: Barretenberg;
 
   beforeAll(async () => {
-    api = await newBarretenbergApiSync();
-    api.pedersenHashInit();
-  });
+    api = await Barretenberg.new(1);
+    await api.pedersenHashInit();
+  }, 30000);
 
   afterAll(async () => {
     await api.destroy();
   });
 
-  it('pedersenCompressFields', () => {
-    const result = api.pedersenCompressFields(new Fr(4n), new Fr(8n));
+  it('pedersenCompressFields', async () => {
+    const result = await api.pedersenCompressFields(new Fr(4n), new Fr(8n));
     expect(result).toEqual(new Fr(16672613430297770667465722499387909817686322516130512258122141976728892914370n));
   });
 
-  it('pedersenPlookupCompressFields', () => {
-    const result = api.pedersenPlookupCompressFields(new Fr(4n), new Fr(8n));
+  it('pedersenPlookupCompressFields', async () => {
+    const result = await api.pedersenPlookupCompressFields(new Fr(4n), new Fr(8n));
     expect(result).toEqual(new Fr(21568810706345846819294487214368613840251909831689369685420108292337497444070n));
   });
 
-  it('pedersenCompress', () => {
-    const result = api.pedersenCompress([new Fr(4n), new Fr(8n), new Fr(12n)]);
+  it('pedersenCompress', async () => {
+    const result = await api.pedersenCompress([new Fr(4n), new Fr(8n), new Fr(12n)]);
     expect(result).toEqual(new Fr(20749503715308760529311051818180468653739005441229560405092292242074298877245n));
   });
 
-  it('pedersenPlookupCompress', () => {
-    const result = api.pedersenPlookupCompress([new Fr(4n), new Fr(8n), new Fr(12n)]);
+  it('pedersenPlookupCompress', async () => {
+    const result = await api.pedersenPlookupCompress([new Fr(4n), new Fr(8n), new Fr(12n)]);
     expect(result).toEqual(new Fr(4213911891650716450883144878301329379460622830501147795631256054071351353887n));
   });
 
-  it('pedersenCompressWithHashIndex', () => {
-    const result = api.pedersenCompressWithHashIndex([new Fr(4n), new Fr(8n)], 7);
+  it('pedersenCompressWithHashIndex', async () => {
+    const result = await api.pedersenCompressWithHashIndex([new Fr(4n), new Fr(8n)], 7);
     expect(result).toEqual(new Fr(11068631634751286805527305272746775861010877976108429785597565355072506728435n));
   });
 
-  it('pedersenCommit', () => {
-    const result = api.pedersenCommit([new Fr(4n), new Fr(8n), new Fr(12n)]);
+  it('pedersenCommit', async () => {
+    const result = await api.pedersenCommit([new Fr(4n), new Fr(8n), new Fr(12n)]);
     expect(result).toEqual(new Fr(20749503715308760529311051818180468653739005441229560405092292242074298877245n));
   });
 
-  it('pedersenPlookupCommit', () => {
-    const result = api.pedersenPlookupCommit([new Fr(4n), new Fr(8n)]);
+  it('pedersenPlookupCommit', async () => {
+    const result = await api.pedersenPlookupCommit([new Fr(4n), new Fr(8n)]);
     expect(result).toEqual(new Fr(21568810706345846819294487214368613840251909831689369685420108292337497444070n));
   });
 
-  it('pedersenBufferToField', () => {
-    const result = api.pedersenBufferToField(Buffer.from('Hello world! I am a buffer to be converted to a field!'));
+  it('pedersenBufferToField', async () => {
+    const result = await api.pedersenBufferToField(
+      Buffer.from('Hello world! I am a buffer to be converted to a field!'),
+    );
     expect(result).toEqual(new Fr(4923399520610513632896240312051201308554838580477778325691012985962614653619n));
   });
 
-  it('pedersenHashPair', () => {
-    const result = api.pedersenHashPair(new Fr(4n), new Fr(8n));
+  it('pedersenHashPair', async () => {
+    const result = await api.pedersenHashPair(new Fr(4n), new Fr(8n));
     expect(result).toEqual(new Fr(7508407170365331152493586290597472346478280823936748458450026785528968221772n));
   });
 
-  it('pedersenHashMultiple', () => {
-    const result = api.pedersenHashMultiple([new Fr(4n), new Fr(8n), new Fr(12n)]);
+  it('pedersenHashMultiple', async () => {
+    const result = await api.pedersenHashMultiple([new Fr(4n), new Fr(8n), new Fr(12n)]);
     expect(result).toEqual(new Fr(641613987782189905475142047603559162464012327378197326488471789040703504911n));
   });
 
-  it('pedersenHashMultipleWithHashIndex', () => {
-    const result = api.pedersenHashMultipleWithHashIndex([new Fr(4n), new Fr(8n)], 7);
+  it('pedersenHashMultipleWithHashIndex', async () => {
+    const result = await api.pedersenHashMultipleWithHashIndex([new Fr(4n), new Fr(8n)], 7);
     expect(result).toEqual(new Fr(14181105996307540196932058280391669339364159586581375348016341320932872505408n));
   });
 
-  it('pedersenHashToTree', () => {
-    const result = api.pedersenHashToTree([new Fr(4n), new Fr(8n), new Fr(12n), new Fr(16n)]);
+  it('pedersenHashToTree', async () => {
+    const result = await api.pedersenHashToTree([new Fr(4n), new Fr(8n), new Fr(12n), new Fr(16n)]);
     expect(result).toEqual([
       new Fr(4n),
       new Fr(8n),

package/src/barretenberg_api/schnorr.test.ts

@@ -1,36 +1,36 @@
 import { TextEncoder } from 'util';
 import { Buffer128, Buffer32, Fr, Point } from '../types/index.js';
-import { BarretenbergApiSync } from './index.js';
-import { newBarretenbergApiSync } from '../factory/index.js';
+import { Barretenberg } from '../barretenberg/index.js';
+import { asyncMap } from '../async_map/index.js';
 
 describe('schnorr', () => {
   const msg = Buffer.from(new TextEncoder().encode('The quick brown dog jumped over the lazy fox.'));
-  let api: BarretenbergApiSync;
+  let api: Barretenberg;
 
   beforeAll(async () => {
-    api = await newBarretenbergApiSync();
-    api.pedersenInit();
-  });
+    api = await Barretenberg.new(1);
+    await api.pedersenInit();
+  }, 30000);
 
   afterAll(async () => {
     await api.destroy();
   });
 
-  it('should verify signature', () => {
+  it('should verify signature', async () => {
     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);
+    const pubKey = await api.schnorrComputePublicKey(pk);
+    const [s, e] = await api.schnorrConstructSignature(msg, pk);
+    const verified = await api.schnorrVerifySignature(msg, pubKey, s, e);
 
     expect(verified).toBe(true);
   });
 
-  it('public key negation should work', () => {
+  it('public key negation should work', async () => {
     const publicKeyStr =
       '0x164f01b1011a1b292217acf53eef4d74f625f6e9bd5edfdb74c56fd81aafeebb21912735f9266a3719f61c1eb747ddee0cac9917f5c807485d356709b529b62c';
     const publicKey = Point.fromString(publicKeyStr);
@@ -40,91 +40,99 @@ describe('schnorr', () => {
     const expectedInverted = Point.fromString(expectedInvertedStr);
 
     // negate - should match expected negated key
-    const negatedPublicKey = api.schnorrNegatePublicKey(publicKey);
+    const negatedPublicKey = await 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);
+    expect((await api.schnorrNegatePublicKey(negatedPublicKey)).equals(publicKey)).toEqual(true);
   });
 
-  it('should create + verify multi signature', () => {
+  it('should create + verify multi signature', async () => {
     // set up multisig accounts
     const numSigners = 7;
     const pks = [...Array(numSigners)].map(() => Fr.random());
-    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
+    const pubKeys = await asyncMap(pks, pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
 
     // round one
     const roundOnePublicOutputs: Buffer128[] = [];
     const roundOnePrivateOutputs: Buffer128[] = [];
     for (let i = 0; i < numSigners; ++i) {
-      const [publicOutput, privateOutput] = api.schnorrMultisigConstructSignatureRound1();
+      const [publicOutput, privateOutput] = await api.schnorrMultisigConstructSignatureRound1();
       roundOnePublicOutputs.push(publicOutput);
       roundOnePrivateOutputs.push(privateOutput);
     }
 
     // round two
-    const roundTwoOutputs = pks.map(
-      (pk, i) =>
-        api.schnorrMultisigConstructSignatureRound2(
-          msg,
-          pk,
-          roundOnePrivateOutputs[i],
-          pubKeys,
-          roundOnePublicOutputs,
+    const roundTwoOutputs = await asyncMap(
+      pks,
+      async (pk, i) =>
+        (
+          await 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);
+    const [s, e] = await api.schnorrMultisigCombineSignatures(msg, pubKeys, roundOnePublicOutputs, roundTwoOutputs)!;
+    const [combinedKey] = await api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys);
     expect(combinedKey).not.toEqual(Buffer.alloc(64));
-    const verified = api.schnorrVerifySignature(msg, combinedKey, s, e);
+    const verified = await api.schnorrVerifySignature(msg, combinedKey, s, e);
     expect(verified).toBe(true);
   });
 
-  it('should identify invalid multi signature', () => {
+  it('should identify invalid multi signature', async () => {
     const pks = [...Array(3)].map(() => Fr.random());
-    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
-    const [combinedKey] = api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys);
+    const pubKeys = await asyncMap(pks, pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
+    const [combinedKey] = await api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys);
 
-    const verified = api.schnorrVerifySignature(msg, combinedKey, Buffer32.random(), Buffer32.random());
+    const verified = await api.schnorrVerifySignature(msg, combinedKey, Buffer32.random(), Buffer32.random());
     expect(verified).toBe(false);
   });
 
-  it('should not construct invalid multi signature', () => {
+  it('should not construct invalid multi signature', async () => {
     // set up multisig accounts
     const numSigners = 7;
     const pks = [...Array(numSigners)].map(() => Fr.random());
-    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
+    const pubKeys = await asyncMap(pks, pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
 
     // round one
     const roundOnePublicOutputs: Buffer128[] = [];
     const roundOnePrivateOutputs: Buffer128[] = [];
     for (let i = 0; i < numSigners; ++i) {
-      const [publicOutput, privateOutput] = api.schnorrMultisigConstructSignatureRound1();
+      const [publicOutput, privateOutput] = await api.schnorrMultisigConstructSignatureRound1();
       roundOnePublicOutputs.push(publicOutput);
       roundOnePrivateOutputs.push(privateOutput);
     }
 
     // round two
-    const roundTwoOutputs = pks.map(
-      (pk, i) =>
-        api.schnorrMultisigConstructSignatureRound2(
-          msg,
-          pk,
-          roundOnePrivateOutputs[i],
-          pubKeys,
-          roundOnePublicOutputs,
+    const roundTwoOutputs = await asyncMap(
+      pks,
+      async (pk, i) =>
+        (
+          await 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),
+        (
+          await api.schnorrMultisigCombineSignatures(
+            msg,
+            pubKeys.slice(0, -1),
+            roundOnePublicOutputs.slice(0, -1),
+            roundTwoOutputs.slice(0, -1),
+          )
         )[2],
       ).toBe(false);
     }
@@ -132,38 +140,44 @@ describe('schnorr', () => {
     // invalid round two output
     {
       const invalidOutputs = [...roundTwoOutputs];
-      invalidOutputs[1] = api.schnorrMultisigConstructSignatureRound2(
-        msg,
-        pks[2], // <- Wrong private key.
-        roundOnePrivateOutputs[1],
-        pubKeys,
-        roundOnePublicOutputs,
+      invalidOutputs[1] = (
+        await api.schnorrMultisigConstructSignatureRound2(
+          msg,
+          pks[2], // <- Wrong private key.
+          roundOnePrivateOutputs[1],
+          pubKeys,
+          roundOnePublicOutputs,
+        )
       )[0];
-      expect(api.schnorrMultisigCombineSignatures(msg, pubKeys, roundOnePublicOutputs, invalidOutputs)[2]).toBe(false);
+      expect((await 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);
+      expect((await api.schnorrMultisigCombineSignatures(msg, pubKeys, roundOnePublicOutputs, invalidOutputs))[2]).toBe(
+        false,
+      );
     }
   });
 
-  it('should not create combined key from public keys containing invalid key', () => {
+  it('should not create combined key from public keys containing invalid key', async () => {
     const pks = [...Array(5)].map(() => Fr.random());
-    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
+    const pubKeys = await asyncMap(pks, pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
 
     // not a valid point
     {
       pubKeys[1] = new Buffer128(Buffer.alloc(128));
-      expect(api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys)[1]).toBe(false);
+      expect((await api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys))[1]).toBe(false);
     }
 
     // contains duplicates
     {
       pubKeys[1] = pubKeys[2];
-      expect(api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys)[1]).toBe(false);
+      expect((await api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys))[1]).toBe(false);
     }
   });
 });

package/src/barretenberg_binder/heap_allocator.ts

@@ -1,5 +1,5 @@
 import { Bufferable, serializeBufferable, OutputType } from '../serialize/index.js';
-import { BarretenbergWasm, BarretenbergWasmWorker } from '../barretenberg_wasm/barretenberg_wasm.js';
+import { BarretenbergWasm, BarretenbergWasmWorker } from '../barretenberg_wasm/index.js';
 import { asyncMap } from '../async_map/index.js';
 
 /**

package/src/barretenberg_binder/index.ts

@@ -1,8 +1,10 @@
-import { BarretenbergWasm, BarretenbergWasmWorker } from '../barretenberg_wasm/barretenberg_wasm.js';
+import { BarretenbergWasm, BarretenbergWasmWorker } from '../barretenberg_wasm/index.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';
+// import createDebug from 'debug';
+
+// const debug = createDebug('bb.js:barretenberg_binder');
 
 /**
  * Calls a WASM export function, handles allocating/freeing of memory, and serializing/deserializing to types.
@@ -29,7 +31,7 @@ export class BarretenbergBinder {
     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);
+    const outArgs = await this.deserializeOutputArgs(outTypes, outPtrs, alloc);
     await alloc.freeAll();
     return outArgs;
   }
@@ -42,35 +44,16 @@ export class BarretenbergBinder {
       }
       const slice = await this.wasm.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);
-      return t.fromBuffer(await this.wasm.getMemorySlice(ptr));
-    });
-  }
-}
 
-export class BarretenbergBinderSync {
-  constructor(public wasm: BarretenbergWasm) {}
+      // The length will be found in the first 4 bytes of the buffer, big endian. See to_heap_buffer.
+      const lslice = await this.wasm.getMemorySlice(ptr, ptr + 4);
+      const length = new DataView(lslice.buffer, lslice.byteOffset, lslice.byteLength).getUint32(0, false);
 
-  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));
+      const buf = await this.wasm.getMemorySlice(ptr + 4, ptr + 4 + length);
+      return t.fromBuffer(buf);
     });
   }
 }

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -0,0 +1,136 @@
+import createDebug from 'debug';
+import { randomBytes } from '../../random/index.js';
+import { killSelf } from '../helpers/index.js';
+
+const debug = createDebug('bb.js:wasm');
+
+export class BarretenbergWasmBase {
+  protected memStore: { [key: string]: Uint8Array } = {};
+  protected memory!: WebAssembly.Memory;
+  protected instance!: WebAssembly.Instance;
+  protected logger: (msg: string) => void = debug;
+
+  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. This is maybe caused by "joining" with unstable wasi pthreads.');
+          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: {
+        /**
+         * 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);
+          if (str2.startsWith('WARNING:')) {
+            this.logger(new Error().stack!);
+          }
+        },
+
+        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,10 @@
+import debug from 'debug';
+import MainWorker from './main.worker.js';
+
+export function createMainWorker() {
+  const worker = new MainWorker();
+  const debugStr = debug.disable();
+  debug.enable(debugStr);
+  worker.postMessage({ debug: debugStr });
+  return worker;
+}

package/src/barretenberg_wasm/{browser/worker.ts → barretenberg_wasm_main/factory/browser/main.worker.ts}

@@ -1,5 +1,5 @@
 import { expose } from 'comlink';
-import { BarretenbergWasm } from '../index.js';
+import { BarretenbergWasmMain } from '../../index.js';
 import debug from 'debug';
 
 self.onmessage = function (e) {
@@ -8,6 +8,8 @@ self.onmessage = function (e) {
   }
 };
 
-expose(new BarretenbergWasm());
+expose(new BarretenbergWasmMain());
 
 self.postMessage({ ready: true });
+
+export default null as any;

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

@@ -0,0 +1,8 @@
+import { Worker } from 'worker_threads';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+export function createMainWorker() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return new Worker(__dirname + `/main.worker.js`);
+}

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

@@ -0,0 +1,10 @@
+import { parentPort } from 'worker_threads';
+import { expose } from 'comlink';
+import { BarretenbergWasmMain } from '../../index.js';
+import { nodeEndpoint } from '../../../helpers/node/node_endpoint.js';
+
+if (!parentPort) {
+  throw new Error('No parentPort');
+}
+
+expose(new BarretenbergWasmMain(), nodeEndpoint(parentPort));