@aztec/ivc-integration 0.86.0 → 0.87.0

package/dest/witgen.js

@@ -1,76 +1,86 @@
-import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
+import { AVM_CIRCUIT_PUBLIC_INPUTS_LENGTH, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
+import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
 import { Noir } from '@aztec/noir-noir_js';
-import createDebug from 'debug';
-import MockAppCreatorCircuit from '../artifacts/app_creator.json' assert {
+import { strict as assert } from 'assert';
+import MockAppCreatorCircuit from '../artifacts/app_creator.json' with {
     type: 'json'
 };
-import MockAppReaderCircuit from '../artifacts/app_reader.json' assert {
+import MockAppReaderCircuit from '../artifacts/app_reader.json' with {
     type: 'json'
 };
-import MockAppCreatorVk from '../artifacts/keys/app_creator.vk.data.json' assert {
+import MockAppCreatorVk from '../artifacts/keys/app_creator.vk.data.json' with {
     type: 'json'
 };
-import MockAppReaderVk from '../artifacts/keys/app_reader.vk.data.json' assert {
+import MockAppReaderVk from '../artifacts/keys/app_reader.vk.data.json' with {
     type: 'json'
 };
-import MockPrivateKernelInitVk from '../artifacts/keys/mock_private_kernel_init.vk.data.json' assert {
+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' assert {
+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' assert {
+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' assert {
+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' assert {
+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' assert {
+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' assert {
+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' assert {
+import MockRollupRootVk from '../artifacts/keys/mock_rollup_root.vk.data.json' with {
     type: 'json'
 };
-import MockPrivateKernelInitCircuit from '../artifacts/mock_private_kernel_init.json' assert {
+import MockPrivateKernelInitCircuit from '../artifacts/mock_private_kernel_init.json' with {
     type: 'json'
 };
-import MockPrivateKernelInnerCircuit from '../artifacts/mock_private_kernel_inner.json' assert {
+import MockPrivateKernelInnerCircuit from '../artifacts/mock_private_kernel_inner.json' with {
     type: 'json'
 };
-import MockPrivateKernelResetCircuit from '../artifacts/mock_private_kernel_reset.json' assert {
+import MockPrivateKernelResetCircuit from '../artifacts/mock_private_kernel_reset.json' with {
     type: 'json'
 };
-import MockPrivateKernelTailCircuit from '../artifacts/mock_private_kernel_tail.json' assert {
+import MockPrivateKernelTailCircuit from '../artifacts/mock_private_kernel_tail.json' with {
     type: 'json'
 };
-import MockRollupBasePrivateCircuit from '../artifacts/mock_rollup_base_private.json' assert {
+import MockRollupBasePrivateCircuit from '../artifacts/mock_rollup_base_private.json' with {
     type: 'json'
 };
-import MockRollupBasePublicCircuit from '../artifacts/mock_rollup_base_public.json' assert {
+import MockRollupBasePublicCircuit from '../artifacts/mock_rollup_base_public.json' with {
     type: 'json'
 };
-import MockRollupMergeCircuit from '../artifacts/mock_rollup_merge.json' assert {
+import MockRollupMergeCircuit from '../artifacts/mock_rollup_merge.json' with {
     type: 'json'
 };
-import MockRollupRootCircuit from '../artifacts/mock_rollup_root.json' assert {
+import MockRollupRootCircuit from '../artifacts/mock_rollup_root.json' with {
     type: 'json'
 };
 // Re export the circuit jsons
 export { MockAppCreatorCircuit, MockAppReaderCircuit, MockPrivateKernelInitCircuit, MockPrivateKernelInnerCircuit, MockPrivateKernelResetCircuit, MockPrivateKernelTailCircuit, MockRollupBasePublicCircuit, MockRollupBasePrivateCircuit, MockRollupMergeCircuit, MockRollupRootCircuit, MockAppCreatorVk, MockAppReaderVk, MockPrivateKernelInitVk, MockPrivateKernelInnerVk, MockPrivateKernelResetVk, MockPrivateKernelTailVk, MockRollupBasePublicVk, MockRollupBasePrivateVk, MockRollupMergeVk, MockRollupRootVk };
-/* eslint-disable camelcase */ const logger = createDebug('aztec:ivc-test');
+/* eslint-disable camelcase */ const log = createLogger('aztec:ivc-test');
 export function getVkAsFields(vk) {
     return vk.keyAsFields;
 }
 export const MOCK_MAX_COMMITMENTS_PER_TX = 4;
-function foreignCallHandler() {
-    throw new Error('Unexpected foreign call');
+function foreignCallHandler(name, args) {
+    if (name === 'debugLog') {
+        assert(args.length === 3, 'expected 3 arguments for debugLog: msg, fields_length, fields');
+        const [msgRaw, _ignoredFieldsSize, fields] = args;
+        const msg = msgRaw.map((acvmField)=>String.fromCharCode(Fr.fromString(acvmField).toNumber())).join('');
+        const fieldsFr = fields.map((field)=>Fr.fromString(field));
+        log.verbose('debug_log ' + applyStringFormatting(msg, fieldsFr));
+    } else {
+        throw new Error('Unexpected foreign call');
+    }
+    return Promise.resolve([]);
 }
 export async function witnessGenCreatorAppMockCircuit(args) {
     const program = new Noir(MockAppCreatorCircuit);
@@ -163,18 +173,18 @@ export async function generate3FunctionTestingIVCStack() {
             '0x2'
         ]
     });
-    logger('generated app mock circuit witness');
+    log.debug('generated app mock circuit witness');
     const initWitnessGenResult = await witnessGenMockPrivateKernelInitCircuit({
         app_inputs: appWitnessGenResult.publicInputs,
         tx,
         app_vk: getVkAsFields(MockAppCreatorVk)
     });
-    logger('generated mock private kernel init witness');
+    log.debug('generated mock private kernel init witness');
     const tailWitnessGenResult = await witnessGenMockPrivateKernelTailCircuit({
         prev_kernel_public_inputs: initWitnessGenResult.publicInputs,
-        kernel_vk: getVkAsFields(MockPrivateKernelResetVk)
+        kernel_vk: getVkAsFields(MockPrivateKernelInitVk)
     });
-    logger('generated mock private kernel tail witness');
+    log.debug('generated mock private kernel tail witness');
     // Create client IVC proof
     const bytecodes = [
         MockAppCreatorCircuit.bytecode,
@@ -186,10 +196,16 @@ export async function generate3FunctionTestingIVCStack() {
         initWitnessGenResult.witness,
         tailWitnessGenResult.witness
     ];
+    const precomputedVks = [
+        MockAppCreatorVk.keyAsBytes,
+        MockPrivateKernelInitVk.keyAsBytes,
+        MockPrivateKernelTailVk.keyAsBytes
+    ];
     return [
         bytecodes,
         witnessStack,
-        tailWitnessGenResult.publicInputs
+        tailWitnessGenResult.publicInputs,
+        precomputedVks
     ];
 }
 export async function generate6FunctionTestingIVCStack() {
@@ -251,10 +267,19 @@ export async function generate6FunctionTestingIVCStack() {
         resetWitnessGenResult.witness,
         tailWitnessGenResult.witness
     ];
+    const precomputedVks = [
+        MockAppCreatorVk.keyAsBytes,
+        MockPrivateKernelInitVk.keyAsBytes,
+        MockAppReaderVk.keyAsBytes,
+        MockPrivateKernelInnerVk.keyAsBytes,
+        MockPrivateKernelResetVk.keyAsBytes,
+        MockPrivateKernelTailVk.keyAsBytes
+    ];
     return [
         bytecodes,
         witnessStack,
-        tailWitnessGenResult.publicInputs
+        tailWitnessGenResult.publicInputs,
+        precomputedVks
     ];
 }
 export function mapRecursiveProofToNoir(proof) {
@@ -282,11 +307,8 @@ export function mapAvmVerificationKeyToNoir(vk) {
     return vk.map((field)=>field.toString());
 }
 export function mapAvmPublicInputsToNoir(publicInputs) {
-    // TODO: Currently the recursive verifier only expects a single public input, the reverted field.
-    const serialized = [
-        new Fr(publicInputs.reverted)
-    ];
-    if (serialized.length != AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE) {
+    const serialized = publicInputs.toFields();
+    if (serialized.length != AVM_CIRCUIT_PUBLIC_INPUTS_LENGTH) {
         throw new Error('Invalid number of AVM public inputs');
     }
     return serialized.map((x)=>x.toString());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ivc-integration",
-  "version": "0.86.0",
+  "version": "0.87.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -58,14 +58,14 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.86.0",
-    "@aztec/constants": "0.86.0",
-    "@aztec/foundation": "0.86.0",
-    "@aztec/noir-noir_codegen": "0.86.0",
-    "@aztec/noir-noir_js": "0.86.0",
-    "@aztec/noir-noirc_abi": "0.86.0",
-    "@aztec/noir-types": "0.86.0",
-    "@aztec/stdlib": "0.86.0",
+    "@aztec/bb.js": "0.87.0",
+    "@aztec/constants": "0.87.0",
+    "@aztec/foundation": "0.87.0",
+    "@aztec/noir-noir_codegen": "0.87.0",
+    "@aztec/noir-noir_js": "0.87.0",
+    "@aztec/noir-noirc_abi": "0.87.0",
+    "@aztec/noir-types": "0.87.0",
+    "@aztec/stdlib": "0.87.0",
     "chalk": "^5.3.0",
     "change-case": "^5.4.4",
     "pako": "^2.1.0",
@@ -74,16 +74,17 @@
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/bb-prover": "0.86.0",
-    "@aztec/kv-store": "0.86.0",
-    "@aztec/noir-contracts.js": "0.86.0",
-    "@aztec/simulator": "0.86.0",
-    "@aztec/telemetry-client": "0.86.0",
-    "@aztec/world-state": "0.86.0",
+    "@aztec/bb-prover": "0.87.0",
+    "@aztec/kv-store": "0.87.0",
+    "@aztec/noir-protocol-circuits-types": "0.87.0",
+    "@aztec/noir-test-contracts.js": "0.87.0",
+    "@aztec/simulator": "0.87.0",
+    "@aztec/telemetry-client": "0.87.0",
+    "@aztec/world-state": "0.87.0",
     "@jest/globals": "^29.5.0",
     "@playwright/test": "1.49.0",
     "@types/jest": "^29.5.0",
-    "@types/node": "^22.8.1",
+    "@types/node": "^22.15.17",
     "@types/pako": "^2.0.3",
     "copy-webpack-plugin": "^12.0.2",
     "debug": "^4.3.4",
@@ -95,7 +96,7 @@
     "serve": "^14.2.1",
     "ts-loader": "^9.5.1",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4",
+    "typescript": "^5.3.3",
     "webpack": "^5.99.6",
     "webpack-cli": "^6.0.1",
     "webpack-dev-server": "^5.2.1"
@@ -108,6 +109,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/prove_native.ts

@@ -11,6 +11,7 @@ import {
   generateTubeProof,
   readClientIVCProofFromOutputDirectory,
   readProofAsFields,
+  verifyAvmProofV2,
   verifyProof,
 } from '@aztec/bb-prover';
 import {
@@ -38,13 +39,14 @@ export async function proveClientIVC(
   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([]),
+      vk: Buffer.from(vks[index], 'hex'),
       functionName: `unknown_${index}`,
     };
   };
@@ -235,6 +237,18 @@ export async function proveAvm(
     vk.push(new Fr(0));
   }
 
+  const verificationResult = await verifyAvmProofV2(
+    bbPath,
+    workingDirectory,
+    proofRes.proofPath!,
+    avmCircuitInputs.publicInputs,
+    proofRes.vkPath!,
+    logger,
+  );
+
+  if (verificationResult.status === BB_RESULT.FAILURE) {
+    throw new Error(`AVM V2 proof verification failed: ${verificationResult.reason}`);
+  }
   return {
     proof,
     vk,

package/src/types/index.ts

@@ -10,6 +10,7 @@ export { type ForeignCallHandler } from "@aztec/noir-noir_js"
 export type FixedLengthArray<T, L extends number> = L extends 0 ? never[]: T[] & { length: L }
 export type Field = string;
 export type u32 = string;
+export type u64 = string;
 
 export type AppPublicInputs = {
   commitments: FixedLengthArray<Field, 2>;
@@ -41,6 +42,127 @@ export type VerificationKey = {
   hash: Field;
 }
 
+export type AvmCircuitPublicInputs = {
+  global_variables: GlobalVariables;
+  start_tree_snapshots: TreeSnapshots;
+  start_gas_used: Gas;
+  gas_settings: GasSettings;
+  fee_payer: AztecAddress;
+  public_setup_call_requests: FixedLengthArray<PublicCallRequest, 32>;
+  public_app_logic_call_requests: FixedLengthArray<PublicCallRequest, 32>;
+  public_teardown_call_request: PublicCallRequest;
+  previous_non_revertible_accumulated_data_array_lengths: PrivateToAvmAccumulatedDataArrayLengths;
+  previous_revertible_accumulated_data_array_lengths: PrivateToAvmAccumulatedDataArrayLengths;
+  previous_non_revertible_accumulated_data: PrivateToAvmAccumulatedData;
+  previous_revertible_accumulated_data: PrivateToAvmAccumulatedData;
+  end_tree_snapshots: TreeSnapshots;
+  end_gas_used: Gas;
+  accumulated_data: AvmAccumulatedData;
+  transaction_fee: Field;
+  reverted: boolean;
+}
+
+export type GlobalVariables = {
+  chain_id: Field;
+  version: Field;
+  block_number: Field;
+  slot_number: Field;
+  timestamp: u64;
+  coinbase: EthAddress;
+  fee_recipient: AztecAddress;
+  gas_fees: GasFees;
+}
+
+export type TreeSnapshots = {
+  l1_to_l2_message_tree: AppendOnlyTreeSnapshot;
+  note_hash_tree: AppendOnlyTreeSnapshot;
+  nullifier_tree: AppendOnlyTreeSnapshot;
+  public_data_tree: AppendOnlyTreeSnapshot;
+}
+
+export type Gas = {
+  da_gas: u32;
+  l2_gas: u32;
+}
+
+export type GasSettings = {
+  gas_limits: Gas;
+  teardown_gas_limits: Gas;
+  max_fees_per_gas: GasFees;
+  max_priority_fees_per_gas: GasFees;
+}
+
+export type AztecAddress = {
+  inner: Field;
+}
+
+export type PublicCallRequest = {
+  msg_sender: AztecAddress;
+  contract_address: AztecAddress;
+  is_static_call: boolean;
+  calldata_hash: Field;
+}
+
+export type PrivateToAvmAccumulatedDataArrayLengths = {
+  note_hashes: u32;
+  nullifiers: u32;
+  l2_to_l1_msgs: u32;
+}
+
+export type PrivateToAvmAccumulatedData = {
+  note_hashes: FixedLengthArray<Field, 64>;
+  nullifiers: FixedLengthArray<Field, 64>;
+  l2_to_l1_msgs: FixedLengthArray<ScopedL2ToL1Message, 8>;
+}
+
+export type AvmAccumulatedData = {
+  note_hashes: FixedLengthArray<Field, 64>;
+  nullifiers: FixedLengthArray<Field, 64>;
+  l2_to_l1_msgs: FixedLengthArray<ScopedL2ToL1Message, 8>;
+  public_logs: FixedLengthArray<PublicLog, 8>;
+  public_data_writes: FixedLengthArray<PublicDataWrite, 64>;
+}
+
+export type EthAddress = {
+  inner: Field;
+}
+
+export type GasFees = {
+  fee_per_da_gas: Field;
+  fee_per_l2_gas: Field;
+}
+
+export type AppendOnlyTreeSnapshot = {
+  root: Field;
+  next_available_leaf_index: u32;
+}
+
+export type ScopedL2ToL1Message = {
+  message: L2ToL1Message;
+  contract_address: AztecAddress;
+}
+
+export type PublicLog = {
+  log: Log;
+  contract_address: AztecAddress;
+}
+
+export type PublicDataWrite = {
+  leaf_slot: Field;
+  value: Field;
+}
+
+export type L2ToL1Message = {
+  recipient: EthAddress;
+  content: Field;
+  counter: u32;
+}
+
+export type Log = {
+  fields: FixedLengthArray<Field, 13>;
+  length: u32;
+}
+
 export type RollupPublicInputs = {
   accumulated: u32;
 }
@@ -142,15 +264,15 @@ export type MockRollupBasePublicInputType = {
   tube_data: TubeData;
   verification_key: FixedLengthArray<Field, 1000>;
   proof: FixedLengthArray<Field, 20000>;
-  pub_cols_flattened: FixedLengthArray<Field, 1>;
+  public_inputs: AvmCircuitPublicInputs;
 }
 
 export type MockRollupBasePublicReturnType = RollupPublicInputs;
 
 
-export async function MockRollupBasePublic(tube_data: TubeData, verification_key: FixedLengthArray<Field, 1000>, proof: FixedLengthArray<Field, 20000>, pub_cols_flattened: FixedLengthArray<Field, 1>, MockRollupBasePublic_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
+export async function MockRollupBasePublic(tube_data: TubeData, verification_key: FixedLengthArray<Field, 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, pub_cols_flattened };
+  const args: InputMap = { tube_data, verification_key, proof, public_inputs };
   const { returnValue } = await program.execute(args, foreignCallHandler);
   return returnValue as RollupPublicInputs;
 }

package/src/witgen.ts

@@ -1,37 +1,38 @@
 import {
+  AVM_CIRCUIT_PUBLIC_INPUTS_LENGTH,
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
-  AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE,
   AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED,
   CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS,
 } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { type ForeignCallOutput, Noir } from '@aztec/noir-noir_js';
+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';
 import type { RecursiveProof } from '@aztec/stdlib/proofs';
 import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 
-import createDebug from 'debug';
-
-import MockAppCreatorCircuit from '../artifacts/app_creator.json' assert { type: 'json' };
-import MockAppReaderCircuit from '../artifacts/app_reader.json' assert { type: 'json' };
-import MockAppCreatorVk from '../artifacts/keys/app_creator.vk.data.json' assert { type: 'json' };
-import MockAppReaderVk from '../artifacts/keys/app_reader.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelInitVk from '../artifacts/keys/mock_private_kernel_init.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelInnerVk from '../artifacts/keys/mock_private_kernel_inner.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelResetVk from '../artifacts/keys/mock_private_kernel_reset.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelTailVk from '../artifacts/keys/mock_private_kernel_tail.vk.data.json' assert { type: 'json' };
-import MockRollupBasePrivateVk from '../artifacts/keys/mock_rollup_base_private.vk.data.json' assert { type: 'json' };
-import MockRollupBasePublicVk from '../artifacts/keys/mock_rollup_base_public.vk.data.json' assert { type: 'json' };
-import MockRollupMergeVk from '../artifacts/keys/mock_rollup_merge.vk.data.json' assert { type: 'json' };
-import MockRollupRootVk from '../artifacts/keys/mock_rollup_root.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelInitCircuit from '../artifacts/mock_private_kernel_init.json' assert { type: 'json' };
-import MockPrivateKernelInnerCircuit from '../artifacts/mock_private_kernel_inner.json' assert { type: 'json' };
-import MockPrivateKernelResetCircuit from '../artifacts/mock_private_kernel_reset.json' assert { type: 'json' };
-import MockPrivateKernelTailCircuit from '../artifacts/mock_private_kernel_tail.json' assert { type: 'json' };
-import MockRollupBasePrivateCircuit from '../artifacts/mock_rollup_base_private.json' assert { type: 'json' };
-import MockRollupBasePublicCircuit from '../artifacts/mock_rollup_base_public.json' assert { type: 'json' };
-import MockRollupMergeCircuit from '../artifacts/mock_rollup_merge.json' assert { type: 'json' };
-import MockRollupRootCircuit from '../artifacts/mock_rollup_root.json' assert { type: 'json' };
+import { strict as assert } from 'assert';
+
+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 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 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 type {
   AppCreatorInputType,
   AppPublicInputs,
@@ -76,7 +77,7 @@ export {
 
 /* eslint-disable camelcase */
 
-const logger = createDebug('aztec:ivc-test');
+const log = createLogger('aztec:ivc-test');
 
 export function getVkAsFields(vk: {
   keyAsBytes: string;
@@ -87,8 +88,17 @@ export function getVkAsFields(vk: {
 
 export const MOCK_MAX_COMMITMENTS_PER_TX = 4;
 
-function foreignCallHandler(): Promise<ForeignCallOutput[]> {
-  throw new Error('Unexpected foreign call');
+function foreignCallHandler(name: string, args: ForeignCallInput[]): Promise<ForeignCallOutput[]> {
+  if (name === 'debugLog') {
+    assert(args.length === 3, 'expected 3 arguments for debugLog: msg, fields_length, fields');
+    const [msgRaw, _ignoredFieldsSize, fields] = args;
+    const msg: string = msgRaw.map(acvmField => String.fromCharCode(Fr.fromString(acvmField).toNumber())).join('');
+    const fieldsFr: Fr[] = fields.map((field: string) => Fr.fromString(field));
+    log.verbose('debug_log ' + applyStringFormatting(msg, fieldsFr));
+  } else {
+    throw new Error('Unexpected foreign call');
+  }
+  return Promise.resolve([]);
 }
 
 export interface WitnessGenResult<PublicInputsType> {
@@ -206,27 +216,29 @@ export async function witnessGenMockRollupRootCircuit(
   };
 }
 
-export async function generate3FunctionTestingIVCStack(): Promise<[string[], Uint8Array[], KernelPublicInputs]> {
+export async function generate3FunctionTestingIVCStack(): Promise<
+  [string[], Uint8Array[], KernelPublicInputs, string[]]
+> {
   const tx = {
     number_of_calls: '0x1',
   };
 
   // Witness gen app and kernels
   const appWitnessGenResult = await witnessGenCreatorAppMockCircuit({ commitments_to_create: ['0x1', '0x2'] });
-  logger('generated app mock circuit witness');
+  log.debug('generated app mock circuit witness');
 
   const initWitnessGenResult = await witnessGenMockPrivateKernelInitCircuit({
     app_inputs: appWitnessGenResult.publicInputs,
     tx,
     app_vk: getVkAsFields(MockAppCreatorVk),
   });
-  logger('generated mock private kernel init witness');
+  log.debug('generated mock private kernel init witness');
 
   const tailWitnessGenResult = await witnessGenMockPrivateKernelTailCircuit({
     prev_kernel_public_inputs: initWitnessGenResult.publicInputs,
-    kernel_vk: getVkAsFields(MockPrivateKernelResetVk),
+    kernel_vk: getVkAsFields(MockPrivateKernelInitVk),
   });
-  logger('generated mock private kernel tail witness');
+  log.debug('generated mock private kernel tail witness');
 
   // Create client IVC proof
   const bytecodes = [
@@ -236,10 +248,18 @@ export async function generate3FunctionTestingIVCStack(): Promise<[string[], Uin
   ];
   const witnessStack = [appWitnessGenResult.witness, initWitnessGenResult.witness, tailWitnessGenResult.witness];
 
-  return [bytecodes, witnessStack, tailWitnessGenResult.publicInputs];
+  const precomputedVks = [
+    MockAppCreatorVk.keyAsBytes,
+    MockPrivateKernelInitVk.keyAsBytes,
+    MockPrivateKernelTailVk.keyAsBytes,
+  ];
+
+  return [bytecodes, witnessStack, tailWitnessGenResult.publicInputs, precomputedVks];
 }
 
-export async function generate6FunctionTestingIVCStack(): Promise<[string[], Uint8Array[], KernelPublicInputs]> {
+export async function generate6FunctionTestingIVCStack(): Promise<
+  [string[], Uint8Array[], KernelPublicInputs, string[]]
+> {
   const tx = {
     number_of_calls: '0x2',
   };
@@ -293,7 +313,16 @@ export async function generate6FunctionTestingIVCStack(): Promise<[string[], Uin
     tailWitnessGenResult.witness,
   ];
 
-  return [bytecodes, witnessStack, tailWitnessGenResult.publicInputs];
+  const precomputedVks = [
+    MockAppCreatorVk.keyAsBytes,
+    MockPrivateKernelInitVk.keyAsBytes,
+    MockAppReaderVk.keyAsBytes,
+    MockPrivateKernelInnerVk.keyAsBytes,
+    MockPrivateKernelResetVk.keyAsBytes,
+    MockPrivateKernelTailVk.keyAsBytes,
+  ];
+
+  return [bytecodes, witnessStack, tailWitnessGenResult.publicInputs, precomputedVks];
 }
 
 export function mapRecursiveProofToNoir<N extends number>(proof: RecursiveProof<N>): FixedLengthArray<string, N> {
@@ -337,11 +366,10 @@ export function mapAvmVerificationKeyToNoir(
 
 export function mapAvmPublicInputsToNoir(
   publicInputs: AvmCircuitPublicInputs,
-): FixedLengthArray<string, typeof AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE> {
-  // TODO: Currently the recursive verifier only expects a single public input, the reverted field.
-  const serialized = [new Fr(publicInputs.reverted)];
-  if (serialized.length != AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE) {
+): FixedLengthArray<string, typeof AVM_CIRCUIT_PUBLIC_INPUTS_LENGTH> {
+  const serialized = publicInputs.toFields();
+  if (serialized.length != AVM_CIRCUIT_PUBLIC_INPUTS_LENGTH) {
     throw new Error('Invalid number of AVM public inputs');
   }
-  return serialized.map(x => x.toString()) as FixedLengthArray<string, typeof AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE>;
+  return serialized.map(x => x.toString()) as FixedLengthArray<string, typeof AVM_CIRCUIT_PUBLIC_INPUTS_LENGTH>;
 }