@aztec/bb-prover 0.41.0 → 0.43.0

package/src/stats.ts

@@ -55,7 +55,13 @@ export function mapProtocolArtifactNameToCircuitName(
       return 'private-kernel-reset-medium';
     case 'PrivateKernelResetSmallArtifact':
       return 'private-kernel-reset-small';
-    default:
+    case 'EmptyNestedArtifact':
+      return 'empty-nested';
+    case 'PrivateKernelEmptyArtifact':
+      return 'private-kernel-empty';
+    default: {
+      const _foo: never = artifact;
       throw new Error(`Unknown circuit type: ${artifact}`);
+    }
   }
 }

package/src/test/index.ts

@@ -1 +1,2 @@
 export * from './test_circuit_prover.js';
+export * from './test_verifier.js';

package/src/test/test_circuit_prover.ts

@@ -1,18 +1,22 @@
 import {
-  type PublicInputsAndProof,
+  type ProofAndVerificationKey,
+  type PublicInputsAndRecursiveProof,
   type PublicKernelNonTailRequest,
   type PublicKernelTailRequest,
-  PublicKernelType,
   type ServerCircuitProver,
-  makePublicInputsAndProof,
+  makePublicInputsAndRecursiveProof,
 } from '@aztec/circuit-types';
 import {
+  type AvmCircuitInputs,
   type BaseOrMergeRollupPublicInputs,
   type BaseParityInputs,
   type BaseRollupInputs,
+  EmptyNestedData,
   type KernelCircuitPublicInputs,
   type MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
+  type PrivateKernelEmptyInputData,
+  PrivateKernelEmptyInputs,
   type Proof,
   type PublicKernelCircuitPublicInputs,
   RECURSIVE_PROOF_LENGTH,
@@ -21,7 +25,9 @@ import {
   type RootRollupInputs,
   type RootRollupPublicInputs,
   VerificationKeyAsFields,
+  VerificationKeyData,
   makeEmptyProof,
+  makeEmptyRecursiveProof,
   makeRecursiveProof,
 } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -29,27 +35,30 @@ import { Timer } from '@aztec/foundation/timer';
 import {
   BaseParityArtifact,
   MergeRollupArtifact,
+  PrivateKernelEmptyArtifact,
   RootParityArtifact,
   RootRollupArtifact,
-  ServerCircuitArtifacts,
   type ServerProtocolArtifact,
   SimulatedBaseRollupArtifact,
+  SimulatedServerCircuitArtifacts,
   convertBaseParityInputsToWitnessMap,
   convertBaseParityOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
   convertMergeRollupOutputsFromWitnessMap,
-  convertPublicTailInputsToWitnessMap,
-  convertPublicTailOutputFromWitnessMap,
+  convertPrivateKernelEmptyInputsToWitnessMap,
+  convertPrivateKernelEmptyOutputsFromWitnessMap,
   convertRootParityInputsToWitnessMap,
   convertRootParityOutputsFromWitnessMap,
   convertRootRollupInputsToWitnessMap,
   convertRootRollupOutputsFromWitnessMap,
   convertSimulatedBaseRollupInputsToWitnessMap,
   convertSimulatedBaseRollupOutputsFromWitnessMap,
+  convertSimulatedPublicTailInputsToWitnessMap,
+  convertSimulatedPublicTailOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 import { type SimulationProvider, WASMSimulator, emitCircuitSimulationStats } from '@aztec/simulator';
 
-import { PublicKernelArtifactMapping } from '../mappings/mappings.js';
+import { SimulatedPublicKernelArtifactMapping } from '../mappings/mappings.js';
 import { mapPublicKernelToCircuitName } from '../stats.js';
 
 const VERIFICATION_KEYS: Record<ServerProtocolArtifact, VerificationKeyAsFields> = {
@@ -62,6 +71,8 @@ const VERIFICATION_KEYS: Record<ServerProtocolArtifact, VerificationKeyAsFields>
   BaseRollupArtifact: VerificationKeyAsFields.makeFake(),
   MergeRollupArtifact: VerificationKeyAsFields.makeFake(),
   RootRollupArtifact: VerificationKeyAsFields.makeFake(),
+  PrivateKernelEmptyArtifact: VerificationKeyAsFields.makeFake(),
+  EmptyNestedArtifact: VerificationKeyAsFields.makeFake(),
 };
 
 /**
@@ -76,6 +87,25 @@ export class TestCircuitProver implements ServerCircuitProver {
     private logger = createDebugLogger('aztec:test-prover'),
   ) {}
 
+  public async getEmptyPrivateKernelProof(
+    inputs: PrivateKernelEmptyInputData,
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+    const emptyNested = new EmptyNestedData(
+      makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+      VERIFICATION_KEYS['EmptyNestedArtifact'],
+    );
+    const kernelInputs = new PrivateKernelEmptyInputs(emptyNested, inputs.header, inputs.chainId, inputs.version);
+    const witnessMap = convertPrivateKernelEmptyInputsToWitnessMap(kernelInputs);
+    const witness = await this.wasmSimulator.simulateCircuit(witnessMap, PrivateKernelEmptyArtifact);
+    const result = convertPrivateKernelEmptyOutputsFromWitnessMap(witness);
+
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      VerificationKeyData.makeFake(),
+    );
+  }
+
   /**
    * Simulates the base parity circuit from its inputs.
    * @param inputs - Inputs to the circuit.
@@ -146,7 +176,7 @@ export class TestCircuitProver implements ServerCircuitProver {
    */
   public async getBaseRollupProof(
     input: BaseRollupInputs,
-  ): Promise<PublicInputsAndProof<BaseOrMergeRollupPublicInputs>> {
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     const timer = new Timer();
     const witnessMap = convertSimulatedBaseRollupInputsToWitnessMap(input);
 
@@ -162,7 +192,11 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
-    return makePublicInputsAndProof(result, makeEmptyProof());
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      VerificationKeyData.makeFake(),
+    );
   }
   /**
    * Simulates the merge rollup circuit from its inputs.
@@ -171,7 +205,7 @@ export class TestCircuitProver implements ServerCircuitProver {
    */
   public async getMergeRollupProof(
     input: MergeRollupInputs,
-  ): Promise<PublicInputsAndProof<BaseOrMergeRollupPublicInputs>> {
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     const timer = new Timer();
     const witnessMap = convertMergeRollupInputsToWitnessMap(input);
 
@@ -187,7 +221,11 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
-    return makePublicInputsAndProof(result, makeEmptyProof());
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      VerificationKeyData.makeFake(),
+    );
   }
 
   /**
@@ -195,7 +233,9 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  public async getRootRollupProof(input: RootRollupInputs): Promise<PublicInputsAndProof<RootRollupPublicInputs>> {
+  public async getRootRollupProof(
+    input: RootRollupInputs,
+  ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
     const timer = new Timer();
     const witnessMap = convertRootRollupInputsToWitnessMap(input);
 
@@ -211,20 +251,27 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
-    return makePublicInputsAndProof(result, makeEmptyProof());
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      VerificationKeyData.makeFake(),
+    );
   }
 
   public async getPublicKernelProof(
     kernelRequest: PublicKernelNonTailRequest,
-  ): Promise<PublicInputsAndProof<PublicKernelCircuitPublicInputs>> {
+  ): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
     const timer = new Timer();
-    const kernelOps = PublicKernelArtifactMapping[kernelRequest.type];
+    const kernelOps = SimulatedPublicKernelArtifactMapping[kernelRequest.type];
     if (kernelOps === undefined) {
-      throw new Error(`Unable to prove for kernel type ${PublicKernelType[kernelRequest.type]}`);
+      throw new Error(`Unable to prove for kernel type ${kernelRequest.type}`);
     }
     const witnessMap = kernelOps.convertInputs(kernelRequest.inputs);
 
-    const witness = await this.wasmSimulator.simulateCircuit(witnessMap, ServerCircuitArtifacts[kernelOps.artifact]);
+    const witness = await this.wasmSimulator.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts[kernelOps.artifact],
+    );
 
     const result = kernelOps.convertOutputs(witness);
     emitCircuitSimulationStats(
@@ -235,21 +282,25 @@ export class TestCircuitProver implements ServerCircuitProver {
       this.logger,
     );
 
-    return makePublicInputsAndProof(result, makeEmptyProof());
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      VerificationKeyData.makeFake(),
+    );
   }
 
   public async getPublicTailProof(
     kernelRequest: PublicKernelTailRequest,
-  ): Promise<PublicInputsAndProof<KernelCircuitPublicInputs>> {
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
     const timer = new Timer();
-    const witnessMap = convertPublicTailInputsToWitnessMap(kernelRequest.inputs);
+    const witnessMap = convertSimulatedPublicTailInputsToWitnessMap(kernelRequest.inputs);
     // use WASM here as it is faster for small circuits
     const witness = await this.wasmSimulator.simulateCircuit(
       witnessMap,
-      ServerCircuitArtifacts['PublicKernelTailArtifact'],
+      SimulatedServerCircuitArtifacts['PublicKernelTailArtifact'],
     );
 
-    const result = convertPublicTailOutputFromWitnessMap(witness);
+    const result = convertSimulatedPublicTailOutputFromWitnessMap(witness);
     emitCircuitSimulationStats(
       'public-kernel-tail',
       timer.ms(),
@@ -258,7 +309,18 @@ export class TestCircuitProver implements ServerCircuitProver {
       this.logger,
     );
 
-    return makePublicInputsAndProof(result, makeEmptyProof());
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      VerificationKeyData.makeFake(),
+    );
+  }
+
+  getAvmProof(_inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey> {
+    // We can't simulate the AVM because we don't have enough context to do so (e.g., DBs).
+    // We just return an empty proof and VK data.
+    this.logger.debug('Skipping AVM simulation in TestCircuitProver.');
+    return Promise.resolve({ proof: makeEmptyProof(), verificationKey: VerificationKeyData.makeFake() });
   }
 
   // Not implemented for test circuits

package/src/test/test_verifier.ts

@@ -0,0 +1,12 @@
+import { type ClientProtocolCircuitVerifier, type Tx } from '@aztec/circuit-types';
+import { type VerificationKeys, getMockVerificationKeys } from '@aztec/circuits.js';
+
+export class TestCircuitVerifier implements ClientProtocolCircuitVerifier {
+  verifyProof(_tx: Tx): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  getVerificationKeys(): Promise<VerificationKeys> {
+    return Promise.resolve(getMockVerificationKeys());
+  }
+}

package/src/verification_key/verification_key_data.ts

@@ -0,0 +1,35 @@
+import {
+  Fr,
+  type VERIFICATION_KEY_LENGTH_IN_FIELDS,
+  VerificationKeyAsFields,
+  VerificationKeyData,
+} from '@aztec/circuits.js';
+import { type Tuple } from '@aztec/foundation/serialize';
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+import { VK_FIELDS_FILENAME, VK_FILENAME } from '../bb/execute.js';
+
+/**
+ * Reads the verification key data stored at the specified location and parses into a VerificationKeyData
+ * @param vkDirectoryPath - The directory containing the verification key data files
+ * @returns The verification key data
+ */
+export async function extractVkData(vkDirectoryPath: string): Promise<VerificationKeyData> {
+  const [rawFields, rawBinary] = await Promise.all([
+    fs.readFile(path.join(vkDirectoryPath, VK_FIELDS_FILENAME), { encoding: 'utf-8' }),
+    fs.readFile(path.join(vkDirectoryPath, VK_FILENAME)),
+  ]);
+  const fieldsJson = JSON.parse(rawFields);
+  const fields = fieldsJson.map(Fr.fromString);
+  // The first item is the hash, this is not part of the actual VK
+  const vkHash = fields[0];
+  const actualVk = fields.slice(1);
+  const vkAsFields = new VerificationKeyAsFields(
+    actualVk as Tuple<Fr, typeof VERIFICATION_KEY_LENGTH_IN_FIELDS>,
+    vkHash,
+  );
+  const vk = new VerificationKeyData(vkAsFields, rawBinary);
+  return vk;
+}

package/src/verifier/bb_verifier.ts

@@ -0,0 +1,156 @@
+import { type ClientProtocolCircuitVerifier, Tx } from '@aztec/circuit-types';
+import { type Proof, type VerificationKeyData, type VerificationKeys } from '@aztec/circuits.js';
+import { runInDirectory } from '@aztec/foundation/fs';
+import { type DebugLogger, type LogFn, createDebugLogger } from '@aztec/foundation/log';
+import {
+  type ClientProtocolArtifact,
+  type ProtocolArtifact,
+  ProtocolCircuitArtifacts,
+} from '@aztec/noir-protocol-circuits-types';
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+import {
+  BB_RESULT,
+  PROOF_FILENAME,
+  VK_FILENAME,
+  generateContractForCircuit,
+  generateKeyForNoirCircuit,
+  verifyProof,
+} from '../bb/execute.js';
+import { type BBConfig } from '../config.js';
+import { extractVkData } from '../verification_key/verification_key_data.js';
+
+export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
+  private constructor(
+    private config: BBConfig,
+    private verificationKeys = new Map<ProtocolArtifact, Promise<VerificationKeyData>>(),
+    private logger: DebugLogger,
+  ) {}
+
+  public static async new(
+    config: BBConfig,
+    initialCircuits: ProtocolArtifact[] = [],
+    logger = createDebugLogger('aztec:bb-verifier'),
+  ) {
+    const keys = new Map<ProtocolArtifact, Promise<VerificationKeyData>>();
+    for (const circuit of initialCircuits) {
+      const vkData = await this.generateVerificationKey(
+        circuit,
+        config.bbBinaryPath,
+        config.bbWorkingDirectory,
+        logger.debug,
+      );
+      keys.set(circuit, Promise.resolve(vkData));
+    }
+    return new BBCircuitVerifier(config, keys, logger);
+  }
+
+  private static async generateVerificationKey(
+    circuit: ProtocolArtifact,
+    bbPath: string,
+    workingDirectory: string,
+    logFn: LogFn,
+  ) {
+    return await generateKeyForNoirCircuit(
+      bbPath,
+      workingDirectory,
+      circuit,
+      ProtocolCircuitArtifacts[circuit],
+      'vk',
+      logFn,
+    ).then(result => {
+      if (result.status === BB_RESULT.FAILURE) {
+        throw new Error(`Failed to created verification key for ${circuit}, ${result.reason}`);
+      }
+
+      return extractVkData(result.vkPath!);
+    });
+  }
+
+  public async getVerificationKeyData(circuit: ProtocolArtifact) {
+    let promise = this.verificationKeys.get(circuit);
+    if (!promise) {
+      promise = BBCircuitVerifier.generateVerificationKey(
+        circuit,
+        this.config.bbBinaryPath,
+        this.config.bbWorkingDirectory,
+        this.logger.debug,
+      );
+    }
+    this.verificationKeys.set(circuit, promise);
+    const vk = await promise;
+    return vk.clone();
+  }
+
+  public async verifyProofForCircuit(circuit: ProtocolArtifact, proof: Proof) {
+    const operation = async (bbWorkingDirectory: string) => {
+      const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
+      const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
+      const verificationKey = await this.getVerificationKeyData(circuit);
+
+      this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
+
+      await fs.writeFile(proofFileName, proof.buffer);
+      await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+
+      const logFunction = (message: string) => {
+        this.logger.debug(`${circuit} BB out - ${message}`);
+      };
+
+      const result = await verifyProof(this.config.bbBinaryPath, proofFileName, verificationKeyPath!, logFunction);
+
+      if (result.status === BB_RESULT.FAILURE) {
+        const errorMessage = `Failed to verify ${circuit} proof!`;
+        throw new Error(errorMessage);
+      }
+
+      this.logger.debug(`${circuit} verification successful`);
+    };
+    await runInDirectory(this.config.bbWorkingDirectory, operation);
+  }
+
+  public async generateSolidityContract(circuit: ProtocolArtifact, contractName: string) {
+    const result = await generateContractForCircuit(
+      this.config.bbBinaryPath,
+      this.config.bbWorkingDirectory,
+      circuit,
+      ProtocolCircuitArtifacts[circuit],
+      contractName,
+      this.logger.debug,
+    );
+
+    if (result.status === BB_RESULT.FAILURE) {
+      throw new Error(`Failed to create verifier contract for ${circuit}, ${result.reason}`);
+    }
+
+    return fs.readFile(result.contractPath!, 'utf-8');
+  }
+
+  async verifyProof(tx: Tx): Promise<boolean> {
+    const { proof, enqueuedPublicFunctionCalls } = tx;
+    const expectedCircuit: ClientProtocolArtifact =
+      enqueuedPublicFunctionCalls.length > 0 ? 'PrivateKernelTailToPublicArtifact' : 'PrivateKernelTailArtifact';
+
+    try {
+      await this.verifyProofForCircuit(expectedCircuit, proof);
+      return true;
+    } catch (err) {
+      this.logger.warn(`Failed to verify ${expectedCircuit} proof for tx ${Tx.getHash(tx)}: ${String(err)}`);
+      return false;
+    }
+  }
+
+  async getVerificationKeys(): Promise<VerificationKeys> {
+    const [privateKernelCircuit, privateKernelToPublicCircuit] = await Promise.all([
+      this.getVerificationKeyData('PrivateKernelTailArtifact'),
+      this.getVerificationKeyData('PrivateKernelTailToPublicArtifact'),
+    ]);
+
+    return {
+      privateKernelCircuit,
+      privateKernelToPublicCircuit,
+    };
+  }
+}

package/src/verifier/index.ts

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

package/dest/prover/verification_key_data.d.ts

@@ -1,16 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { type Fr, type VERIFICATION_KEY_LENGTH_IN_FIELDS } from '@aztec/circuits.js';
-import { type Tuple } from '@aztec/foundation/serialize';
-export declare const AGGREGATION_OBJECT_SIZE = 16;
-export declare const CIRCUIT_SIZE_INDEX = 3;
-export declare const CIRCUIT_PUBLIC_INPUTS_INDEX = 4;
-export declare const CIRCUIT_RECURSIVE_INDEX = 5;
-export type VerificationKeyData = {
-    hash: Fr;
-    keyAsFields: Tuple<Fr, typeof VERIFICATION_KEY_LENGTH_IN_FIELDS>;
-    keyAsBytes: Buffer;
-    numPublicInputs: number;
-    circuitSize: number;
-    isRecursive: boolean;
-};
-//# sourceMappingURL=verification_key_data.d.ts.map

package/dest/prover/verification_key_data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"verification_key_data.d.ts","sourceRoot":"","sources":["../../src/prover/verification_key_data.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AACrF,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAC7C,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,EAAE,CAAC;IACT,WAAW,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,iCAAiC,CAAC,CAAC;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC"}

package/dest/prover/verification_key_data.js

@@ -1,5 +0,0 @@
-export const AGGREGATION_OBJECT_SIZE = 16;
-export const CIRCUIT_SIZE_INDEX = 3;
-export const CIRCUIT_PUBLIC_INPUTS_INDEX = 4;
-export const CIRCUIT_RECURSIVE_INDEX = 5;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyaWZpY2F0aW9uX2tleV9kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3Zlci92ZXJpZmljYXRpb25fa2V5X2RhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsRUFBRSxDQUFDO0FBQzFDLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLENBQUMsQ0FBQztBQUNwQyxNQUFNLENBQUMsTUFBTSwyQkFBMkIsR0FBRyxDQUFDLENBQUM7QUFDN0MsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsQ0FBQyxDQUFDIn0=

package/src/prover/verification_key_data.ts

@@ -1,16 +0,0 @@
-import { type Fr, type VERIFICATION_KEY_LENGTH_IN_FIELDS } from '@aztec/circuits.js';
-import { type Tuple } from '@aztec/foundation/serialize';
-
-export const AGGREGATION_OBJECT_SIZE = 16;
-export const CIRCUIT_SIZE_INDEX = 3;
-export const CIRCUIT_PUBLIC_INPUTS_INDEX = 4;
-export const CIRCUIT_RECURSIVE_INDEX = 5;
-
-export type VerificationKeyData = {
-  hash: Fr;
-  keyAsFields: Tuple<Fr, typeof VERIFICATION_KEY_LENGTH_IN_FIELDS>;
-  keyAsBytes: Buffer;
-  numPublicInputs: number;
-  circuitSize: number;
-  isRecursive: boolean;
-};