@aztec/bb-prover 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/dest/prover/server/bb_prover.js

@@ -4,29 +4,27 @@ function _ts_decorate(decorators, target, key, desc) {
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, PAIRING_POINTS_SIZE, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH, ULTRA_KECCAK_PROOF_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, PAIRING_POINTS_SIZE, RECURSIVE_PROOF_LENGTH, ULTRA_KECCAK_PROOF_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
-import { convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap, convertBlockRootRollupInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertPaddingBlockRootRollupInputsToWitnessMap, convertPaddingBlockRootRollupOutputsFromWitnessMap, convertPrivateBaseRollupInputsToWitnessMap, convertPrivateBaseRollupOutputsFromWitnessMap, convertPublicBaseRollupInputsToWitnessMap, convertPublicBaseRollupOutputsFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertSingleTxBlockRootRollupInputsToWitnessMap, convertSingleTxBlockRootRollupOutputsFromWitnessMap, getServerCircuitArtifact } from '@aztec/noir-protocol-circuits-types/server';
+import { convertBlockMergeRollupOutputsFromWitnessMap, convertBlockMergeRollupPrivateInputsToWitnessMap, convertBlockRootEmptyTxFirstRollupOutputsFromWitnessMap, convertBlockRootEmptyTxFirstRollupPrivateInputsToWitnessMap, convertBlockRootFirstRollupOutputsFromWitnessMap, convertBlockRootFirstRollupPrivateInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap, convertBlockRootRollupPrivateInputsToWitnessMap, convertBlockRootSingleTxFirstRollupOutputsFromWitnessMap, convertBlockRootSingleTxFirstRollupPrivateInputsToWitnessMap, convertBlockRootSingleTxRollupOutputsFromWitnessMap, convertBlockRootSingleTxRollupPrivateInputsToWitnessMap, convertCheckpointMergeRollupOutputsFromWitnessMap, convertCheckpointMergeRollupPrivateInputsToWitnessMap, convertCheckpointPaddingRollupOutputsFromWitnessMap, convertCheckpointPaddingRollupPrivateInputsToWitnessMap, convertCheckpointRootRollupOutputsFromWitnessMap, convertCheckpointRootRollupPrivateInputsToWitnessMap, convertCheckpointRootSingleBlockRollupOutputsFromWitnessMap, convertCheckpointRootSingleBlockRollupPrivateInputsToWitnessMap, convertParityBaseOutputsFromWitnessMap, convertParityBasePrivateInputsToWitnessMap, convertParityRootOutputsFromWitnessMap, convertParityRootPrivateInputsToWitnessMap, convertPrivateTxBaseRollupOutputsFromWitnessMap, convertPrivateTxBaseRollupPrivateInputsToWitnessMap, convertPublicChonkVerifierOutputsFromWitnessMap, convertPublicChonkVerifierPrivateInputsToWitnessMap, convertPublicTxBaseRollupOutputsFromWitnessMap, convertPublicTxBaseRollupPrivateInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertRootRollupPrivateInputsToWitnessMap, convertTxMergeRollupOutputsFromWitnessMap, convertTxMergeRollupPrivateInputsToWitnessMap, getServerCircuitArtifact } from '@aztec/noir-protocol-circuits-types/server';
 import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
+import { mapProtocolArtifactNameToCircuitName } from '@aztec/noir-protocol-circuits-types/types';
 import { NativeACVMSimulator } from '@aztec/simulator/server';
 import { ProvingError } from '@aztec/stdlib/errors';
 import { makeProofAndVerificationKey, makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { Proof, RecursiveProof, makeRecursiveProofFromBinary } from '@aztec/stdlib/proofs';
 import { enhanceProofWithPiValidationFlag } from '@aztec/stdlib/rollup';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import crypto from 'crypto';
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { BB_RESULT, PROOF_FILENAME, PUBLIC_INPUTS_FILENAME, VK_FILENAME, generateAvmProof, generateProof, generateTubeProof, verifyAvmProof, verifyProof } from '../../bb/execute.js';
+import { BB_RESULT, PROOF_FILENAME, PUBLIC_INPUTS_FILENAME, VK_FILENAME, generateAvmProof, generateProof, verifyAvmProof, verifyProof } from '../../bb/execute.js';
 import { getUltraHonkFlavorForCircuit } from '../../honk.js';
 import { ProverInstrumentation } from '../../instrumentation.js';
-import { mapProtocolArtifactNameToCircuitName } from '../../stats.js';
-import { extractAvmVkData, extractVkData } from '../../verification_key/verification_key_data.js';
-import { PRIVATE_TAIL_CIVC_VK, PUBLIC_TAIL_CIVC_VK } from '../../verifier/bb_verifier.js';
-import { readProofAsFields, writeClientIVCProofToOutputDirectory } from '../proof_utils.js';
+import { extractAvmVkData } from '../../verification_key/verification_key_data.js';
+import { readProofsFromOutputDirectory } from '../proof_utils.js';
 const logger = createLogger('bb-prover');
 /**
  * Prover implementation that uses barretenberg native proving
@@ -57,21 +55,15 @@ const logger = createLogger('bb-prover');
    * Simulates the base parity circuit from its inputs.
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs of the parity circuit.
-   */ async getBaseParityProof(inputs) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'BaseParityArtifact', RECURSIVE_PROOF_LENGTH, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('BaseParityArtifact');
-        await this.verifyProof('BaseParityArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+   */ getBaseParityProof(inputs) {
+        return this.createRecursiveProofAndVerify(inputs, 'ParityBaseArtifact', RECURSIVE_PROOF_LENGTH, convertParityBasePrivateInputsToWitnessMap, convertParityBaseOutputsFromWitnessMap);
     }
     /**
    * Simulates the root parity circuit from its inputs.
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs of the parity circuit.
-   */ async getRootParityProof(inputs) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'RootParityArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('RootParityArtifact');
-        await this.verifyProof('RootParityArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+   */ getRootParityProof(inputs) {
+        return this.createRecursiveProofAndVerify(inputs, 'ParityRootArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertParityRootPrivateInputsToWitnessMap, convertParityRootOutputsFromWitnessMap);
     }
     /**
    * Creates an AVM proof and verifies it.
@@ -84,92 +76,83 @@ const logger = createLogger('bb-prover');
         proofAndVk.proof.proof = enhanceProofWithPiValidationFlag(proofAndVk.proof.proof, skipPublicInputsValidation);
         return proofAndVk;
     }
+    async getPublicChonkVerifierProof(inputs) {
+        const artifactName = 'PublicChonkVerifier';
+        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, artifactName, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPublicChonkVerifierPrivateInputsToWitnessMap, convertPublicChonkVerifierOutputsFromWitnessMap);
+        const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
+        await this.verifyProof(artifactName, proof.binaryProof);
+        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+    }
     /**
    * Simulates the base rollup circuit from its inputs.
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
-   */ async getPrivateBaseRollupProof(inputs) {
-        const artifactName = 'PrivateBaseRollupArtifact';
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, artifactName, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPrivateBaseRollupInputsToWitnessMap, convertPrivateBaseRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
-        await this.verifyProof(artifactName, proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+   */ getPrivateTxBaseRollupProof(inputs) {
+        return this.createRecursiveProofAndVerify(inputs, 'PrivateTxBaseRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPrivateTxBaseRollupPrivateInputsToWitnessMap, convertPrivateTxBaseRollupOutputsFromWitnessMap);
     }
     /**
    * Requests that the public kernel tail circuit be executed and the proof generated
    * @param kernelRequest - The object encapsulating the request for a proof
    * @returns The requested circuit's public inputs and proof
-   */ async getPublicBaseRollupProof(inputs) {
-        const artifactName = 'PublicBaseRollupArtifact';
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, artifactName, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPublicBaseRollupInputsToWitnessMap, convertPublicBaseRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
-        await this.verifyProof(artifactName, proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+   */ getPublicTxBaseRollupProof(inputs) {
+        return this.createRecursiveProofAndVerify(inputs, 'PublicTxBaseRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPublicTxBaseRollupPrivateInputsToWitnessMap, convertPublicTxBaseRollupOutputsFromWitnessMap);
     }
     /**
    * Simulates the merge rollup circuit from its inputs.
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
-   */ async getMergeRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'MergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
-        await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+   */ getTxMergeRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'TxMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertTxMergeRollupPrivateInputsToWitnessMap, convertTxMergeRollupOutputsFromWitnessMap);
     }
-    /**
-   * Simulates the block root rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootRollupInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
-        await this.verifyProof('BlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+    getBlockRootFirstRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'BlockRootFirstRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootFirstRollupPrivateInputsToWitnessMap, convertBlockRootFirstRollupOutputsFromWitnessMap);
     }
-    async getSingleTxBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'SingleTxBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSingleTxBlockRootRollupInputsToWitnessMap, convertSingleTxBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('SingleTxBlockRootRollupArtifact');
-        await this.verifyProof('SingleTxBlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+    getBlockRootSingleTxFirstRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'BlockRootSingleTxFirstRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootSingleTxFirstRollupPrivateInputsToWitnessMap, convertBlockRootSingleTxFirstRollupOutputsFromWitnessMap);
     }
-    /**
-   * Simulates the empty block root rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getEmptyBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'EmptyBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('EmptyBlockRootRollupArtifact');
-        await this.verifyProof('EmptyBlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+    getBlockRootEmptyTxFirstRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'BlockRootEmptyTxFirstRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootEmptyTxFirstRollupPrivateInputsToWitnessMap, convertBlockRootEmptyTxFirstRollupOutputsFromWitnessMap);
     }
-    async getPaddingBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'PaddingBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPaddingBlockRootRollupInputsToWitnessMap, convertPaddingBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('PaddingBlockRootRollupArtifact');
-        await this.verifyProof('PaddingBlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+    getBlockRootRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'BlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootRollupPrivateInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap);
     }
-    /**
-   * Simulates the block merge rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getBlockMergeRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BlockMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('BlockMergeRollupArtifact');
-        await this.verifyProof('BlockMergeRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+    getBlockRootSingleTxRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'BlockRootSingleTxRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootSingleTxRollupPrivateInputsToWitnessMap, convertBlockRootSingleTxRollupOutputsFromWitnessMap);
+    }
+    getBlockMergeRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'BlockMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockMergeRollupPrivateInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap);
+    }
+    getCheckpointRootRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'CheckpointRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertCheckpointRootRollupPrivateInputsToWitnessMap, convertCheckpointRootRollupOutputsFromWitnessMap);
+    }
+    getCheckpointRootSingleBlockRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'CheckpointRootSingleBlockRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertCheckpointRootSingleBlockRollupPrivateInputsToWitnessMap, convertCheckpointRootSingleBlockRollupOutputsFromWitnessMap);
+    }
+    getCheckpointPaddingRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'CheckpointPaddingRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertCheckpointPaddingRollupPrivateInputsToWitnessMap, convertCheckpointPaddingRollupOutputsFromWitnessMap);
+    }
+    getCheckpointMergeRollupProof(input) {
+        return this.createRecursiveProofAndVerify(input, 'CheckpointMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertCheckpointMergeRollupPrivateInputsToWitnessMap, convertCheckpointMergeRollupOutputsFromWitnessMap);
     }
     /**
    * Simulates the root rollup circuit from its inputs.
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */ async getRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createProof(input, 'RootRollupArtifact', convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap);
-        const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
-        const verificationKey = this.getVerificationKeyDataForCircuit('RootRollupArtifact');
-        await this.verifyProof('RootRollupArtifact', proof);
+        const { proof, ...output } = await this.createRecursiveProofAndVerify(input, 'RootRollupArtifact', ULTRA_KECCAK_PROOF_LENGTH, convertRootRollupPrivateInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap);
+        const recursiveProof = makeRecursiveProofFromBinary(proof.binaryProof, NESTED_RECURSIVE_PROOF_LENGTH);
         // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13188): Remove this hack.
         recursiveProof.binaryProof.numPublicInputs += PAIRING_POINTS_SIZE;
-        return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, verificationKey);
+        return {
+            ...output,
+            proof: recursiveProof
+        };
+    }
+    async createRecursiveProofAndVerify(input, artifactName, proofLength, convertInput, convertOutput) {
+        const { circuitOutput, proof } = await this.createRecursiveProof(input, artifactName, proofLength, convertInput, convertOutput);
+        await this.verifyProof(artifactName, proof.binaryProof);
+        const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
+        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
     }
     async generateProofWithBB(input, circuitType, convertInput, convertOutput, workingDirectory) {
         // Have the ACVM write the partial witness here
@@ -196,7 +179,7 @@ const logger = createLogger('bb-prover');
         });
         // Now prove the circuit from the generated witness
         logger.debug(`Proving ${circuitType}...`);
-        const provingResult = await generateProof(this.config.bbBinaryPath, workingDirectory, circuitType, Buffer.from(artifact.bytecode, 'base64'), outputWitnessFile, getUltraHonkFlavorForCircuit(circuitType), logger);
+        const provingResult = await generateProof(this.config.bbBinaryPath, workingDirectory, circuitType, Buffer.from(artifact.bytecode, 'base64'), this.getVerificationKeyDataForCircuit(circuitType).keyAsBytes, outputWitnessFile, getUltraHonkFlavorForCircuit(circuitType), logger);
         if (provingResult.status === BB_RESULT.FAILURE) {
             logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
             throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
@@ -206,35 +189,6 @@ const logger = createLogger('bb-prover');
             provingResult
         };
     }
-    async createProof(input, circuitType, convertInput, convertOutput) {
-        const operation = async (bbWorkingDirectory)=>{
-            const { provingResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
-            const vkData = this.getVerificationKeyDataForCircuit(circuitType);
-            const PROOF_LENGTH = circuitType == 'RootRollupArtifact' ? ULTRA_KECCAK_PROOF_LENGTH : RECURSIVE_PROOF_LENGTH;
-            const proof = await readProofAsFields(provingResult.proofPath, vkData, PROOF_LENGTH, logger);
-            const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
-            this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs);
-            this.instrumentation.recordSize('proofSize', circuitName, proof.binaryProof.buffer.length);
-            this.instrumentation.recordSize('circuitPublicInputCount', circuitName, vkData.numPublicInputs);
-            this.instrumentation.recordSize('circuitSize', circuitName, vkData.circuitSize);
-            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.durationMs)} ms`, {
-                circuitName,
-                // does not include reading the proof from disk
-                duration: provingResult.durationMs,
-                proofSize: proof.binaryProof.buffer.length,
-                eventName: 'circuit-proving',
-                // circuitOutput is the partial witness that became the input to the proof
-                inputSize: output.toBuffer().length,
-                circuitSize: vkData.circuitSize,
-                numPublicInputs: vkData.numPublicInputs
-            });
-            return {
-                circuitOutput: output,
-                proof: proof.binaryProof
-            };
-        };
-        return await this.runInDirectory(operation);
-    }
     async generateAvmProofWithBB(input, workingDirectory) {
         logger.info(`Proving avm-circuit for TX ${input.hints.tx.hash}...`);
         const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger);
@@ -244,18 +198,6 @@ const logger = createLogger('bb-prover');
         }
         return provingResult;
     }
-    async generateTubeProofWithBB(bbWorkingDirectory, input) {
-        logger.debug(`Proving tube...`);
-        const hasher = crypto.createHash('sha256');
-        hasher.update(input.toBuffer());
-        await writeClientIVCProofToOutputDirectory(input.clientIVCData, bbWorkingDirectory);
-        const provingResult = await generateTubeProof(this.config.bbBinaryPath, bbWorkingDirectory, input.usePublicTailVk ? PUBLIC_TAIL_CIVC_VK : PRIVATE_TAIL_CIVC_VK, logger.verbose);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate proof for tube circuit: ${provingResult.reason}`);
-            throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
-        }
-        return provingResult;
-    }
     async createAvmProof(input) {
         const operation = async (bbWorkingDirectory)=>{
             const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
@@ -280,25 +222,6 @@ const logger = createLogger('bb-prover');
         };
         return await this.runInDirectory(operation);
     }
-    async getTubeProof(input) {
-        const operation = async (bbWorkingDirectory)=>{
-            logger.debug(`createTubeProof: ${bbWorkingDirectory}`);
-            const provingResult = await this.generateTubeProofWithBB(bbWorkingDirectory, input);
-            // Read the proof as fields
-            // TODO(AD): this is the only remaining use of extractVkData.
-            const tubeVK = await extractVkData(provingResult.vkDirectoryPath);
-            const tubeProof = await readProofAsFields(provingResult.proofPath, tubeVK, TUBE_PROOF_LENGTH, logger);
-            this.instrumentation.recordDuration('provingDuration', 'tubeCircuit', provingResult.durationMs);
-            this.instrumentation.recordSize('proofSize', 'tubeCircuit', tubeProof.binaryProof.buffer.length);
-            this.instrumentation.recordSize('circuitPublicInputCount', 'tubeCircuit', tubeVK.numPublicInputs);
-            this.instrumentation.recordSize('circuitSize', 'tubeCircuit', tubeVK.circuitSize);
-            // Sanity check the tube proof (can be removed later)
-            await this.verifyWithKey('ultra_rollup_honk', tubeVK, tubeProof.binaryProof);
-            logger.info(`Generated proof for tubeCircuit in ${Math.ceil(provingResult.durationMs)} ms, size: ${tubeProof.proof.length} fields`);
-            return makeProofAndVerificationKey(tubeProof, tubeVK);
-        };
-        return await this.runInDirectory(operation);
-    }
     /**
    * Executes a circuit and returns its outputs and corresponding proof with embedded aggregation object
    * @param witnessMap - The input witness
@@ -308,12 +231,12 @@ const logger = createLogger('bb-prover');
    * @param convertOutput - Function for parsing the output witness to it's corresponding object
    * @returns The circuits output object and it's proof
    */ async createRecursiveProof(input, circuitType, proofLength, convertInput, convertOutput) {
-        // this probably is gonna need to call client ivc
+        // this probably is gonna need to call chonk
         const operation = async (bbWorkingDirectory)=>{
             const { provingResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
             const vkData = this.getVerificationKeyDataForCircuit(circuitType);
             // Read the proof as fields
-            const proof = await readProofAsFields(provingResult.proofPath, vkData, proofLength, logger);
+            const proof = await readProofsFromOutputDirectory(provingResult.proofPath, vkData, proofLength, logger);
             const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
             this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs);
             this.instrumentation.recordSize('proofSize', circuitName, proof.binaryProof.buffer.length);
@@ -401,12 +324,12 @@ const logger = createLogger('bb-prover');
 }
 _ts_decorate([
     trackSpan('BBNativeRollupProver.getBaseParityProof', {
-        [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity'
+        [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-base'
     })
 ], BBNativeRollupProver.prototype, "getBaseParityProof", null);
 _ts_decorate([
     trackSpan('BBNativeRollupProver.getRootParityProof', {
-        [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity'
+        [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-root'
     })
 ], BBNativeRollupProver.prototype, "getRootParityProof", null);
 _ts_decorate([

package/dest/test/delay_values.d.ts

@@ -1,4 +1,4 @@
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 export declare const WITGEN_DELAY_MS: Record<ProvingRequestType, number>;
 export declare const PROOF_DELAY_MS: Record<ProvingRequestType, number>;
-//# sourceMappingURL=delay_values.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsYXlfdmFsdWVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC9kZWxheV92YWx1ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFMUQsZUFBTyxNQUFNLGVBQWUsRUFBRSxNQUFNLENBQUMsa0JBQWtCLEVBQUUsTUFBTSxDQW1COUQsQ0FBQztBQUVGLGVBQU8sTUFBTSxjQUFjLEVBQUUsTUFBTSxDQUFDLGtCQUFrQixFQUFFLE1BQU0sQ0FtQjdELENBQUMifQ==

package/dest/test/delay_values.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delay_values.d.ts","sourceRoot":"","sources":["../../src/test/delay_values.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAc9D,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAc7D,CAAC"}
+{"version":3,"file":"delay_values.d.ts","sourceRoot":"","sources":["../../src/test/delay_values.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAmB9D,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAmB7D,CAAC"}

package/dest/test/delay_values.js

@@ -1,31 +1,41 @@
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 export const WITGEN_DELAY_MS = {
-    [ProvingRequestType.BASE_PARITY]: 60,
-    [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 650,
-    [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 60_000,
-    [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: 0,
-    [ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP]: 0,
-    [ProvingRequestType.MERGE_ROLLUP]: 0,
-    [ProvingRequestType.PRIVATE_BASE_ROLLUP]: 400_000,
-    [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: 0,
-    [ProvingRequestType.PUBLIC_BASE_ROLLUP]: 470_000,
-    [ProvingRequestType.ROOT_PARITY]: 100,
-    [ProvingRequestType.ROOT_ROLLUP]: 650,
-    [ProvingRequestType.TUBE_PROOF]: 0,
+    [ProvingRequestType.PARITY_BASE]: 2_000,
+    [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 30,
+    [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 45,
+    [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 27,
+    [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 18,
+    [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 40_000,
+    [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 20_000,
+    [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 40_000,
+    [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 36_600,
+    [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
+    [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 30,
+    [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
+    [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 2_500,
+    [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 2_500,
+    [ProvingRequestType.PARITY_ROOT]: 40,
+    [ProvingRequestType.ROOT_ROLLUP]: 35,
+    [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 60,
     [ProvingRequestType.PUBLIC_VM]: 0
 };
 export const PROOF_DELAY_MS = {
-    [ProvingRequestType.BASE_PARITY]: 3_000,
+    [ProvingRequestType.PARITY_BASE]: 16_300,
     [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 15_000,
-    [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 55_000,
-    [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: 0,
-    [ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP]: 0,
-    [ProvingRequestType.MERGE_ROLLUP]: 0,
-    [ProvingRequestType.PRIVATE_BASE_ROLLUP]: 145_000,
-    [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: 0,
-    [ProvingRequestType.PUBLIC_BASE_ROLLUP]: 160_000,
-    [ProvingRequestType.ROOT_PARITY]: 30_000,
-    [ProvingRequestType.ROOT_ROLLUP]: 15_000,
-    [ProvingRequestType.TUBE_PROOF]: 30_000,
+    [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 16_500,
+    [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 9_210,
+    [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 4_560,
+    [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 35_000,
+    [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 15_000,
+    [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 35_000,
+    [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 38_800,
+    [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
+    [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 9_760,
+    [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
+    [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 45_000,
+    [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 45_000,
+    [ProvingRequestType.PARITY_ROOT]: 18_600,
+    [ProvingRequestType.ROOT_ROLLUP]: 84_000,
+    [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 16_300,
     [ProvingRequestType.PUBLIC_VM]: 0
 };

package/dest/test/index.d.ts

@@ -1,3 +1,3 @@
 export * from './test_circuit_prover.js';
 export * from './test_verifier.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxvQkFBb0IsQ0FBQyJ9

package/dest/test/test_circuit_prover.d.ts

@@ -1,11 +1,11 @@
-import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH } from '@aztec/constants';
 import { type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
 import { type CircuitSimulator } from '@aztec/simulator/server';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import { type ProofAndVerificationKey, type PublicInputsAndRecursiveProof, type ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
-import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
 import { type Proof } from '@aztec/stdlib/proofs';
-import type { BaseOrMergeRollupPublicInputs, BlockMergeRollupInputs, BlockRootOrBlockMergePublicInputs, BlockRootRollupInputs, EmptyBlockRootRollupInputs, MergeRollupInputs, PaddingBlockRootRollupInputs, PrivateBaseRollupInputs, PublicBaseRollupInputs, RootRollupInputs, RootRollupPublicInputs, SingleTxBlockRootRollupInputs, TubeInputs } from '@aztec/stdlib/rollup';
+import { type BlockMergeRollupPrivateInputs, type BlockRollupPublicInputs, type BlockRootEmptyTxFirstRollupPrivateInputs, type BlockRootFirstRollupPrivateInputs, type BlockRootRollupPrivateInputs, type BlockRootSingleTxFirstRollupPrivateInputs, type BlockRootSingleTxRollupPrivateInputs, type CheckpointMergeRollupPrivateInputs, type CheckpointPaddingRollupPrivateInputs, type CheckpointRollupPublicInputs, type CheckpointRootRollupPrivateInputs, type CheckpointRootSingleBlockRollupPrivateInputs, type PrivateTxBaseRollupPrivateInputs, type PublicChonkVerifierPrivateInputs, PublicChonkVerifierPublicInputs, type PublicTxBaseRollupPrivateInputs, type RootRollupPrivateInputs, type RootRollupPublicInputs, type TxMergeRollupPrivateInputs, type TxRollupPublicInputs } from '@aztec/stdlib/rollup';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 type TestDelay = {
     proverTestDelayType: 'fixed';
@@ -31,52 +31,42 @@ export declare class TestCircuitProver implements ServerCircuitProver {
      * @param inputs - Inputs to the circuit.
      * @returns The public inputs of the parity circuit.
      */
-    getBaseParityProof(inputs: BaseParityInputs): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>>;
+    getBaseParityProof(inputs: ParityBasePrivateInputs): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>>;
     /**
      * Simulates the root parity circuit from its inputs.
      * @param inputs - Inputs to the circuit.
      * @returns The public inputs of the parity circuit.
      */
-    getRootParityProof(inputs: RootParityInputs): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
-    getTubeProof(_tubeInput: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>;
-    getPrivateBaseRollupProof(inputs: PrivateBaseRollupInputs): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    getPublicBaseRollupProof(inputs: PublicBaseRollupInputs): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getRootParityProof(inputs: ParityRootPrivateInputs): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
+    getPublicChonkVerifierProof(inputs: PublicChonkVerifierPrivateInputs): Promise<PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getPrivateTxBaseRollupProof(inputs: PrivateTxBaseRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getPublicTxBaseRollupProof(inputs: PublicTxBaseRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
     /**
      * Simulates the merge rollup circuit from its inputs.
      * @param input - Inputs to the circuit.
      * @returns The public inputs as outputs of the simulation.
      */
-    getMergeRollupProof(input: MergeRollupInputs): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    /**
-     * Simulates the block root rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    getBlockRootRollupProof(input: BlockRootRollupInputs): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    getSingleTxBlockRootRollupProof(input: SingleTxBlockRootRollupInputs): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    /**
-     * Simulates the empty block root rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    getEmptyBlockRootRollupProof(input: EmptyBlockRootRollupInputs): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    getPaddingBlockRootRollupProof(input: PaddingBlockRootRollupInputs): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    /**
-     * Simulates the block merge rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    getBlockMergeRollupProof(input: BlockMergeRollupInputs): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getTxMergeRollupProof(input: TxMergeRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootFirstRollupProof(input: BlockRootFirstRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootSingleTxFirstRollupProof(input: BlockRootSingleTxFirstRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootEmptyTxFirstRollupProof(input: BlockRootEmptyTxFirstRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootRollupProof(input: BlockRootRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootSingleTxRollupProof(input: BlockRootSingleTxRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockMergeRollupProof(input: BlockMergeRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getCheckpointRootRollupProof(input: CheckpointRootRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getCheckpointRootSingleBlockRollupProof(input: CheckpointRootSingleBlockRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getCheckpointPaddingRollupProof(input: CheckpointPaddingRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getCheckpointMergeRollupProof(input: CheckpointMergeRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
     /**
      * Simulates the root rollup circuit from its inputs.
      * @param input - Inputs to the circuit.
      * @returns The public inputs as outputs of the simulation.
      */
-    getRootRollupProof(input: RootRollupInputs): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>>;
+    getRootRollupProof(input: RootRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>>;
     getAvmProof(_inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>>;
     private applyDelay;
     verifyProof(_1: ServerProtocolArtifact, _2: Proof): Promise<void>;
     private simulate;
 }
 export {};
-//# sourceMappingURL=test_circuit_prover.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

package/dest/test/test_circuit_prover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test_circuit_prover.d.ts","sourceRoot":"","sources":["../../src/test/test_circuit_prover.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"test_circuit_prover.d.ts","sourceRoot":"","sources":["../../src/test/test_circuit_prover.ts"],"names":[],"mappings":"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"}