@aztec/bb.js 3.0.0-nightly.20251016 → 3.0.0-nightly.20251022

package/src/barretenberg/index.ts

@@ -1,33 +1,13 @@
-import { proxy } from 'comlink';
-import { BarretenbergApi, BarretenbergApiSync } from '../barretenberg_api/index.js';
-import { createMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js';
-import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
-import { getRemoteBarretenbergWasm } from '../barretenberg_wasm/helpers/index.js';
 import { Crs, GrumpkinCrs } from '../crs/index.js';
-import { RawBuffer } from '../types/raw_buffer.js';
-import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
 import { createDebugLogger } from '../log/index.js';
 import { AsyncApi } from '../cbind/generated/async.js';
-import { BbApiBase, CircuitComputeVk, CircuitProve, CircuitVerify, ClientIvcAccumulate, ClientIvcComputeIvcVk, ClientIvcStats, ClientIvcLoad, ClientIvcProve, ClientIvcStart, ClientIvcVerify, VkAsFields } from '../cbind/generated/api_types.js';
+import { SyncApi } from '../cbind/generated/sync.js';
+import { IMsgpackBackendSync, IMsgpackBackendAsync } from '../bb_backends/interface.js';
+import { BackendOptions, BackendType } from '../bb_backends/index.js';
+import { createAsyncBackend, createSyncBackend } from '../bb_backends/node/index.js';
 
 export { UltraHonkBackend, UltraHonkVerifierBackend, AztecClientBackend } from './backend.js';
-
-export type BackendOptions = {
-  /** @description Number of threads to run the backend worker on */
-  threads?: number;
-
-  /** @description Initial and Maximum memory to be alloted to the backend worker */
-  memory?: { initial?: number; maximum?: number };
-
-  /** @description Path to download CRS files */
-  crsPath?: string;
-
-  /** @description Path to download WASM files */
-  wasmPath?: string;
-
-  /** @description Logging function */
-  logger?: (msg: string) => void;
-};
+export * from '../bb_backends/index.js';
 
 export type CircuitOptions = {
   /** @description Whether to produce SNARK friendly proofs */
@@ -38,42 +18,46 @@ export type CircuitOptions = {
  * The main class library consumers interact with.
  * It extends the generated api, and provides a static constructor "new" to compose components.
  */
-export class Barretenberg extends BarretenbergApi {
+export class Barretenberg extends AsyncApi {
   private options: BackendOptions;
-  private bbApi: BbApiBase;
-
-  private constructor(
-    private worker: any,
-    wasm: BarretenbergWasmMainWorker,
-    options: BackendOptions,
-  ) {
-    super(wasm);
+
+  constructor(backend: IMsgpackBackendAsync, options: BackendOptions) {
+    super(backend);
     this.options = options;
-    this.bbApi = new AsyncApi(wasm);
   }
 
   /**
    * Constructs an instance of Barretenberg.
-   * Launches it within a worker. This is necessary as it blocks waiting on child threads to complete,
-   * and blocking the main thread in the browser is not allowed.
-   * It threads > 1 (defaults to hardware availability), child threads will be created on their own workers.
+   *
+   * If options.backend is set: uses that specific backend (throws if unavailable)
+   * If options.backend is unset: tries backends in order with fallback:
+   *   1. NativeSharedMemory (if bb binary available)
+   *   2. WasmWorker (in browser) or Wasm (in Node.js)
    */
   static async new(options: BackendOptions = {}) {
-    const worker = await createMainWorker();
-    const wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
-    const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath, options.logger);
-    await wasm.init(
-      module,
-      threads,
-      proxy(options.logger ?? createDebugLogger('bb_wasm_async')),
-      options.memory?.initial,
-      options.memory?.maximum,
-    );
-    return new Barretenberg(worker, wasm, options);
-  }
+    const logger = options.logger ?? createDebugLogger('bb_async');
+
+    if (options.backend) {
+      // Explicit backend required - no fallback
+      return await createAsyncBackend(options.backend, options, logger);
+    }
 
-  async getNumThreads() {
-    return await this.wasm.getNumThreads();
+    if (typeof window === 'undefined') {
+      try {
+        return await createAsyncBackend(BackendType.NativeSharedMemory, options, logger);
+      } catch (err: any) {
+        logger(`Shared memory unavailable (${err.message}), falling back to other backends`);
+        try {
+          return await createAsyncBackend(BackendType.NativeUnixSocket, options, logger);
+        } catch (err: any) {
+          logger(`Unix socket unavailable (${err.message}), falling back to WASM`);
+          return await createAsyncBackend(BackendType.Wasm, options, logger);
+        }
+      }
+    } else {
+      logger(`In browser, using WASM over worker backend.`);
+      return await createAsyncBackend(BackendType.WasmWorker, options, logger);
+    }
   }
 
   async initSRSForCircuitSize(circuitSize: number): Promise<void> {
@@ -81,7 +65,7 @@ export class Barretenberg extends BarretenbergApi {
     const crs = await Crs.new(Math.max(circuitSize, minSRSSize) + 1, this.options.crsPath, this.options.logger);
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/1129): Do slab allocator initialization?
     // await this.commonInitSlabAllocator(circuitSize);
-    await this.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
+    await this.srsInitSrs({ pointsBuf: crs.getG1Data(), numPoints: crs.numPoints, g2Point: crs.getG2Data() });
   }
 
   async initSRSClientIVC(srsSize = this.getDefaultSrsSize()): Promise<void> {
@@ -91,8 +75,8 @@ export class Barretenberg extends BarretenbergApi {
 
     // Load CRS into wasm global CRS state.
     // TODO: Make RawBuffer be default behavior, and have a specific Vector type for when wanting length prefixed.
-    await this.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
-    await this.srsInitGrumpkinSrs(new RawBuffer(grumpkinCrs.getG1Data()), grumpkinCrs.numPoints);
+    await this.srsInitSrs({ pointsBuf: crs.getG1Data(), numPoints: crs.numPoints, g2Point: crs.getG2Data() });
+    await this.srsInitGrumpkinSrs({ pointsBuf: grumpkinCrs.getG1Data(), numPoints: grumpkinCrs.numPoints });
   }
 
   getDefaultSrsSize(): number {
@@ -104,101 +88,136 @@ export class Barretenberg extends BarretenbergApi {
     return 2 ** 20;
   }
 
+  async acirGetCircuitSizes(
+    bytecode: Uint8Array,
+    recursive: boolean,
+    honkRecursion: boolean,
+  ): Promise<[number, number]> {
+    const response = await this.circuitStats({
+      circuit: { name: '', bytecode, verificationKey: new Uint8Array() },
+      includeGatesPerOpcode: false,
+      settings: {
+        ipaAccumulation: false,
+        oracleHashType: honkRecursion ? 'poseidon2' : 'keccak',
+        disableZk: !recursive,
+        optimizedSolidityVerifier: false,
+      },
+    });
+    return [response.numGates, response.numGatesDyadic];
+  }
+
   async acirInitSRS(bytecode: Uint8Array, recursive: boolean, honkRecursion: boolean): Promise<void> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_total, subgroupSize] = await this.acirGetCircuitSizes(bytecode, recursive, honkRecursion);
+    const [_, subgroupSize] = await this.acirGetCircuitSizes(bytecode, recursive, honkRecursion);
     return this.initSRSForCircuitSize(subgroupSize);
   }
 
   async destroy() {
-    await this.wasm.destroy();
-    await this.worker.terminate();
-  }
-
-  getWasm() {
-    return this.wasm;
-  }
-
-  // Wrap ClientIVC methods used by AztecClientBackend and UltraHonkBackend
-  async clientIvcStart(command: ClientIvcStart) {
-    return this.bbApi.clientIvcStart(command);
-  }
-
-  async clientIvcLoad(command: ClientIvcLoad) {
-    return this.bbApi.clientIvcLoad(command);
-  }
-
-  async clientIvcAccumulate(command: ClientIvcAccumulate) {
-    return this.bbApi.clientIvcAccumulate(command);
+    return super.destroy();
   }
 
-  async clientIvcProve(command: ClientIvcProve) {
-    return this.bbApi.clientIvcProve(command);
-  }
-
-  async clientIvcVerify(command: ClientIvcVerify) {
-    return this.bbApi.clientIvcVerify(command);
-  }
-
-  async clientIvcComputeIvcVk(command: ClientIvcComputeIvcVk) {
-    return this.bbApi.clientIvcComputeIvcVk(command);
+  /**
+   * Initialize the singleton instance of Barretenberg.
+   * @param options Backend configuration options
+   */
+  static async initSingleton(options: BackendOptions = {}) {
+    if (!barretenbergSingletonPromise) {
+      barretenbergSingletonPromise = Barretenberg.new(options);
+    }
+    try {
+      barretenbergSingleton = await barretenbergSingletonPromise;
+      return barretenbergSingleton;
+    } catch (error) {
+      // If initialization fails, clear the singleton so next call can retry
+      barretenbergSingleton = undefined!;
+      barretenbergSingletonPromise = undefined!;
+      throw error;
+    }
   }
 
-  async clientIvcStats(command: ClientIvcStats) {
-    return this.bbApi.clientIvcStats(command);
+  static async destroySingleton() {
+    if (barretenbergSingleton) {
+      await barretenbergSingleton.destroy();
+      barretenbergSingleton = undefined!;
+      barretenbergSingletonPromise = undefined!;
+    }
   }
 
-  // Wrap circuit methods used by BbApiUltraHonkBackend
-  async circuitProve(command: CircuitProve) {
-    return this.bbApi.circuitProve(command);
+  /**
+   * Get the singleton instance of Barretenberg.
+   * Must call initSingleton() first.
+   */
+  static getSingleton() {
+    if (!barretenbergSingleton) {
+      throw new Error('First call Barretenberg.initSingleton() on @aztec/bb.js module.');
+    }
+    return barretenbergSingleton;
   }
+}
 
-  async circuitComputeVk(command: CircuitComputeVk) {
-    return this.bbApi.circuitComputeVk(command);
-  }
+let barretenbergSingletonPromise: Promise<Barretenberg>;
+let barretenbergSingleton: Barretenberg;
 
-  async circuitVerify(command: CircuitVerify) {
-    return this.bbApi.circuitVerify(command);
-  }
+let barretenbergSyncSingletonPromise: Promise<BarretenbergSync>;
+let barretenbergSyncSingleton: BarretenbergSync;
 
-  async vkAsFields(command: VkAsFields) {
-    return this.bbApi.vkAsFields(command);
+export class BarretenbergSync extends SyncApi {
+  constructor(backend: IMsgpackBackendSync) {
+    super(backend);
   }
 
-}
+  /**
+   * Create a new BarretenbergSync instance.
+   *
+   * If options.backend is set: uses that specific backend (throws if unavailable)
+   * If options.backend is unset: tries backends in order with fallback:
+   *   1. NativeSharedMem (if bb binary + NAPI module available)
+   *   2. Wasm
+   *
+   * Supported backends: Wasm, NativeSharedMem
+   * Not supported: WasmWorker (no workers in sync), NativeUnixSocket (async only)
+   */
+  static async new(options: BackendOptions = {}) {
+    const logger = options.logger ?? createDebugLogger('bb_sync');
 
-let barretenbergSyncSingletonPromise: Promise<BarretenbergSync>;
-let barretenbergSyncSingleton: BarretenbergSync;
+    if (options.backend) {
+      return await createSyncBackend(options.backend, options, logger);
+    }
 
-export class BarretenbergSync extends BarretenbergApiSync {
-  private constructor(wasm: BarretenbergWasmMain) {
-    super(wasm);
-  }
+    // Try native, fallback to WASM.
+    try {
+      return await createSyncBackend(BackendType.NativeSharedMemory, options, logger);
+    } catch (err: any) {
+      logger(`Shared memory unavailable (${err.message}), falling back to WASM`);
+    }
 
-  private static async new(wasmPath?: string, logger: (msg: string) => void = createDebugLogger('bb_wasm_sync')) {
-    const wasm = new BarretenbergWasmMain();
-    const { module, threads } = await fetchModuleAndThreads(1, wasmPath, logger);
-    await wasm.init(module, threads, logger);
-    return new BarretenbergSync(wasm);
+    return await createSyncBackend(BackendType.Wasm, options, logger);
   }
 
-  static async initSingleton(wasmPath?: string, logger: (msg: string) => void = createDebugLogger('bb_wasm_sync')) {
+  /**
+   * Initialize the singleton instance.
+   * @param options Backend configuration options
+   */
+  static async initSingleton(options: BackendOptions = {}) {
     if (!barretenbergSyncSingletonPromise) {
-      barretenbergSyncSingletonPromise = BarretenbergSync.new(wasmPath, logger);
+      barretenbergSyncSingletonPromise = BarretenbergSync.new(options);
     }
 
     barretenbergSyncSingleton = await barretenbergSyncSingletonPromise;
     return barretenbergSyncSingleton;
   }
 
+  static destroySingleton() {
+    if (barretenbergSyncSingleton) {
+      barretenbergSyncSingleton.destroy();
+      barretenbergSyncSingleton = undefined!;
+      barretenbergSyncSingletonPromise = undefined!;
+    }
+  }
+
   static getSingleton() {
     if (!barretenbergSyncSingleton) {
       throw new Error('First call BarretenbergSync.initSingleton() on @aztec/bb.js module.');
     }
     return barretenbergSyncSingleton;
   }
-
-  getWasm() {
-    return this.wasm;
-  }
 }

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,267 @@
+import { Barretenberg, BarretenbergSync, Fr } from '../index.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());
+      }
+    }
+  });
+});