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

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,12 @@ 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
+  private msgpackOutputScratch: number = 0; // 8MB output buffer
+  private readonly MSGPACK_SCRATCH_SIZE = 1024 * 1024 * 8; // 8MB
 
   public getNumThreads() {
     return this.workers.length + 1;
@@ -29,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'),
-    initial = 32,
+    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);
@@ -54,12 +61,26 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     // Init all global/static data.
     this.call('_initialize');
 
+    // Allocate dedicated msgpack scratch buffers (never freed, reused for all msgpack calls)
+    this.msgpackInputScratch = this.call('bbmalloc', this.MSGPACK_SCRATCH_SIZE);
+    this.msgpackOutputScratch = this.call('bbmalloc', this.MSGPACK_SCRATCH_SIZE);
+    this.logger(
+      `Allocated msgpack scratch buffers: ` +
+        `input @ ${this.msgpackInputScratch}, output @ ${this.msgpackOutputScratch} (${this.MSGPACK_SCRATCH_SIZE} bytes each)`,
+    );
+
     // Create worker threads. Create 1 less than requested, as main thread counts as a thread.
     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)));
     }
   }
 
@@ -72,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.
    */
@@ -138,25 +184,63 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   }
 
   cbindCall(cbind: string, inputBuffer: Uint8Array): any {
-    const outputSizePtr = this.call('bbmalloc', 4);
-    const outputMsgpackPtr = this.call('bbmalloc', 4);
+    const needsCustomInputBuffer = inputBuffer.length > this.MSGPACK_SCRATCH_SIZE;
+    let inputPtr: number;
+
+    if (needsCustomInputBuffer) {
+      // Allocate temporary buffer for oversized input
+      inputPtr = this.call('bbmalloc', inputBuffer.length);
+    } else {
+      // Use pre-allocated scratch buffer
+      inputPtr = this.msgpackInputScratch;
+    }
 
-    const inputPtr = this.call('bbmalloc', inputBuffer.length);
+    // Write input to buffer
     this.writeMemory(inputPtr, inputBuffer);
-    this.call(cbind, inputPtr, inputBuffer.length, outputMsgpackPtr, outputSizePtr);
 
-    const readPtr32 = (ptr32: number) => {
-      const dataView = new DataView(this.getMemorySlice(ptr32, ptr32 + 4).buffer);
-      return dataView.getUint32(0, true);
-    };
+    // Setup output scratch buffer with IN-OUT parameter pattern:
+    // Reserve 8 bytes for metadata (pointer + size), rest is scratch data space
+    const METADATA_SIZE = 8;
+    const outputPtrLocation = this.msgpackOutputScratch;
+    const outputSizeLocation = this.msgpackOutputScratch + 4;
+    const scratchDataPtr = this.msgpackOutputScratch + METADATA_SIZE;
+    const scratchDataSize = this.MSGPACK_SCRATCH_SIZE - METADATA_SIZE;
+
+    // Get memory and create DataView for writing IN values
+    let mem = this.getMemory();
+    let view = new DataView(mem.buffer);
+
+    // Write IN values: provide scratch buffer pointer and size to C++
+    view.setUint32(outputPtrLocation, scratchDataPtr, true);
+    view.setUint32(outputSizeLocation, scratchDataSize, true);
+
+    // Call WASM
+    this.call(cbind, inputPtr, inputBuffer.length, outputPtrLocation, outputSizeLocation);
+
+    // Free custom input buffer if allocated
+    if (needsCustomInputBuffer) {
+      this.call('bbfree', inputPtr);
+    }
+
+    // Re-fetch memory after WASM call, as the buffer may have been detached if memory grew
+    mem = this.getMemory();
+    view = new DataView(mem.buffer);
+
+    // Read OUT values: C++ returns actual buffer pointer and size
+    const outputDataPtr = view.getUint32(outputPtrLocation, true);
+    const outputSize = view.getUint32(outputSizeLocation, true);
+
+    // Check if C++ used scratch (pointer unchanged) or allocated (pointer changed)
+    const usedScratch = outputDataPtr === scratchDataPtr;
+
+    // Copy output data from WASM memory
+    const encodedResult = this.getMemorySlice(outputDataPtr, outputDataPtr + outputSize);
+
+    // Only free if C++ allocated beyond scratch
+    if (!usedScratch) {
+      this.call('bbfree', outputDataPtr);
+    }
 
-    const encodedResult = this.getMemorySlice(
-      readPtr32(outputMsgpackPtr),
-      readPtr32(outputMsgpackPtr) + readPtr32(outputSizePtr),
-    );
-    this.call('bbfree', inputPtr);
-    this.call('bbfree', outputSizePtr);
-    this.call('bbfree', outputMsgpackPtr);
     return encodedResult;
   }
 }

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

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/node/thread.worker.ts

@@ -2,7 +2,6 @@ import { parentPort } from 'worker_threads';
 import { expose } from 'comlink';
 import { BarretenbergWasmThread } 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');
@@ -10,10 +9,4 @@ if (!parentPort) {
 
 const endpoint = nodeEndpoint(parentPort);
 
-endpoint.addEventListener('message', (e: any) => {
-  if (e.data.log) {
-    initLogger(e.data.log);
-  }
-});
-
 expose(new BarretenbergWasmThread(), endpoint);

package/src/barretenberg_wasm/barretenberg_wasm_thread/index.ts

@@ -5,9 +5,10 @@ import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
 export class BarretenbergWasmThread extends BarretenbergWasmBase {
   /**
    * Init as worker thread.
+   * @param useCustomLogger - If true, logs will be posted back to main thread for custom logger routing
    */
-  public async initThread(module: WebAssembly.Module, memory: WebAssembly.Memory) {
-    this.logger = threadLogger() || this.logger;
+  public async initThread(module: WebAssembly.Module, memory: WebAssembly.Memory, useCustomLogger = false) {
+    this.logger = threadLogger(useCustomLogger) || this.logger;
     this.memory = memory;
     this.instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
   }

package/src/barretenberg_wasm/helpers/browser/index.ts

@@ -13,7 +13,14 @@ export function getNumCpu() {
   return navigator.hardwareConcurrency;
 }
 
-export function threadLogger(): ((msg: string) => void) | undefined {
+export function threadLogger(useCustomLogger: boolean): ((msg: string) => void) | undefined {
+  if (useCustomLogger) {
+    // Post log messages back to main thread for routing through user-provided logger
+    return (msg: string) => {
+      postMessage({ type: 'log', msg });
+    };
+  }
+  // Use console.log directly when no custom logger is provided
   return console.log;
 }
 

package/src/barretenberg_wasm/helpers/node/index.ts

@@ -1,4 +1,4 @@
-import { Worker } from 'worker_threads';
+import { Worker, parentPort } from 'worker_threads';
 import os from 'os';
 import { wrap } from 'comlink';
 import { nodeEndpoint } from './node_endpoint.js';
@@ -25,12 +25,19 @@ export function getNumCpu() {
 }
 
 /**
- * In node, the message passing is different to the browser. When using 'debug' in the browser, we seemingly always
- * get our logs, but in node it looks like it's dependent on the chain of workers from child to main thread be
- * unblocked. If one of our threads aborts, we can't see it as the parent is blocked waiting on threads to join.
- * To work around this in node, threads will by default write directly to stdout.
+ * Returns a logger function for worker threads.
+ * When a custom logger is provided, posts messages back to the main thread.
+ * Otherwise, writes directly to stdout.
  */
-export function threadLogger(): ((msg: string) => void) | undefined {
+export function threadLogger(useCustomLogger: boolean): ((msg: string) => void) | undefined {
+  if (useCustomLogger) {
+    return (msg: string) => {
+      if (parentPort) {
+        parentPort.postMessage({ type: 'log', msg });
+      }
+    };
+  }
+  // Write directly to stdout when no custom logger is provided
   return (msg: string) => {
     writeSync(1, msg + '\n');
   };

package/src/barretenberg_wasm/index.test.ts

@@ -1,17 +1,23 @@
-import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from './barretenberg_wasm_main/index.js';
-import { Barretenberg } from '../index.js';
+import { createMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js';
+import { BarretenbergWasmMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { getRemoteBarretenbergWasm } from '../barretenberg_wasm/helpers/index.js';
+import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import { Worker } from 'worker_threads';
 
 describe('barretenberg wasm', () => {
-  let api: Barretenberg;
   let wasm: BarretenbergWasmMainWorker;
+  let worker: Worker;
 
   beforeAll(async () => {
-    api = await Barretenberg.new({ threads: 2 });
-    wasm = api.getWasm();
+    worker = await createMainWorker();
+    wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
+    const { module, threads } = await fetchModuleAndThreads(2);
+    await wasm.init(module, threads);
   }, 20000);
 
   afterAll(async () => {
-    await api.destroy();
+    await wasm.destroy();
+    await worker.terminate();
   });
 
   it('should new malloc, transfer and slice mem', async () => {
@@ -28,11 +34,6 @@ describe('barretenberg wasm', () => {
     await expect(() => wasm.call('test_abort')).rejects.toThrow();
   });
 
-  it('test c/c++ stdout/stderr', async () => {
-    // We're checking we don't crash, but you can manually confirm you see log lines handled by logstr.
-    await wasm.call('test_stdout_stderr');
-  });
-
   it('should new malloc, transfer and slice mem', async () => {
     const length = 1024;
     const ptr = await wasm.call('bbmalloc', length);

package/src/barretenberg_wasm/index.ts

@@ -1,11 +1,10 @@
 import { getSharedMemoryAvailable, getAvailableThreads } from './helpers/node/index.js';
 import { fetchCode } from './fetch_code/index.js';
-import { createDebugLogger } from '../log/index.js';
 
 export async function fetchModuleAndThreads(
   desiredThreads = 32,
   wasmPath?: string,
-  logger: (msg: string) => void = createDebugLogger('fetch_mat'),
+  logger: (msg: string) => void = () => {},
 ) {
   const shared = getSharedMemoryAvailable();
 

package/src/bb_backends/browser/index.ts

@@ -0,0 +1,50 @@
+import { BarretenbergWasmSyncBackend, BarretenbergWasmAsyncBackend } from '../wasm.js';
+import { Barretenberg, BarretenbergSync } from '../../barretenberg/index.js';
+import { BackendOptions, BackendType } from '../index.js';
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createAsyncBackend(
+  type: BackendType,
+  options: BackendOptions,
+  logger: (msg: string) => void,
+): Promise<Barretenberg> {
+  switch (type) {
+    case BackendType.Wasm:
+    case BackendType.WasmWorker: {
+      const useWorker = type === BackendType.WasmWorker;
+      logger(`Using WASM backend (worker: ${useWorker})`);
+      const wasm = await BarretenbergWasmAsyncBackend.new({
+        threads: options.threads,
+        wasmPath: options.wasmPath,
+        logger,
+        memory: options.memory,
+        useWorker,
+      });
+      return new Barretenberg(wasm, options);
+    }
+
+    default:
+      throw new Error(`Unknown backend type: ${type}`);
+  }
+}
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createSyncBackend(
+  type: BackendType,
+  options: BackendOptions,
+  logger: (msg: string) => void,
+): Promise<BarretenbergSync> {
+  switch (type) {
+    case BackendType.Wasm:
+      logger('Using WASM backend');
+      const wasm = await BarretenbergWasmSyncBackend.new(options.wasmPath, logger);
+      return new BarretenbergSync(wasm);
+
+    default:
+      throw new Error(`Backend ${type} not supported for BarretenbergSync`);
+  }
+}

package/src/bb_backends/browser/platform.ts

@@ -0,0 +1,11 @@
+export function findPackageRoot(): string | null {
+  throw new Error('Not implemented in browser environment.');
+}
+
+export function findBbBinary(customPath?: string): string | null {
+  throw new Error('Not implemented in browser environment.');
+}
+
+export function findNapiBinary(customPath?: string): string | null {
+  throw new Error('Not implemented in browser environment.');
+}

package/src/bb_backends/index.ts

@@ -0,0 +1,55 @@
+/**
+ * Backend types for Barretenberg
+ */
+export enum BackendType {
+  /** WASM direct execution (no worker) */
+  Wasm = 'Wasm',
+  /** WASM with worker threads */
+  WasmWorker = 'WasmWorker',
+  /** Native via Unix domain socket (async only) */
+  NativeUnixSocket = 'NativeUnixSocket',
+  /** Native via shared memory */
+  NativeSharedMemory = 'NativeSharedMemory',
+}
+
+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 Custom path to bb binary for native backend (overrides automatic detection) */
+  bbPath?: string;
+
+  /** @description Custom path to bb NAPI module for native backend (overrides automatic detection) */
+  napiPath?: string;
+
+  /**
+   * @description Logging function
+   * Warning: Attaching a logger can prevent nodejs from exiting without explicitly destroying the backend.
+   */
+  logger?: (msg: string) => void;
+
+  /**
+   * @description Maximum concurrent clients for shared memory IPC server (default: 1)
+   * Only applies to NativeSharedMemory backend
+   */
+  maxClients?: number;
+
+  /**
+   * @description Specify exact backend to use
+   * - If unset: tries backends in default order with fallback
+   * - If set: must succeed with specified backend or throw error (no fallback)
+   *
+   * Barretenberg (async) supports: all types
+   * BarretenbergSync supports: Wasm, NativeSharedMem only
+   */
+  backend?: BackendType;
+};

package/src/bb_backends/interface.ts

@@ -0,0 +1,35 @@
+/**
+ * Generic interface for msgpack backend implementations.
+ * Both WASM and native binary backends implement this interface.
+ */
+export interface IMsgpackBackend {
+  /**
+   * Execute a msgpack command and return the msgpack response.
+   * @param inputBuffer The msgpack-encoded input buffer
+   * @returns The msgpack-encoded response buffer (sync or async)
+   */
+  call(inputBuffer: Uint8Array): Uint8Array | Promise<Uint8Array>;
+
+  /**
+   * Clean up resources.
+   */
+  destroy(): void | Promise<void>;
+}
+
+/**
+ * Synchronous variant of IMsgpackBackend.
+ * Used by BarretenbergSync and SyncApi.
+ */
+export interface IMsgpackBackendSync extends IMsgpackBackend {
+  call(inputBuffer: Uint8Array): Uint8Array;
+  destroy(): void;
+}
+
+/**
+ * Asynchronous variant of IMsgpackBackend.
+ * Used by Barretenberg and AsyncApi.
+ */
+export interface IMsgpackBackendAsync extends IMsgpackBackend {
+  call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+  destroy(): Promise<void>;
+}

package/src/bb_backends/node/index.ts

@@ -0,0 +1,107 @@
+import { BarretenbergNativeSocketAsyncBackend } from './native_socket.js';
+import { BarretenbergWasmSyncBackend, BarretenbergWasmAsyncBackend } from '../wasm.js';
+import { BarretenbergNativeShmSyncBackend } from './native_shm.js';
+import { BarretenbergNativeShmAsyncBackend } from './native_shm_async.js';
+import { findBbBinary, findNapiBinary } from './platform.js';
+import { Barretenberg, BarretenbergSync } from '../../barretenberg/index.js';
+import { BackendOptions, BackendType } from '../index.js';
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createAsyncBackend(
+  type: BackendType,
+  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);
+      if (!bbPath) {
+        throw new Error('Native backend requires bb binary.');
+      }
+      logger(`Using native Unix socket backend: ${bbPath}`);
+      const socket = new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads, options.logger);
+      return new Barretenberg(socket, options);
+    }
+
+    case BackendType.NativeSharedMemory: {
+      const bbPath = findBbBinary(options.bbPath);
+      if (!bbPath) {
+        throw new Error('Native backend requires bb binary.');
+      }
+      const napiPath = findNapiBinary(options.napiPath);
+      if (!napiPath) {
+        throw new Error('Native async backend requires napi client stub.');
+      }
+      logger(`Using native shared memory async backend: ${bbPath}`);
+      const asyncBackend = await BarretenbergNativeShmAsyncBackend.new(
+        bbPath,
+        napiPath,
+        options.threads,
+        options.logger,
+      );
+      return new Barretenberg(asyncBackend, options);
+    }
+
+    case BackendType.Wasm:
+    case BackendType.WasmWorker: {
+      const useWorker = type === BackendType.WasmWorker;
+      logger(`Using WASM backend (worker: ${useWorker})`);
+      const wasm = await BarretenbergWasmAsyncBackend.new({
+        threads: options.threads,
+        wasmPath: options.wasmPath,
+        logger: options.logger,
+        memory: options.memory,
+        useWorker,
+      });
+      return new Barretenberg(wasm, options);
+    }
+
+    default:
+      throw new Error(`Unknown backend type: ${type}`);
+  }
+}
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createSyncBackend(
+  type: BackendType,
+  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);
+      if (!bbPath) {
+        throw new Error('Native backend requires bb binary.');
+      }
+      const napiPath = findNapiBinary(options.napiPath);
+      if (!napiPath) {
+        throw new Error('Native sync backend requires napi client stub.');
+      }
+      logger(`Using native shared memory backend: ${bbPath}`);
+      const shm = await BarretenbergNativeShmSyncBackend.new(bbPath, napiPath, options.threads, options.logger);
+      return new BarretenbergSync(shm);
+    }
+
+    case BackendType.Wasm:
+      logger('Using WASM backend');
+      const wasm = await BarretenbergWasmSyncBackend.new(options.wasmPath, logger);
+      return new BarretenbergSync(wasm);
+
+    default:
+      throw new Error(`Backend ${type} not supported for BarretenbergSync`);
+  }
+}