@aztec/bb-prover 0.46.2 → 0.46.3

package/src/prover/bb_prover.ts

@@ -9,7 +9,6 @@ import {
 } from '@aztec/circuit-types';
 import { type CircuitProvingStats, type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
-  AGGREGATION_OBJECT_LENGTH,
   type AvmCircuitInputs,
   type BaseOrMergeRollupPublicInputs,
   type BaseParityInputs,
@@ -30,6 +29,8 @@ import {
   type RootParityInputs,
   type RootRollupInputs,
   type RootRollupPublicInputs,
+  TUBE_PROOF_LENGTH,
+  TubeInputs,
   type VerificationKeyAsFields,
   type VerificationKeyData,
   makeRecursiveProofFromBinary,
@@ -62,6 +63,7 @@ import { Attributes, type TelemetryClient, trackSpan } from '@aztec/telemetry-cl
 
 import { abiEncode } from '@noir-lang/noirc_abi';
 import { type Abi, type WitnessMap } from '@noir-lang/types';
+import crypto from 'crypto';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 
@@ -75,6 +77,7 @@ import {
   generateAvmProof,
   generateKeyForNoirCircuit,
   generateProof,
+  generateTubeProof,
   verifyAvmProof,
   verifyProof,
   writeProofAsFields,
@@ -222,6 +225,16 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       kernelRequest.inputs.previousKernel.vk,
     );
 
+    // PUBLIC KERNEL: kernel request should be nonempty at start of public kernel proving but it is not
+    // TODO(#7369): We should properly enqueue the tube in the public kernel lifetime
+    if (!kernelRequest.inputs.previousKernel.clientIvcProof.isEmpty()) {
+      const { tubeVK, tubeProof } = await this.getTubeProof(
+        new TubeInputs(kernelRequest.inputs.previousKernel.clientIvcProof),
+      );
+      kernelRequest.inputs.previousKernel.vk = tubeVK;
+      kernelRequest.inputs.previousKernel.proof = tubeProof;
+    }
+
     await this.verifyWithKey(
       kernelRequest.inputs.previousKernel.vk,
       kernelRequest.inputs.previousKernel.proof.binaryProof,
@@ -267,23 +280,27 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
   /**
    * Simulates the base rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
+   * @param baseRollupInput - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
   public async getBaseRollupProof(
-    input: BaseRollupInputs,
+    baseRollupInput: BaseRollupInputs, // TODO: remove tail proof from here
   ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     // We may need to convert the recursive proof into fields format
-    input.kernelData.proof = await this.ensureValidProof(
-      input.kernelData.proof,
+    logger.debug(`kernel Data proof: ${baseRollupInput.kernelData.proof}`);
+    logger.info(`in getBaseRollupProof`);
+    logger.info(`Number of public inputs in baseRollupInput: ${baseRollupInput.kernelData.vk.numPublicInputs}`);
+    logger.info(`Number of public inputs ${baseRollupInput.kernelData.publicInputs}`);
+    baseRollupInput.kernelData.proof = await this.ensureValidProof(
+      baseRollupInput.kernelData.proof,
       'BaseRollupArtifact',
-      input.kernelData.vk,
+      baseRollupInput.kernelData.vk,
     );
 
     const { circuitOutput, proof } = await this.createRecursiveProof(
-      input,
+      baseRollupInput, // BaseRollupInputs
       'BaseRollupArtifact',
-      NESTED_RECURSIVE_PROOF_LENGTH,
+      NESTED_RECURSIVE_PROOF_LENGTH, // WORKTODO: this should be BASE_ROLLUP_PROOF_LENGTH or something like this
       convertBaseRollupInputsToWitnessMap,
       convertBaseRollupOutputsFromWitnessMap,
     );
@@ -356,6 +373,20 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     return emptyPrivateKernelProof;
   }
 
+  public async getEmptyTubeProof(
+    inputs: PrivateKernelEmptyInputData,
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+    const emptyNested = await this.getEmptyNestedProof();
+    const emptyPrivateKernelProof = await this.getEmptyTubeProofFromEmptyNested(
+      PrivateKernelEmptyInputs.from({
+        ...inputs,
+        emptyNested,
+      }),
+    );
+
+    return emptyPrivateKernelProof;
+  }
+
   private async getEmptyNestedProof(): Promise<EmptyNestedData> {
     const inputs = new EmptyNestedCircuitInputs();
     const { proof } = await this.createRecursiveProof(
@@ -368,11 +399,15 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
     const verificationKey = await this.getVerificationKeyDataForCircuit('EmptyNestedArtifact');
     await this.verifyProof('EmptyNestedArtifact', proof.binaryProof);
+    // logger.debug(`EmptyNestedData proof size: ${proof.proof.length}`);
+    // logger.debug(`EmptyNestedData proof: ${proof.proof}`);
+    // logger.debug(`EmptyNestedData vk size: ${verificationKey.keyAsFields.key.length}`);
+    // logger.debug(`EmptyNestedData vk: ${verificationKey.keyAsFields.key}`);
 
     return new EmptyNestedData(proof, verificationKey.keyAsFields);
   }
 
-  private async getEmptyPrivateKernelProofFromEmptyNested(
+  private async getEmptyTubeProofFromEmptyNested(
     inputs: PrivateKernelEmptyInputs,
   ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
     const { circuitOutput, proof } = await this.createRecursiveProof(
@@ -382,7 +417,24 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertPrivateKernelEmptyInputsToWitnessMap,
       convertPrivateKernelEmptyOutputsFromWitnessMap,
     );
+    // info(`proof: ${proof.proof}`);
+    const verificationKey = await this.getVerificationKeyDataForCircuit('PrivateKernelEmptyArtifact');
+    await this.verifyProof('PrivateKernelEmptyArtifact', proof.binaryProof);
 
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+  }
+
+  private async getEmptyPrivateKernelProofFromEmptyNested(
+    inputs: PrivateKernelEmptyInputs,
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+    const { circuitOutput, proof } = await this.createRecursiveProof(
+      inputs,
+      'PrivateKernelEmptyArtifact',
+      NESTED_RECURSIVE_PROOF_LENGTH,
+      convertPrivateKernelEmptyInputsToWitnessMap,
+      convertPrivateKernelEmptyOutputsFromWitnessMap,
+    );
+    //info(`proof: ${proof.proof}`);
     const verificationKey = await this.getVerificationKeyDataForCircuit('PrivateKernelEmptyArtifact');
     await this.verifyProof('PrivateKernelEmptyArtifact', proof.binaryProof);
 
@@ -513,6 +565,22 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     return provingResult;
   }
 
+  private async generateTubeProofWithBB(bbWorkingDirectory: string, input: TubeInputs): Promise<BBSuccess> {
+    logger.debug(`Proving tube...`);
+
+    const hasher = crypto.createHash('sha256');
+    hasher.update(input.toBuffer());
+
+    await input.clientIVCData.writeToOutputDirectory(bbWorkingDirectory);
+    const provingResult = await generateTubeProof(this.config.bbBinaryPath, bbWorkingDirectory, logger.verbose);
+
+    if (provingResult.status === BB_RESULT.FAILURE) {
+      logger.error(`Failed to generate proof for tube proof: ${provingResult.reason}`);
+      throw new Error(provingResult.reason);
+    }
+    return provingResult;
+  }
+
   private async createAvmProof(input: AvmCircuitInputs): Promise<ProofAndVerificationKey> {
     const cleanupDir: boolean = !process.env.AVM_PROVING_PRESERVE_WORKING_DIR;
     const operation = async (bbWorkingDirectory: string): Promise<ProofAndVerificationKey> => {
@@ -554,8 +622,34 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     return await runInDirectory(this.config.bbWorkingDirectory, operation, cleanupDir);
   }
 
+  public async getTubeProof(
+    input: TubeInputs,
+  ): Promise<{ tubeVK: VerificationKeyData; tubeProof: RecursiveProof<typeof TUBE_PROOF_LENGTH> }> {
+    // this probably is gonna need to call client ivc
+    const operation = async (bbWorkingDirectory: string) => {
+      logger.debug(`createTubeProof: ${bbWorkingDirectory}`);
+      const provingResult = await this.generateTubeProofWithBB(bbWorkingDirectory, input);
+
+      // Read the proof as fields
+      const tubeVK = await extractVkData(provingResult.vkPath!);
+      const tubeProof = await this.readTubeProofAsFields(provingResult.proofPath!, tubeVK, TUBE_PROOF_LENGTH);
+      // Sanity check the tube proof (can be removed later)
+      await this.verifyWithKey(tubeVK, tubeProof.binaryProof);
+
+      // TODO(#7369): properly time tube construction
+      logger.info(
+        `Generated proof for tubeCircuit in ${Math.ceil(provingResult.durationMs)} ms, size: ${
+          tubeProof.proof.length
+        } fields`,
+      );
+
+      return { tubeVK, tubeProof };
+    };
+    return await runInDirectory(this.config.bbWorkingDirectory, operation);
+  }
+
   /**
-   * Executes a circuit and returns it's outputs and corresponding proof with embedded aggregation object
+   * Executes a circuit and returns its outputs and corresponding proof with embedded aggregation object
    * @param witnessMap - The input witness
    * @param circuitType - The type of circuit to be executed
    * @param proofLength - The length of the proof to be generated. This is a dummy parameter to aid in type checking
@@ -574,6 +668,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     convertInput: (input: CircuitInputType) => WitnessMap,
     convertOutput: (outputWitness: WitnessMap) => CircuitOutputType,
   ): Promise<{ circuitOutput: CircuitOutputType; proof: RecursiveProof<PROOF_LENGTH> }> {
+    // this probably is gonna need to call client ivc
     const operation = async (bbWorkingDirectory: string) => {
       const {
         provingResult,
@@ -619,6 +714,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    */
   public async verifyProof(circuitType: ServerProtocolArtifact, proof: Proof) {
     const verificationKey = await this.getVerificationKeyDataForCircuit(circuitType);
+    // info(`vkey in: ${verificationKey.keyAsFields.key}`);
     return await this.verifyWithKey(verificationKey, proof);
   }
 
@@ -691,7 +787,8 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     }
 
     const operation = async (bbWorkingDirectory: string) => {
-      const numPublicInputs = vk.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+      // const numPublicInputs = vk.numPublicInputs;
+      const numPublicInputs = vk.numPublicInputs; // - AGGREGATION_OBJECT_LENGTH;
       const proofFullFilename = path.join(bbWorkingDirectory, PROOF_FILENAME);
       const vkFullFilename = path.join(bbWorkingDirectory, VK_FILENAME);
 
@@ -723,7 +820,10 @@ export class BBNativeRollupProver implements ServerCircuitProver {
         encoding: 'utf-8',
       });
       const json = JSON.parse(proofString);
-      const fields = json.slice(numPublicInputs).map(Fr.fromString);
+      const fields = json
+        .slice(0, 3)
+        .map(Fr.fromString)
+        .concat(json.slice(3 + numPublicInputs).map(Fr.fromString));
       return new RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>(
         fields,
         new Proof(proof.binaryProof.buffer, vk.numPublicInputs),
@@ -800,13 +900,21 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     if (!vkData) {
       throw new Error(`Invalid verification key for ${circuitType}`);
     }
-    const numPublicInputs = CIRCUITS_WITHOUT_AGGREGATION.has(circuitType)
-      ? vkData.numPublicInputs
-      : vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-    const fieldsWithoutPublicInputs = json.slice(numPublicInputs).map(Fr.fromString);
+    const numPublicInputs = vkData.numPublicInputs;
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1044): Reinstate aggregation
+    // const numPublicInputs = CIRCUITS_WITHOUT_AGGREGATION.has(circuitType)
+    //   ? vkData.numPublicInputs
+    //   : vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+    const fieldsWithoutPublicInputs = json
+      .slice(0, 3)
+      .map(Fr.fromString)
+      .concat(json.slice(3 + numPublicInputs).map(Fr.fromString));
     logger.debug(
-      `Circuit type: ${circuitType}, complete proof length: ${json.length}, without public inputs: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`,
+      `num pub inputs ${vkData.numPublicInputs} and without aggregation ${CIRCUITS_WITHOUT_AGGREGATION.has(
+        circuitType,
+      )}`,
     );
+
     const proof = new RecursiveProof<PROOF_LENGTH>(
       fieldsWithoutPublicInputs,
       new Proof(binaryProof, numPublicInputs),
@@ -818,4 +926,46 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
     return proof;
   }
+
+  /**
+   * Parses and returns a tube proof stored in the specified directory. TODO merge wih above
+   * @param filePath - The directory containing the proof data
+   * @param circuitType - The type of circuit proven
+   * @returns The proof
+   * TODO(#7369) This is entirely redundant now with the above method, deduplicate
+   */
+  private async readTubeProofAsFields<PROOF_LENGTH extends number>(
+    filePath: string,
+    vkData: VerificationKeyData,
+    proofLength: PROOF_LENGTH,
+  ): Promise<RecursiveProof<PROOF_LENGTH>> {
+    const proofFilename = path.join(filePath, PROOF_FILENAME);
+    const proofFieldsFilename = path.join(filePath, PROOF_FIELDS_FILENAME);
+
+    const [binaryProof, proofString] = await Promise.all([
+      fs.readFile(proofFilename),
+      fs.readFile(proofFieldsFilename, { encoding: 'utf-8' }),
+    ]);
+
+    const json = JSON.parse(proofString);
+
+    const numPublicInputs = vkData.numPublicInputs;
+    if (numPublicInputs === 0) {
+      throw new Error(`Tube proof should have public inputs (e.g. the number of public inputs from PrivateKernelTail)`);
+    }
+
+    const proofFields = json
+      .slice(0, 3)
+      .map(Fr.fromString)
+      .concat(json.slice(3 + numPublicInputs).map(Fr.fromString));
+    logger.debug(
+      `Circuit type: tube circuit, complete proof length: ${json.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`,
+    );
+    const proof = new RecursiveProof<PROOF_LENGTH>(proofFields, new Proof(binaryProof, numPublicInputs), true);
+    if (proof.proof.length !== proofLength) {
+      throw new Error(`Proof length doesn't match expected length (${proof.proof.length} != ${proofLength})`);
+    }
+
+    return proof;
+  }
 }

package/src/prover/index.ts

@@ -1,2 +1,2 @@
 export * from './bb_prover.js';
-export * from './bb_native_proof_creator.js';
+export * from './bb_private_kernel_prover.js';

package/src/stats.ts

@@ -41,6 +41,8 @@ export function mapProtocolArtifactNameToCircuitName(
       return 'private-kernel-reset-medium';
     case 'PrivateKernelResetSmallArtifact':
       return 'private-kernel-reset-small';
+    case 'PrivateKernelResetTinyArtifact':
+      return 'private-kernel-reset-tiny';
     case 'EmptyNestedArtifact':
       return 'empty-nested';
     case 'PrivateKernelEmptyArtifact':

package/src/test/test_circuit_prover.ts

@@ -20,10 +20,13 @@ import {
   type Proof,
   type PublicKernelCircuitPublicInputs,
   RECURSIVE_PROOF_LENGTH,
+  type RecursiveProof,
   RootParityInput,
   type RootParityInputs,
   type RootRollupInputs,
   type RootRollupPublicInputs,
+  TUBE_PROOF_LENGTH,
+  type TubeInputs,
   VerificationKeyData,
   makeEmptyProof,
   makeEmptyRecursiveProof,
@@ -41,6 +44,7 @@ import {
   convertMergeRollupInputsToWitnessMap,
   convertMergeRollupOutputsFromWitnessMap,
   convertPrivateKernelEmptyInputsToWitnessMap,
+  convertPrivateKernelEmptyOutputsFromWitnessMap,
   convertRootParityInputsToWitnessMap,
   convertRootParityOutputsFromWitnessMap,
   convertRootRollupInputsToWitnessMap,
@@ -107,6 +111,34 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
+  public async getEmptyTubeProof(
+    inputs: PrivateKernelEmptyInputData,
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+    const emptyNested = new EmptyNestedData(
+      makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+      ProtocolCircuitVks['EmptyNestedArtifact'].keyAsFields,
+    );
+    const kernelInputs = new PrivateKernelEmptyInputs(
+      emptyNested,
+      inputs.header,
+      inputs.chainId,
+      inputs.version,
+      inputs.vkTreeRoot,
+    );
+    const witnessMap = convertPrivateKernelEmptyInputsToWitnessMap(kernelInputs);
+    const witness = await this.wasmSimulator.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.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.
@@ -217,6 +249,16 @@ export class TestCircuitProver implements ServerCircuitProver {
       ProtocolCircuitVks['BaseRollupArtifact'],
     );
   }
+
+  public getTubeProof(
+    _tubeInput: TubeInputs,
+  ): Promise<{ tubeVK: VerificationKeyData; tubeProof: RecursiveProof<typeof TUBE_PROOF_LENGTH> }> {
+    return Promise.resolve({
+      tubeVK: VerificationKeyData.makeFake(),
+      tubeProof: makeEmptyRecursiveProof(TUBE_PROOF_LENGTH),
+    });
+  }
+
   /**
    * Simulates the merge rollup circuit from its inputs.
    * @param input - Inputs to the circuit.

package/src/verification_key/verification_key_data.ts

@@ -25,11 +25,7 @@ export async function extractVkData(vkDirectoryPath: string): Promise<Verificati
   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 vkAsFields = new VerificationKeyAsFields(fields as Tuple<Fr, typeof VERIFICATION_KEY_LENGTH_IN_FIELDS>, vkHash);
   const vk = new VerificationKeyData(vkAsFields, rawBinary);
   return vk;
 }

package/src/verifier/bb_verifier.ts

@@ -128,18 +128,19 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
     return fs.readFile(result.contractPath!, 'utf-8');
   }
 
-  async verifyProof(tx: Tx): Promise<boolean> {
-    const { proof, data } = tx;
-    const expectedCircuit: ClientProtocolArtifact = data.forPublic
+  verifyProof(tx: Tx): Promise<boolean> {
+    const expectedCircuit: ClientProtocolArtifact = tx.data.forPublic
       ? 'PrivateKernelTailToPublicArtifact'
       : 'PrivateKernelTailArtifact';
 
     try {
-      await this.verifyProofForCircuit(expectedCircuit, proof);
-      return true;
+      // TODO(https://github.com/AztecProtocol/barretenberg/issues/1050) we need a proper verify flow for clientIvcProof
+      // For now we handle only the trivial blank data case
+      // await this.verifyProofForCircuit(expectedCircuit, proof);
+      return Promise.resolve(!tx.clientIvcProof.isEmpty());
     } catch (err) {
       this.logger.warn(`Failed to verify ${expectedCircuit} proof for tx ${Tx.getHash(tx)}: ${String(err)}`);
-      return false;
+      return Promise.resolve(false);
     }
   }
 }

package/dest/prover/bb_native_proof_creator.d.ts

@@ -1,47 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { type AppCircuitProofOutput, type KernelProofOutput, type ProofCreator } from '@aztec/circuit-types';
-import { Fr, type PrivateCircuitPublicInputs, type PrivateKernelCircuitPublicInputs, type PrivateKernelInitCircuitPrivateInputs, type PrivateKernelInnerCircuitPrivateInputs, type PrivateKernelResetCircuitPrivateInputsVariants, type PrivateKernelTailCircuitPrivateInputs, type PrivateKernelTailCircuitPublicInputs, Proof } from '@aztec/circuits.js';
-import { type ClientProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
-import { type WitnessMap } from '@noir-lang/types';
-/**
- * This proof creator implementation uses the native bb binary.
- * This is a temporary implementation until we make the WASM version work.
- */
-export declare class BBNativeProofCreator implements ProofCreator {
-    private bbBinaryPath;
-    private bbWorkingDirectory;
-    private log;
-    private simulator;
-    private verificationKeys;
-    constructor(bbBinaryPath: string, bbWorkingDirectory: string, log?: import("@aztec/foundation/log").Logger);
-    getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs): Promise<Fr[]>;
-    createProofInit(inputs: PrivateKernelInitCircuitPrivateInputs): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>>;
-    createProofInner(inputs: PrivateKernelInnerCircuitPrivateInputs): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>>;
-    createProofReset(inputs: PrivateKernelResetCircuitPrivateInputsVariants): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>>;
-    createProofTail(inputs: PrivateKernelTailCircuitPrivateInputs): Promise<KernelProofOutput<PrivateKernelTailCircuitPublicInputs>>;
-    createAppCircuitProof(partialWitness: WitnessMap, bytecode: Buffer, appCircuitName?: string): Promise<AppCircuitProofOutput>;
-    /**
-     * Verifies a proof, will generate the verification key if one is not cached internally
-     * @param circuitType - The type of circuit whose proof is to be verified
-     * @param proof - The proof to be verified
-     */
-    verifyProofForProtocolCircuit(circuitType: ClientProtocolArtifact, proof: Proof): Promise<void>;
-    private verifyProofFromKey;
-    /**
-     * Ensures our verification key cache includes the key data located at the specified directory
-     * @param filePath - The directory containing the verification key data files
-     * @param circuitType - The type of circuit to which the verification key corresponds
-     */
-    private updateVerificationKeyAfterProof;
-    private createSafeProof;
-    private generateWitnessAndCreateProof;
-    private createProof;
-    /**
-     * Parses and returns the proof data stored at the specified directory
-     * @param filePath - The directory containing the proof data
-     * @param circuitType - The type of circuit proven
-     * @returns The proof
-     */
-    private readProofAsFields;
-}
-//# sourceMappingURL=bb_native_proof_creator.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"bb_native_proof_creator.d.ts","sourceRoot":"","sources":["../../src/prover/bb_native_proof_creator.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAE7G,OAAO,EAEL,EAAE,EAEF,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,qCAAqC,EAC1C,KAAK,sCAAsC,EAC3C,KAAK,8CAA8C,EACnD,KAAK,qCAAqC,EAC1C,KAAK,oCAAoC,EACzC,KAAK,EAKN,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EAEL,KAAK,sBAAsB,EAa5B,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAQnD;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IASrD,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,GAAG;IAVb,OAAO,CAAC,SAAS,CAAuB;IAExC,OAAO,CAAC,gBAAgB,CAGpB;gBAGM,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,yCAA8C;IAGpD,oBAAoB,CAAC,YAAY,EAAE,0BAA0B;IAMvD,eAAe,CAC1B,MAAM,EAAE,qCAAqC,GAC5C,OAAO,CAAC,iBAAiB,CAAC,gCAAgC,CAAC,CAAC;IASlD,gBAAgB,CAC3B,MAAM,EAAE,sCAAsC,GAC7C,OAAO,CAAC,iBAAiB,CAAC,gCAAgC,CAAC,CAAC;IASlD,gBAAgB,CAC3B,MAAM,EAAE,8CAA8C,GACrD,OAAO,CAAC,iBAAiB,CAAC,gCAAgC,CAAC,CAAC;IASlD,eAAe,CAC1B,MAAM,EAAE,qCAAqC,GAC5C,OAAO,CAAC,iBAAiB,CAAC,oCAAoC,CAAC,CAAC;IAiBtD,qBAAqB,CAChC,cAAc,EAAE,UAAU,EAC1B,QAAQ,EAAE,MAAM,EAChB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,qBAAqB,CAAC;IAkBjC;;;;OAIG;IACU,6BAA6B,CAAC,WAAW,EAAE,sBAAsB,EAAE,KAAK,EAAE,KAAK;YAmB9E,kBAAkB;IAgBhC;;;;OAIG;YACW,+BAA+B;YAU/B,eAAe;YAYf,6BAA6B;YA6C7B,WAAW;IA4EzB;;;;;OAKG;YACW,iBAAiB;CAwBhC"}