@aztec/bb.js 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/barretenberg/pedersen.test.ts

@@ -10,7 +10,8 @@ describe('pedersen sync', () => {
   });
 
   it('pedersenHash', () => {
-    const result = api.pedersenHash([new Fr(4n), new Fr(8n)], 7);
+    const response = api.pedersenHash({ inputs: [new Fr(4n).toBuffer(), new Fr(8n).toBuffer()], hashIndex: 7 });
+    const result = Fr.fromBuffer(response.hash);
     expect(result).toMatchSnapshot();
   });
 
@@ -19,34 +20,40 @@ describe('pedersen sync', () => {
     const fields = Array.from({ length: loops * 2 }).map(() => Fr.random());
     const t = new Timer();
     for (let i = 0; i < loops; ++i) {
-      api.pedersenHash([fields[i * 2], fields[i * 2 + 1]], 0);
+      api.pedersenHash({ inputs: [fields[i * 2].toBuffer(), fields[i * 2 + 1].toBuffer()], hashIndex: 0 });
     }
     const us = t.us() / loops;
     console.log(`Executed ${loops} hashes at an average ${us}us / hash`);
   });
 
-  it('pedersenHashes perf test', () => {
-    const loops = 10;
-    const numHashesPerLoop = 1024;
-    const fields = Array.from({ length: numHashesPerLoop * 2 }).map(() => Fr.random());
-    const t = new Timer();
-    for (let i = 0; i < loops; ++i) {
-      api.pedersenHashes(fields, 0);
-    }
-    const us = t.us() / (numHashesPerLoop * loops);
-    console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
-  });
+  // TODO: pedersenHashes not yet in new msgpack API
+  // it.skip('pedersenHashes perf test', () => {
+  //   const loops = 10;
+  //   const numHashesPerLoop = 1024;
+  //   const fields = Array.from({ length: numHashesPerLoop * 2 }).map(() => Fr.random());
+  //   const t = new Timer();
+  //   for (let i = 0; i < loops; ++i) {
+  //     // api.pedersenHashes(fields, 0); // Not in new API yet
+  //   }
+  //   const us = t.us() / (numHashesPerLoop * loops);
+  //   console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
+  // });
 
   it('pedersenHashBuffer', () => {
     const input = Buffer.alloc(123);
     input.writeUint32BE(321, 0);
     input.writeUint32BE(456, 119);
-    const r = api.pedersenHashBuffer(input, 0);
+    const response = api.pedersenHashBuffer({ input, hashIndex: 0 });
+    const r = Fr.fromBuffer(response.hash);
     expect(r).toMatchSnapshot();
   });
 
   it('pedersenCommit', () => {
-    const result = api.pedersenCommit([new Fr(4n), new Fr(8n), new Fr(12n)], 0);
+    const response = api.pedersenCommit({
+      inputs: [new Fr(4n).toBuffer(), new Fr(8n).toBuffer(), new Fr(12n).toBuffer()],
+      hashIndex: 0,
+    });
+    const result = { x: Fr.fromBuffer(response.point.x), y: Fr.fromBuffer(response.point.y) };
     expect(result).toMatchSnapshot();
   });
 
@@ -55,7 +62,7 @@ describe('pedersen sync', () => {
     const fields = Array.from({ length: loops * 2 }).map(() => Fr.random());
     const t = new Timer();
     for (let i = 0; i < loops; ++i) {
-      api.pedersenCommit([fields[i * 2], fields[i * 2 + 1]], 0);
+      api.pedersenCommit({ inputs: [fields[i * 2].toBuffer(), fields[i * 2 + 1].toBuffer()], hashIndex: 0 });
     }
     console.log(t.us() / loops);
   });

package/src/barretenberg/poseidon.bench.test.ts

@@ -0,0 +1,268 @@
+import { Barretenberg, BarretenbergSync } from '../index.js';
+import { Fr } from '../types/fields.js';
+import { serializeBufferable } from '../serialize/index.js';
+import { BarretenbergWasmMain } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import { BackendType } from './index.js';
+
+/**
+ * Async API benchmark test: WASM vs Native backends with proper non-blocking I/O
+ *
+ * This test uses the async Barretenberg API which properly handles:
+ * - Non-blocking I/O for native backend (event-based)
+ * - Concurrent operations via promises
+ * - Better performance for native backend compared to sync API
+ */
+describe('poseidon2Hash benchmark (Async API): WASM vs Native', () => {
+  const ITERATIONS = 10000;
+  const SIZES = [2, 4, 8];
+
+  let wasmApi: Barretenberg | null = null;
+  let nativeSocketApi: Barretenberg | null = null;
+  let nativeShmApi: Barretenberg | null = null;
+  let nativeShmSyncApi: BarretenbergSync | null = null;
+  let wasm: BarretenbergWasmMain;
+
+  beforeAll(async () => {
+    // Setup direct WASM access for baseline benchmark (always required)
+    wasm = new BarretenbergWasmMain();
+    const { module } = await fetchModuleAndThreads(1);
+    await wasm.init(module, 1);
+
+    // Setup WASM API
+    try {
+      wasmApi = await Barretenberg.new({ backend: BackendType.Wasm, threads: 1 });
+    } catch (error) {
+      console.warn('Failed to initialize WASM backend:', error instanceof Error ? error.message : String(error));
+    }
+
+    // Setup native socket API
+    try {
+      nativeSocketApi = await Barretenberg.new({ backend: BackendType.NativeUnixSocket, threads: 1 });
+    } catch (error) {
+      console.warn(
+        'Failed to initialize Native Socket backend:',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+
+    // Setup native shared memory API (async)
+    try {
+      nativeShmApi = await Barretenberg.new({ backend: BackendType.NativeSharedMemory, threads: 1 });
+    } catch (error) {
+      console.warn(
+        'Failed to initialize Native Shared Memory (async) backend:',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+
+    // Setup native shared memory API (sync)
+    try {
+      nativeShmSyncApi = await BarretenbergSync.new({ backend: BackendType.NativeSharedMemory, threads: 1 });
+    } catch (error) {
+      console.warn(
+        'Failed to initialize Native Shared Memory (sync) backend:',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }, 20000);
+
+  afterAll(async () => {
+    await wasm.destroy();
+    if (wasmApi) {
+      await wasmApi.destroy();
+    }
+    if (nativeSocketApi) {
+      await nativeSocketApi.destroy();
+    }
+    if (nativeShmApi) {
+      await nativeShmApi.destroy();
+    }
+    if (nativeShmSyncApi) {
+      nativeShmSyncApi.destroy();
+    }
+  });
+
+  async function directPoseidon2Hash(inputsBuffer: Fr[]): Promise<Fr> {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = wasm.callWasmExport(
+      'poseidon2_hash',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return Promise.resolve(out[0]);
+  }
+
+  it.each(SIZES)('benchmark with %p field elements', async size => {
+    // Generate random inputs
+    const inputs = Array(size)
+      .fill(0)
+      .map(() => Fr.random());
+
+    // Benchmark 1: Direct WASM (baseline - always available)
+    const directStart = performance.now();
+    for (let i = 0; i < ITERATIONS; i++) {
+      await directPoseidon2Hash(inputs);
+    }
+    const directTime = performance.now() - directStart;
+
+    // Benchmark 2: WASM (async)
+    let wasmTime = 0;
+    if (wasmApi) {
+      const wasmStart = performance.now();
+      for (let i = 0; i < ITERATIONS; i++) {
+        await wasmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      }
+      wasmTime = performance.now() - wasmStart;
+    }
+
+    // Benchmark 3: Native Socket (async with non-blocking I/O)
+    let nativeSocketTime = 0;
+    if (nativeSocketApi) {
+      const nativeSocketStart = performance.now();
+      for (let i = 0; i < ITERATIONS; i++) {
+        await nativeSocketApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      }
+      nativeSocketTime = performance.now() - nativeSocketStart;
+    }
+
+    // Benchmark 4: Native Shared Memory (async)
+    let nativeShmTime = 0;
+    if (nativeShmApi) {
+      const nativeShmStart = performance.now();
+      for (let i = 0; i < ITERATIONS; i++) {
+        await nativeShmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      }
+      nativeShmTime = performance.now() - nativeShmStart;
+    }
+
+    // Benchmark 5: Native Shared Memory (sync)
+    let nativeShmSyncTime = 0;
+    if (nativeShmSyncApi) {
+      const nativeShmSyncStart = performance.now();
+      for (let i = 0; i < ITERATIONS; i++) {
+        nativeShmSyncApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      }
+      nativeShmSyncTime = performance.now() - nativeShmSyncStart;
+    }
+
+    // Calculate metrics (all relative to WASM baseline)
+    const directOverhead = ((directTime - wasmTime) / wasmTime) * 100;
+    const nativeSocketOverhead = ((nativeSocketTime - wasmTime) / wasmTime) * 100;
+    const nativeShmOverhead = ((nativeShmTime - wasmTime) / wasmTime) * 100;
+    const nativeShmSyncOverhead = ((nativeShmSyncTime - wasmTime) / wasmTime) * 100;
+
+    const avgDirectTimeUs = (directTime / ITERATIONS) * 1000; // microseconds
+    const avgWasmTimeUs = (wasmTime / ITERATIONS) * 1000;
+    const avgNativeSocketTimeUs = (nativeSocketTime / ITERATIONS) * 1000;
+    const avgNativeShmTimeUs = (nativeShmTime / ITERATIONS) * 1000;
+    const avgNativeShmSyncTimeUs = (nativeShmSyncTime / ITERATIONS) * 1000;
+
+    process.stdout.write(`┌─ Size ${size.toString().padStart(3)} field elements ──────────────────────────────────┐\n`);
+    const formatOverhead = (overhead: number): string => {
+      const sign = overhead >= 0 ? '+' : '-';
+      const value = Math.abs(overhead).toFixed(1).padStart(6);
+      return `${sign}${value}%`;
+    };
+
+    if (wasmApi) {
+      process.stdout.write(
+        `│ WASM:               ${wasmTime.toFixed(2).padStart(8)}ms (${avgWasmTimeUs.toFixed(2).padStart(7)}µs/call) [baseline] │\n`,
+      );
+    } else {
+      process.stdout.write(`│ WASM:                                          unavailable │\n`);
+    }
+
+    process.stdout.write(
+      `│ Direct WASM:        ${directTime.toFixed(2).padStart(8)}ms (${avgDirectTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(directOverhead)}   │\n`,
+    );
+
+    if (nativeSocketApi) {
+      process.stdout.write(
+        `│ Native Socket:      ${nativeSocketTime.toFixed(2).padStart(8)}ms (${avgNativeSocketTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeSocketOverhead)}   │\n`,
+      );
+    } else {
+      process.stdout.write(`│ Native Socket:                                 unavailable │\n`);
+    }
+
+    if (nativeShmApi) {
+      process.stdout.write(
+        `│ Native Shared:      ${nativeShmTime.toFixed(2).padStart(8)}ms (${avgNativeShmTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmOverhead)}   │\n`,
+      );
+    } else {
+      process.stdout.write(`│ Native Shared:                                 unavailable │\n`);
+    }
+
+    if (nativeShmSyncApi) {
+      process.stdout.write(
+        `│ Native Shared Sync: ${nativeShmSyncTime.toFixed(2).padStart(8)}ms (${avgNativeShmSyncTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmSyncOverhead)}   │\n`,
+      );
+    } else {
+      process.stdout.write(`│ Native Shared Sync:                            unavailable │\n`);
+    }
+
+    process.stdout.write(`└────────────────────────────────────────────────────────────┘\n`);
+
+    // Sanity check: verify all backends produce same result as direct WASM
+    const directResult = await directPoseidon2Hash(inputs);
+
+    if (wasmApi) {
+      const wasmResult = await wasmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      expect(Buffer.from(wasmResult.hash)).toEqual(directResult.toBuffer());
+    }
+
+    if (nativeSocketApi) {
+      const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      expect(Buffer.from(nativeSocketResult.hash)).toEqual(directResult.toBuffer());
+    }
+
+    if (nativeShmApi) {
+      const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      expect(Buffer.from(nativeShmResult.hash)).toEqual(directResult.toBuffer());
+    }
+
+    if (nativeShmSyncApi) {
+      const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(directResult.toBuffer());
+    }
+
+    // Test always passes, this is just for measuring performance
+    expect(true).toBe(true);
+  });
+
+  const TEST_VECTORS = [1, 2, 3, 5, 10, 50, 100];
+  const NUM_RANDOM_TESTS = 10;
+
+  it.each(TEST_VECTORS)('produces identical results for %p field elements', async size => {
+    // Test with multiple random input vectors
+    for (let test = 0; test < NUM_RANDOM_TESTS; test++) {
+      const inputs = Array(size)
+        .fill(0)
+        .map(() => Fr.random());
+
+      const directResult = await directPoseidon2Hash(inputs);
+
+      if (wasmApi) {
+        const wasmResult = await wasmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+        expect(Buffer.from(wasmResult.hash)).toEqual(directResult.toBuffer());
+      }
+
+      if (nativeSocketApi) {
+        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+        expect(Buffer.from(nativeSocketResult.hash)).toEqual(directResult.toBuffer());
+      }
+
+      if (nativeShmApi) {
+        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+        expect(Buffer.from(nativeShmResult.hash)).toEqual(directResult.toBuffer());
+      }
+
+      if (nativeShmSyncApi) {
+        const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+        expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(directResult.toBuffer());
+      }
+    }
+  });
+});

package/src/barretenberg/poseidon.test.ts

@@ -10,30 +10,30 @@ describe('poseidon sync', () => {
   });
 
   it('poseidonHash', () => {
-    const result = api.poseidon2Hash([new Fr(4n), new Fr(8n)]);
+    const result = api.poseidon2Hash({ inputs: [new Fr(4n).toBuffer(), new Fr(8n).toBuffer()] });
     expect(result).toMatchSnapshot();
   });
 
   it('poseidonHash perf test', () => {
     const loops = 1000;
-    const fields = Array.from({ length: loops * 2 }).map(() => Fr.random());
+    const fields = Array.from({ length: loops * 2 }).map(() => Fr.random().toBuffer());
     const t = new Timer();
     for (let i = 0; i < loops; ++i) {
-      api.poseidon2Hash([fields[i * 2], fields[i * 2 + 1]]);
+      api.poseidon2Hash({ inputs: [fields[i * 2], fields[i * 2 + 1]] });
     }
     const us = t.us() / loops;
     console.log(`Executed ${loops} hashes at an average ${us}us / hash`);
   });
 
-  it('poseidonHashes perf test', () => {
-    const loops = 10;
-    const numHashesPerLoop = 1024;
-    const fields = Array.from({ length: numHashesPerLoop * 2 }).map(() => Fr.random());
-    const t = new Timer();
-    for (let i = 0; i < loops; ++i) {
-      api.poseidon2Hashes(fields);
-    }
-    const us = t.us() / (numHashesPerLoop * loops);
-    console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
-  });
+  // it('poseidonHashes perf test', () => {
+  //   const loops = 10;
+  //   const numHashesPerLoop = 1024;
+  //   const fields = Array.from({ length: numHashesPerLoop * 2 }).map(() => Fr.random());
+  //   const t = new Timer();
+  //   for (let i = 0; i < loops; ++i) {
+  //     api.poseidon2Hashes(fields);
+  //   }
+  //   const us = t.us() / (numHashesPerLoop * loops);
+  //   console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
+  // });
 });

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -121,12 +121,12 @@ export class BarretenbergWasmBase {
     mem.set(arr, offset);
   }
 
-  // PRIVATE METHODS
-
-  private getMemory() {
+  public getMemory() {
     return new Uint8Array(this.memory.buffer);
   }
 
+  // PRIVATE METHODS
+
   private stringFromAddress(addr: number) {
     addr = addr >>> 0;
     const m = this.getMemory();

package/src/barretenberg_wasm/barretenberg_wasm_main/heap_allocator.ts

@@ -5,25 +5,29 @@ import { type BarretenbergWasmMain } from './index.js';
  * 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.
+ * Input scratch grows UP from 0, output scratch grows DOWN from 1024, meeting in the middle.
+ * This maximizes space utilization while preventing overlap.
  */
 export class HeapAllocator {
   private allocs: number[] = [];
-  private inScratchRemaining = 1024;
-  private outScratchRemaining = 1024;
+  private inScratchPtr = 0; // Next input starts here, grows UP
+  private outScratchPtr = 1024; // Next output ends here, grows DOWN
 
   constructor(private wasm: BarretenbergWasmMain) {}
 
   getInputs(buffers: (Uint8Array | number)[]) {
     return buffers.map(bufOrNum => {
       if (typeof bufOrNum === 'object') {
-        if (bufOrNum.length <= this.inScratchRemaining) {
-          const ptr = (this.inScratchRemaining -= bufOrNum.length);
+        const size = bufOrNum.length;
+        // Check if there's room in scratch space (inputs grow up, outputs grow down)
+        if (this.inScratchPtr + size <= this.outScratchPtr) {
+          const ptr = this.inScratchPtr;
+          this.inScratchPtr += size; // Grow UP
           this.wasm.writeMemory(ptr, bufOrNum);
           return ptr;
         } else {
-          const ptr = this.wasm.call('bbmalloc', bufOrNum.length);
+          // Fall back to heap allocation
+          const ptr = this.wasm.call('bbmalloc', size);
           this.wasm.writeMemory(ptr, bufOrNum);
           this.allocs.push(ptr);
           return ptr;
@@ -40,9 +44,12 @@ export class HeapAllocator {
       // WARNING: 4 only works with WASM as it has 32 bit memory.
       const size = len || 4;
 
-      if (size <= this.outScratchRemaining) {
-        return (this.outScratchRemaining -= size);
+      // Check if there's room in scratch space (inputs grow up, outputs grow down)
+      if (this.inScratchPtr + size <= this.outScratchPtr) {
+        this.outScratchPtr -= size; // Grow DOWN
+        return this.outScratchPtr;
       } else {
+        // Fall back to heap allocation
         const ptr = this.wasm.call('bbmalloc', size);
         this.allocs.push(ptr);
         return ptr;
@@ -51,6 +58,7 @@ export class HeapAllocator {
   }
 
   addOutputPtr(ptr: number) {
+    // Only add to dealloc list if it's a heap allocation (not in scratch space 0-1023)
     if (ptr >= 1024) {
       this.allocs.push(ptr);
     }

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -19,6 +19,11 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   private nextWorker = 0;
   private nextThreadId = 1;
 
+  // Pre-allocated scratch buffers for msgpack I/O to avoid malloc/free overhead
+  private msgpackInputScratch: number = 0; // 8MB input buffer
+  private msgpackOutputScratch: number = 0; // 8MB output buffer
+  private readonly MSGPACK_SCRATCH_SIZE = 1024 * 1024 * 8; // 8MB
+
   public getNumThreads() {
     return this.workers.length + 1;
   }
@@ -30,7 +35,7 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     module: WebAssembly.Module,
     threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS),
     logger: (msg: string) => void = createDebugLogger('bb_wasm'),
-    initial = 32,
+    initial = 33,
     maximum = this.getDefaultMaximumMemoryPages(),
   ) {
     this.logger = logger;
@@ -54,6 +59,14 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     // Init all global/static data.
     this.call('_initialize');
 
+    // Allocate dedicated msgpack scratch buffers (never freed, reused for all msgpack calls)
+    this.msgpackInputScratch = this.call('bbmalloc', this.MSGPACK_SCRATCH_SIZE);
+    this.msgpackOutputScratch = this.call('bbmalloc', this.MSGPACK_SCRATCH_SIZE);
+    this.logger(
+      `Allocated msgpack scratch buffers: ` +
+        `input @ ${this.msgpackInputScratch}, output @ ${this.msgpackOutputScratch} (${this.MSGPACK_SCRATCH_SIZE} bytes each)`,
+    );
+
     // Create worker threads. Create 1 less than requested, as main thread counts as a thread.
     if (threads > 1) {
       this.logger(`Creating ${threads} worker threads`);
@@ -138,25 +151,63 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   }
 
   cbindCall(cbind: string, inputBuffer: Uint8Array): any {
-    const outputSizePtr = this.call('bbmalloc', 4);
-    const outputMsgpackPtr = this.call('bbmalloc', 4);
+    const needsCustomInputBuffer = inputBuffer.length > this.MSGPACK_SCRATCH_SIZE;
+    let inputPtr: number;
+
+    if (needsCustomInputBuffer) {
+      // Allocate temporary buffer for oversized input
+      inputPtr = this.call('bbmalloc', inputBuffer.length);
+    } else {
+      // Use pre-allocated scratch buffer
+      inputPtr = this.msgpackInputScratch;
+    }
 
-    const inputPtr = this.call('bbmalloc', inputBuffer.length);
+    // Write input to buffer
     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);
-    };
+    // Setup output scratch buffer with IN-OUT parameter pattern:
+    // Reserve 8 bytes for metadata (pointer + size), rest is scratch data space
+    const METADATA_SIZE = 8;
+    const outputPtrLocation = this.msgpackOutputScratch;
+    const outputSizeLocation = this.msgpackOutputScratch + 4;
+    const scratchDataPtr = this.msgpackOutputScratch + METADATA_SIZE;
+    const scratchDataSize = this.MSGPACK_SCRATCH_SIZE - METADATA_SIZE;
+
+    // Get memory and create DataView for writing IN values
+    let mem = this.getMemory();
+    let view = new DataView(mem.buffer);
+
+    // Write IN values: provide scratch buffer pointer and size to C++
+    view.setUint32(outputPtrLocation, scratchDataPtr, true);
+    view.setUint32(outputSizeLocation, scratchDataSize, true);
+
+    // Call WASM
+    this.call(cbind, inputPtr, inputBuffer.length, outputPtrLocation, outputSizeLocation);
+
+    // Free custom input buffer if allocated
+    if (needsCustomInputBuffer) {
+      this.call('bbfree', inputPtr);
+    }
+
+    // Re-fetch memory after WASM call, as the buffer may have been detached if memory grew
+    mem = this.getMemory();
+    view = new DataView(mem.buffer);
+
+    // Read OUT values: C++ returns actual buffer pointer and size
+    const outputDataPtr = view.getUint32(outputPtrLocation, true);
+    const outputSize = view.getUint32(outputSizeLocation, true);
+
+    // Check if C++ used scratch (pointer unchanged) or allocated (pointer changed)
+    const usedScratch = outputDataPtr === scratchDataPtr;
+
+    // Copy output data from WASM memory
+    const encodedResult = this.getMemorySlice(outputDataPtr, outputDataPtr + outputSize);
+
+    // Only free if C++ allocated beyond scratch
+    if (!usedScratch) {
+      this.call('bbfree', outputDataPtr);
+    }
 
-    const encodedResult = this.getMemorySlice(
-      readPtr32(outputMsgpackPtr),
-      readPtr32(outputMsgpackPtr) + readPtr32(outputSizePtr),
-    );
-    this.call('bbfree', inputPtr);
-    this.call('bbfree', outputSizePtr);
-    this.call('bbfree', outputMsgpackPtr);
     return encodedResult;
   }
 }

package/src/barretenberg_wasm/index.test.ts

@@ -1,17 +1,23 @@
-import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from './barretenberg_wasm_main/index.js';
-import { Barretenberg } from '../index.js';
+import { createMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js';
+import { BarretenbergWasmMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { getRemoteBarretenbergWasm } from '../barretenberg_wasm/helpers/index.js';
+import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import { Worker } from 'worker_threads';
 
 describe('barretenberg wasm', () => {
-  let api: Barretenberg;
   let wasm: BarretenbergWasmMainWorker;
+  let worker: Worker;
 
   beforeAll(async () => {
-    api = await Barretenberg.new({ threads: 2 });
-    wasm = api.getWasm();
+    worker = await createMainWorker();
+    wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
+    const { module, threads } = await fetchModuleAndThreads(2);
+    await wasm.init(module, threads);
   }, 20000);
 
   afterAll(async () => {
-    await api.destroy();
+    await wasm.destroy();
+    await worker.terminate();
   });
 
   it('should new malloc, transfer and slice mem', async () => {
@@ -28,11 +34,6 @@ describe('barretenberg wasm', () => {
     await expect(() => wasm.call('test_abort')).rejects.toThrow();
   });
 
-  it('test c/c++ stdout/stderr', async () => {
-    // We're checking we don't crash, but you can manually confirm you see log lines handled by logstr.
-    await wasm.call('test_stdout_stderr');
-  });
-
   it('should new malloc, transfer and slice mem', async () => {
     const length = 1024;
     const ptr = await wasm.call('bbmalloc', length);

package/src/bb_backends/browser/index.ts

@@ -0,0 +1,50 @@
+import { BarretenbergWasmSyncBackend, BarretenbergWasmAsyncBackend } from '../wasm.js';
+import { Barretenberg, BarretenbergSync } from '../../barretenberg/index.js';
+import { BackendOptions, BackendType } from '../index.js';
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createAsyncBackend(
+  type: BackendType,
+  options: BackendOptions,
+  logger: (msg: string) => void,
+): Promise<Barretenberg> {
+  switch (type) {
+    case BackendType.Wasm:
+    case BackendType.WasmWorker: {
+      const useWorker = type === BackendType.WasmWorker;
+      logger(`Using WASM backend (worker: ${useWorker})`);
+      const wasm = await BarretenbergWasmAsyncBackend.new({
+        threads: options.threads,
+        wasmPath: options.wasmPath,
+        logger,
+        memory: options.memory,
+        useWorker,
+      });
+      return new Barretenberg(wasm, options);
+    }
+
+    default:
+      throw new Error(`Unknown backend type: ${type}`);
+  }
+}
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createSyncBackend(
+  type: BackendType,
+  options: BackendOptions,
+  logger: (msg: string) => void,
+): Promise<BarretenbergSync> {
+  switch (type) {
+    case BackendType.Wasm:
+      logger('Using WASM backend');
+      const wasm = await BarretenbergWasmSyncBackend.new(options.wasmPath, logger);
+      return new BarretenbergSync(wasm);
+
+    default:
+      throw new Error(`Backend ${type} not supported for BarretenbergSync`);
+  }
+}