@aztec/ivc-integration 3.0.0-nightly.20251115 → 3.0.0-nightly.20251118

package/src/prove_native.ts

@@ -4,8 +4,6 @@ import {
   PUBLIC_INPUTS_FILENAME,
   type UltraHonkFlavor,
   VK_FILENAME,
-  executeBbChonkProof,
-  extractVkData,
   generateAvmProof,
   generateProof,
   readProofsFromOutputDirectory,
@@ -16,6 +14,7 @@ import {
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED,
   CHONK_PROOF_LENGTH,
+  HIDING_KERNEL_IO_PUBLIC_INPUTS_SIZE,
   NESTED_RECURSIVE_PROOF_LENGTH,
   RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
 } from '@aztec/constants';
@@ -23,61 +22,33 @@ import { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
 import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
-import { type ProofAndVerificationKey, makeProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
+import { makeProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
 import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
-import type { Proof } from '@aztec/stdlib/proofs';
+import { Proof, RecursiveProof } from '@aztec/stdlib/proofs';
 import { enhanceProofWithPiValidationFlag } from '@aztec/stdlib/rollup';
 import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
 
 import * as fs from 'fs/promises';
-import { Encoder } from 'msgpackr';
 import * as path from 'path';
 
-/**
- * Converts verification key bytes from a compiled circuit to VerificationKeyData format
- * @param vkBytes - The verification key bytes from the circuit
- * @returns The verification key data
- */
-async function convertVkBytesToVkData(vkBytes: Buffer): Promise<VerificationKeyData> {
-  // Convert binary to field elements (32 bytes per field)
-  const numFields = vkBytes.length / Fr.SIZE_IN_BYTES;
-  const reader = BufferReader.asReader(vkBytes);
-  const fields = reader.readArray(numFields, Fr);
+export async function proofBytesToRecursiveProof(
+  proofAsFields: Uint8Array[],
+  vkBytes: Uint8Array,
+): Promise<RecursiveProof<typeof CHONK_PROOF_LENGTH>> {
+  const vk = await VerificationKeyAsFields.fromFrBuffer(Buffer.from(vkBytes));
+  const numCustomPublicInputs = vk.numPublicInputs - HIDING_KERNEL_IO_PUBLIC_INPUTS_SIZE;
+  // Convert Uint8Array fields to Fr instances
+  const fields = proofAsFields.map(f => Fr.fromBuffer(Buffer.from(f)));
 
-  const vkAsFields = await VerificationKeyAsFields.fromKey(fields);
-  return new VerificationKeyData(vkAsFields, vkBytes);
-}
-
-export async function proveChonk(
-  bbBinaryPath: string,
-  bbWorkingDirectory: string,
-  witnessStack: Uint8Array[],
-  bytecodes: string[],
-  vks: string[],
-  logger: Logger,
-): Promise<ProofAndVerificationKey<typeof CHONK_PROOF_LENGTH>> {
-  const stepToStruct = (bytecode: string, index: number) => {
-    return {
-      bytecode: Buffer.from(bytecode, 'base64'),
-      witness: witnessStack[index],
-      vk: Buffer.from(vks[index], 'hex'),
-      functionName: `unknown_${index}`,
-    };
-  };
-  const encoded = new Encoder({ useRecords: false }).pack(bytecodes.map(stepToStruct));
-  const ivcInputsPath = path.join(bbWorkingDirectory, 'ivc-inputs.msgpack');
-  await fs.writeFile(ivcInputsPath, encoded);
+  // Slice off custom public inputs from the beginning.
+  const fieldsWithoutPublicInputs = fields.slice(numCustomPublicInputs);
 
-  const provingResult = await executeBbChonkProof(bbBinaryPath, bbWorkingDirectory, ivcInputsPath, logger.info, true);
+  // Convert fields to binary buffer
+  const proofBuffer = Buffer.concat(proofAsFields.slice(numCustomPublicInputs));
 
-  if (provingResult.status === BB_RESULT.FAILURE) {
-    throw new Error(provingResult.reason);
-  }
-
-  const vk = await extractVkData(provingResult.vkDirectoryPath!);
-  const proof = await readProofsFromOutputDirectory(provingResult.proofPath!, vk, CHONK_PROOF_LENGTH, logger);
-
-  return makeProofAndVerificationKey(proof, vk);
+  // Create Proof directly (not using fromBuffer which expects different format)
+  const proof = new Proof(proofBuffer, numCustomPublicInputs);
+  return new RecursiveProof(fieldsWithoutPublicInputs, proof, true, CHONK_PROOF_LENGTH);
 }
 
 async function verifyProofWithKey(
@@ -130,7 +101,7 @@ async function proveRollupCircuit<T extends UltraHonkFlavor, ProofLength extends
     throw new Error(`Failed to generate proof for ${name} with flavor ${flavor}`);
   }
 
-  const vk = await convertVkBytesToVkData(vkBuffer);
+  const vk = await VerificationKeyData.fromFrBuffer(vkBuffer);
   const proof = await readProofsFromOutputDirectory(proofResult.proofPath!, vk, proofLength, logger);
 
   await verifyProofWithKey(pathToBB, workingDirectory, vk, proof.binaryProof, flavor, logger);

package/src/serve.ts

@@ -1,12 +1,27 @@
+import { AztecClientBackend, Barretenberg } from '@aztec/bb.js';
 import { createLogger } from '@aztec/foundation/log';
 
-import { proveThenVerifyAztecClient } from './prove_wasm.js';
-import { generateTestingIVCStack } from './witgen.js';
+import {
+  MockAppCreatorCircuit,
+  MockHidingCircuit,
+  MockPrivateKernelInitCircuit,
+  MockPrivateKernelTailCircuit,
+  generateTestingIVCStack,
+} from './witgen.js';
 
 const logger = createLogger('aztec:ivc-test');
 
 /* eslint-disable no-console */
 
+// Expose APIs on window for browser testing
+(window as any).Barretenberg = Barretenberg;
+(window as any).AztecClientBackend = AztecClientBackend;
+(window as any).generateTestingIVCStack = generateTestingIVCStack;
+(window as any).MockAppCreatorCircuit = MockAppCreatorCircuit;
+(window as any).MockPrivateKernelInitCircuit = MockPrivateKernelInitCircuit;
+(window as any).MockPrivateKernelTailCircuit = MockPrivateKernelTailCircuit;
+(window as any).MockHidingCircuit = MockHidingCircuit;
+
 // Function to set up the output element and redirect all console output
 function setupConsoleOutput() {
   const container = document.createElement('div');
@@ -78,20 +93,32 @@ function setupConsoleOutput() {
   };
 }
 
-(window as any).proveThenVerifyAztecClient = proveThenVerifyAztecClient;
+// Only set up the interactive UI if this is not being used for automated testing
+if (!document.getElementById('status')) {
+  document.addEventListener('DOMContentLoaded', function () {
+    setupConsoleOutput(); // Initialize console output capture
+
+    const button = document.createElement('button');
+    button.innerText = 'Run Test';
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    button.addEventListener('click', async () => {
+      logger.info(`generating circuit and witness...`);
+      const [bytecodes, witnessStack, _publicInputs, precomputedVks] = await generateTestingIVCStack(1, 0);
+      logger.info(`done. proving and verifying...`);
+
+      const barretenberg = await Barretenberg.initSingleton({
+        threads: 16,
+        logger: (m: string) => logger.info(m),
+      });
+
+      const backend = new AztecClientBackend(bytecodes, barretenberg);
+      const [, proof, vk] = await backend.prove(witnessStack, precomputedVks);
+      const verified = await backend.verify(proof, vk);
 
-document.addEventListener('DOMContentLoaded', function () {
-  setupConsoleOutput(); // Initialize console output capture
+      logger.info(`verified? ${verified}`);
 
-  const button = document.createElement('button');
-  button.innerText = 'Run Test';
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  button.addEventListener('click', async () => {
-    logger.info(`generating circuit and witness...`);
-    const [bytecodes, witnessStack, _publicInputs, precomputedVks] = await generateTestingIVCStack(1, 0);
-    logger.info(`done. proving and verifying...`);
-    const verified = await proveThenVerifyAztecClient(bytecodes, witnessStack, precomputedVks);
-    logger.info(`verified? ${verified}`);
+      await Barretenberg.destroySingleton();
+    });
+    document.body.appendChild(button);
   });
-  document.body.appendChild(button);
-});
+}

package/src/witgen.ts

@@ -12,6 +12,7 @@ import type { RecursiveProof } from '@aztec/stdlib/proofs';
 import { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 
 import { strict as assert } from 'assert';
+import { ungzip } from 'pako';
 
 import MockAppCreatorCircuit from '../artifacts/app_creator.json' with { type: 'json' };
 import MockAppReaderCircuit from '../artifacts/app_reader.json' with { type: 'json' };
@@ -251,7 +252,7 @@ export async function generateTestingIVCStack(
   // A call to the reader app creates 1 read request. A reset kernel will be run if there are 2 read requests in the
   // public inputs. All read requests must be cleared before running the tail kernel.
   numReaderAppCalls: number,
-): Promise<[string[], Uint8Array[], KernelPublicInputs, string[]]> {
+): Promise<[Uint8Array[], Uint8Array[], KernelPublicInputs, Uint8Array[]]> {
   if (numCreatorAppCalls > 2) {
     throw new Error('The creator app can only be called at most twice.');
   }
@@ -368,7 +369,22 @@ export async function generateTestingIVCStack(
   bytecodes.push(MockHidingCircuit.bytecode);
   vks.push(MockHidingVk.keyAsBytes);
 
-  return [bytecodes, witnessStack, hidingWitnessGenResult.publicInputs, vks];
+  function base64ToUint8Array(base64: string): Uint8Array {
+    return Uint8Array.from(atob(base64), c => c.charCodeAt(0));
+  }
+  function hexToUint8Array(hex: string): Uint8Array {
+    const cleaned = hex.replace(/^0x/i, '');
+    const bytes = new Uint8Array(cleaned.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = parseInt(cleaned.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  const rawBytecodes = bytecodes.map(base64ToUint8Array).map((arr: Uint8Array) => ungzip(arr));
+  const rawWitnessStack = witnessStack.map((arr: Uint8Array) => ungzip(arr));
+  const rawVks = vks.map(hexToUint8Array);
+
+  return [rawBytecodes, rawWitnessStack, hidingWitnessGenResult.publicInputs, rawVks];
 }
 
 export function mapRecursiveProofToNoir<N extends number>(proof: RecursiveProof<N>): FixedLengthArray<string, N> {

package/dest/prove_wasm.d.ts

@@ -1,4 +0,0 @@
-import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
-export declare function proveChonk(bytecodes: string[], witnessStack: Uint8Array[], vks: string[], threads?: number): Promise<ChonkProofWithPublicInputs>;
-export declare function proveThenVerifyAztecClient(bytecodes: string[], witnessStack: Uint8Array[], vks: string[], threads?: number): Promise<boolean>;
-//# sourceMappingURL=prove_wasm.d.ts.map

package/dest/prove_wasm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prove_wasm.d.ts","sourceRoot":"","sources":["../src/prove_wasm.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAWlE,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,GAAG,EAAE,MAAM,EAAE,EACb,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,0BAA0B,CAAC,CAerC;AAED,wBAAsB,0BAA0B,CAC9C,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,GAAG,EAAE,MAAM,EAAE,EACb,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAiBlB"}

package/dest/prove_wasm.js

@@ -1,38 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
-import os from 'os';
-import { ungzip } from 'pako';
-const logger = createLogger('ivc-integration:prove_wasm');
-function base64ToUint8Array(base64) {
-    return Uint8Array.from(atob(base64), (c)=>c.charCodeAt(0));
-}
-export async function proveChonk(bytecodes, witnessStack, vks, threads) {
-    const { AztecClientBackend } = await import('@aztec/bb.js');
-    const backend = new AztecClientBackend(bytecodes.map(base64ToUint8Array).map((arr)=>ungzip(arr)), {
-        threads: threads || Math.min(os.cpus().length, 16),
-        logger: logger.info,
-        wasmPath: process.env.BB_WASM_PATH
-    });
-    try {
-        const [proof] = await backend.prove(witnessStack.map((arr)=>ungzip(arr)), vks.map((hex)=>new Uint8Array(Buffer.from(hex, 'hex'))));
-        return ChonkProofWithPublicInputs.fromBufferArray(proof);
-    } finally{
-        await backend.destroy();
-    }
-}
-export async function proveThenVerifyAztecClient(bytecodes, witnessStack, vks, threads) {
-    const { AztecClientBackend } = await import('@aztec/bb.js');
-    const backend = new AztecClientBackend(bytecodes.map(base64ToUint8Array).map((arr)=>ungzip(arr)), {
-        threads: threads || Math.min(os.cpus().length, 16),
-        logger: logger.info,
-        wasmPath: process.env.BB_WASM_PATH
-    });
-    try {
-        // These are optional - easier not to pass them.
-        const [_, msgpackProof, vk] = await backend.prove(witnessStack.map((arr)=>ungzip(arr)), vks.map((hex)=>new Uint8Array(Buffer.from(hex, 'hex'))));
-        const verified = await backend.verify(msgpackProof, vk);
-        return verified;
-    } finally{
-        await backend.destroy();
-    }
-}

package/src/prove_wasm.ts

@@ -1,57 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
-
-import os from 'os';
-import { ungzip } from 'pako';
-
-const logger = createLogger('ivc-integration:prove_wasm');
-
-function base64ToUint8Array(base64: string): Uint8Array {
-  return Uint8Array.from(atob(base64), c => c.charCodeAt(0));
-}
-
-export async function proveChonk(
-  bytecodes: string[],
-  witnessStack: Uint8Array[],
-  vks: string[],
-  threads?: number,
-): Promise<ChonkProofWithPublicInputs> {
-  const { AztecClientBackend } = await import('@aztec/bb.js');
-  const backend = new AztecClientBackend(
-    bytecodes.map(base64ToUint8Array).map((arr: Uint8Array) => ungzip(arr)),
-    { threads: threads || Math.min(os.cpus().length, 16), logger: logger.info, wasmPath: process.env.BB_WASM_PATH },
-  );
-  try {
-    const [proof] = await backend.prove(
-      witnessStack.map((arr: Uint8Array) => ungzip(arr)),
-      vks.map(hex => new Uint8Array(Buffer.from(hex, 'hex'))),
-    );
-    return ChonkProofWithPublicInputs.fromBufferArray(proof);
-  } finally {
-    await backend.destroy();
-  }
-}
-
-export async function proveThenVerifyAztecClient(
-  bytecodes: string[],
-  witnessStack: Uint8Array[],
-  vks: string[],
-  threads?: number,
-): Promise<boolean> {
-  const { AztecClientBackend } = await import('@aztec/bb.js');
-  const backend = new AztecClientBackend(
-    bytecodes.map(base64ToUint8Array).map((arr: Uint8Array) => ungzip(arr)),
-    { threads: threads || Math.min(os.cpus().length, 16), logger: logger.info, wasmPath: process.env.BB_WASM_PATH },
-  );
-  try {
-    // These are optional - easier not to pass them.
-    const [_, msgpackProof, vk] = await backend.prove(
-      witnessStack.map((arr: Uint8Array) => ungzip(arr)),
-      vks.map(hex => new Uint8Array(Buffer.from(hex, 'hex'))),
-    );
-    const verified = await backend.verify(msgpackProof, vk);
-    return verified;
-  } finally {
-    await backend.destroy();
-  }
-}