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

package/src/barretenberg/index.ts

@@ -1,12 +1,17 @@
 import { Crs, GrumpkinCrs } from '../crs/index.js';
-import { createDebugLogger } from '../log/index.js';
 import { AsyncApi } from '../cbind/generated/async.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 {
+  UltraHonkBackend,
+  UltraHonkVerifierBackend,
+  AztecClientBackend,
+  type UltraHonkBackendOptions,
+  type VerifierTarget,
+} from './backend.js';
 export * from '../bb_backends/index.js';
 
 export type CircuitOptions = {
@@ -31,44 +36,39 @@ export class Barretenberg extends AsyncApi {
    *
    * 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)
+   *   1. NativeUnixSocket (if bb binary available)
    *   2. WasmWorker (in browser) or Wasm (in Node.js)
    */
   static async new(options: BackendOptions = {}) {
-    const logger = options.logger ?? createDebugLogger('bb_async');
+    const logger = options.logger ?? (() => {});
 
     if (options.backend) {
       // Explicit backend required - no fallback
-      return await createAsyncBackend(options.backend, options, logger);
+      const backend = await createAsyncBackend(options.backend, options, logger);
+      if (options.backend === BackendType.Wasm || options.backend === BackendType.WasmWorker) {
+        await backend.initSRSChonk();
+      }
+      return backend;
     }
 
     if (typeof window === 'undefined') {
       try {
-        return await createAsyncBackend(BackendType.NativeSharedMemory, options, logger);
+        return await createAsyncBackend(BackendType.NativeUnixSocket, 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);
-        }
+        logger(`Unix socket unavailable (${err.message}), falling back to WASM`);
+        const backend = await createAsyncBackend(BackendType.Wasm, options, logger);
+        await backend.initSRSChonk();
+        return backend;
       }
     } else {
       logger(`In browser, using WASM over worker backend.`);
-      return await createAsyncBackend(BackendType.WasmWorker, options, logger);
+      const backend = await createAsyncBackend(BackendType.WasmWorker, options, logger);
+      await backend.initSRSChonk();
+      return backend;
     }
   }
 
-  async initSRSForCircuitSize(circuitSize: number): Promise<void> {
-    const minSRSSize = 2 ** 9; // 2**9 is the dyadic size for the SmallSubgroupIPA MSM.
-    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({ pointsBuf: crs.getG1Data(), numPoints: crs.numPoints, g2Point: crs.getG2Data() });
-  }
-
-  async initSRSClientIVC(srsSize = this.getDefaultSrsSize()): Promise<void> {
+  async initSRSChonk(srsSize = this.getDefaultSrsSize()): Promise<void> {
     // crsPath can be undefined
     const crs = await Crs.new(srsSize + 1, this.options.crsPath, this.options.logger);
     const grumpkinCrs = await GrumpkinCrs.new(2 ** 16 + 1, this.options.crsPath, this.options.logger);
@@ -106,11 +106,6 @@ export class Barretenberg extends AsyncApi {
     return [response.numGates, response.numGatesDyadic];
   }
 
-  async acirInitSRS(bytecode: Uint8Array, recursive: boolean, honkRecursion: boolean): Promise<void> {
-    const [_, subgroupSize] = await this.acirGetCircuitSizes(bytecode, recursive, honkRecursion);
-    return this.initSRSForCircuitSize(subgroupSize);
-  }
-
   async destroy() {
     return super.destroy();
   }
@@ -177,7 +172,7 @@ export class BarretenbergSync extends SyncApi {
    * Not supported: WasmWorker (no workers in sync), NativeUnixSocket (async only)
    */
   static async new(options: BackendOptions = {}) {
-    const logger = options.logger ?? createDebugLogger('bb_sync');
+    const logger = options.logger ?? (() => {});
 
     if (options.backend) {
       return await createSyncBackend(options.backend, options, logger);

package/src/barretenberg/pedersen.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('pedersen sync', () => {
   let api: BarretenbergSync;

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

@@ -1,8 +1,8 @@
-import { Barretenberg, BarretenbergSync, Fr } from '../index.js';
-import { serializeBufferable } from '../serialize/index.js';
+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
@@ -66,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;
@@ -239,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/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 */

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));