@aztec/ivc-integration 1.0.0-staging.2 → 1.0.0

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 { VerificationKeyAsFields, type VerificationKeyData } from '@aztec/stdlib/vks';
+import 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: VerificationKeyAsFields;
+  vk: Fr[];
   proof: Fr[];
   publicInputs: AvmCircuitPublicInputs;
 }> {
@@ -259,7 +259,7 @@ export async function proveAvm(
 
   return {
     proof: proofWithPublicInputsValidationFlag,
-    vk: await VerificationKeyAsFields.fromKey(vk),
+    vk,
     publicInputs: avmCircuitInputs.publicInputs,
   };
 }

package/src/types/index.ts

@@ -22,11 +22,6 @@ 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>;
@@ -40,7 +35,12 @@ export type KernelPublicInputs = {
 export type TubeData = {
   public_inputs: KernelPublicInputs;
   proof: FixedLengthArray<Field, 535>;
-  vk_data: VerificationKey<113>;
+  vk_data: VerificationKey;
+}
+
+export type VerificationKey = {
+  key: FixedLengthArray<Field, 113>;
+  hash: Field;
 }
 
 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<113>;
+  vk: VerificationKey;
 }
 
 
@@ -220,13 +220,13 @@ export async function AppReader(commitments_to_read: FixedLengthArray<Field, 2>,
 export type MockPrivateKernelInitInputType = {
   tx: TxRequest;
   app_inputs: AppPublicInputs;
-  app_vk: VerificationKey<127>;
+  app_vk: FixedLengthArray<Field, 127>;
 }
 
 export type MockPrivateKernelInitReturnType = PrivateKernelPublicInputs;
 
 
-export async function MockPrivateKernelInit(tx: TxRequest, app_inputs: AppPublicInputs, app_vk: VerificationKey<127>, MockPrivateKernelInit_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs> {
+export async function MockPrivateKernelInit(tx: TxRequest, app_inputs: AppPublicInputs, app_vk: FixedLengthArray<Field, 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: VerificationKey<127>;
+  kernel_vk: FixedLengthArray<Field, 127>;
   app_inputs: AppPublicInputs;
-  app_vk: VerificationKey<127>;
+  app_vk: FixedLengthArray<Field, 127>;
 }
 
 export type MockPrivateKernelInnerReturnType = 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> {
+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> {
   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: VerificationKey<127>;
+  kernel_vk: FixedLengthArray<Field, 127>;
   commitment_read_hints: FixedLengthArray<u32, 4>;
 }
 
 export type MockPrivateKernelResetReturnType = 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> {
+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> {
   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: VerificationKey<127>;
+  kernel_vk: FixedLengthArray<Field, 127>;
 }
 
 export type MockPrivateKernelTailReturnType = KernelPublicInputs;
 
 
-export async function MockPrivateKernelTail(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: VerificationKey<127>, MockPrivateKernelTail_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<KernelPublicInputs> {
+export async function MockPrivateKernelTail(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 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: VerificationKey<1000>;
+  verification_key: FixedLengthArray<Field, 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: VerificationKey<1000>, proof: FixedLengthArray<Field, 20000>, public_inputs: AvmCircuitPublicInputs, 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, public_inputs };
   const { returnValue } = await program.execute(args, foreignCallHandler);

package/src/witgen.ts

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