@aztec-labs/ivc-integration 6.0.0-nightly.20260829

package/src/batch_verifier_test_helpers.ts

@@ -0,0 +1,32 @@
+import { BatchChonkVerifier } from '@aztec-labs/bb-prover';
+import type { IVCProofVerificationResult } from '@aztec-labs/stdlib/interfaces/server';
+
+/** Corrupt flat proof fields by flipping bytes in an early field element. */
+export function corruptProofFields(fields: Uint8Array[]): Uint8Array[] {
+  const corrupted = fields.map(f => Uint8Array.from(f));
+  corrupted[2] = Uint8Array.from(corrupted[2]);
+  corrupted[2][30] ^= 0xff;
+  corrupted[2][31] ^= 0xff;
+  return corrupted;
+}
+
+/** Create a BatchChonkVerifier, enqueue proofs, collect results, and stop. */
+export async function runBatchVerifier(opts: {
+  vks: Uint8Array[];
+  numCores: number;
+  batchSize: number;
+  proofs: { vkIndex: number; proofFields: Uint8Array[] }[];
+}): Promise<IVCProofVerificationResult[]> {
+  const verifier = await BatchChonkVerifier.newForTesting(
+    { bbChonkVerifyConcurrency: opts.numCores },
+    opts.vks,
+    opts.batchSize,
+  );
+
+  try {
+    const promises = opts.proofs.map(p => verifier.enqueueProof(p.vkIndex, p.proofFields));
+    return await Promise.all(promises);
+  } finally {
+    await verifier.stop();
+  }
+}

package/src/bb_working_directory.ts

@@ -0,0 +1,9 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+export async function getWorkingDirectory(prefix: string): Promise<string> {
+  const baseFolder = process.env.BB_WORKING_DIRECTORY || os.tmpdir();
+  await fs.mkdir(baseFolder, { recursive: true });
+  return await fs.mkdtemp(path.join(baseFolder, prefix));
+}

package/src/index.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>My Test bb.js App</title>
+  </head>
+  <body>
+    <script src="index.js"></script>
+  </body>
+</html>

package/src/index.ts

@@ -0,0 +1 @@
+export * from './witgen.js';

package/src/prove_native.ts

@@ -0,0 +1,171 @@
+import { BBJsFactory, type UltraHonkFlavor, constructRecursiveProofFromBuffers } from '@aztec-labs/bb-prover';
+import {
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
+  CHONK_PROOF_LENGTH,
+  HIDING_KERNEL_IO_PUBLIC_INPUTS_SIZE,
+  NESTED_RECURSIVE_PROOF_LENGTH,
+  RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+} from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec-labs/stdlib/avm';
+import { makeProofAndVerificationKey } from '@aztec-labs/stdlib/interfaces/server';
+import type { NoirCompiledCircuit } from '@aztec-labs/stdlib/noir';
+import { Proof, RecursiveProof } from '@aztec-labs/stdlib/proofs';
+import { VerificationKeyAsFields, VerificationKeyData } from '@aztec-labs/stdlib/vks';
+import { ungzip } from 'pako';
+import * as path from 'path';
+
+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)));
+
+  // Slice off custom public inputs from the beginning.
+  const fieldsWithoutPublicInputs = fields.slice(numCustomPublicInputs);
+
+  // Convert fields to binary buffer
+  const proofBuffer = Buffer.concat(proofAsFields.slice(numCustomPublicInputs));
+
+  // 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 proveRollupCircuit<T extends UltraHonkFlavor, ProofLength extends number>(
+  name: string,
+  pathToBB: string,
+  _workingDirectory: string,
+  circuit: NoirCompiledCircuit,
+  witness: Uint8Array,
+  logger: Logger,
+  flavor: T,
+  proofLength: ProofLength,
+) {
+  const factory = new BBJsFactory(pathToBB, { logger });
+  try {
+    // Decompress witness and bytecode for bb.js
+    const decompressedWitness = ungzip(witness);
+    const bytecode = ungzip(Buffer.from(circuit.bytecode, 'base64'));
+    const vkBuffer = Buffer.from(circuit.verificationKey.bytes, 'hex');
+
+    // Generate proof via bb.js
+    await using proveInstance = await factory.getInstance();
+    const proofResult = await proveInstance.generateProof(name, bytecode, vkBuffer, decompressedWitness, flavor);
+
+    const vk = await VerificationKeyData.fromFrBuffer(vkBuffer);
+
+    // Construct proof from in-memory buffers
+    const proof = constructRecursiveProofFromBuffers(
+      proofResult.proofFields,
+      proofResult.publicInputFields,
+      vk,
+      proofLength,
+    );
+
+    // Verify the proof via bb.js
+    await using verifyInstance = await factory.getInstance();
+    const { verified } = await verifyInstance.verifyProof(
+      proofResult.proofFields,
+      vk.keyAsBytes,
+      proofResult.publicInputFields,
+      flavor,
+    );
+
+    if (!verified) {
+      throw new Error(`Failed to verify proof from key!`);
+    }
+    logger.info(`Successfully verified proof from key`);
+
+    return makeProofAndVerificationKey(proof, vk);
+  } finally {
+    await factory.destroy();
+  }
+}
+
+export function proveRollupHonk(
+  name: string,
+  pathToBB: string,
+  workingDirectory: string,
+  circuit: NoirCompiledCircuit,
+  witness: Uint8Array,
+  logger: Logger,
+) {
+  return proveRollupCircuit(
+    name,
+    pathToBB,
+    workingDirectory,
+    circuit,
+    witness,
+    logger,
+    'ultra_rollup_honk',
+    RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  );
+}
+
+export function proveKeccakHonk(
+  name: string,
+  pathToBB: string,
+  workingDirectory: string,
+  circuit: NoirCompiledCircuit,
+  witness: Uint8Array,
+  logger: Logger,
+) {
+  return proveRollupCircuit(
+    name,
+    pathToBB,
+    workingDirectory,
+    circuit,
+    witness,
+    logger,
+    'ultra_keccak_honk',
+    NESTED_RECURSIVE_PROOF_LENGTH,
+  );
+}
+
+/** Generate and verify an AVM proof via bb.js. */
+export async function proveAvm(
+  avmCircuitInputs: AvmCircuitInputs,
+  _workingDirectory: string,
+  logger: Logger,
+): Promise<{
+  proof: Fr[];
+  publicInputs: AvmCircuitPublicInputs;
+}> {
+  const bbPath = path.resolve('../../labs-aztec-toolchain/bin/bb-avm');
+  const factory = new BBJsFactory(bbPath, { logger });
+  try {
+    const inputsBuffer = avmCircuitInputs.serializeWithMessagePack();
+    let proofFields: Uint8Array[];
+    {
+      await using instance = await factory.getInstance();
+      ({ proof: proofFields } = await instance.generateAvmProof(inputsBuffer));
+    }
+
+    // Convert Uint8Array field elements → Fr[]
+    const proof: Fr[] = proofFields.map(f => Fr.fromBuffer(Buffer.from(f)));
+
+    if (proof.length !== AVM_V2_PROOF_LENGTH_IN_FIELDS) {
+      throw new Error(`AVM V2 proof has ${proof.length} fields, expected exactly ${AVM_V2_PROOF_LENGTH_IN_FIELDS}.`);
+    }
+
+    // Explicit verify pass against the serialized public inputs (matches the legacy binary flow).
+    const piBuffer = avmCircuitInputs.publicInputs.serializeWithMessagePack();
+    await using verifyInstance = await factory.getInstance();
+    const { verified: reVerified } = await verifyInstance.verifyAvmProof(proofFields, piBuffer);
+    if (!reVerified) {
+      throw new Error('AVM V2 proof verification failed');
+    }
+
+    return {
+      proof,
+      publicInputs: avmCircuitInputs.publicInputs,
+    };
+  } finally {
+    await factory.destroy();
+  }
+}

package/src/scripts/generate_declaration_files.ts

@@ -0,0 +1,24 @@
+import { fileURLToPath } from '@aztec-labs/foundation/url';
+import { readdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+
+const contract = `\
+import { type NoirCompiledCircuit } from '@aztec-labs/stdlib/noir';
+const circuit: NoirCompiledCircuit;
+export = circuit;
+`;
+
+async function generateDeclarationFor(target: string, content: string) {
+  const files = await readdir(target);
+  for (const file of files) {
+    // guard against running this script twice without cleaning the artifacts/ dir first
+    if (!file.endsWith('.json')) {
+      continue;
+    }
+    const name = file.replace('.json', '');
+    await writeFile(join(target, `${name}.d.json.ts`), content);
+  }
+}
+
+// Generate declaration files for contracts
+await generateDeclarationFor(fileURLToPath(new URL('../../artifacts', import.meta.url).href), contract);

package/src/scripts/generate_ts_from_abi.ts

@@ -0,0 +1,57 @@
+import { codegen } from '@aztec/noir-noir_codegen';
+import { type CompiledCircuit } from '@aztec/noir-types';
+
+import { createConsoleLogger } from '@aztec-labs/foundation/log';
+import { pascalCase } from 'change-case';
+import { promises as fs } from 'fs';
+
+const log = createConsoleLogger('mock-circuits');
+
+const circuits = [
+  'app_creator',
+  'app_reader',
+  'mock_hiding',
+  'mock_private_kernel_init',
+  'mock_private_kernel_inner',
+  'mock_private_kernel_reset',
+  'mock_private_kernel_tail',
+  'mock_rollup_tx_base_public',
+  'mock_rollup_tx_base_private',
+  'mock_rollup_tx_merge',
+  'mock_rollup_root',
+];
+
+const main = async () => {
+  try {
+    await fs.access('./src/types/');
+  } catch (error) {
+    await fs.mkdir('./src/types', { recursive: true });
+  }
+  const programs: [string, CompiledCircuit][] = [];
+  // Collect all circuits
+  for (const circuit of circuits) {
+    const rawData = await fs.readFile(`./artifacts/${circuit}.json`, 'utf-8');
+    const abiObj: CompiledCircuit = JSON.parse(rawData);
+    programs.push([pascalCase(circuit), abiObj]);
+  }
+  let code = codegen(
+    programs,
+    false, // Don't embed artifacts
+    true, // Use fixed length arrays
+  );
+  // noir_codegen emits `InputMap` as a value import, but it is type-only: under
+  // verbatimModuleSyntax that trips TS1484. Rewrite until the generator qualifies it upstream.
+  // TODO(A-1611): Remove once fixed upstream in Noir.
+  code = code.replace(
+    'import { Noir, InputMap, type CompiledCircuit, type ForeignCallHandler }',
+    'import { Noir, type InputMap, type CompiledCircuit, type ForeignCallHandler }',
+  );
+  await fs.writeFile('./src/types/index.ts', code);
+};
+
+try {
+  await main();
+} catch (err: unknown) {
+  log(`Error generating types ${err}`);
+  process.exit(1);
+}

package/src/serve.ts

@@ -0,0 +1,128 @@
+import { AztecClientBackend, Barretenberg } from '@aztec/bb.js';
+
+import { createLogger } from '@aztec-labs/foundation/log';
+
+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');
+  container.style.marginBottom = '10px';
+  document.body.appendChild(container);
+
+  const copyButton = document.createElement('button');
+  copyButton.innerText = 'Copy Logs to Clipboard';
+  copyButton.style.marginBottom = '10px';
+  copyButton.addEventListener('click', () => {
+    const logContent = logContainer.textContent || ''; // Get text content of log container
+    navigator.clipboard
+      .writeText(logContent)
+      .then(() => {
+        alert('Logs copied to clipboard!');
+      })
+      .catch(err => {
+        console.error('Failed to copy logs:', err);
+      });
+  });
+  container.appendChild(copyButton);
+
+  const logContainer = document.createElement('pre');
+  logContainer.id = 'logOutput';
+  logContainer.style.border = '1px solid #ccc';
+  logContainer.style.padding = '10px';
+  logContainer.style.maxHeight = '400px';
+  logContainer.style.overflowY = 'auto';
+  container.appendChild(logContainer);
+
+  // Helper to append messages to logContainer
+  function addLogMessage(message: string) {
+    logContainer.textContent += message + '\n';
+    logContainer.scrollTop = logContainer.scrollHeight; // Auto-scroll to the bottom
+  }
+
+  // Override console methods to output clean logs
+  const originalLog = console.log;
+  const originalDebug = console.debug;
+
+  console.log = (...args: any[]) => {
+    const message = args
+      .map(arg =>
+        typeof arg === 'string'
+          ? arg
+              .replace(/%c/g, '')
+              .replace(/color:.*?(;|$)/g, '')
+              .trim()
+          : arg,
+      )
+      .join(' ');
+    originalLog.apply(console, args); // Keep original behavior
+    addLogMessage(message);
+  };
+
+  console.debug = (...args: any[]) => {
+    const message = args
+      .map(arg =>
+        typeof arg === 'string'
+          ? arg
+              .replace(/%c/g, '')
+              .replace(/color:.*?(;|$)/g, '')
+              .trim()
+          : arg,
+      )
+      .join(' ');
+    originalDebug.apply(console, args); // Keep original behavior
+    addLogMessage(message);
+  };
+}
+
+// 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, circuitKinds] = 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, [], circuitKinds);
+      const { proof, vk } = await backend.prove(witnessStack, precomputedVks);
+      const verified = await backend.verify(proof, vk);
+
+      logger.info(`verified? ${verified}`);
+
+      await Barretenberg.destroySingleton();
+    });
+    document.body.appendChild(button);
+  });
+}