@aztec/bb.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

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

@@ -0,0 +1,271 @@
+import { Barretenberg, BarretenbergSync } from '../index.js';
+import { BarretenbergWasmMain } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import { BackendType } from './index.js';
+import { Fr } from './testing/fields.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);
+
+  it.each(SIZES)(
+    'benchmark with %p field elements',
+    async size => {
+      // Generate random inputs
+      const inputs = Array(size)
+        .fill(0)
+        .map(() => Fr.random().toBuffer());
+
+      // Benchmark 1: WASM (async)
+      let wasmTime = 0;
+      if (wasmApi) {
+        const wasmStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          await wasmApi.poseidon2Hash({ inputs });
+        }
+        wasmTime = performance.now() - wasmStart;
+      }
+
+      // Benchmark 2: 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 });
+        }
+        nativeSocketTime = performance.now() - nativeSocketStart;
+      }
+
+      // Benchmark 3: Native Socket (async, request pipelined)
+      let nativeSocketPipelinedTime = 0;
+      if (nativeSocketApi) {
+        const nativeSocketPipelinedStart = performance.now();
+        // Use promise.all to pipeline requests
+        const promises = [];
+        for (let i = 0; i < ITERATIONS; i++) {
+          promises.push(nativeSocketApi.poseidon2Hash({ inputs }));
+        }
+        await Promise.all(promises);
+        nativeSocketPipelinedTime = performance.now() - nativeSocketPipelinedStart;
+      }
+
+      // 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 });
+        }
+        nativeShmTime = performance.now() - nativeShmStart;
+      }
+
+      // Benchmark 5: Native Shared Memory (async, request pipelined)
+      let nativeShmPipelinedTime = 0;
+      if (nativeShmApi) {
+        const nativeShmPipelinedStart = performance.now();
+        // Use promise.all to pipeline requests
+        const promises = [];
+        for (let i = 0; i < ITERATIONS; i++) {
+          promises.push(nativeShmApi.poseidon2Hash({ inputs }));
+        }
+        await Promise.all(promises);
+        nativeShmPipelinedTime = performance.now() - nativeShmPipelinedStart;
+      }
+
+      // Benchmark 6: Native Shared Memory (sync)
+      let nativeShmSyncTime = 0;
+      if (nativeShmSyncApi) {
+        const nativeShmSyncStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          nativeShmSyncApi.poseidon2Hash({ inputs });
+        }
+        nativeShmSyncTime = performance.now() - nativeShmSyncStart;
+      }
+
+      // Calculate metrics (all relative to WASM baseline)
+      const nativeSocketOverhead = ((nativeSocketTime - wasmTime) / wasmTime) * 100;
+      const nativeSocketPipelinedOverhead = ((nativeSocketPipelinedTime - wasmTime) / wasmTime) * 100;
+      const nativeShmOverhead = ((nativeShmTime - wasmTime) / wasmTime) * 100;
+      const nativeShmPipelinedOverhead = ((nativeShmPipelinedTime - wasmTime) / wasmTime) * 100;
+      const nativeShmSyncOverhead = ((nativeShmSyncTime - wasmTime) / wasmTime) * 100;
+
+      const avgWasmTimeUs = (wasmTime / ITERATIONS) * 1000;
+      const avgNativeSocketTimeUs = (nativeSocketTime / ITERATIONS) * 1000;
+      const avgNativeSocketPipelinedTimeUs = (nativeSocketPipelinedTime / ITERATIONS) * 1000;
+      const avgNativeShmTimeUs = (nativeShmTime / ITERATIONS) * 1000;
+      const avgNativeShmPipelinedTimeUs = (nativeShmPipelinedTime / 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`);
+      }
+
+      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 (nativeSocketApi) {
+        process.stdout.write(
+          `│ Native Socket Pipelined: ${nativeSocketPipelinedTime
+            .toFixed(2)
+            .padStart(8)}ms (${avgNativeSocketPipelinedTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(
+            nativeSocketPipelinedOverhead,
+          )}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Socket Pipelined:                            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 (nativeShmApi) {
+        process.stdout.write(
+          `│ Native Shared Pipelined: ${nativeShmPipelinedTime.toFixed(2).padStart(8)}ms (${avgNativeShmPipelinedTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmPipelinedOverhead)}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Shared Pipelined:                            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`);
+
+      const wasmResult = await wasmApi!.poseidon2Hash({ inputs });
+
+      if (nativeSocketApi) {
+        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeSocketResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      if (nativeShmApi) {
+        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      if (nativeShmSyncApi) {
+        const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      // Test always passes, this is just for measuring performance
+      expect(true).toBe(true);
+    },
+    10000,
+  );
+
+  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().toBuffer());
+
+      const wasmResult = await wasmApi!.poseidon2Hash({ inputs });
+
+      if (nativeSocketApi) {
+        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeSocketResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      if (nativeShmApi) {
+        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      if (nativeShmSyncApi) {
+        const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(wasmResult.hash);
+      }
+    }
+  });
+});

package/src/barretenberg/poseidon.test.ts

@@ -1,6 +1,6 @@
 import { BarretenbergSync } from './index.js';
 import { Timer } from '../benchmark/timer.js';
-import { Fr } from '../types/index.js';
+import { Fr } from './testing/fields.js';
 
 describe('poseidon sync', () => {
   let api: BarretenbergSync;
@@ -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/testing/fields.ts

@@ -0,0 +1,63 @@
+import { randomBytes } from '../../random/index.js';
+import {
+  buffer32BytesToBigIntBE,
+  uint8ArrayToBigIntBE,
+  bigIntToBufferBE,
+  bigIntToUint8ArrayBE,
+} from './bigint-buffer.js';
+
+export class Fr {
+  static ZERO = new Fr(0n);
+  static MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
+  static MAX_VALUE = this.MODULUS - 1n;
+  static SIZE_IN_BYTES = 32;
+  value: Uint8Array;
+
+  constructor(value: Uint8Array | Buffer | bigint) {
+    // We convert buffer value to bigint to be able to check it fits within modulus
+    const valueBigInt =
+      typeof value === 'bigint'
+        ? value
+        : value instanceof Buffer
+          ? buffer32BytesToBigIntBE(value)
+          : uint8ArrayToBigIntBE(value);
+
+    if (valueBigInt > Fr.MAX_VALUE) {
+      throw new Error(`Value 0x${valueBigInt.toString(16)} is greater or equal to field modulus.`);
+    }
+
+    this.value =
+      typeof value === 'bigint' ? bigIntToUint8ArrayBE(value) : value instanceof Buffer ? new Uint8Array(value) : value;
+  }
+
+  static random() {
+    const r = uint8ArrayToBigIntBE(randomBytes(64)) % Fr.MODULUS;
+    return new this(r);
+  }
+
+  toBuffer() {
+    return this.value;
+  }
+
+  toString() {
+    return '0x' + this.toBuffer().reduce((accumulator, byte) => accumulator + byte.toString(16).padStart(2, '0'), '');
+  }
+
+  equals(rhs: Fr) {
+    return this.value.every((v, i) => v === rhs.value[i]);
+  }
+
+  isZero() {
+    return this.value.every(v => v === 0);
+  }
+
+  static fromBuffer(value: Uint8Array): Fr {
+    return Fr.fromBufferReduce(value);
+  }
+
+  static fromBufferReduce(value: Uint8Array): Fr {
+    const valueBigInt = uint8ArrayToBigIntBE(value);
+    const reducedValue = valueBigInt % Fr.MODULUS;
+    return new Fr(reducedValue);
+  }
+}

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -1,4 +1,3 @@
-import { createDebugLogger } from '../../log/index.js';
 import { randomBytes } from '../../random/index.js';
 
 /**
@@ -9,7 +8,7 @@ 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 logger: (msg: string) => void = () => {};
 
   protected getImportObj(memory: WebAssembly.Memory) {
     /* eslint-disable camelcase */
@@ -121,12 +120,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/factory/browser/index.ts

@@ -1,11 +1,9 @@
-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

@@ -1,13 +1,6 @@
 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

@@ -1,7 +1,6 @@
 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') {
@@ -16,6 +15,5 @@ function getCurrentDir() {
 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

@@ -2,18 +2,9 @@ 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_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);
     }