@aztec/bb.js 0.0.1-fake-ceab37513c → 0.0.1-fake-c83136db25

package/src/bb_backends/wasm.ts

@@ -0,0 +1,103 @@
+import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import { IMsgpackBackendSync, IMsgpackBackendAsync } from './interface.js';
+import { createMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js';
+import { getRemoteBarretenbergWasm } from '../barretenberg_wasm/helpers/index.js';
+import { createDebugLogger } from '../log/index.js';
+import { proxy } from 'comlink';
+
+/**
+ * Synchronous WASM backend that wraps BarretenbergWasmMain.
+ * Encapsulates all WASM initialization and memory management.
+ */
+export class BarretenbergWasmSyncBackend implements IMsgpackBackendSync {
+  private constructor(private wasm: BarretenbergWasmMain) {}
+
+  /**
+   * Create and initialize a synchronous WASM backend.
+   * @param wasmPath Optional path to WASM files
+   * @param logger Optional logging function
+   */
+  static async new(wasmPath?: string, logger?: (msg: string) => void): Promise<BarretenbergWasmSyncBackend> {
+    const wasm = new BarretenbergWasmMain();
+    const { module, threads } = await fetchModuleAndThreads(1, wasmPath, logger);
+    await wasm.init(module, threads, logger);
+    return new BarretenbergWasmSyncBackend(wasm);
+  }
+
+  call(inputBuffer: Uint8Array): Uint8Array {
+    return this.wasm.cbindCall('bbapi', inputBuffer);
+  }
+
+  destroy(): void {
+    // BarretenbergWasmMain has async destroy, but for sync API we call it without awaiting
+    // This is consistent with the synchronous semantics expected by the caller
+    void this.wasm.destroy();
+  }
+}
+
+/**
+ * Asynchronous WASM backend that supports both direct WASM and worker-based modes.
+ *
+ * Worker mode (default): Runs WASM on a worker thread to avoid blocking the main thread. Used in browsers.
+ * Direct mode: Runs WASM directly on the calling thread. Used by node.js for better performance.
+ */
+export class BarretenbergWasmAsyncBackend implements IMsgpackBackendAsync {
+  private constructor(
+    private wasm: BarretenbergWasmMain | BarretenbergWasmMainWorker,
+    private worker?: any,
+  ) {}
+
+  /**
+   * Create and initialize an asynchronous WASM backend.
+   * @param options.threads Number of threads (defaults to hardware max, up to 32 for parallel proving)
+   * @param options.wasmPath Optional path to WASM files
+   * @param options.logger Optional logging function
+   * @param options.memory Optional initial and maximum memory configuration
+   * @param options.useWorker Run on worker thread (default: true for browser safety)
+   */
+  static async new(
+    options: {
+      threads?: number;
+      wasmPath?: string;
+      logger?: (msg: string) => void;
+      memory?: { initial?: number; maximum?: number };
+      useWorker?: boolean;
+    } = {},
+  ): Promise<BarretenbergWasmAsyncBackend> {
+    // Default to worker mode for browser safety
+    const useWorker = options.useWorker ?? true;
+
+    if (useWorker) {
+      // Worker-based mode: runs on worker thread (browser-safe)
+      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 BarretenbergWasmAsyncBackend(wasm, worker);
+    } else {
+      // Direct mode: runs on calling thread (faster but blocks thread)
+      const wasm = new BarretenbergWasmMain();
+      const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath, options.logger);
+      await wasm.init(module, threads, options.logger, options.memory?.initial, options.memory?.maximum);
+      return new BarretenbergWasmAsyncBackend(wasm);
+    }
+  }
+
+  async call(inputBuffer: Uint8Array): Promise<Uint8Array> {
+    return this.wasm.cbindCall('bbapi', inputBuffer);
+  }
+
+  async destroy(): Promise<void> {
+    await this.wasm.destroy();
+    if (this.worker) {
+      await this.worker.terminate();
+    }
+  }
+}

package/src/bbapi_exception.ts

@@ -0,0 +1,13 @@
+/**
+ * Exception thrown when barretenberg API operations fail
+ */
+export class BBApiException extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'BBApiException';
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, BBApiException);
+    }
+  }
+}

package/src/cbind/README.md

@@ -1 +1 @@
-Derive bindings from the reported scheme of msgpack from bb. Currently redundant with bindgen, until that is supplanted.
+Derives bindings from the reported msgpack schema from bb.

package/src/cbind/generate.ts

@@ -7,11 +7,11 @@ import { dirname, join } from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
+import { unpack } from 'msgpackr';
 import {
   createSharedTypesCompiler,
   createSyncApiCompiler,
   createAsyncApiCompiler,
-  createNativeApiCompiler,
   type SchemaCompiler,
 } from './schema_compiler.js';
 
@@ -39,11 +39,6 @@ const GENERATORS: GeneratorConfig[] = [
     outputFile: 'generated/async.ts',
     createCompiler: createAsyncApiCompiler,
   },
-  {
-    name: 'Native API',
-    outputFile: 'generated/native.ts',
-    createCompiler: createNativeApiCompiler,
-  },
 ];
 
 // @ts-ignore
@@ -79,9 +74,107 @@ async function generate() {
     console.log(`✓ ${config.name}: ${outputPath}`);
   }
 
+  // Generate curve constants
+  console.log('\nGenerating curve constants...');
+  await generateCurveConstants(bbBuildPath, outputDir);
+
   console.log('\nGeneration complete!');
 }
 
+async function generateCurveConstants(bbBuildPath: string, outputDir: string) {
+  // Get curve constants from bb as msgpack binary
+  const { stdout: constantsBuffer } = await execAsync(`${bbBuildPath} msgpack curve_constants`, {
+    encoding: 'buffer',
+    maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+  });
+
+  // Decode msgpack
+  const constants = unpack(constantsBuffer as Buffer);
+
+  // Helper to convert Uint8Array to hex string
+  const toHex = (bytes: Uint8Array) => '0x' + Buffer.from(bytes).toString('hex');
+
+  // Helper to convert Uint8Array to bigint (big-endian)
+  const toBigInt = (bytes: Uint8Array) => {
+    let result = 0n;
+    for (const byte of bytes) {
+      result = (result << 8n) | BigInt(byte);
+    }
+    return result;
+  };
+
+  // Helper to serialize point coordinate (handles both Uint8Array and array of Uint8Array for field2)
+  const serializeCoordinate = (coord: Uint8Array | Uint8Array[]) => {
+    if (Array.isArray(coord)) {
+      // For field2 (like BN254 G2), we have array of two Uint8Arrays
+      return `[${coord.map(c => `new Uint8Array([${Array.from(c).join(', ')}])`).join(', ')}]`;
+    } else {
+      // For regular fields, single Uint8Array
+      return `new Uint8Array([${Array.from(coord).join(', ')}])`;
+    }
+  };
+
+  // Generate TypeScript file
+  const content = `/**
+ * Curve constants generated from barretenberg native binary.
+ * DO NOT EDIT - This file is auto-generated by generate.ts
+ */
+
+/**
+ * BN254 curve constants
+ */
+export const BN254_FR_MODULUS = ${toBigInt(constants.bn254_fr_modulus)}n;
+export const BN254_FQ_MODULUS = ${toBigInt(constants.bn254_fq_modulus)}n;
+
+export const BN254_G1_GENERATOR = {
+  x: ${serializeCoordinate(constants.bn254_g1_generator.x)},
+  y: ${serializeCoordinate(constants.bn254_g1_generator.y)},
+} as const;
+
+export const BN254_G2_GENERATOR = {
+  x: ${serializeCoordinate(constants.bn254_g2_generator.x)},
+  y: ${serializeCoordinate(constants.bn254_g2_generator.y)},
+} as const;
+
+/**
+ * Grumpkin curve constants
+ */
+export const GRUMPKIN_FR_MODULUS = ${toBigInt(constants.grumpkin_fr_modulus)}n;
+export const GRUMPKIN_FQ_MODULUS = ${toBigInt(constants.grumpkin_fq_modulus)}n;
+
+export const GRUMPKIN_G1_GENERATOR = {
+  x: ${serializeCoordinate(constants.grumpkin_g1_generator.x)},
+  y: ${serializeCoordinate(constants.grumpkin_g1_generator.y)},
+} as const;
+
+/**
+ * Secp256k1 curve constants
+ */
+export const SECP256K1_FR_MODULUS = ${toBigInt(constants.secp256k1_fr_modulus)}n;
+export const SECP256K1_FQ_MODULUS = ${toBigInt(constants.secp256k1_fq_modulus)}n;
+
+export const SECP256K1_G1_GENERATOR = {
+  x: ${serializeCoordinate(constants.secp256k1_g1_generator.x)},
+  y: ${serializeCoordinate(constants.secp256k1_g1_generator.y)},
+} as const;
+
+/**
+ * Secp256r1 curve constants
+ */
+export const SECP256R1_FR_MODULUS = ${toBigInt(constants.secp256r1_fr_modulus)}n;
+export const SECP256R1_FQ_MODULUS = ${toBigInt(constants.secp256r1_fq_modulus)}n;
+
+export const SECP256R1_G1_GENERATOR = {
+  x: ${serializeCoordinate(constants.secp256r1_g1_generator.x)},
+  y: ${serializeCoordinate(constants.secp256r1_g1_generator.y)},
+} as const;
+`;
+
+  const outputPath = join(outputDir, 'curve_constants.ts');
+  writeFileSync(outputPath, content);
+  console.log(`✓ Curve constants: ${outputPath}`);
+}
+
 // Run the generator
 generate().catch(error => {
   console.error('Generation failed:', error);