@aztec/bb-prover 0.0.0-test.0 → 0.0.1-commit.21caa21

package/dest/test/test_circuit_prover.js

@@ -4,34 +4,35 @@ 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_PROOF_LENGTH_IN_FIELDS, AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, 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, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
-import { SimulatedServerCircuitArtifacts, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertSimulatedBlockRootRollupInputsToWitnessMap, convertSimulatedBlockRootRollupOutputsFromWitnessMap, convertSimulatedPrivateBaseRollupInputsToWitnessMap, convertSimulatedPrivateBaseRollupOutputsFromWitnessMap, convertSimulatedPublicBaseRollupInputsToWitnessMap, convertSimulatedPublicBaseRollupOutputsFromWitnessMap, convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap, convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap } 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, convertPublicTxBaseRollupOutputsFromWitnessMap, convertPublicTxBaseRollupPrivateInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertRootRollupPrivateInputsToWitnessMap, convertTxMergeRollupOutputsFromWitnessMap, convertTxMergeRollupPrivateInputsToWitnessMap, foreignCallHandler, getSimulatedServerCircuitArtifact } from '@aztec/noir-protocol-circuits-types/server';
 import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
+import { mapProtocolArtifactNameToCircuitName } from '@aztec/noir-protocol-circuits-types/types';
 import { WASMSimulatorWithBlobs, emitCircuitSimulationStats } from '@aztec/simulator/server';
 import { makeProofAndVerificationKey, makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { ProvingRequestType, makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
+import { PublicChonkVerifierPublicInputs } from '@aztec/stdlib/rollup';
 import { VerificationKeyData } from '@aztec/stdlib/vks';
 import { getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { ProverInstrumentation } from '../instrumentation.js';
-import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { PROOF_DELAY_MS, WITGEN_DELAY_MS } from './delay_values.js';
 /**
  * A class for use in testing situations (e2e, unit test, etc) and temporarily for assembling a block in the sequencer.
  * Simulates circuits using the most efficient method and performs no proving.
  */ export class TestCircuitProver {
-    simulationProvider;
+    simulator;
     opts;
     wasmSimulator;
     instrumentation;
     logger;
-    constructor(simulationProvider, opts = {
+    constructor(simulator, opts = {
         proverTestDelayType: 'fixed',
         proverTestDelayMs: 0
     }, telemetry = getTelemetryClient()){
-        this.simulationProvider = simulationProvider;
+        this.simulator = simulator;
         this.opts = opts;
         this.wasmSimulator = new WASMSimulatorWithBlobs();
         this.logger = createLogger('bb-prover:test-prover');
@@ -45,67 +46,73 @@ import { PROOF_DELAY_MS, WITGEN_DELAY_MS } from './delay_values.js';
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs of the parity circuit.
    */ getBaseParityProof(inputs) {
-        return this.applyDelay(ProvingRequestType.BASE_PARITY, ()=>this.simulate(inputs, 'BaseParityArtifact', RECURSIVE_PROOF_LENGTH, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap));
+        return this.applyDelay(ProvingRequestType.PARITY_BASE, ()=>this.simulate(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.
    */ getRootParityProof(inputs) {
-        return this.applyDelay(ProvingRequestType.ROOT_PARITY, ()=>this.simulate(inputs, 'RootParityArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap));
+        return this.applyDelay(ProvingRequestType.PARITY_ROOT, ()=>this.simulate(inputs, 'ParityRootArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertParityRootPrivateInputsToWitnessMap, convertParityRootOutputsFromWitnessMap));
     }
-    getTubeProof(_tubeInput) {
-        return this.applyDelay(ProvingRequestType.TUBE_PROOF, ()=>makeProofAndVerificationKey(makeEmptyRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    getPublicChonkVerifierProof(inputs) {
+        return this.applyDelay(ProvingRequestType.PUBLIC_CHONK_VERIFIER, ()=>makePublicInputsAndRecursiveProof(new PublicChonkVerifierPublicInputs(inputs.hidingKernelProofData.publicInputs, inputs.proverId), makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), ProtocolCircuitVks.PublicChonkVerifier));
     }
-    getPrivateBaseRollupProof(inputs) {
-        return this.applyDelay(ProvingRequestType.PRIVATE_BASE_ROLLUP, ()=>this.simulate(inputs, 'PrivateBaseRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSimulatedPrivateBaseRollupInputsToWitnessMap, convertSimulatedPrivateBaseRollupOutputsFromWitnessMap));
+    getPrivateTxBaseRollupProof(inputs) {
+        return this.applyDelay(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, ()=>this.simulate(inputs, 'PrivateTxBaseRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPrivateTxBaseRollupPrivateInputsToWitnessMap, convertPrivateTxBaseRollupOutputsFromWitnessMap));
     }
-    getPublicBaseRollupProof(inputs) {
-        return this.applyDelay(ProvingRequestType.PUBLIC_BASE_ROLLUP, ()=>this.simulate(inputs, 'PublicBaseRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSimulatedPublicBaseRollupInputsToWitnessMap, convertSimulatedPublicBaseRollupOutputsFromWitnessMap));
+    getPublicTxBaseRollupProof(inputs) {
+        return this.applyDelay(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP, ()=>this.simulate(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.
-   */ getMergeRollupProof(input) {
-        return this.applyDelay(ProvingRequestType.MERGE_ROLLUP, ()=>this.simulate(input, 'MergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap));
+   */ getTxMergeRollupProof(input) {
+        return this.applyDelay(ProvingRequestType.TX_MERGE_ROLLUP, ()=>this.simulate(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.
-   */ getBlockRootRollupProof(input) {
-        return this.applyDelay(ProvingRequestType.BLOCK_ROOT_ROLLUP, ()=>this.simulate(input, 'BlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSimulatedBlockRootRollupInputsToWitnessMap, convertSimulatedBlockRootRollupOutputsFromWitnessMap));
+    getBlockRootFirstRollupProof(input) {
+        return this.applyDelay(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP, ()=>this.simulate(input, 'BlockRootFirstRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootFirstRollupPrivateInputsToWitnessMap, convertBlockRootFirstRollupOutputsFromWitnessMap));
     }
-    async getSingleTxBlockRootRollupProof(input) {
-        return await this.applyDelay(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP, ()=>this.simulate(input, 'SingleTxBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap, convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap));
+    async getBlockRootSingleTxFirstRollupProof(input) {
+        return await this.applyDelay(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP, ()=>this.simulate(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.
-   */ getEmptyBlockRootRollupProof(input) {
-        return this.applyDelay(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, ()=>this.simulate(input, 'EmptyBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap));
+    getBlockRootEmptyTxFirstRollupProof(input) {
+        return this.applyDelay(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP, ()=>this.simulate(input, 'BlockRootEmptyTxFirstRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootEmptyTxFirstRollupPrivateInputsToWitnessMap, convertBlockRootEmptyTxFirstRollupOutputsFromWitnessMap));
     }
-    /**
-   * 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) {
-        return this.applyDelay(ProvingRequestType.BLOCK_MERGE_ROLLUP, ()=>this.simulate(input, 'BlockMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap));
+    getBlockRootRollupProof(input) {
+        return this.applyDelay(ProvingRequestType.BLOCK_ROOT_ROLLUP, ()=>this.simulate(input, 'BlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootRollupPrivateInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap));
+    }
+    async getBlockRootSingleTxRollupProof(input) {
+        return await this.applyDelay(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP, ()=>this.simulate(input, 'BlockRootSingleTxRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootSingleTxRollupPrivateInputsToWitnessMap, convertBlockRootSingleTxRollupOutputsFromWitnessMap));
+    }
+    getBlockMergeRollupProof(input) {
+        return this.applyDelay(ProvingRequestType.BLOCK_MERGE_ROLLUP, ()=>this.simulate(input, 'BlockMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockMergeRollupPrivateInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap));
+    }
+    getCheckpointRootRollupProof(input) {
+        return this.applyDelay(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP, ()=>this.simulate(input, 'CheckpointRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertCheckpointRootRollupPrivateInputsToWitnessMap, convertCheckpointRootRollupOutputsFromWitnessMap));
+    }
+    getCheckpointRootSingleBlockRollupProof(input) {
+        return this.applyDelay(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP, ()=>this.simulate(input, 'CheckpointRootSingleBlockRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertCheckpointRootSingleBlockRollupPrivateInputsToWitnessMap, convertCheckpointRootSingleBlockRollupOutputsFromWitnessMap));
+    }
+    getCheckpointPaddingRollupProof(input) {
+        return this.applyDelay(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP, ()=>this.simulate(input, 'CheckpointPaddingRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertCheckpointPaddingRollupPrivateInputsToWitnessMap, convertCheckpointPaddingRollupOutputsFromWitnessMap));
+    }
+    getCheckpointMergeRollupProof(input) {
+        return this.applyDelay(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP, ()=>this.simulate(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.
    */ getRootRollupProof(input) {
-        return this.applyDelay(ProvingRequestType.ROOT_ROLLUP, ()=>this.simulate(input, 'RootRollupArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap));
+        return this.applyDelay(ProvingRequestType.ROOT_ROLLUP, ()=>this.simulate(input, 'RootRollupArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootRollupPrivateInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap));
     }
     getAvmProof(_inputs) {
         // 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 this.applyDelay(ProvingRequestType.PUBLIC_VM, ()=>makeProofAndVerificationKey(makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS), VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS)));
+        return this.applyDelay(ProvingRequestType.PUBLIC_VM, ()=>makeProofAndVerificationKey(makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED), VerificationKeyData.makeFake(AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED)));
     }
     async applyDelay(type, fn) {
         const timer = new Timer();
@@ -125,19 +132,20 @@ import { PROOF_DELAY_MS, WITGEN_DELAY_MS } from './delay_values.js';
     }
     async simulate(input, artifactName, proofLength, convertInput, convertOutput) {
         const timer = new Timer();
-        const witnessMap = convertInput(input);
+        const witnessMap = convertInput(input, true);
         const circuitName = mapProtocolArtifactNameToCircuitName(artifactName);
-        let simulationProvider = this.simulationProvider ?? this.wasmSimulator;
+        let witness;
         if ([
-            'BlockRootRollupArtifact',
-            'SingleTxBlockRootRollupArtifact'
-        ].includes(artifactName)) {
-            // TODO(#10323): temporarily force block root to use wasm while we simulate
-            // the blob operations with an oracle. Appears to be no way to provide nativeACVM with a foreign call hander.
-            simulationProvider = this.wasmSimulator;
+            'CheckpointRootRollupArtifact',
+            'CheckpointRootSingleBlockRollupArtifact'
+        ].includes(artifactName) || this.simulator == undefined) {
+            // TODO(#10323): Native ACVM simulator does not support foreign call handler so we use the wasm simulator
+            // when simulating checkpoint root rollup circuits or when the native ACVM simulator is not provided.
+            witness = (await this.wasmSimulator.executeProtocolCircuit(witnessMap, getSimulatedServerCircuitArtifact(artifactName), foreignCallHandler)).witness;
+        } else {
+            witness = (await this.simulator.executeProtocolCircuit(witnessMap, getSimulatedServerCircuitArtifact(artifactName), undefined)).witness;
         }
-        const witness = await simulationProvider.executeProtocolCircuit(witnessMap, SimulatedServerCircuitArtifacts[artifactName]);
-        const result = convertOutput(witness);
+        const result = convertOutput(witness, true);
         this.instrumentation.recordDuration('simulationDuration', circuitName, timer);
         emitCircuitSimulationStats(circuitName, timer.ms(), input.toBuffer().length, result.toBuffer().length, this.logger);
         return makePublicInputsAndRecursiveProof(result, makeRecursiveProof(proofLength), ProtocolCircuitVks[artifactName]);
@@ -150,26 +158,44 @@ _ts_decorate([
     trackSpan('TestCircuitProver.getRootParityProof')
 ], TestCircuitProver.prototype, "getRootParityProof", null);
 _ts_decorate([
-    trackSpan('TestCircuitProver.getPrivateBaseRollupProof')
-], TestCircuitProver.prototype, "getPrivateBaseRollupProof", null);
+    trackSpan('TestCircuitProver.getPrivateTxBaseRollupProof')
+], TestCircuitProver.prototype, "getPrivateTxBaseRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getPublicTxBaseRollupProof')
+], TestCircuitProver.prototype, "getPublicTxBaseRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getTxMergeRollupProof')
+], TestCircuitProver.prototype, "getTxMergeRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getBlockRootFirstRollupProof')
+], TestCircuitProver.prototype, "getBlockRootFirstRollupProof", null);
 _ts_decorate([
-    trackSpan('TestCircuitProver.getPublicBaseRollupProof')
-], TestCircuitProver.prototype, "getPublicBaseRollupProof", null);
+    trackSpan('TestCircuitProver.getBlockRootSingleTxFirstRollupProof')
+], TestCircuitProver.prototype, "getBlockRootSingleTxFirstRollupProof", null);
 _ts_decorate([
-    trackSpan('TestCircuitProver.getMergeRollupProof')
-], TestCircuitProver.prototype, "getMergeRollupProof", null);
+    trackSpan('TestCircuitProver.getBlockRootEmptyTxFirstRollupProof')
+], TestCircuitProver.prototype, "getBlockRootEmptyTxFirstRollupProof", null);
 _ts_decorate([
     trackSpan('TestCircuitProver.getBlockRootRollupProof')
 ], TestCircuitProver.prototype, "getBlockRootRollupProof", null);
 _ts_decorate([
-    trackSpan('TestCircuitProver.getSingleTxBlockRootRollupProof')
-], TestCircuitProver.prototype, "getSingleTxBlockRootRollupProof", null);
-_ts_decorate([
-    trackSpan('TestCircuitProver.getEmptyBlockRootRollupProof')
-], TestCircuitProver.prototype, "getEmptyBlockRootRollupProof", null);
+    trackSpan('TestCircuitProver.getBlockRootSingleTxRollupProof')
+], TestCircuitProver.prototype, "getBlockRootSingleTxRollupProof", null);
 _ts_decorate([
     trackSpan('TestCircuitProver.getBlockMergeRollupProof')
 ], TestCircuitProver.prototype, "getBlockMergeRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getCheckpointRootRollupProof')
+], TestCircuitProver.prototype, "getCheckpointRootRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getCheckpointRootSingleBlockRollupProof')
+], TestCircuitProver.prototype, "getCheckpointRootSingleBlockRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getCheckpointPaddingRollupProof')
+], TestCircuitProver.prototype, "getCheckpointPaddingRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getCheckpointMergeRollupProof')
+], TestCircuitProver.prototype, "getCheckpointMergeRollupProof", null);
 _ts_decorate([
     trackSpan('TestCircuitProver.getRootRollupProof')
 ], TestCircuitProver.prototype, "getRootRollupProof", null);

package/dest/test/test_verifier.d.ts

@@ -1,6 +1,9 @@
-import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec/stdlib/interfaces/server';
 import type { Tx } from '@aztec/stdlib/tx';
 export declare class TestCircuitVerifier implements ClientProtocolCircuitVerifier {
-    verifyProof(_tx: Tx): Promise<boolean>;
+    private verificationDelayMs?;
+    constructor(verificationDelayMs?: number | undefined);
+    verifyProof(_tx: Tx): Promise<IVCProofVerificationResult>;
+    stop(): Promise<void>;
 }
-//# sourceMappingURL=test_verifier.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdF92ZXJpZmllci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3QvdGVzdF92ZXJpZmllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSw2QkFBNkIsRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pILE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTNDLHFCQUFhLG1CQUFvQixZQUFXLDZCQUE2QjtJQUMzRCxPQUFPLENBQUMsbUJBQW1CLENBQUM7SUFBeEMsWUFBb0IsbUJBQW1CLENBQUMsb0JBQVEsRUFBSTtJQUNwRCxXQUFXLENBQUMsR0FBRyxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsMEJBQTBCLENBQUMsQ0FTeEQ7SUFFTSxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUUzQjtDQUNGIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"test_verifier.d.ts","sourceRoot":"","sources":["../../src/test/test_verifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,mBAAoB,YAAW,6BAA6B;IACvE,WAAW,CAAC,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CAGvC"}
+{"version":3,"file":"test_verifier.d.ts","sourceRoot":"","sources":["../../src/test/test_verifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AACjH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,mBAAoB,YAAW,6BAA6B;IAC3D,OAAO,CAAC,mBAAmB,CAAC;IAAxC,YAAoB,mBAAmB,CAAC,oBAAQ,EAAI;IACpD,WAAW,CAAC,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CASxD;IAEM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;CACF"}

package/dest/test/test_verifier.js

@@ -1,5 +1,27 @@
 export class TestCircuitVerifier {
+    verificationDelayMs;
+    constructor(verificationDelayMs){
+        this.verificationDelayMs = verificationDelayMs;
+    }
     verifyProof(_tx) {
-        return Promise.resolve(true);
+        if (this.verificationDelayMs !== undefined && this.verificationDelayMs > 0) {
+            return new Promise((resolve)=>{
+                setTimeout(()=>{
+                    resolve({
+                        valid: true,
+                        durationMs: this.verificationDelayMs,
+                        totalDurationMs: this.verificationDelayMs
+                    });
+                }, this.verificationDelayMs);
+            });
+        }
+        return Promise.resolve({
+            valid: true,
+            durationMs: 0,
+            totalDurationMs: 0
+        });
+    }
+    stop() {
+        return Promise.resolve();
     }
 }

package/dest/verification_key/verification_key_data.d.ts

@@ -5,5 +5,11 @@ import { VerificationKeyData } from '@aztec/stdlib/vks';
  * @returns The verification key data
  */
 export declare function extractVkData(vkDirectoryPath: string): Promise<VerificationKeyData>;
+/**
+ * Reads the verification key data stored in a binary file at the specified directory location and parses into a VerificationKeyData.
+ * We do not assume any JSON file available but only the binary version, contrary to the above extractVkData() method.
+ * @param vkDirectoryPath - The directory containing the verification key binary data file.
+ * @returns The verification key data
+ */
 export declare function extractAvmVkData(vkDirectoryPath: string): Promise<VerificationKeyData>;
-//# sourceMappingURL=verification_key_data.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyaWZpY2F0aW9uX2tleV9kYXRhLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmVyaWZpY2F0aW9uX2tleS92ZXJpZmljYXRpb25fa2V5X2RhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUEyQixtQkFBbUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBUWpGOzs7O0dBSUc7QUFDSCx3QkFBc0IsYUFBYSxDQUFDLGVBQWUsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBVXpGO0FBRUQ7Ozs7O0dBS0c7QUFDSCx3QkFBc0IsZ0JBQWdCLENBQUMsZUFBZSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FlNUYifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"verification_key_data.d.ts","sourceRoot":"","sources":["../../src/verification_key/verification_key_data.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAQjF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAWzF;AAGD,wBAAsB,gBAAgB,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAc5F"}
+{"version":3,"file":"verification_key_data.d.ts","sourceRoot":"","sources":["../../src/verification_key/verification_key_data.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAQjF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAUzF;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAe5F"}

package/dest/verification_key/verification_key_data.js

@@ -1,44 +1,38 @@
-import { AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS } from '@aztec/constants';
+import { AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { hashVK } from '@aztec/stdlib/hash';
+import { BufferReader } from '@aztec/foundation/serialize';
 import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
 import { strict as assert } from 'assert';
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { VK_FIELDS_FILENAME, VK_FILENAME } from '../bb/execute.js';
+import { 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) {
-    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.fromHexString);
-    // The hash is not included in the BB response
-    const vkHash = await hashVK(fields);
-    const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
+    const rawBinary = await fs.readFile(path.join(vkDirectoryPath, VK_FILENAME));
+    // Convert binary to field elements (32 bytes per field)
+    const numFields = rawBinary.length / Fr.SIZE_IN_BYTES;
+    const reader = BufferReader.asReader(rawBinary);
+    const fields = reader.readArray(numFields, Fr);
+    const vkAsFields = await VerificationKeyAsFields.fromKey(fields);
     return new VerificationKeyData(vkAsFields, rawBinary);
 }
-// TODO: This was adapted from the above function. A refactor might be needed.
-export async function extractAvmVkData(vkDirectoryPath) {
-    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.fromHexString);
-    // The first item is the hash, this is not part of the actual VK
-    // TODO: is the above actually the case?
-    const vkHash = fields[0];
-    assert(fields.length === AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, 'Invalid AVM verification key length');
-    const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
+/**
+ * Reads the verification key data stored in a binary file at the specified directory location and parses into a VerificationKeyData.
+ * We do not assume any JSON file available but only the binary version, contrary to the above extractVkData() method.
+ * @param vkDirectoryPath - The directory containing the verification key binary data file.
+ * @returns The verification key data
+ */ export async function extractAvmVkData(vkDirectoryPath) {
+    const rawBinary = await fs.readFile(path.join(vkDirectoryPath, VK_FILENAME));
+    const numFields = rawBinary.length / Fr.SIZE_IN_BYTES;
+    assert(numFields <= AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED, 'Invalid AVM verification key length');
+    const reader = BufferReader.asReader(rawBinary);
+    const fieldsArray = reader.readArray(numFields, Fr);
+    const fieldsArrayPadded = fieldsArray.concat(Array(AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED - fieldsArray.length).fill(new Fr(0)));
+    const vkAsFields = await VerificationKeyAsFields.fromKey(fieldsArrayPadded);
+    // TODO(#16644): We should have a different type for AVM verification keys since we don't have circuit size or num public inputs in AVM VKs.
     const vk = new VerificationKeyData(vkAsFields, rawBinary);
     return vk;
 }

package/dest/verifier/bb_verifier.d.ts

@@ -1,6 +1,6 @@
 import { type Logger } from '@aztec/foundation/log';
-import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
-import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import { type ProtocolArtifact, type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
 import { Tx } from '@aztec/stdlib/tx';
 import type { VerificationKeyData } from '@aztec/stdlib/vks';
@@ -9,9 +9,10 @@ export declare class BBCircuitVerifier implements ClientProtocolCircuitVerifier
     private config;
     private logger;
     private constructor();
+    stop(): Promise<void>;
     static new(config: BBConfig, logger?: Logger): Promise<BBCircuitVerifier>;
-    getVerificationKeyData(circuitType: ServerProtocolArtifact): VerificationKeyData;
+    getVerificationKeyData(circuit: ProtocolArtifact): VerificationKeyData;
     verifyProofForCircuit(circuit: ServerProtocolArtifact, proof: Proof): Promise<void>;
-    verifyProof(tx: Tx): Promise<boolean>;
+    verifyProof(tx: Tx): Promise<IVCProofVerificationResult>;
 }
-//# sourceMappingURL=bb_verifier.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmJfdmVyaWZpZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZmllci9iYl92ZXJpZmllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFHbEUsT0FBTyxFQUVMLEtBQUssZ0JBQWdCLEVBQ3JCLEtBQUssc0JBQXNCLEVBRTVCLE1BQU0sMkNBQTJDLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsNkJBQTZCLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqSCxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVsRCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQWE3RCxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFJN0MscUJBQWEsaUJBQWtCLFlBQVcsNkJBQTZCO0lBRW5FLE9BQU8sQ0FBQyxNQUFNO0lBQ2QsT0FBTyxDQUFDLE1BQU07SUFGaEIsT0FBTyxlQUdIO0lBRUcsSUFBSSxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFM0I7SUFFRCxPQUFvQixHQUFHLENBQUMsTUFBTSxFQUFFLFFBQVEsRUFBRSxNQUFNLFNBQXFDLDhCQU1wRjtJQUVNLHNCQUFzQixDQUFDLE9BQU8sRUFBRSxnQkFBZ0IsR0FBRyxtQkFBbUIsQ0FNNUU7SUFFWSxxQkFBcUIsQ0FBQyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsS0FBSyxFQUFFLEtBQUssaUJBbUMvRTtJQUVZLFdBQVcsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQywwQkFBMEIsQ0FBQyxDQWlEcEU7Q0FDRiJ9

package/dest/verifier/bb_verifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bb_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/bb_verifier.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAA0B,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAChH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAM7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAK7C,qBAAa,iBAAkB,YAAW,6BAA6B;IACjD,OAAO,CAAC,MAAM;IAAY,OAAO,CAAC,MAAM;IAA5D,OAAO;WAEa,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAqC;IAK9E,sBAAsB,CAAC,WAAW,EAAE,sBAAsB,GAAG,mBAAmB;IAQ1E,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,KAAK;IAkCnE,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CA4CnD"}
+{"version":3,"file":"bb_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/bb_verifier.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAGlE,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAE5B,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AACjH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAa7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAI7C,qBAAa,iBAAkB,YAAW,6BAA6B;IAEnE,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IAFhB,OAAO,eAGH;IAEG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAED,OAAoB,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAqC,8BAMpF;IAEM,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,GAAG,mBAAmB,CAM5E;IAEY,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,KAAK,iBAmC/E;IAEY,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAiDpE;CACF"}

package/dest/verifier/bb_verifier.js

@@ -1,13 +1,13 @@
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
-import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
-import { Tx } from '@aztec/stdlib/tx';
+import { Timer } from '@aztec/foundation/timer';
+import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
+import { mapProtocolArtifactNameToCircuitName } from '@aztec/noir-protocol-circuits-types/types';
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { BB_RESULT, PROOF_FILENAME, VK_FILENAME, verifyClientIvcProof, verifyProof } from '../bb/execute.js';
+import { BB_RESULT, PROOF_FILENAME, PUBLIC_INPUTS_FILENAME, VK_FILENAME, verifyChonkProof, verifyProof } from '../bb/execute.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
-import { writeToOutputDirectory } from '../prover/client_ivc_proof_utils.js';
-import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+import { writeChonkProofToPath } from '../prover/proof_utils.js';
 export class BBCircuitVerifier {
     config;
     logger;
@@ -15,26 +15,35 @@ export class BBCircuitVerifier {
         this.config = config;
         this.logger = logger;
     }
+    stop() {
+        return Promise.resolve();
+    }
     static async new(config, logger = createLogger('bb-prover:verifier')) {
+        if (!config.bbWorkingDirectory) {
+            throw new Error(`Barretenberg working directory (BB_WORKING_DIRECTORY) is not set`);
+        }
         await fs.mkdir(config.bbWorkingDirectory, {
             recursive: true
         });
         return new BBCircuitVerifier(config, logger);
     }
-    getVerificationKeyData(circuitType) {
-        const vk = ServerCircuitVks[circuitType];
+    getVerificationKeyData(circuit) {
+        const vk = ProtocolCircuitVks[circuit];
         if (vk === undefined) {
-            throw new Error('Could not find VK for server artifact ' + circuitType);
+            throw new Error(`Could not find VK for artifact ${circuit}`);
         }
         return vk;
     }
     async verifyProofForCircuit(circuit, proof) {
         const operation = async (bbWorkingDirectory)=>{
+            const publicInputsFileName = path.join(bbWorkingDirectory, PUBLIC_INPUTS_FILENAME);
             const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
             const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
             const verificationKey = this.getVerificationKeyData(circuit);
             this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
-            await fs.writeFile(proofFileName, proof.buffer);
+            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13189): Put this proof parsing logic in the proof class.
+            await fs.writeFile(publicInputsFileName, proof.buffer.slice(0, proof.numPublicInputs * 32));
+            await fs.writeFile(proofFileName, proof.buffer.slice(proof.numPublicInputs * 32));
             await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
             const result = await verifyProof(this.config.bbBinaryPath, proofFileName, verificationKeyPath, getUltraHonkFlavorForCircuit(circuit), this.logger);
             if (result.status === BB_RESULT.FAILURE) {
@@ -51,36 +60,48 @@ export class BBCircuitVerifier {
         await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
     }
     async verifyProof(tx) {
+        const proofType = 'Chonk';
         try {
-            // TODO(#7370) The verification keys should be supplied separately and based on the expectedCircuit
-            // rather than read from the tx object itself. We also need the vks for the translator and ecc, which
-            // are not being saved along the other vks yet. Reuse the 'verifyProofForCircuit' method above once
-            // we have all the verification keys available.
-            const expectedCircuit = tx.data.forPublic ? 'PrivateKernelTailToPublicArtifact' : 'PrivateKernelTailArtifact';
-            const circuit = 'ClientIVC';
+            const totalTimer = new Timer();
+            let verificationDuration = 0;
+            const circuit = tx.data.forPublic ? 'HidingKernelToPublic' : 'HidingKernelToRollup';
             // Block below is almost copy-pasted from verifyProofForCircuit
             const operation = async (bbWorkingDirectory)=>{
                 const logFunction = (message)=>{
-                    this.logger.debug(`${circuit} BB out - ${message}`);
+                    this.logger.debug(`${proofType} BB out - ${message}`);
                 };
-                await writeToOutputDirectory(tx.clientIvcProof, bbWorkingDirectory);
-                const result = await verifyClientIvcProof(this.config.bbBinaryPath, bbWorkingDirectory.concat('/proof'), bbWorkingDirectory.concat('/vk'), logFunction);
+                const proofPath = path.join(bbWorkingDirectory, PROOF_FILENAME);
+                await writeChonkProofToPath(tx.chonkProof.attachPublicInputs(tx.data.publicInputs().toFields()), proofPath);
+                const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
+                const verificationKey = this.getVerificationKeyData(circuit);
+                await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+                const timer = new Timer();
+                const result = await verifyChonkProof(this.config.bbBinaryPath, proofPath, verificationKeyPath, logFunction, this.config.bbIVCConcurrency);
+                verificationDuration = timer.ms();
                 if (result.status === BB_RESULT.FAILURE) {
-                    const errorMessage = `Failed to verify ${circuit} proof!`;
+                    const errorMessage = `Failed to verify ${proofType} proof for ${circuit}!`;
                     throw new Error(errorMessage);
                 }
-                this.logger.debug(`${circuit} verification successful`, {
-                    circuitName: mapProtocolArtifactNameToCircuitName(expectedCircuit),
+                this.logger.debug(`${proofType} verification successful`, {
+                    circuitName: mapProtocolArtifactNameToCircuitName(circuit),
                     duration: result.durationMs,
                     eventName: 'circuit-verification',
-                    proofType: 'client-ivc'
+                    proofType: 'chonk'
                 });
             };
             await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
-            return true;
+            return {
+                valid: true,
+                durationMs: verificationDuration,
+                totalDurationMs: totalTimer.ms()
+            };
         } catch (err) {
-            this.logger.warn(`Failed to verify ClientIVC proof for tx ${Tx.getHash(tx)}: ${String(err)}`);
-            return false;
+            this.logger.warn(`Failed to verify ${proofType} proof for tx ${tx.getTxHash().toString()}: ${String(err)}`);
+            return {
+                valid: false,
+                durationMs: 0,
+                totalDurationMs: 0
+            };
         }
     }
 }

package/dest/verifier/index.d.ts

@@ -1,2 +1,3 @@
 export * from './bb_verifier.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './queued_chonk_verifier.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZmllci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsNEJBQTRCLENBQUMifQ==

package/dest/verifier/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/verifier/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/verifier/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC"}

package/dest/verifier/index.js

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

package/dest/verifier/queued_chonk_verifier.d.ts

@@ -0,0 +1,15 @@
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec/stdlib/interfaces/server';
+import type { Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { BBConfig } from '../config.js';
+export declare class QueuedIVCVerifier implements ClientProtocolCircuitVerifier {
+    private verifier;
+    private telemetry;
+    private logger;
+    private queue;
+    private metrics;
+    constructor(config: BBConfig, verifier: ClientProtocolCircuitVerifier, telemetry?: TelemetryClient, logger?: import("@aztec/foundation/log").Logger);
+    verifyProof(tx: Tx): Promise<IVCProofVerificationResult>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVldWVkX2Nob25rX3ZlcmlmaWVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmVyaWZpZXIvcXVldWVkX2Nob25rX3ZlcmlmaWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLDZCQUE2QixFQUFFLDBCQUEwQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakgsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDM0MsT0FBTyxFQU1MLEtBQUssZUFBZSxFQUlyQixNQUFNLHlCQUF5QixDQUFDO0FBSWpDLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQWdHN0MscUJBQWEsaUJBQWtCLFlBQVcsNkJBQTZCO0lBTW5FLE9BQU8sQ0FBQyxRQUFRO0lBQ2hCLE9BQU8sQ0FBQyxTQUFTO0lBQ2pCLE9BQU8sQ0FBQyxNQUFNO0lBUGhCLE9BQU8sQ0FBQyxLQUFLLENBQWM7SUFDM0IsT0FBTyxDQUFDLE9BQU8sQ0FBcUI7SUFFcEMsWUFDRSxNQUFNLEVBQUUsUUFBUSxFQUNSLFFBQVEsRUFBRSw2QkFBNkIsRUFDdkMsU0FBUyxHQUFFLGVBQXNDLEVBQ2pELE1BQU0seUNBQWtELEVBTWpFO0lBRVksV0FBVyxDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLDBCQUEwQixDQUFDLENBSXBFO0lBRUQsSUFBSSxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFcEI7Q0FDRiJ9

package/dest/verifier/queued_chonk_verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queued_chonk_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/queued_chonk_verifier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AACjH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAML,KAAK,eAAe,EAIrB,MAAM,yBAAyB,CAAC;AAIjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAgG7C,qBAAa,iBAAkB,YAAW,6BAA6B;IAMnE,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,MAAM;IAPhB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAqB;IAEpC,YACE,MAAM,EAAE,QAAQ,EACR,QAAQ,EAAE,6BAA6B,EACvC,SAAS,GAAE,eAAsC,EACjD,MAAM,yCAAkD,EAMjE;IAEY,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAIpE;IAED,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpB;CACF"}