@aztec/ivc-integration 1.0.0 → 1.1.2

package/src/prove_native.ts

@@ -29,7 +29,7 @@ import { makeProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
 import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
 import type { ClientIvcProof, Proof } from '@aztec/stdlib/proofs';
 import { enhanceProofWithPiValidationFlag } from '@aztec/stdlib/rollup';
-import type { VerificationKeyData } from '@aztec/stdlib/vks';
+import { VerificationKeyAsFields, type VerificationKeyData } from '@aztec/stdlib/vks';
 
 import * as fs from 'fs/promises';
 import { Encoder } from 'msgpackr';
@@ -189,7 +189,7 @@ export async function proveAvm(
   logger: Logger,
   skipPublicInputsValidation: boolean = false,
 ): Promise<{
-  vk: Fr[];
+  vk: VerificationKeyAsFields;
   proof: Fr[];
   publicInputs: AvmCircuitPublicInputs;
 }> {
@@ -259,7 +259,7 @@ export async function proveAvm(
 
   return {
     proof: proofWithPublicInputsValidationFlag,
-    vk,
+    vk: await VerificationKeyAsFields.fromKey(vk),
     publicInputs: avmCircuitInputs.publicInputs,
   };
 }

package/src/types/index.ts

@@ -22,6 +22,11 @@ export type TxRequest = {
   number_of_calls: u32;
 }
 
+export type VerificationKey<A extends number> = {
+  key: FixedLengthArray<Field, A>;
+  hash: Field;
+}
+
 export type PrivateKernelPublicInputs = {
   remaining_calls: u32;
   commitments: FixedLengthArray<Field, 4>;
@@ -35,12 +40,7 @@ export type KernelPublicInputs = {
 export type TubeData = {
   public_inputs: KernelPublicInputs;
   proof: FixedLengthArray<Field, 535>;
-  vk_data: VerificationKey;
-}
-
-export type VerificationKey = {
-  key: FixedLengthArray<Field, 113>;
-  hash: Field;
+  vk_data: VerificationKey<113>;
 }
 
 export type AvmCircuitPublicInputs = {
@@ -187,7 +187,7 @@ export type RollupPublicInputs = {
 export type PreviousRollupData = {
   base_or_merge_public_inputs: RollupPublicInputs;
   proof: FixedLengthArray<Field, 535>;
-  vk: VerificationKey;
+  vk: VerificationKey<113>;
 }
 
 
@@ -220,13 +220,13 @@ export async function AppReader(commitments_to_read: FixedLengthArray<Field, 2>,
 export type MockPrivateKernelInitInputType = {
   tx: TxRequest;
   app_inputs: AppPublicInputs;
-  app_vk: FixedLengthArray<Field, 127>;
+  app_vk: VerificationKey<127>;
 }
 
 export type MockPrivateKernelInitReturnType = PrivateKernelPublicInputs;
 
 
-export async function MockPrivateKernelInit(tx: TxRequest, app_inputs: AppPublicInputs, app_vk: FixedLengthArray<Field, 127>, MockPrivateKernelInit_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs> {
+export async function MockPrivateKernelInit(tx: TxRequest, app_inputs: AppPublicInputs, app_vk: VerificationKey<127>, MockPrivateKernelInit_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs> {
   const program = new Noir(MockPrivateKernelInit_circuit);
   const args: InputMap = { tx, app_inputs, app_vk };
   const { returnValue } = await program.execute(args, foreignCallHandler);
@@ -234,15 +234,15 @@ export async function MockPrivateKernelInit(tx: TxRequest, app_inputs: AppPublic
 }
 export type MockPrivateKernelInnerInputType = {
   prev_kernel_public_inputs: PrivateKernelPublicInputs;
-  kernel_vk: FixedLengthArray<Field, 127>;
+  kernel_vk: VerificationKey<127>;
   app_inputs: AppPublicInputs;
-  app_vk: FixedLengthArray<Field, 127>;
+  app_vk: VerificationKey<127>;
 }
 
 export type MockPrivateKernelInnerReturnType = PrivateKernelPublicInputs;
 
 
-export async function MockPrivateKernelInner(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 127>, app_inputs: AppPublicInputs, app_vk: FixedLengthArray<Field, 127>, MockPrivateKernelInner_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs> {
+export async function MockPrivateKernelInner(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: VerificationKey<127>, app_inputs: AppPublicInputs, app_vk: VerificationKey<127>, MockPrivateKernelInner_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs> {
   const program = new Noir(MockPrivateKernelInner_circuit);
   const args: InputMap = { prev_kernel_public_inputs, kernel_vk, app_inputs, app_vk };
   const { returnValue } = await program.execute(args, foreignCallHandler);
@@ -250,14 +250,14 @@ export async function MockPrivateKernelInner(prev_kernel_public_inputs: PrivateK
 }
 export type MockPrivateKernelResetInputType = {
   prev_kernel_public_inputs: PrivateKernelPublicInputs;
-  kernel_vk: FixedLengthArray<Field, 127>;
+  kernel_vk: VerificationKey<127>;
   commitment_read_hints: FixedLengthArray<u32, 4>;
 }
 
 export type MockPrivateKernelResetReturnType = PrivateKernelPublicInputs;
 
 
-export async function MockPrivateKernelReset(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 127>, commitment_read_hints: FixedLengthArray<u32, 4>, MockPrivateKernelReset_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs> {
+export async function MockPrivateKernelReset(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: VerificationKey<127>, commitment_read_hints: FixedLengthArray<u32, 4>, MockPrivateKernelReset_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs> {
   const program = new Noir(MockPrivateKernelReset_circuit);
   const args: InputMap = { prev_kernel_public_inputs, kernel_vk, commitment_read_hints };
   const { returnValue } = await program.execute(args, foreignCallHandler);
@@ -265,13 +265,13 @@ export async function MockPrivateKernelReset(prev_kernel_public_inputs: PrivateK
 }
 export type MockPrivateKernelTailInputType = {
   prev_kernel_public_inputs: PrivateKernelPublicInputs;
-  kernel_vk: FixedLengthArray<Field, 127>;
+  kernel_vk: VerificationKey<127>;
 }
 
 export type MockPrivateKernelTailReturnType = KernelPublicInputs;
 
 
-export async function MockPrivateKernelTail(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 127>, MockPrivateKernelTail_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<KernelPublicInputs> {
+export async function MockPrivateKernelTail(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: VerificationKey<127>, MockPrivateKernelTail_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<KernelPublicInputs> {
   const program = new Noir(MockPrivateKernelTail_circuit);
   const args: InputMap = { prev_kernel_public_inputs, kernel_vk };
   const { returnValue } = await program.execute(args, foreignCallHandler);
@@ -279,7 +279,7 @@ export async function MockPrivateKernelTail(prev_kernel_public_inputs: PrivateKe
 }
 export type MockRollupBasePublicInputType = {
   tube_data: TubeData;
-  verification_key: FixedLengthArray<Field, 1000>;
+  verification_key: VerificationKey<1000>;
   proof: FixedLengthArray<Field, 20000>;
   public_inputs: AvmCircuitPublicInputs;
 }
@@ -287,7 +287,7 @@ export type MockRollupBasePublicInputType = {
 export type MockRollupBasePublicReturnType = 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> {
+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 };
   const { returnValue } = await program.execute(args, foreignCallHandler);

package/src/witgen.ts

@@ -1,7 +1,6 @@
 import {
   AVM_CIRCUIT_PUBLIC_INPUTS_LENGTH,
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
-  AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED,
   CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS,
 } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
@@ -9,7 +8,7 @@ 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 { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 
 import { strict as assert } from 'assert';
 
@@ -49,29 +48,30 @@ import type {
   MockRollupRootInputType,
   PrivateKernelPublicInputs,
   RollupPublicInputs,
+  VerificationKey,
 } from './types/index.js';
 
 // Re export the circuit jsons
 export {
   MockAppCreatorCircuit,
-  MockAppReaderCircuit,
-  MockPrivateKernelInitCircuit,
-  MockPrivateKernelInnerCircuit,
-  MockPrivateKernelResetCircuit,
-  MockPrivateKernelTailCircuit,
-  MockRollupBasePublicCircuit,
-  MockRollupBasePrivateCircuit,
-  MockRollupMergeCircuit,
-  MockRollupRootCircuit,
   MockAppCreatorVk,
+  MockAppReaderCircuit,
   MockAppReaderVk,
+  MockPrivateKernelInitCircuit,
   MockPrivateKernelInitVk,
+  MockPrivateKernelInnerCircuit,
   MockPrivateKernelInnerVk,
+  MockPrivateKernelResetCircuit,
   MockPrivateKernelResetVk,
+  MockPrivateKernelTailCircuit,
   MockPrivateKernelTailVk,
-  MockRollupBasePublicVk,
+  MockRollupBasePrivateCircuit,
   MockRollupBasePrivateVk,
+  MockRollupBasePublicCircuit,
+  MockRollupBasePublicVk,
+  MockRollupMergeCircuit,
   MockRollupMergeVk,
+  MockRollupRootCircuit,
   MockRollupRootVk,
 };
 
@@ -79,11 +79,14 @@ export {
 
 const log = createLogger('aztec:ivc-test');
 
-export function getVkAsFields(vk: {
-  keyAsBytes: string;
+export async function getVkAsFields({
+  keyAsFields,
+}: {
   keyAsFields: string[];
-}): FixedLengthArray<string, typeof CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS> {
-  return vk.keyAsFields as FixedLengthArray<string, typeof CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS>;
+}): Promise<VerificationKey<typeof CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS>> {
+  const key = keyAsFields.map(f => Fr.fromString(f));
+  const vk = await VerificationKeyAsFields.fromKey(key);
+  return mapVerificationKeyToNoir(vk, CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS);
 }
 
 export const MOCK_MAX_COMMITMENTS_PER_TX = 4;
@@ -230,13 +233,13 @@ export async function generate3FunctionTestingIVCStack(): Promise<
   const initWitnessGenResult = await witnessGenMockPrivateKernelInitCircuit({
     app_inputs: appWitnessGenResult.publicInputs,
     tx,
-    app_vk: getVkAsFields(MockAppCreatorVk),
+    app_vk: await getVkAsFields(MockAppCreatorVk),
   });
   log.debug('generated mock private kernel init witness');
 
   const tailWitnessGenResult = await witnessGenMockPrivateKernelTailCircuit({
     prev_kernel_public_inputs: initWitnessGenResult.publicInputs,
-    kernel_vk: getVkAsFields(MockPrivateKernelInitVk),
+    kernel_vk: await getVkAsFields(MockPrivateKernelInitVk),
   });
   log.debug('generated mock private kernel tail witness');
 
@@ -270,13 +273,13 @@ export async function generate6FunctionTestingIVCStack(): Promise<
   const initWitnessGenResult = await witnessGenMockPrivateKernelInitCircuit({
     app_inputs: creatorAppWitnessGenResult.publicInputs,
     tx,
-    app_vk: getVkAsFields(MockAppCreatorVk),
+    app_vk: await getVkAsFields(MockAppCreatorVk),
   });
   const innerWitnessGenResult = await witnessGenMockPrivateKernelInnerCircuit({
     prev_kernel_public_inputs: initWitnessGenResult.publicInputs,
     app_inputs: readerAppWitnessGenResult.publicInputs,
-    app_vk: getVkAsFields(MockAppReaderVk),
-    kernel_vk: getVkAsFields(MockPrivateKernelInitVk),
+    app_vk: await getVkAsFields(MockAppReaderVk),
+    kernel_vk: await getVkAsFields(MockPrivateKernelInitVk),
   });
 
   const resetWitnessGenResult = await witnessGenMockPrivateKernelResetCircuit({
@@ -287,12 +290,12 @@ export async function generate6FunctionTestingIVCStack(): Promise<
       MOCK_MAX_COMMITMENTS_PER_TX.toString(),
       MOCK_MAX_COMMITMENTS_PER_TX.toString(),
     ],
-    kernel_vk: getVkAsFields(MockPrivateKernelInnerVk),
+    kernel_vk: await getVkAsFields(MockPrivateKernelInnerVk),
   });
 
   const tailWitnessGenResult = await witnessGenMockPrivateKernelTailCircuit({
     prev_kernel_public_inputs: resetWitnessGenResult.publicInputs,
-    kernel_vk: getVkAsFields(MockPrivateKernelResetVk),
+    kernel_vk: await getVkAsFields(MockPrivateKernelResetVk),
   });
 
   // Create client IVC proof
@@ -352,18 +355,6 @@ export function mapVerificationKeyToNoir<N extends number>(
   };
 }
 
-export function mapAvmVerificationKeyToNoir(
-  vk: Fr[],
-): FixedLengthArray<string, typeof AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED> {
-  if (vk.length != AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED) {
-    throw new Error('Invalid number of AVM verification key fields');
-  }
-  return vk.map(field => field.toString()) as FixedLengthArray<
-    string,
-    typeof AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED
-  >;
-}
-
 export function mapAvmPublicInputsToNoir(
   publicInputs: AvmCircuitPublicInputs,
 ): FixedLengthArray<string, typeof AVM_CIRCUIT_PUBLIC_INPUTS_LENGTH> {