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

package/src/barretenberg/index.ts

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

package/src/barretenberg/pedersen.test.ts

@@ -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;
@@ -10,7 +10,8 @@ describe('pedersen sync', () => {
   });
 
   it('pedersenHash', () => {
-    const result = api.pedersenHash([new Fr(4n), new Fr(8n)], 7);
+    const response = api.pedersenHash({ inputs: [new Fr(4n).toBuffer(), new Fr(8n).toBuffer()], hashIndex: 7 });
+    const result = Fr.fromBuffer(response.hash);
     expect(result).toMatchSnapshot();
   });
 
@@ -19,34 +20,40 @@ describe('pedersen sync', () => {
     const fields = Array.from({ length: loops * 2 }).map(() => Fr.random());
     const t = new Timer();
     for (let i = 0; i < loops; ++i) {
-      api.pedersenHash([fields[i * 2], fields[i * 2 + 1]], 0);
+      api.pedersenHash({ inputs: [fields[i * 2].toBuffer(), fields[i * 2 + 1].toBuffer()], hashIndex: 0 });
     }
     const us = t.us() / loops;
     console.log(`Executed ${loops} hashes at an average ${us}us / hash`);
   });
 
-  it('pedersenHashes perf test', () => {
-    const loops = 10;
-    const numHashesPerLoop = 1024;
-    const fields = Array.from({ length: numHashesPerLoop * 2 }).map(() => Fr.random());
-    const t = new Timer();
-    for (let i = 0; i < loops; ++i) {
-      api.pedersenHashes(fields, 0);
-    }
-    const us = t.us() / (numHashesPerLoop * loops);
-    console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
-  });
+  // TODO: pedersenHashes not yet in new msgpack API
+  // it.skip('pedersenHashes perf test', () => {
+  //   const loops = 10;
+  //   const numHashesPerLoop = 1024;
+  //   const fields = Array.from({ length: numHashesPerLoop * 2 }).map(() => Fr.random());
+  //   const t = new Timer();
+  //   for (let i = 0; i < loops; ++i) {
+  //     // api.pedersenHashes(fields, 0); // Not in new API yet
+  //   }
+  //   const us = t.us() / (numHashesPerLoop * loops);
+  //   console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
+  // });
 
   it('pedersenHashBuffer', () => {
     const input = Buffer.alloc(123);
     input.writeUint32BE(321, 0);
     input.writeUint32BE(456, 119);
-    const r = api.pedersenHashBuffer(input, 0);
+    const response = api.pedersenHashBuffer({ input, hashIndex: 0 });
+    const r = Fr.fromBuffer(response.hash);
     expect(r).toMatchSnapshot();
   });
 
   it('pedersenCommit', () => {
-    const result = api.pedersenCommit([new Fr(4n), new Fr(8n), new Fr(12n)], 0);
+    const response = api.pedersenCommit({
+      inputs: [new Fr(4n).toBuffer(), new Fr(8n).toBuffer(), new Fr(12n).toBuffer()],
+      hashIndex: 0,
+    });
+    const result = { x: Fr.fromBuffer(response.point.x), y: Fr.fromBuffer(response.point.y) };
     expect(result).toMatchSnapshot();
   });
 
@@ -55,7 +62,7 @@ describe('pedersen sync', () => {
     const fields = Array.from({ length: loops * 2 }).map(() => Fr.random());
     const t = new Timer();
     for (let i = 0; i < loops; ++i) {
-      api.pedersenCommit([fields[i * 2], fields[i * 2 + 1]], 0);
+      api.pedersenCommit({ inputs: [fields[i * 2].toBuffer(), fields[i * 2 + 1].toBuffer()], hashIndex: 0 });
     }
     console.log(t.us() / loops);
   });