@aztec/bb.js 3.0.0-nightly.20251114 → 3.0.0-nightly.20251118

package/src/barretenberg/index.ts

@@ -31,7 +31,7 @@ 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 = {}) {
@@ -39,35 +39,30 @@ export class Barretenberg extends AsyncApi {
 
     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 initSRSChonk(srsSize = this.getDefaultSrsSize()): Promise<void> {
     // crsPath can be undefined
     const crs = await Crs.new(srsSize + 1, this.options.crsPath, this.options.logger);
@@ -106,11 +101,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();
   }

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,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,129 @@ 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();
-    }
-  });
-
-  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;
+  it.each(SIZES)(
+    'benchmark with %p field elements',
+    async size => {
+      // Generate random inputs
+      const inputs = Array(size)
+        .fill(0)
+        .map(() => Fr.random().toBuffer());
 
-    // 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 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;
       }
-      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 (sync)
+      let nativeShmSyncTime = 0;
+      if (nativeShmSyncApi) {
+        const nativeShmSyncStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          nativeShmSyncApi.poseidon2Hash({ inputs });
+        }
+        nativeShmSyncTime = performance.now() - nativeShmSyncStart;
       }
-      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;
+      // Calculate metrics (all relative to WASM baseline)
+      const nativeSocketOverhead = ((nativeSocketTime - wasmTime) / wasmTime) * 100;
+      const nativeShmOverhead = ((nativeShmTime - wasmTime) / wasmTime) * 100;
+      const nativeShmSyncOverhead = ((nativeShmSyncTime - wasmTime) / wasmTime) * 100;
 
-    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}%`;
-    };
+      const avgWasmTimeUs = (wasmTime / ITERATIONS) * 1000;
+      const avgNativeSocketTimeUs = (nativeSocketTime / ITERATIONS) * 1000;
+      const avgNativeShmTimeUs = (nativeShmTime / ITERATIONS) * 1000;
+      const avgNativeShmSyncTimeUs = (nativeShmSyncTime / ITERATIONS) * 1000;
 
-    if (wasmApi) {
       process.stdout.write(
-        `│ WASM:               ${wasmTime.toFixed(2).padStart(8)}ms (${avgWasmTimeUs.toFixed(2).padStart(7)}µs/call) [baseline] │\n`,
+        `┌─ Size ${size.toString().padStart(3)} field elements ──────────────────────────────────┐\n`,
       );
-    } else {
-      process.stdout.write(`│ WASM:                                          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(
-      `│ 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 (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 (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 (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 (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`);
-    }
+      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`);
+      }
 
-    process.stdout.write(`└────────────────────────────────────────────────────────────┘\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`);
+      }
 
-    // Sanity check: verify all backends produce same result as direct WASM
-    const directResult = await directPoseidon2Hash(inputs);
+      process.stdout.write(`└────────────────────────────────────────────────────────────┘\n`);
 
-    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());
-    }
+      if (nativeSocketApi) {
+        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());
-    }
+      if (nativeShmApi) {
+        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());
-    }
+      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);
-  });
+      // 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 +198,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/bb_backends/index.ts

@@ -3,13 +3,13 @@
  */
 export enum BackendType {
   /** WASM direct execution (no worker) */
-  Wasm = 'wasm',
+  Wasm = 'Wasm',
   /** WASM with worker threads */
-  WasmWorker = 'wasm-worker',
+  WasmWorker = 'WasmWorker',
   /** Native via Unix domain socket (async only) */
-  NativeUnixSocket = 'native-unix-socket',
+  NativeUnixSocket = 'NativeUnixSocket',
   /** Native via shared memory (sync only currently) */
-  NativeSharedMemory = 'native-shared-mem',
+  NativeSharedMemory = 'NativeSharedMemory',
 }
 
 export type BackendOptions = {
@@ -28,7 +28,10 @@ export type BackendOptions = {
   /** @description Custom path to bb binary for native backend (overrides automatic detection) */
   bbPath?: string;
 
-  /** @description Logging function */
+  /**
+   * @description Logging function
+   * Warning: Attaching a logger can prevent nodejs from exiting without explicitly destroying the backend.
+   */
   logger?: (msg: string) => void;
 
   /**

package/src/bb_backends/node/index.ts

@@ -14,6 +14,11 @@ export async function createAsyncBackend(
   options: BackendOptions,
   logger: (msg: string) => void,
 ): Promise<Barretenberg> {
+  options = {
+    ...options,
+    wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+  };
+
   switch (type) {
     case BackendType.NativeUnixSocket: {
       const bbPath = findBbBinary(options.bbPath);
@@ -21,7 +26,7 @@ export async function createAsyncBackend(
         throw new Error('Native backend requires bb binary.');
       }
       logger(`Using native Unix socket backend: ${bbPath}`);
-      const socket = new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads);
+      const socket = new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads, options.logger);
       return new Barretenberg(socket, options);
     }
 
@@ -36,7 +41,12 @@ export async function createAsyncBackend(
       }
       logger(`Using native shared memory backend (via sync adapter): ${bbPath}`);
       // Use sync backend with adapter to provide async interface
-      const syncBackend = await BarretenbergNativeShmSyncBackend.new(bbPath, options.threads, options.maxClients);
+      const syncBackend = await BarretenbergNativeShmSyncBackend.new(
+        bbPath,
+        options.threads,
+        options.maxClients,
+        options.logger,
+      );
       const asyncBackend = new SyncToAsyncAdapter(syncBackend);
       return new Barretenberg(asyncBackend, options);
     }
@@ -68,6 +78,11 @@ export async function createSyncBackend(
   options: BackendOptions,
   logger: (msg: string) => void,
 ): Promise<BarretenbergSync> {
+  options = {
+    ...options,
+    wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+  };
+
   switch (type) {
     case BackendType.NativeSharedMemory: {
       const bbPath = findBbBinary(options.bbPath);
@@ -79,7 +94,12 @@ export async function createSyncBackend(
         throw new Error('Native sync backend requires napi client stub.');
       }
       logger(`Using native shared memory backend: ${bbPath}`);
-      const shm = await BarretenbergNativeShmSyncBackend.new(bbPath, options.threads, options.maxClients);
+      const shm = await BarretenbergNativeShmSyncBackend.new(
+        bbPath,
+        options.threads,
+        options.maxClients,
+        options.logger,
+      );
       return new BarretenbergSync(shm);
     }