@aztec/ivc-integration 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/src/prove_native.ts

@@ -4,70 +4,51 @@ import {
   PUBLIC_INPUTS_FILENAME,
   type UltraHonkFlavor,
   VK_FILENAME,
-  executeBbClientIvcProof,
-  extractVkData,
   generateAvmProof,
   generateProof,
-  generateTubeProof,
-  readClientIVCProofFromOutputDirectory,
-  readProofAsFields,
+  readProofsFromOutputDirectory,
   verifyAvmProof,
   verifyProof,
 } from '@aztec/bb-prover';
 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,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
 import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
 import { makeProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
 import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
-import type { ClientIvcProof, Proof } from '@aztec/stdlib/proofs';
+import { Proof, RecursiveProof } from '@aztec/stdlib/proofs';
 import { enhanceProofWithPiValidationFlag } from '@aztec/stdlib/rollup';
-import { VerificationKeyAsFields, type VerificationKeyData } from '@aztec/stdlib/vks';
+import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
 
 import * as fs from 'fs/promises';
-import { Encoder } from 'msgpackr';
 import * as path from 'path';
 
-export async function proveClientIVC(
-  bbBinaryPath: string,
-  bbWorkingDirectory: string,
-  witnessStack: Uint8Array[],
-  bytecodes: string[],
-  vks: string[],
-  logger: Logger,
-): Promise<ClientIvcProof> {
-  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);
+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 provingResult = await executeBbClientIvcProof(
-    bbBinaryPath,
-    bbWorkingDirectory,
-    ivcInputsPath,
-    logger.info,
-    true,
-  );
+  // Slice off custom public inputs from the beginning.
+  const fieldsWithoutPublicInputs = fields.slice(numCustomPublicInputs);
 
-  if (provingResult.status === BB_RESULT.FAILURE) {
-    throw new Error(provingResult.reason);
-  }
+  // Convert fields to binary buffer
+  const proofBuffer = Buffer.concat(proofAsFields.slice(numCustomPublicInputs));
 
-  return readClientIVCProofFromOutputDirectory(bbWorkingDirectory);
+  // 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(
@@ -93,22 +74,6 @@ async function verifyProofWithKey(
   logger.info(`Successfully verified proof from key in ${result.durationMs} ms`);
 }
 
-export async function proveTube(pathToBB: string, workingDirectory: string, logger: Logger) {
-  const tubeResult = await generateTubeProof(pathToBB, workingDirectory, workingDirectory.concat('/vk'), logger.info);
-
-  if (tubeResult.status != BB_RESULT.SUCCESS) {
-    throw new Error('Failed to prove tube');
-  }
-
-  const tubeVK = await extractVkData(tubeResult.vkDirectoryPath!);
-  const tubeProof = await readProofAsFields(tubeResult.proofPath!, tubeVK, TUBE_PROOF_LENGTH, logger);
-
-  // Sanity check the tube proof
-  await verifyProofWithKey(pathToBB, workingDirectory, tubeVK, tubeProof.binaryProof, 'ultra_rollup_honk', logger);
-
-  return makeProofAndVerificationKey(tubeProof, tubeVK);
-}
-
 async function proveRollupCircuit<T extends UltraHonkFlavor, ProofLength extends number>(
   name: string,
   pathToBB: string,
@@ -120,11 +85,13 @@ async function proveRollupCircuit<T extends UltraHonkFlavor, ProofLength extends
   proofLength: ProofLength,
 ) {
   await fs.writeFile(path.join(workingDirectory, 'witness.gz'), witness);
+  const vkBuffer = Buffer.from(circuit.verificationKey.bytes, 'hex');
   const proofResult = await generateProof(
     pathToBB,
     workingDirectory,
     name,
     Buffer.from(circuit.bytecode, 'base64'),
+    vkBuffer,
     path.join(workingDirectory, 'witness.gz'),
     flavor,
     logger,
@@ -134,8 +101,8 @@ async function proveRollupCircuit<T extends UltraHonkFlavor, ProofLength extends
     throw new Error(`Failed to generate proof for ${name} with flavor ${flavor}`);
   }
 
-  const vk = await extractVkData(proofResult.vkDirectoryPath!);
-  const proof = await readProofAsFields(proofResult.proofPath!, vk, proofLength, logger);
+  const vk = await VerificationKeyData.fromFrBuffer(vkBuffer);
+  const proof = await readProofsFromOutputDirectory(proofResult.proofPath!, vk, proofLength, logger);
 
   await verifyProofWithKey(pathToBB, workingDirectory, vk, proof.binaryProof, flavor, logger);
 
@@ -193,7 +160,7 @@ export async function proveAvm(
   publicInputs: AvmCircuitPublicInputs;
 }> {
   // The paths for the barretenberg binary and the write path are hardcoded for now.
-  const bbPath = path.resolve('../../barretenberg/cpp/build/bin/bb');
+  const bbPath = path.resolve('../../barretenberg/cpp/build/bin/bb-avm');
 
   // Then we prove.
   const proofRes = await generateAvmProof(bbPath, workingDirectory, avmCircuitInputs, logger);

package/src/scripts/generate_declaration_files.ts

@@ -9,11 +9,6 @@ const circuit: NoirCompiledCircuit;
 export = circuit;
 `;
 
-const vk = `\
-const vk: { keyAsBytes: string; keyAsFields: string[] };
-export = vk;
-`;
-
 async function generateDeclarationFor(target: string, content: string) {
   const files = await readdir(target);
   for (const file of files) {
@@ -28,6 +23,3 @@ async function generateDeclarationFor(target: string, content: string) {
 
 // Generate declaration files for contracts
 await generateDeclarationFor(fileURLToPath(new URL('../../artifacts', import.meta.url).href), contract);
-
-// Generate declaration files for vks
-await generateDeclarationFor(fileURLToPath(new URL('../../artifacts/keys', import.meta.url).href), vk);

package/src/scripts/generate_ts_from_abi.ts

@@ -15,9 +15,9 @@ const circuits = [
   'mock_private_kernel_inner',
   'mock_private_kernel_reset',
   'mock_private_kernel_tail',
-  'mock_rollup_base_public',
-  'mock_rollup_base_private',
-  'mock_rollup_merge',
+  'mock_rollup_tx_base_public',
+  'mock_rollup_tx_base_private',
+  'mock_rollup_tx_merge',
   'mock_rollup_root',
 ];
 

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/types/index.ts

@@ -37,19 +37,21 @@ export type PrivateKernelPublicInputs = {
   read_requests: FixedLengthArray<Field, 4>;
 }
 
-export type TubeData = {
+export type ChonkProofData = {
   public_inputs: KernelPublicInputs;
-  proof: FixedLengthArray<Field, 535>;
-  vk_data: VerificationKey<115>;
+  proof: FixedLengthArray<Field, 1963>;
+  vk_data: VerificationKey<127>;
 }
 
 export type AvmCircuitPublicInputs = {
   global_variables: GlobalVariables;
+  protocol_contracts: ProtocolContracts;
   start_tree_snapshots: TreeSnapshots;
   start_gas_used: Gas;
   gas_settings: GasSettings;
   effective_gas_fees: GasFees;
   fee_payer: AztecAddress;
+  prover_id: Field;
   public_call_request_array_lengths: PublicCallRequestArrayLengths;
   public_setup_call_requests: FixedLengthArray<PublicCallRequest, 32>;
   public_app_logic_call_requests: FixedLengthArray<PublicCallRequest, 32>;
@@ -77,6 +79,10 @@ export type GlobalVariables = {
   gas_fees: GasFees;
 }
 
+export type ProtocolContracts = {
+  derived_addresses: FixedLengthArray<AztecAddress, 11>;
+}
+
 export type TreeSnapshots = {
   l1_to_l2_message_tree: AppendOnlyTreeSnapshot;
   note_hash_tree: AppendOnlyTreeSnapshot;
@@ -134,7 +140,6 @@ export type AvmAccumulatedDataArrayLengths = {
   note_hashes: u32;
   nullifiers: u32;
   l2_to_l1_msgs: u32;
-  public_logs: u32;
   public_data_writes: u32;
 }
 
@@ -142,7 +147,7 @@ export type AvmAccumulatedData = {
   note_hashes: FixedLengthArray<Field, 64>;
   nullifiers: FixedLengthArray<Field, 64>;
   l2_to_l1_msgs: FixedLengthArray<Scoped, 8>;
-  public_logs: FixedLengthArray<PublicLog, 8>;
+  public_logs: PublicLogs;
   public_data_writes: FixedLengthArray<PublicDataWrite, 64>;
 }
 
@@ -152,7 +157,7 @@ export type EthAddress = {
 
 export type AppendOnlyTreeSnapshot = {
   root: Field;
-  next_available_leaf_index: u32;
+  next_available_leaf_index: Field;
 }
 
 export type Scoped = {
@@ -160,9 +165,9 @@ export type Scoped = {
   contract_address: AztecAddress;
 }
 
-export type PublicLog = {
-  log: Log;
-  contract_address: AztecAddress;
+export type PublicLogs = {
+  length: u32;
+  payload: FixedLengthArray<Field, 4096>;
 }
 
 export type PublicDataWrite = {
@@ -175,18 +180,13 @@ export type L2ToL1Message = {
   content: Field;
 }
 
-export type Log = {
-  fields: FixedLengthArray<Field, 13>;
-  length: u32;
-}
-
 export type RollupPublicInputs = {
   accumulated: u32;
 }
 
 export type PreviousRollupData = {
   base_or_merge_public_inputs: RollupPublicInputs;
-  proof: FixedLengthArray<Field, 535>;
+  proof: FixedLengthArray<Field, 531>;
   vk: VerificationKey<115>;
 }
 
@@ -291,45 +291,45 @@ export async function MockPrivateKernelTail(prev_kernel_public_inputs: PrivateKe
   const { returnValue } = await program.execute(args, foreignCallHandler);
   return returnValue as KernelPublicInputs;
 }
-export type MockRollupBasePublicInputType = {
-  tube_data: TubeData;
+export type MockRollupTxBasePublicInputType = {
+  chonk_proof_data: ChonkProofData;
   verification_key: VerificationKey<1000>;
   proof: FixedLengthArray<Field, 20000>;
   public_inputs: AvmCircuitPublicInputs;
 }
 
-export type MockRollupBasePublicReturnType = RollupPublicInputs;
+export type MockRollupTxBasePublicReturnType = RollupPublicInputs;
 
 
-export async function MockRollupBasePublic(tube_data: TubeData, verification_key: VerificationKey<1000>, proof: FixedLengthArray<Field, 20000>, public_inputs: AvmCircuitPublicInputs, MockRollupBasePublic_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
-  const program = new Noir(MockRollupBasePublic_circuit);
-  const args: InputMap = { tube_data, verification_key, proof, public_inputs };
+export async function MockRollupTxBasePublic(chonk_proof_data: ChonkProofData, verification_key: VerificationKey<1000>, proof: FixedLengthArray<Field, 20000>, public_inputs: AvmCircuitPublicInputs, MockRollupTxBasePublic_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
+  const program = new Noir(MockRollupTxBasePublic_circuit);
+  const args: InputMap = { chonk_proof_data, verification_key, proof, public_inputs };
   const { returnValue } = await program.execute(args, foreignCallHandler);
   return returnValue as RollupPublicInputs;
 }
-export type MockRollupBasePrivateInputType = {
-  tube_data: TubeData;
+export type MockRollupTxBasePrivateInputType = {
+  chonk_proof_data: ChonkProofData;
 }
 
-export type MockRollupBasePrivateReturnType = RollupPublicInputs;
+export type MockRollupTxBasePrivateReturnType = RollupPublicInputs;
 
 
-export async function MockRollupBasePrivate(tube_data: TubeData, MockRollupBasePrivate_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
-  const program = new Noir(MockRollupBasePrivate_circuit);
-  const args: InputMap = { tube_data };
+export async function MockRollupTxBasePrivate(chonk_proof_data: ChonkProofData, MockRollupTxBasePrivate_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
+  const program = new Noir(MockRollupTxBasePrivate_circuit);
+  const args: InputMap = { chonk_proof_data };
   const { returnValue } = await program.execute(args, foreignCallHandler);
   return returnValue as RollupPublicInputs;
 }
-export type MockRollupMergeInputType = {
+export type MockRollupTxMergeInputType = {
   a: PreviousRollupData;
   b: PreviousRollupData;
 }
 
-export type MockRollupMergeReturnType = RollupPublicInputs;
+export type MockRollupTxMergeReturnType = RollupPublicInputs;
 
 
-export async function MockRollupMerge(a: PreviousRollupData, b: PreviousRollupData, MockRollupMerge_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
-  const program = new Noir(MockRollupMerge_circuit);
+export async function MockRollupTxMerge(a: PreviousRollupData, b: PreviousRollupData, MockRollupTxMerge_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
+  const program = new Noir(MockRollupTxMerge_circuit);
   const args: InputMap = { a, b };
   const { returnValue } = await program.execute(args, foreignCallHandler);
   return returnValue as RollupPublicInputs;

package/src/witgen.ts

@@ -4,7 +4,7 @@ import {
   MEGA_VK_LENGTH_IN_FIELDS,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
 import { type ForeignCallInput, type ForeignCallOutput, Noir } from '@aztec/noir-noir_js';
 import type { AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
@@ -12,29 +12,19 @@ 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' };
-import MockAppCreatorVk from '../artifacts/keys/app_creator.vk.data.json' with { type: 'json' };
-import MockAppReaderVk from '../artifacts/keys/app_reader.vk.data.json' with { type: 'json' };
-import MockHidingVk from '../artifacts/keys/mock_hiding.vk.data.json' with { type: 'json' };
-import MockPrivateKernelInitVk from '../artifacts/keys/mock_private_kernel_init.vk.data.json' with { type: 'json' };
-import MockPrivateKernelInnerVk from '../artifacts/keys/mock_private_kernel_inner.vk.data.json' with { type: 'json' };
-import MockPrivateKernelResetVk from '../artifacts/keys/mock_private_kernel_reset.vk.data.json' with { type: 'json' };
-import MockPrivateKernelTailVk from '../artifacts/keys/mock_private_kernel_tail.vk.data.json' with { type: 'json' };
-import MockRollupBasePrivateVk from '../artifacts/keys/mock_rollup_base_private.vk.data.json' with { type: 'json' };
-import MockRollupBasePublicVk from '../artifacts/keys/mock_rollup_base_public.vk.data.json' with { type: 'json' };
-import MockRollupMergeVk from '../artifacts/keys/mock_rollup_merge.vk.data.json' with { type: 'json' };
-import MockRollupRootVk from '../artifacts/keys/mock_rollup_root.vk.data.json' with { type: 'json' };
 import MockHidingCircuit from '../artifacts/mock_hiding.json' with { type: 'json' };
 import MockPrivateKernelInitCircuit from '../artifacts/mock_private_kernel_init.json' with { type: 'json' };
 import MockPrivateKernelInnerCircuit from '../artifacts/mock_private_kernel_inner.json' with { type: 'json' };
 import MockPrivateKernelResetCircuit from '../artifacts/mock_private_kernel_reset.json' with { type: 'json' };
 import MockPrivateKernelTailCircuit from '../artifacts/mock_private_kernel_tail.json' with { type: 'json' };
-import MockRollupBasePrivateCircuit from '../artifacts/mock_rollup_base_private.json' with { type: 'json' };
-import MockRollupBasePublicCircuit from '../artifacts/mock_rollup_base_public.json' with { type: 'json' };
-import MockRollupMergeCircuit from '../artifacts/mock_rollup_merge.json' with { type: 'json' };
 import MockRollupRootCircuit from '../artifacts/mock_rollup_root.json' with { type: 'json' };
+import MockRollupTxBasePrivateCircuit from '../artifacts/mock_rollup_tx_base_private.json' with { type: 'json' };
+import MockRollupTxBasePublicCircuit from '../artifacts/mock_rollup_tx_base_public.json' with { type: 'json' };
+import MockRollupTxMergeCircuit from '../artifacts/mock_rollup_tx_merge.json' with { type: 'json' };
 import type {
   AppCreatorInputType,
   AppPublicInputs,
@@ -46,15 +36,36 @@ import type {
   MockPrivateKernelInnerInputType,
   MockPrivateKernelResetInputType,
   MockPrivateKernelTailInputType,
-  MockRollupBasePrivateInputType,
-  MockRollupBasePublicInputType,
-  MockRollupMergeInputType,
   MockRollupRootInputType,
+  MockRollupTxBasePrivateInputType,
+  MockRollupTxBasePublicInputType,
+  MockRollupTxMergeInputType,
   PrivateKernelPublicInputs,
   RollupPublicInputs,
   VerificationKey,
 } from './types/index.js';
 
+// Helper to extract VK from circuit artifact
+function extractVkFromCircuit(circuit: any) {
+  return {
+    keyAsBytes: circuit.verificationKey.bytes,
+    keyAsFields: circuit.verificationKey.fields,
+  };
+}
+
+// Extract VKs from circuit artifacts
+const MockAppCreatorVk = extractVkFromCircuit(MockAppCreatorCircuit);
+const MockAppReaderVk = extractVkFromCircuit(MockAppReaderCircuit);
+const MockPrivateKernelInitVk = extractVkFromCircuit(MockPrivateKernelInitCircuit);
+const MockPrivateKernelInnerVk = extractVkFromCircuit(MockPrivateKernelInnerCircuit);
+const MockPrivateKernelResetVk = extractVkFromCircuit(MockPrivateKernelResetCircuit);
+const MockPrivateKernelTailVk = extractVkFromCircuit(MockPrivateKernelTailCircuit);
+const MockHidingVk = extractVkFromCircuit(MockHidingCircuit);
+const MockRollupTxBasePrivateVk = extractVkFromCircuit(MockRollupTxBasePrivateCircuit);
+const MockRollupTxBasePublicVk = extractVkFromCircuit(MockRollupTxBasePublicCircuit);
+const MockRollupTxMergeVk = extractVkFromCircuit(MockRollupTxMergeCircuit);
+const MockRollupRootVk = extractVkFromCircuit(MockRollupRootCircuit);
+
 // Re export the circuit jsons
 export {
   MockAppCreatorCircuit,
@@ -70,12 +81,12 @@ export {
   MockPrivateKernelTailCircuit,
   MockHidingCircuit,
   MockPrivateKernelTailVk,
-  MockRollupBasePrivateCircuit,
-  MockRollupBasePrivateVk,
-  MockRollupBasePublicCircuit,
-  MockRollupBasePublicVk,
-  MockRollupMergeCircuit,
-  MockRollupMergeVk,
+  MockRollupTxBasePrivateCircuit,
+  MockRollupTxBasePrivateVk,
+  MockRollupTxBasePublicCircuit,
+  MockRollupTxBasePublicVk,
+  MockRollupTxMergeCircuit,
+  MockRollupTxMergeVk,
   MockRollupRootCircuit,
   MockRollupRootVk,
 };
@@ -192,9 +203,9 @@ export async function witnessGenMockHidingCircuit(
 }
 
 export async function witnessGenMockPublicBaseCircuit(
-  args: MockRollupBasePublicInputType,
+  args: MockRollupTxBasePublicInputType,
 ): Promise<WitnessGenResult<RollupPublicInputs>> {
-  const program = new Noir(MockRollupBasePublicCircuit);
+  const program = new Noir(MockRollupTxBasePublicCircuit);
   const { witness, returnValue } = await program.execute(args, foreignCallHandler);
   return {
     witness,
@@ -202,10 +213,10 @@ export async function witnessGenMockPublicBaseCircuit(
   };
 }
 
-export async function witnessGenMockRollupBasePrivateCircuit(
-  args: MockRollupBasePrivateInputType,
+export async function witnessGenMockRollupTxBasePrivateCircuit(
+  args: MockRollupTxBasePrivateInputType,
 ): Promise<WitnessGenResult<RollupPublicInputs>> {
-  const program = new Noir(MockRollupBasePrivateCircuit);
+  const program = new Noir(MockRollupTxBasePrivateCircuit);
   const { witness, returnValue } = await program.execute(args, foreignCallHandler);
   return {
     witness,
@@ -213,10 +224,10 @@ export async function witnessGenMockRollupBasePrivateCircuit(
   };
 }
 
-export async function witnessGenMockRollupMergeCircuit(
-  args: MockRollupMergeInputType,
+export async function witnessGenMockRollupTxMergeCircuit(
+  args: MockRollupTxMergeInputType,
 ): Promise<WitnessGenResult<RollupPublicInputs>> {
-  const program = new Noir(MockRollupMergeCircuit);
+  const program = new Noir(MockRollupTxMergeCircuit);
   const { witness, returnValue } = await program.execute(args, foreignCallHandler);
   return {
     witness,
@@ -241,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.');
   }
@@ -358,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/artifacts/keys/app_creator.vk.data.d.json.ts

@@ -1,2 +0,0 @@
-const vk: { keyAsBytes: string; keyAsFields: string[] };
-export = vk;