@aztec/bb.js 0.0.1-commit.24de95ac → 0.0.1-commit.2ed92850

package/src/barretenberg/backend.ts

@@ -1,8 +1,7 @@
-import { BackendOptions, Barretenberg, CircuitOptions } from './index.js';
+import { Barretenberg } from './index.js';
 import { ProofData, uint8ArrayToHex, hexToUint8Array } from '../proof/index.js';
-import { fromChonkProof, toChonkProof } from '../cbind/generated/api_types.js';
+import { fromChonkProof, toChonkProof, ChonkProof } from '../cbind/generated/api_types.js';
 import { ungzip } from 'pako';
-import { Buffer } from 'buffer';
 import { Decoder, Encoder } from 'msgpackr';
 
 export class AztecClientBackendError extends Error {
@@ -11,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;
 };
 
@@ -43,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:
@@ -51,36 +128,18 @@ 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,
   };
 }
 
 export class UltraHonkVerifierBackend {
-  protected api!: Barretenberg;
-
-  constructor(
-    protected backendOptions: BackendOptions = { threads: 1 },
-    protected circuitOptions: CircuitOptions = { recursive: false },
-  ) {}
-  /** @ignore */
-  private async instantiate(): Promise<void> {
-    if (!this.api) {
-      const api = await Barretenberg.new(this.backendOptions);
-      const honkRecursion = true;
-      await api.initSRSForCircuitSize(0);
-
-      this.api = api;
-    }
-  }
+  constructor(private api: Barretenberg) {}
 
   async verifyProof(
     proofData: ProofData & { verificationKey: Uint8Array },
     options?: UltraHonkBackendOptions,
   ): Promise<boolean> {
-    await this.instantiate();
-
     const proofFrs: Uint8Array[] = [];
     for (let i = 0; i < proofData.proof.length; i += 32) {
       proofFrs.push(proofData.proof.slice(i, i + 32));
@@ -93,12 +152,6 @@ export class UltraHonkVerifierBackend {
     });
     return verified;
   }
-  destroy(): Promise<void> {
-    if (!this.api) {
-      return Promise.resolve();
-    }
-    return this.api.destroy();
-  }
 }
 
 export class UltraHonkBackend {
@@ -107,37 +160,23 @@ export class UltraHonkBackend {
   // These are initialized asynchronously in the `init` function,
   // constructors cannot be asynchronous which is why we do this.
 
-  protected api!: Barretenberg;
-  protected acirUncompressedBytecode: Uint8Array;
+  private acirUncompressedBytecode: Uint8Array;
 
   constructor(
     acirBytecode: string,
-    protected backendOptions: BackendOptions = { threads: 1 },
-    protected circuitOptions: CircuitOptions = { recursive: false },
+    private api: Barretenberg,
   ) {
     this.acirUncompressedBytecode = acirToUint8Array(acirBytecode);
   }
-  /** @ignore */
-  private async instantiate(): Promise<void> {
-    if (!this.api) {
-      const api = await Barretenberg.new(this.backendOptions);
-      const honkRecursion = true;
-      await api.acirInitSRS(this.acirUncompressedBytecode, this.circuitOptions.recursive, honkRecursion);
-
-      this.api = api;
-    }
-  }
 
   async generateProof(compressedWitness: Uint8Array, options?: UltraHonkBackendOptions): Promise<ProofData> {
-    await this.instantiate();
-
     const witness = ungzip(compressedWitness);
     const { proof, publicInputs } = await this.api.circuitProve({
       witness,
       circuit: {
         name: 'circuit',
-        bytecode: Buffer.from(this.acirUncompressedBytecode),
-        verificationKey: Buffer.from([]), // Empty VK - lower performance.
+        bytecode: this.acirUncompressedBytecode,
+        verificationKey: new Uint8Array(0), // Empty VK - lower performance.
       },
       settings: getProofSettingsFromOptions(options),
     });
@@ -153,8 +192,6 @@ export class UltraHonkBackend {
   }
 
   async verifyProof(proofData: ProofData, options?: UltraHonkBackendOptions): Promise<boolean> {
-    await this.instantiate();
-
     const proofFrs: Uint8Array[] = [];
     for (let i = 0; i < proofData.proof.length; i += 32) {
       proofFrs.push(proofData.proof.slice(i, i + 32));
@@ -177,12 +214,10 @@ export class UltraHonkBackend {
   }
 
   async getVerificationKey(options?: UltraHonkBackendOptions): Promise<Uint8Array> {
-    await this.instantiate();
-
     const vkResult = await this.api.circuitComputeVk({
       circuit: {
         name: 'circuit',
-        bytecode: Buffer.from(this.acirUncompressedBytecode),
+        bytecode: this.acirUncompressedBytecode,
       },
       settings: getProofSettingsFromOptions(options),
     });
@@ -191,7 +226,6 @@ export class UltraHonkBackend {
 
   /** @description Returns a solidity verifier */
   async getSolidityVerifier(vk: Uint8Array, options?: UltraHonkBackendOptions): Promise<string> {
-    await this.instantiate();
     const result = await this.api.circuitWriteSolidityVerifier({
       verificationKey: vk,
       settings: getProofSettingsFromOptions(options),
@@ -205,8 +239,8 @@ 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 }> {
-    await this.instantiate();
     // 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
     // is a list of field elements.
@@ -215,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: Buffer.from(this.acirUncompressedBytecode),
+        bytecode: this.acirUncompressedBytecode,
       },
-      settings: getProofSettingsFromOptions({}),
+      settings: getProofSettingsFromOptions(options),
     });
 
     // Convert VK bytes to field elements (32-byte chunks)
@@ -242,13 +274,6 @@ export class UltraHonkBackend {
       vkHash: uint8ArrayToHex(vkResult.hash),
     };
   }
-
-  async destroy(): Promise<void> {
-    if (!this.api) {
-      return;
-    }
-    await this.api.destroy();
-  }
 }
 
 export class AztecClientBackend {
@@ -257,22 +282,11 @@ export class AztecClientBackend {
   // These are initialized asynchronously in the `init` function,
   // constructors cannot be asynchronous which is why we do this.
 
-  protected api!: Barretenberg;
-
   constructor(
-    protected acirBuf: Uint8Array[],
-    protected options: BackendOptions = { threads: 1 },
+    private acirBuf: Uint8Array[],
+    private api: Barretenberg,
   ) {}
 
-  /** @ignore */
-  private async instantiate(): Promise<void> {
-    if (!this.api) {
-      const api = await Barretenberg.new(this.options);
-      await api.initSRSChonk();
-      this.api = api;
-    }
-  }
-
   async prove(witnessBuf: Uint8Array[], vksBuf: Uint8Array[] = []): Promise<[Uint8Array[], Uint8Array, Uint8Array]> {
     if (vksBuf.length !== 0 && this.acirBuf.length !== witnessBuf.length) {
       throw new AztecClientBackendError('Witness and bytecodes must have the same stack depth!');
@@ -281,7 +295,6 @@ export class AztecClientBackend {
       // NOTE: we allow 0 as an explicit 'I have no VKs'. This is a deprecated feature.
       throw new AztecClientBackendError('Witness and VKs must have the same stack depth!');
     }
-    await this.instantiate();
 
     // Queue IVC start with the number of circuits
     this.api.chonkStart({ numCircuits: this.acirBuf.length });
@@ -289,22 +302,22 @@ export class AztecClientBackend {
     // Queue load and accumulate for each circuit
     for (let i = 0; i < this.acirBuf.length; i++) {
       const bytecode = this.acirBuf[i];
-      const witness = witnessBuf[i] || Buffer.from([]);
-      const vk = vksBuf[i] || Buffer.from([]);
+      const witness = witnessBuf[i] || new Uint8Array(0);
+      const vk = vksBuf[i] || new Uint8Array(0);
       const functionName = `unknown_wasm_${i}`;
 
       // Load the circuit
       this.api.chonkLoad({
         circuit: {
           name: functionName,
-          bytecode: Buffer.from(bytecode),
-          verificationKey: Buffer.from(vk),
+          bytecode: bytecode,
+          verificationKey: vk,
         },
       });
 
       // Accumulate with witness
       this.api.chonkAccumulate({
-        witness: Buffer.from(witness),
+        witness,
       });
     }
 
@@ -313,7 +326,7 @@ export class AztecClientBackend {
     // The API currently expects a msgpack-encoded API.
     const proof = new Encoder({ useRecords: false }).encode(fromChonkProof(proveResult.proof));
     // Generate the VK
-    const vkResult = await this.api.chonkComputeIvcVk({
+    const vkResult = await this.api.chonkComputeVk({
       circuit: {
         name: 'hiding',
         bytecode: this.acirBuf[this.acirBuf.length - 1],
@@ -323,29 +336,39 @@ export class AztecClientBackend {
     const proofFields = [
       proveResult.proof.megaProof,
       proveResult.proof.goblinProof.mergeProof,
-      proveResult.proof.goblinProof.eccvmProof.preIpaProof,
-      proveResult.proof.goblinProof.eccvmProof.ipaProof,
+      proveResult.proof.goblinProof.eccvmProof,
+      proveResult.proof.goblinProof.ipaProof,
       proveResult.proof.goblinProof.translatorProof,
     ].flat();
 
-    // Note: Verification may not work correctly until we properly serialize the proof
-    if (!(await this.verify(proof, vkResult.bytes))) {
+    // Verify using native proof directly to avoid redundant encode/decode cycle
+    if (!(await this.verifyNative(proveResult.proof, vkResult.bytes))) {
       throw new AztecClientBackendError('Failed to verify the private (Chonk) transaction proof!');
     }
     return [proofFields, proof, vkResult.bytes];
   }
 
   async verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean> {
-    await this.instantiate();
     const result = await this.api.chonkVerify({
       proof: toChonkProof(new Decoder({ useRecords: false }).decode(proof)),
-      vk: Buffer.from(vk),
+      vk,
+    });
+    return result.valid;
+  }
+
+  /**
+   * Internal verification using native ChonkProof type.
+   * Avoids encode/decode cycle when called from prove().
+   */
+  private async verifyNative(proof: ChonkProof, vk: Uint8Array): Promise<boolean> {
+    const result = await this.api.chonkVerify({
+      proof,
+      vk,
     });
     return result.valid;
   }
 
   async gates(): Promise<number[]> {
-    await this.instantiate();
     const circuitSizes: number[] = [];
     for (const buf of this.acirBuf) {
       const gates = await this.api.chonkStats({
@@ -359,13 +382,6 @@ export class AztecClientBackend {
     }
     return circuitSizes;
   }
-
-  async destroy(): Promise<void> {
-    if (!this.api) {
-      return;
-    }
-    await this.api.destroy();
-  }
 }
 
 // Converts bytecode from a base64 string to a Uint8Array
@@ -374,17 +390,49 @@ function acirToUint8Array(base64EncodedBytecode: string): Uint8Array {
   return ungzip(compressedByteCode);
 }
 
-// Since this is a simple function, we can use feature detection to
-// see if we are in the nodeJs environment or the browser environment.
+// Base64 decode using atob (works in both browser and Node.js 18+)
 function base64Decode(input: string): Uint8Array {
-  if (typeof Buffer !== 'undefined') {
-    // Node.js environment
-    const b = Buffer.from(input, 'base64');
-    return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
-  } else if (typeof atob === 'function') {
-    // Browser environment
+  if (typeof atob === 'function') {
     return Uint8Array.from(atob(input), c => c.charCodeAt(0));
   } else {
-    throw new Error('No implementation found for base64 decoding.');
+    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/blake2s.test.ts

@@ -1,5 +1,5 @@
 import { BackendType, Barretenberg, BarretenbergSync } from './index.js';
-import { Fr } from '../types/index.js';
+import { Fr } from './testing/fields.js';
 
 describe('blake2s async', () => {
   let api: Barretenberg;

package/src/barretenberg/index.ts

@@ -1,12 +1,19 @@
 import { Crs, GrumpkinCrs } from '../crs/index.js';
-import { createDebugLogger } from '../log/index.js';
 import { AsyncApi } from '../cbind/generated/async.js';
 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 } 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 = {
@@ -31,43 +38,38 @@ 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 = {}) {
-    const logger = options.logger ?? createDebugLogger('bb_async');
+    const logger = options.logger ?? (() => {});
 
     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 +108,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();
   }
@@ -177,7 +174,7 @@ export class BarretenbergSync extends SyncApi {
    * Not supported: WasmWorker (no workers in sync), NativeUnixSocket (async only)
    */
   static async new(options: BackendOptions = {}) {
-    const logger = options.logger ?? createDebugLogger('bb_sync');
+    const logger = options.logger ?? (() => {});
 
     if (options.backend) {
       return await createSyncBackend(options.backend, options, logger);

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;