@aztec/bb.js 0.0.1-commit.24de95ac → 0.0.1-commit.5daedc8

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

@@ -1,9 +1,8 @@
 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';
+import { Fr } from './testing/fields.js';
 
 /**
  * Async API benchmark test: WASM vs Native backends with proper non-blocking I/O
@@ -67,170 +66,179 @@ describe('poseidon2Hash benchmark (Async API): WASM vs Native', () => {
     }
   }, 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();
-    }
-  });
+  it.each(SIZES)(
+    'benchmark with %p field elements',
+    async size => {
+      // Generate random inputs
+      const inputs = Array(size)
+        .fill(0)
+        .map(() => Fr.random().toBuffer());
 
-  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()) });
+      // 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;
       }
-      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()) });
+      // 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;
       }
-      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()) });
+      // 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;
       }
-      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()) });
+      // 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;
       }
-      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`);
-    }
+      // 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;
+      }
 
-    process.stdout.write(
-      `│ Direct WASM:        ${directTime.toFixed(2).padStart(8)}ms (${avgDirectTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(directOverhead)}   │\n`,
-    );
+      // 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;
+      }
 
-    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`);
-    }
+      // 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;
 
-    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`);
-    }
+      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;
 
-    if (nativeShmSyncApi) {
       process.stdout.write(
-        `│ Native Shared Sync: ${nativeShmSyncTime.toFixed(2).padStart(8)}ms (${avgNativeShmSyncTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmSyncOverhead)}   │\n`,
+        `┌─ Size ${size.toString().padStart(3)} field elements ───────────────────────────────────────┐\n`,
       );
-    } else {
-      process.stdout.write(`│ Native Shared Sync:                            unavailable │\n`);
-    }
+      const formatOverhead = (overhead: number): string => {
+        const sign = overhead >= 0 ? '+' : '-';
+        const value = Math.abs(overhead).toFixed(1).padStart(6);
+        return `${sign}${value}%`;
+      };
 
-    process.stdout.write(`└────────────────────────────────────────────────────────────┘\n`);
+      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`);
+      }
 
-    // Sanity check: verify all backends produce same result as direct WASM
-    const directResult = await directPoseidon2Hash(inputs);
+      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 (wasmApi) {
-      const wasmResult = await wasmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-      expect(Buffer.from(wasmResult.hash)).toEqual(directResult.toBuffer());
-    }
+      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 (nativeSocketApi) {
-      const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-      expect(Buffer.from(nativeSocketResult.hash)).toEqual(directResult.toBuffer());
-    }
+      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) {
-      const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-      expect(Buffer.from(nativeShmResult.hash)).toEqual(directResult.toBuffer());
-    }
+      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) {
-      const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-      expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(directResult.toBuffer());
-    }
+      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`);
+      }
 
-    // Test always passes, this is just for measuring performance
-    expect(true).toBe(true);
-  });
+      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;
@@ -240,28 +248,23 @@ describe('poseidon2Hash benchmark (Async API): WASM vs Native', () => {
     for (let test = 0; test < NUM_RANDOM_TESTS; test++) {
       const inputs = Array(size)
         .fill(0)
-        .map(() => Fr.random());
+        .map(() => Fr.random().toBuffer());
 
-      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());
-      }
+      const wasmResult = await wasmApi!.poseidon2Hash({ inputs });
 
       if (nativeSocketApi) {
-        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-        expect(Buffer.from(nativeSocketResult.hash)).toEqual(directResult.toBuffer());
+        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeSocketResult.hash)).toEqual(wasmResult.hash);
       }
 
       if (nativeShmApi) {
-        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-        expect(Buffer.from(nativeShmResult.hash)).toEqual(directResult.toBuffer());
+        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmResult.hash)).toEqual(wasmResult.hash);
       }
 
       if (nativeShmSyncApi) {
-        const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-        expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(directResult.toBuffer());
+        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;

package/src/{types → barretenberg/testing}/fields.ts

@@ -1,17 +1,11 @@
-import { randomBytes } from '../random/index.js';
+import { randomBytes } from '../../random/index.js';
 import {
   buffer32BytesToBigIntBE,
   uint8ArrayToBigIntBE,
   bigIntToBufferBE,
   bigIntToUint8ArrayBE,
-} from '../bigint-array/index.js';
+} from './bigint-buffer.js';
 
-/**
- * Internal Fr field class for tests.
- * @dev This minimal implementation is provided for testing barretenberg directly.
- * Projects using bb.js should create their own field abstraction using the curve constants
- * exported from the barretenberg binary (see CurveConstants generation).
- */
 export class Fr {
   static ZERO = new Fr(0n);
   static MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
@@ -41,24 +35,6 @@ export class Fr {
     return new this(r);
   }
 
-  static fromBuffer(buffer: Uint8Array | Buffer) {
-    if (buffer.length !== this.SIZE_IN_BYTES) {
-      throw new Error(`Expected ${this.SIZE_IN_BYTES} bytes, got ${buffer.length}`);
-    }
-    return new this(buffer);
-  }
-
-  static fromBufferReduce(buffer: Uint8Array | Buffer) {
-    if (buffer.length !== this.SIZE_IN_BYTES) {
-      throw new Error(`Expected ${this.SIZE_IN_BYTES} bytes, got ${buffer.length}`);
-    }
-    return new this(uint8ArrayToBigIntBE(buffer instanceof Buffer ? new Uint8Array(buffer) : buffer) % Fr.MODULUS);
-  }
-
-  static fromString(str: string) {
-    return this.fromBuffer(Buffer.from(str.replace(/^0x/i, ''), 'hex'));
-  }
-
   toBuffer() {
     return this.value;
   }
@@ -74,4 +50,14 @@ export class Fr {
   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 */

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/index.ts

@@ -5,7 +5,6 @@ import { createThreadWorker } from '../barretenberg_wasm_thread/factory/node/ind
 import { type BarretenbergWasmThreadWorker } from '../barretenberg_wasm_thread/index.js';
 import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
 import { HeapAllocator } from './heap_allocator.js';
-import { createDebugLogger } from '../../log/index.js';
 
 /**
  * This is the "main thread" implementation of BarretenbergWasm.
@@ -18,6 +17,7 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   private remoteWasms: BarretenbergWasmThreadWorker[] = [];
   private nextWorker = 0;
   private nextThreadId = 1;
+  private useCustomLogger = false;
 
   // Pre-allocated scratch buffers for msgpack I/O to avoid malloc/free overhead
   private msgpackInputScratch: number = 0; // 8MB input buffer
@@ -34,11 +34,13 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   public async init(
     module: WebAssembly.Module,
     threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS),
-    logger: (msg: string) => void = createDebugLogger('bb_wasm'),
+    logger?: (msg: string) => void,
     initial = 33,
     maximum = this.getDefaultMaximumMemoryPages(),
   ) {
-    this.logger = logger;
+    // Track whether a custom logger was provided so workers know whether to postMessage logs
+    this.useCustomLogger = logger !== undefined;
+    this.logger = logger ?? (() => {});
 
     const initialMb = (initial * 2 ** 16) / (1024 * 1024);
     const maxMb = (maximum * 2 ** 16) / (1024 * 1024);
@@ -71,8 +73,14 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     if (threads > 1) {
       this.logger(`Creating ${threads} worker threads`);
       this.workers = await Promise.all(Array.from({ length: threads - 1 }).map(createThreadWorker));
+
+      // Set up log message forwarding from workers to our logger (only if custom logger provided)
+      if (this.useCustomLogger) {
+        this.workers.forEach(worker => this.setupWorkerLogForwarding(worker));
+      }
+
       this.remoteWasms = await Promise.all(this.workers.map(getRemoteBarretenbergWasm<BarretenbergWasmThreadWorker>));
-      await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory)));
+      await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory, this.useCustomLogger)));
     }
   }
 
@@ -85,6 +93,31 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     return 2 ** 16;
   }
 
+  /**
+   * Set up forwarding of log messages from worker threads to our logger.
+   * Workers post messages with { type: 'log', msg: string } which we intercept here.
+   */
+  private setupWorkerLogForwarding(worker: Worker) {
+    const handler = (data: unknown) => {
+      if (data && typeof data === 'object' && 'type' in data && data.type === 'log' && 'msg' in data) {
+        this.logger(data.msg as string);
+      }
+    };
+
+    // Node Workers use 'on' method, browser Workers use 'addEventListener'
+    // The 'worker' variable is typed as Node's Worker, but at runtime in browser
+    // it will be a browser Worker (due to browser_postprocess.sh import rewriting)
+    if ('on' in worker && typeof worker.on === 'function') {
+      // Node.js worker_threads Worker
+      worker.on('message', handler);
+    } else if ('addEventListener' in worker) {
+      // Browser Web Worker
+      (worker as unknown as globalThis.Worker).addEventListener('message', (event: MessageEvent) => {
+        handler(event.data);
+      });
+    }
+  }
+
   /**
    * Called on main thread. Signals child threads to gracefully exit.
    */

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/index.ts

@@ -1,11 +1,9 @@
-import { logOptions } from '../../../../log/index.js';
 import { readinessListener } from '../../../helpers/browser/index.js';
 
 export async function createThreadWorker() {
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
   const worker = new Worker(new URL('./thread.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_thread/factory/browser/thread.worker.ts

@@ -1,13 +1,6 @@
 import { expose } from 'comlink';
 import { BarretenbergWasmThread } 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 BarretenbergWasmThread());
 postMessage(Ready);

package/src/barretenberg_wasm/barretenberg_wasm_thread/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 createThreadWorker() {
   const __dirname = getCurrentDir();
   const worker = new Worker(__dirname + `/thread.worker.js`);
-  worker.postMessage({ log: logOptions });
   return Promise.resolve(worker);
 }