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

package/src/barretenberg/backend.ts

@@ -1,16 +1,7 @@
-import { BackendOptions, Barretenberg, CircuitOptions } from './index.js';
-import { RawBuffer } from '../types/raw_buffer.js';
-import {
-  ProofData,
-  reconstructHonkProof,
-  splitHonkProof,
-  PAIRING_POINTS_SIZE,
-  uint8ArrayToHex,
-  hexToUint8Array,
-} from '../proof/index.js';
-import { fromClientIVCProof, toClientIVCProof } from '../cbind/generated/api_types.js';
+import { Barretenberg } from './index.js';
+import { ProofData, uint8ArrayToHex, hexToUint8Array } from '../proof/index.js';
+import { fromChonkProof, toChonkProof } from '../cbind/generated/api_types.js';
 import { ungzip } from 'pako';
-import { Buffer } from 'buffer';
 import { Decoder, Encoder } from 'msgpackr';
 
 export class AztecClientBackendError extends Error {
@@ -19,65 +10,136 @@ 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;
 };
 
-function getProofSettingsFromOptions(
-  options?: UltraHonkBackendOptions,
-): { ipaAccumulation: boolean; oracleHashType: string; disableZk: boolean, optimizedSolidityVerifier: boolean } {
+function getProofSettingsFromOptions(options?: UltraHonkBackendOptions): {
+  ipaAccumulation: boolean;
+  oracleHashType: string;
+  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: options?.keccak || options?.keccakZK ? 'keccak' : (options?.starknet || options?.starknetZK ? 'starknet' : 'poseidon2'),
-    // TODO no current way to target non-zk poseidon2 hash
+    oracleHashType:
+      options?.keccak || options?.keccakZK
+        ? 'keccak'
+        : options?.starknet || options?.starknetZK
+          ? 'starknet'
+          : 'poseidon2',
     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;
-    }
-  }
-
-  async verifyProof(proofData: ProofData & { verificationKey: Uint8Array }, options?: UltraHonkBackendOptions): Promise<boolean> {
-    await this.instantiate();
+  constructor(private api: Barretenberg) {}
 
+  async verifyProof(
+    proofData: ProofData & { verificationKey: Uint8Array },
+    options?: UltraHonkBackendOptions,
+  ): Promise<boolean> {
     const proofFrs: Uint8Array[] = [];
     for (let i = 0; i < proofData.proof.length; i += 32) {
       proofFrs.push(proofData.proof.slice(i, i + 32));
@@ -90,12 +152,6 @@ export class UltraHonkVerifierBackend {
     });
     return verified;
   }
-  destroy(): Promise<void> {
-    if (!this.api) {
-      return Promise.resolve();
-    }
-    return this.api.destroy();
-  }
 }
 
 export class UltraHonkBackend {
@@ -104,39 +160,25 @@ 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)
+      settings: getProofSettingsFromOptions(options),
     });
     console.log(`Generated proof for circuit with ${publicInputs.length} public inputs and ${proof.length} fields.`);
 
@@ -150,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));
@@ -164,7 +204,7 @@ export class UltraHonkBackend {
       },
       settings: getProofSettingsFromOptions(options),
     });
-    const {verified} = await this.api.circuitVerify({
+    const { verified } = await this.api.circuitVerify({
       verificationKey: vkResult.bytes,
       publicInputs: proofData.publicInputs.map(hexToUint8Array),
       proof: proofFrs,
@@ -174,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),
     });
@@ -187,10 +225,12 @@ export class UltraHonkBackend {
   }
 
   /** @description Returns a solidity verifier */
-  async getSolidityVerifier(vk?: Uint8Array): Promise<string> {
-    await this.instantiate();
-    const vkBuf = vk ?? (await this.api.acirWriteVkUltraKeccakHonk(this.acirUncompressedBytecode));
-    return await this.api.acirHonkSolidityVerifier(this.acirUncompressedBytecode, new RawBuffer(vkBuf));
+  async getSolidityVerifier(vk: Uint8Array, options?: UltraHonkBackendOptions): Promise<string> {
+    const result = await this.api.circuitWriteSolidityVerifier({
+      verificationKey: vk,
+      settings: getProofSettingsFromOptions(options),
+    });
+    return result.solidityCode;
   }
 
   // TODO(https://github.com/noir-lang/noir/issues/5661): Update this to handle Honk recursive aggregation in the browser once it is ready in the backend itself
@@ -200,7 +240,6 @@ export class UltraHonkBackend {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _numOfPublicInputs: number,
   ): 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.
@@ -214,7 +253,7 @@ export class UltraHonkBackend {
     const vkResult = await this.api.circuitComputeVk({
       circuit: {
         name: 'circuit',
-        bytecode: Buffer.from(this.acirUncompressedBytecode),
+        bytecode: this.acirUncompressedBytecode,
       },
       settings: getProofSettingsFromOptions({}),
     });
@@ -233,16 +272,9 @@ export class UltraHonkBackend {
       // We use an empty string for the vk hash here as it is unneeded as part of the recursive artifacts
       // The user can be expected to hash the vk inside their circuit to check whether the vk is the circuit
       // they expect
-      vkHash: uint8ArrayToHex(vkResult.hash)
+      vkHash: uint8ArrayToHex(vkResult.hash),
     };
   }
-
-  async destroy(): Promise<void> {
-    if (!this.api) {
-      return;
-    }
-    await this.api.destroy();
-  }
 }
 
 export class AztecClientBackend {
@@ -251,23 +283,12 @@ 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.initSRSClientIVC();
-      this.api = api;
-    }
-  }
-
-  async prove(witnessBuf: Uint8Array[], vksBuf: Uint8Array[] = []): Promise<[Uint8Array, Uint8Array]> {
+  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!');
     }
@@ -275,85 +296,81 @@ 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.clientIvcStart({ numCircuits: this.acirBuf.length });
+    this.api.chonkStart({ numCircuits: this.acirBuf.length });
 
     // 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.clientIvcLoad({
+      this.api.chonkLoad({
         circuit: {
           name: functionName,
-          bytecode: Buffer.from(bytecode),
-          verificationKey: Buffer.from(vk),
-        }
+          bytecode: bytecode,
+          verificationKey: vk,
+        },
       });
 
       // Accumulate with witness
-      this.api.clientIvcAccumulate({
-        witness: Buffer.from(witness),
+      this.api.chonkAccumulate({
+        witness,
       });
-
     }
 
-
-
     // Generate the proof (and wait for all previous steps to finish)
-    const proveResult = await this.api.clientIvcProve({});
+    const proveResult = await this.api.chonkProve({});
     // The API currently expects a msgpack-encoded API.
-    const proof = new Encoder({useRecords: false}).encode(fromClientIVCProof(proveResult.proof));
+    const proof = new Encoder({ useRecords: false }).encode(fromChonkProof(proveResult.proof));
     // Generate the VK
-    const vkResult = await this.api.clientIvcComputeIvcVk({ circuit: {
-      name: 'hiding',
-      bytecode: this.acirBuf[this.acirBuf.length - 1],
-    } });
+    const vkResult = await this.api.chonkComputeIvcVk({
+      circuit: {
+        name: 'hiding',
+        bytecode: this.acirBuf[this.acirBuf.length - 1],
+      },
+    });
 
+    const proofFields = [
+      proveResult.proof.megaProof,
+      proveResult.proof.goblinProof.mergeProof,
+      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))) {
-      throw new AztecClientBackendError('Failed to verify the private (ClientIVC) transaction proof!');
+      throw new AztecClientBackendError('Failed to verify the private (Chonk) transaction proof!');
     }
-    return [proof, vkResult.bytes];
+    return [proofFields, proof, vkResult.bytes];
   }
 
   async verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean> {
-    await this.instantiate();
-    const result = await this.api.clientIvcVerify({
-      proof: toClientIVCProof(new Decoder({useRecords: false}).decode(proof)),
-      vk: Buffer.from(vk),
+    const result = await this.api.chonkVerify({
+      proof: toChonkProof(new Decoder({ useRecords: false }).decode(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.clientIvcStats({
+      const gates = await this.api.chonkStats({
         circuit: {
           name: 'circuit',
           bytecode: buf,
         },
-        includeGatesPerOpcode: false
+        includeGatesPerOpcode: false,
       });
       circuitSizes.push(gates.circuitSize);
     }
     return circuitSizes;
   }
-
-  async destroy(): Promise<void> {
-    if (!this.api) {
-      return;
-    }
-    await this.api.destroy();
-  }
 }
 
 // Converts bytecode from a base64 string to a Uint8Array
@@ -362,17 +379,11 @@ 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.');
   }
 }

package/src/barretenberg/blake2s.test.ts

@@ -1,11 +1,12 @@
-import { Barretenberg, BarretenbergSync } from './index.js';
-import { Buffer32, Fr } from '../types/index.js';
+import { BackendType, Barretenberg, BarretenbergSync } from './index.js';
+import { Fr } from './testing/fields.js';
 
 describe('blake2s async', () => {
   let api: Barretenberg;
 
   beforeAll(async () => {
-    api = await Barretenberg.new({ threads: 1 });
+    // We're going to test over a worker backend to cover more code paths.
+    api = await Barretenberg.new({ threads: 1, backend: BackendType.WasmWorker });
   });
 
   afterAll(async () => {
@@ -14,14 +15,12 @@ describe('blake2s async', () => {
 
   it('blake2s', async () => {
     const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
-    const expected = Buffer32.fromBuffer(
-      new Uint8Array([
-        0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
-        0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
-      ]),
-    );
-    const result = await api.blake2s(input);
-    expect(result).toEqual(expected);
+    const expected = new Uint8Array([
+      0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c, 0x2a,
+      0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+    ]);
+    const response = await api.blake2s({ data: input });
+    expect(response.hash).toEqual(expected);
   });
 
   it('blake2sToField', async () => {
@@ -32,7 +31,8 @@ describe('blake2s async', () => {
         0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
       ]),
     );
-    const result = await api.blake2sToField(input);
+    const response = await api.blake2sToField({ data: input });
+    const result = Fr.fromBuffer(response.field);
     expect(result).toEqual(expected);
   });
 });
@@ -46,14 +46,12 @@ describe('blake2s sync', () => {
 
   it('blake2s', () => {
     const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
-    const expected = Buffer32.fromBuffer(
-      new Uint8Array([
-        0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
-        0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
-      ]),
-    );
-    const result = api.blake2s(input);
-    expect(result).toEqual(expected);
+    const expected = new Uint8Array([
+      0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c, 0x2a,
+      0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+    ]);
+    const response = api.blake2s({ data: input });
+    expect(response.hash).toEqual(expected);
   });
 
   it('blake2sToField', () => {
@@ -64,7 +62,8 @@ describe('blake2s sync', () => {
         0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
       ]),
     );
-    const result = api.blake2sToField(input);
+    const response = api.blake2sToField({ data: input });
+    const result = Fr.fromBuffer(response.field);
     expect(result).toEqual(expected);
   });
 });