@aztec/bb.js 0.0.1-commit.d3ec352c → 0.0.1-commit.f295ac2

package/src/barretenberg/backend.ts

@@ -10,29 +10,46 @@ export class AztecClientBackendError extends Error {
   }
 }
 
+/**
+ * Target verification environment for proof generation.
+ * This determines the hash function used and whether zero-knowledge is enabled.
+ */
+export type VerifierTarget =
+  | 'evm' // Ethereum/Solidity verification (keccak, ZK enabled)
+  | 'evm-no-zk' // Ethereum/Solidity without zero-knowledge
+  | 'noir-recursive' // Recursive verification in Noir circuits (poseidon2, ZK enabled)
+  | 'noir-recursive-no-zk' // Recursive verification without ZK
+  | 'noir-rollup' // Rollup circuits with IPA accumulation (poseidon2, ZK enabled)
+  | 'noir-rollup-no-zk' // Rollup circuits without ZK
+  | 'starknet' // Starknet verification via Garaga (ZK enabled)
+  | 'starknet-no-zk'; // Starknet without zero-knowledge
+
 /**
  * Options for the UltraHonkBackend.
  */
 export type UltraHonkBackendOptions = {
-  /** Selecting this option will use the keccak hash function instead of poseidon
-   * when generating challenges in the proof.
-   * Use this when you want to verify the created proof on an EVM chain.
+  /**
+   * Target verification environment. Determines hash function and ZK settings.
+   * This is the recommended way to configure proof generation.
+   *
+   * @example
+   * // For EVM/Solidity verification
+   * backend.generateProof(witness, { verifierTarget: 'evm' });
+   *
+   * // For recursive verification in Noir
+   * backend.generateProof(witness, { verifierTarget: 'noir-recursive' });
    */
+  verifierTarget?: VerifierTarget;
+
+  // Legacy options - prefer using verifierTarget instead
+
+  /** @deprecated Use verifierTarget: 'evm-no-zk' instead */
   keccak?: boolean;
-  /** Selecting this option will use the keccak hash function instead of poseidon
-   * when generating challenges in the proof.
-   * Use this when you want to verify the created proof on an EVM chain.
-   */
+  /** @deprecated Use verifierTarget: 'evm' instead */
   keccakZK?: boolean;
-  /** Selecting this option will use the poseidon/stark252 hash function instead of poseidon
-   * when generating challenges in the proof.
-   * Use this when you want to verify the created proof on an Starknet chain with Garaga.
-   */
+  /** @deprecated Use verifierTarget: 'starknet-no-zk' instead */
   starknet?: boolean;
-  /** Selecting this option will use the poseidon/stark252 hash function instead of poseidon
-   * when generating challenges in the proof.
-   * Use this when you want to verify the created proof on an Starknet chain with Garaga.
-   */
+  /** @deprecated Use verifierTarget: 'starknet' instead */
   starknetZK?: boolean;
 };
 
@@ -42,6 +59,67 @@ function getProofSettingsFromOptions(options?: UltraHonkBackendOptions): {
   disableZk: boolean;
   optimizedSolidityVerifier: boolean;
 } {
+  // Check for conflicting options - verifierTarget should not be combined with legacy options
+  if (options?.verifierTarget) {
+    const legacyOptions = [options.keccak, options.keccakZK, options.starknet, options.starknetZK].filter(Boolean);
+    if (legacyOptions.length > 0) {
+      throw new Error(
+        'Cannot use verifierTarget with legacy options (keccak, keccakZK, starknet, starknetZK). ' +
+          'Use verifierTarget alone.',
+      );
+    }
+
+    switch (options.verifierTarget) {
+      case 'evm':
+        return { ipaAccumulation: false, oracleHashType: 'keccak', disableZk: false, optimizedSolidityVerifier: false };
+      case 'evm-no-zk':
+        return { ipaAccumulation: false, oracleHashType: 'keccak', disableZk: true, optimizedSolidityVerifier: false };
+      case 'noir-recursive':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'poseidon2',
+          disableZk: false,
+          optimizedSolidityVerifier: false,
+        };
+      case 'noir-recursive-no-zk':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'poseidon2',
+          disableZk: true,
+          optimizedSolidityVerifier: false,
+        };
+      case 'noir-rollup':
+        return {
+          ipaAccumulation: true,
+          oracleHashType: 'poseidon2',
+          disableZk: false,
+          optimizedSolidityVerifier: false,
+        };
+      case 'noir-rollup-no-zk':
+        return {
+          ipaAccumulation: true,
+          oracleHashType: 'poseidon2',
+          disableZk: true,
+          optimizedSolidityVerifier: false,
+        };
+      case 'starknet':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'starknet',
+          disableZk: false,
+          optimizedSolidityVerifier: false,
+        };
+      case 'starknet-no-zk':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'starknet',
+          disableZk: true,
+          optimizedSolidityVerifier: false,
+        };
+    }
+  }
+
+  // Legacy options support (deprecated)
   return {
     ipaAccumulation: false,
     oracleHashType:
@@ -50,7 +128,6 @@ function getProofSettingsFromOptions(options?: UltraHonkBackendOptions): {
         : options?.starknet || options?.starknetZK
           ? 'starknet'
           : 'poseidon2',
-    // TODO no current way to target non-zk poseidon2 hash
     disableZk: options?.keccak || options?.starknet ? true : false,
     optimizedSolidityVerifier: false,
   };
@@ -162,6 +239,7 @@ export class UltraHonkBackend {
     _proof: Uint8Array,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _numOfPublicInputs: number,
+    options?: UltraHonkBackendOptions,
   ): Promise<{ proofAsFields: string[]; vkAsFields: string[]; vkHash: string }> {
     // TODO(https://github.com/noir-lang/noir/issues/5661): This needs to be updated to handle recursive aggregation.
     // There is still a proofAsFields method but we could consider getting rid of it as the proof itself
@@ -171,14 +249,12 @@ export class UltraHonkBackend {
     // const proof = reconstructProofWithPublicInputs(proofData);
     // const proofAsFields = (await this.api.acirProofAsFieldsUltraHonk(proof)).slice(numOfPublicInputs);
 
-    // TODO: perhaps we should put this in the init function. Need to benchmark
-    // TODO how long it takes.
     const vkResult = await this.api.circuitComputeVk({
       circuit: {
         name: 'circuit',
         bytecode: this.acirUncompressedBytecode,
       },
-      settings: getProofSettingsFromOptions({}),
+      settings: getProofSettingsFromOptions(options),
     });
 
     // Convert VK bytes to field elements (32-byte chunks)
@@ -310,3 +386,41 @@ function base64Decode(input: string): Uint8Array {
     throw new Error('atob is not available. Node.js 18+ or browser required.');
   }
 }
+
+/**
+ * Convert a field element (32-byte Uint8Array) to a string.
+ *
+ * @param field - A 32-byte field element
+ * @param radix - The radix for string conversion (2-36), defaults to 10 (decimal)
+ * @returns The field value as a string in the specified radix
+ *
+ * @example
+ * const decimal = fieldToString(field);        // "12345678"
+ * const hex = fieldToString(field, 16);        // "bc614e"
+ */
+export function fieldToString(field: Uint8Array, radix: number = 10): string {
+  let result = 0n;
+  for (const byte of field) {
+    result <<= 8n;
+    result += BigInt(byte);
+  }
+  return result.toString(radix);
+}
+
+/**
+ * Convert an array of field elements to an array of strings.
+ * Useful for passing VK fields to Noir circuits.
+ *
+ * @param fields - Array of 32-byte field elements
+ * @param radix - The radix for string conversion (2-36), defaults to 10 (decimal)
+ * @returns Array of strings in the specified radix
+ *
+ * @example
+ * const vkAsFields = await barretenbergAPI.vkAsFields({ verificationKey: vk });
+ * const vkDecimalStrings = fieldsToStrings(vkAsFields.fields);      // ["12345678", "87654321", ...]
+ * const vkHexStrings = fieldsToStrings(vkAsFields.fields, 16);      // ["bc614e", "5397fb1", ...]
+ */
+export function fieldsToStrings(fields: Uint8Array[], radix: number = 10): string[] {
+  return fields.map(field => fieldToString(field, radix));
+}
+

package/src/barretenberg/index.ts

@@ -5,7 +5,15 @@ import { IMsgpackBackendSync, IMsgpackBackendAsync } from '../bb_backends/interf
 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,
+  fieldToString,
+  fieldsToStrings,
+  type UltraHonkBackendOptions,
+  type VerifierTarget,
+} from './backend.js';
 export * from '../bb_backends/index.js';
 
 export type CircuitOptions = {

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -35,7 +35,7 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     module: WebAssembly.Module,
     threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS),
     logger?: (msg: string) => void,
-    initial = 33,
+    initial = 35,
     maximum = this.getDefaultMaximumMemoryPages(),
   ) {
     // Track whether a custom logger was provided so workers know whether to postMessage logs

package/src/bb_backends/index.ts

@@ -28,6 +28,9 @@ export type BackendOptions = {
   /** @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.

package/src/bb_backends/node/index.ts

@@ -35,12 +35,17 @@ export async function createAsyncBackend(
       if (!bbPath) {
         throw new Error('Native backend requires bb binary.');
       }
-      const napiPath = findNapiBinary();
+      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, options.threads, options.logger);
+      const asyncBackend = await BarretenbergNativeShmAsyncBackend.new(
+        bbPath,
+        napiPath,
+        options.threads,
+        options.logger,
+      );
       return new Barretenberg(asyncBackend, options);
     }
 
@@ -82,12 +87,12 @@ export async function createSyncBackend(
       if (!bbPath) {
         throw new Error('Native backend requires bb binary.');
       }
-      const napiPath = findNapiBinary();
+      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, options.threads, options.logger);
+      const shm = await BarretenbergNativeShmSyncBackend.new(bbPath, napiPath, options.threads, options.logger);
       return new BarretenbergSync(shm);
     }
 

package/src/bb_backends/node/native_shm.ts

@@ -1,24 +1,9 @@
 import { createRequire } from 'module';
 import { spawn, ChildProcess } from 'child_process';
-import { openSync, closeSync } from 'fs';
+import { openSync, closeSync, unlinkSync } from 'fs';
 import { IMsgpackBackendSync } from '../interface.js';
 import { findNapiBinary, findPackageRoot } from './platform.js';
 
-// Import the NAPI module
-// The addon is built to the nodejs_module directory
-const addonPath = findNapiBinary();
-// Try loading, but don't throw if it doesn't exist (will be caught in constructor)
-let addon: any = null;
-try {
-  if (addonPath) {
-    const require = createRequire(findPackageRoot()!);
-    addon = require(addonPath);
-  }
-} catch (err) {
-  // Addon not built yet or not available
-  addon = null;
-}
-
 let instanceCounter = 0;
 
 /**
@@ -46,15 +31,26 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
   /**
    * Create and initialize a shared memory backend.
    * @param bbBinaryPath Path to bb binary
+   * @param napiPath Path to NAPI binary
    * @param threads Optional number of threads
    */
   static async new(
     bbBinaryPath: string,
+    napiPath: string,
     threads?: number,
     logger?: (msg: string) => void,
   ): Promise<BarretenbergNativeShmSyncBackend> {
-    if (!addon || !addon.MsgpackClient) {
-      throw new Error('Shared memory NAPI not available.');
+    // Import the NAPI module
+    // The addon is built to the nodejs_module directory
+    const addonPath = findNapiBinary(napiPath);
+    // Try loading
+    let addon: any = null;
+    try {
+      const require = createRequire(findPackageRoot()!);
+      addon = require(addonPath!);
+    } catch (err) {
+      // Addon not built yet or not available
+      throw new Error('Shared memory sync NAPI not available.');
     }
 
     // Create a unique shared memory name
@@ -74,6 +70,28 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
       logger(`BB process logs redirected to: ${logPath}`);
     }
 
+    // Clean up any stale shared memory files from previous runs
+    // This handles the case where a previous process crashed without cleanup
+    const shmRequestPath = `/dev/shm/${shmName}_request`;
+    const shmResponsePath = `/dev/shm/${shmName}_response`;
+    try {
+      unlinkSync(shmRequestPath);
+    } catch (err) {
+      const isNotFound = err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT';
+      if (!isNotFound) {
+        throw new Error(`Failed to clean up stale shared memory file ${shmRequestPath}: ${err}`);
+      }
+    }
+
+    try {
+      unlinkSync(shmResponsePath);
+    } catch (err) {
+      const isNotFound = err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT';
+      if (!isNotFound) {
+        throw new Error(`Failed to clean up stale shared memory file ${shmResponsePath}: ${err}`);
+      }
+    }
+
     // Spawn bb process with shared memory mode (SPSC-only, no max-clients needed)
     const args = ['msgpack', 'run', '--input', `${shmName}.shm`, '--request-ring-size', `${1024 * 1024 * 4}`];
     const bbProcess = spawn(bbBinaryPath, args, {

package/src/bb_backends/node/native_shm_async.ts

@@ -4,21 +4,6 @@ import { openSync, closeSync } from 'fs';
 import { IMsgpackBackendAsync } from '../interface.js';
 import { findNapiBinary, findPackageRoot } from './platform.js';
 
-// Import the NAPI module
-// The addon is built to the nodejs_module directory
-const addonPath = findNapiBinary();
-// Try loading, but don't throw if it doesn't exist (will be caught in constructor)
-let addon: any = null;
-try {
-  if (addonPath) {
-    const require = createRequire(findPackageRoot()!);
-    addon = require(addonPath);
-  }
-} catch (err) {
-  // Addon not built yet or not available
-  addon = null;
-}
-
 let instanceCounter = 0;
 
 /**
@@ -86,18 +71,28 @@ export class BarretenbergNativeShmAsyncBackend implements IMsgpackBackendAsync {
    */
   static async new(
     bbBinaryPath: string,
+    napiPath: string,
     threads?: number,
     logger?: (msg: string) => void,
   ): Promise<BarretenbergNativeShmAsyncBackend> {
-    if (!addon || !addon.MsgpackClientAsync) {
+    // Import the NAPI module
+    // The addon is built to the nodejs_module directory
+    const addonPath = findNapiBinary(napiPath);
+    // Try loading
+    let addon: any = null;
+    try {
+      const require = createRequire(findPackageRoot()!);
+      addon = require(addonPath!);
+    } catch (err) {
+      // Addon not built yet or not available
       throw new Error('Shared memory async NAPI not available.');
     }
 
     // Create a unique shared memory name
     const shmName = `bb-async-${process.pid}-${instanceCounter++}`;
 
-    // If threads not set use num cpu cores, max 32 (same as socket backend)
-    const hwc = threads ? threads.toString() : '1';
+    // If threads not set use num cpu cores, max 16 (same as socket backend)
+    const hwc = threads ? threads.toString() : '16';
     const env = { ...process.env, HARDWARE_CONCURRENCY: hwc };
 
     // Set up file logging if logger is provided

package/src/bb_backends/node/native_socket.ts

@@ -4,7 +4,6 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { IMsgpackBackendAsync } from '../interface.js';
-import { findPackageRoot } from './platform.js';
 import readline from 'readline';
 
 /**
@@ -58,9 +57,9 @@ export class BarretenbergNativeSocketAsyncBackend implements IMsgpackBackendAsyn
       connectionReject = reject;
     });
 
-    // If threads not set use num cpu cores, max 32.
-    const hwc = threads ? threads.toString() : Math.min(32, os.cpus.length).toString();
-    const env = { ...process.env, HARDWARE_CONCURRENCY: '1' };
+    // If threads not set use num cpu cores, max 16.
+    const hwc = threads ? threads.toString() : Math.min(16, os.cpus().length).toString();
+    const env = { ...process.env, HARDWARE_CONCURRENCY: hwc };
 
     // Spawn bb process - it will create the socket server
     const args = ['msgpack', 'run', '--input', this.socketPath];

package/src/bb_backends/node/platform.ts

@@ -24,7 +24,12 @@ export function findPackageRoot(): string | null {
   while (currentDir !== root) {
     const packageJsonPath = path.join(currentDir, 'package.json');
     if (fs.existsSync(packageJsonPath)) {
-      return currentDir;
+      // Check if this is the actual package root by verifying it has a 'build' directory
+      // This ensures we skip intermediate package.json files (e.g., in dest/node-cjs/)
+      const buildDir = path.join(currentDir, 'build');
+      if (fs.existsSync(buildDir)) {
+        return currentDir;
+      }
     }
     currentDir = path.dirname(currentDir);
   }

package/src/cbind/generate.ts

@@ -1,5 +1,8 @@
 /**
- * Generate TypeScript bindings from msgpack schema
+ * Multi-language code generation from BB msgpack schema
+ *
+ * Architecture:
+ *   Raw Schema → SchemaVisitor → CompiledSchema IR → Language Codegens → Files
  */
 
 import { writeFileSync, mkdirSync } from 'fs';
@@ -8,36 +11,42 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
 import { unpack } from 'msgpackr';
-import {
-  createSharedTypesCompiler,
-  createSyncApiCompiler,
-  createAsyncApiCompiler,
-  type SchemaCompiler,
-} from './schema_compiler.js';
+import { SchemaVisitor, type CompiledSchema } from './schema_visitor.js';
+import { TypeScriptCodegen } from './typescript_codegen.js';
+import { RustCodegen } from './rust_codegen.js';
 
 const execAsync = promisify(exec);
 
-interface GeneratorConfig {
+// Language generators - all use the same CompiledSchema IR
+interface LanguageGenerator {
   name: string;
-  outputFile: string;
-  createCompiler: () => SchemaCompiler;
+  enabled: boolean;
+  generate: (compiled: CompiledSchema) => Array<{ path: string; content: string }>;
 }
 
-const GENERATORS: GeneratorConfig[] = [
+const LANGUAGE_GENERATORS: LanguageGenerator[] = [
   {
-    name: 'Shared types',
-    outputFile: 'generated/api_types.ts',
-    createCompiler: createSharedTypesCompiler,
+    name: 'TypeScript',
+    enabled: true,
+    generate: (compiled) => {
+      const tsGen = new TypeScriptCodegen();
+      return [
+        { path: 'generated/api_types.ts', content: tsGen.generateTypes(compiled) },
+        { path: 'generated/sync.ts', content: tsGen.generateSyncApi(compiled) },
+        { path: 'generated/async.ts', content: tsGen.generateAsyncApi(compiled) },
+      ];
+    },
   },
   {
-    name: 'Sync API',
-    outputFile: 'generated/sync.ts',
-    createCompiler: createSyncApiCompiler,
-  },
-  {
-    name: 'Async API',
-    outputFile: 'generated/async.ts',
-    createCompiler: createAsyncApiCompiler,
+    name: 'Rust',
+    enabled: true,
+    generate: (compiled) => {
+      const rustGen = new RustCodegen();
+      return [
+        { path: '../../../rust/barretenberg-rs/src/generated_types.rs', content: rustGen.generateTypes(compiled) },
+        { path: '../../../rust/barretenberg-rs/src/api.rs', content: rustGen.generateApi(compiled) },
+      ];
+    },
   },
 ];
 
@@ -56,29 +65,39 @@ async function generate() {
     throw new Error('Invalid schema: missing commands or responses');
   }
 
-  console.log('Generating TypeScript bindings...\n');
+  // Compile schema once using visitor pattern
+  console.log('Compiling schema...');
+  const visitor = new SchemaVisitor();
+  const compiled = visitor.visit(schema.commands, schema.responses);
+
+  console.log(`Found ${compiled.commands.length} commands, ${compiled.structs.size} structs\n`);
 
   // Ensure output directory exists
   const outputDir = join(__dirname, 'generated');
   mkdirSync(outputDir, { recursive: true });
 
-  // Generate each output file
-  for (const config of GENERATORS) {
-    const compiler = config.createCompiler();
-    compiler.processApiSchema(schema.commands, schema.responses);
+  // Generate all language bindings from compiled IR
+  for (const generator of LANGUAGE_GENERATORS) {
+    if (!generator.enabled) {
+      console.log(`⊘ ${generator.name}: disabled`);
+      continue;
+    }
 
-    const outputPath = join(__dirname, config.outputFile);
-    const content = compiler.compile();
-    writeFileSync(outputPath, content);
+    const files = generator.generate(compiled);
 
-    console.log(`✓ ${config.name}: ${outputPath}`);
+    for (const file of files) {
+      const outputPath = join(__dirname, file.path);
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync(outputPath, file.content);
+      console.log(`✓ ${generator.name}: ${outputPath}`);
+    }
   }
 
   // Generate curve constants
   console.log('\nGenerating curve constants...');
   await generateCurveConstants(bbBuildPath, outputDir);
 
-  console.log('\nGeneration complete!');
+  console.log('\n✨ Generation complete! Clean, maintainable, multi-language architecture.');
 }
 
 async function generateCurveConstants(bbBuildPath: string, outputDir: string) {