@aztec/bb-prover 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/test/delay_values.ts

@@ -1,33 +1,47 @@
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 
 export const WITGEN_DELAY_MS: Record<ProvingRequestType, number> = {
-  [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, // TBD
-  [ProvingRequestType.PUBLIC_BASE_ROLLUP]: 470_000,
-  [ProvingRequestType.ROOT_PARITY]: 100,
-  [ProvingRequestType.ROOT_ROLLUP]: 650,
-  [ProvingRequestType.TUBE_PROOF]: 0,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 60,
+  [ProvingRequestType.PARITY_BASE]: 1_600,
+  [ProvingRequestType.PARITY_ROOT]: 40,
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 45,
+  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 18,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 27,
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 30,
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 36_000,
+  [ProvingRequestType.ROOT_ROLLUP]: 35,
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 2_500,
+  [ProvingRequestType.TX_MERGE_ROLLUP]: 25,
   [ProvingRequestType.PUBLIC_VM]: 0,
+
+  // TBD
+  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 30,
+  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 40_000,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 20_000,
+  [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 40_000,
+  [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 2_500, // Guess based on public
 };
 
 export const PROOF_DELAY_MS: Record<ProvingRequestType, number> = {
-  [ProvingRequestType.BASE_PARITY]: 3_000,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 16_300,
+  [ProvingRequestType.PARITY_BASE]: 15_300,
+  [ProvingRequestType.PARITY_ROOT]: 18_600,
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 17_400,
+  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 4_500,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 9_200,
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 10_200,
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 37_100,
+  [ProvingRequestType.ROOT_ROLLUP]: 93_000,
+  [ProvingRequestType.TX_MERGE_ROLLUP]: 10_000,
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 44_500,
+  [ProvingRequestType.PUBLIC_VM]: 180_000,
+
+  // TBD
   [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, // TBD
-  [ProvingRequestType.PUBLIC_BASE_ROLLUP]: 160_000,
-  [ProvingRequestType.ROOT_PARITY]: 30_000,
-  [ProvingRequestType.ROOT_ROLLUP]: 15_000,
-  [ProvingRequestType.TUBE_PROOF]: 30_000,
-  [ProvingRequestType.PUBLIC_VM]: 0,
+  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 35_000,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 15_000,
+  [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 35_000,
+  [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 22_000,
 };

package/src/test/index.ts

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

package/src/test/test_circuit_prover.ts

@@ -1,74 +1,92 @@
 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,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
 import {
   type ServerProtocolArtifact,
-  convertBaseParityInputsToWitnessMap,
-  convertBaseParityOutputsFromWitnessMap,
-  convertBlockMergeRollupInputsToWitnessMap,
   convertBlockMergeRollupOutputsFromWitnessMap,
-  convertEmptyBlockRootRollupInputsToWitnessMap,
-  convertEmptyBlockRootRollupOutputsFromWitnessMap,
-  convertMergeRollupInputsToWitnessMap,
-  convertMergeRollupOutputsFromWitnessMap,
-  convertPaddingBlockRootRollupInputsToWitnessMap,
-  convertPaddingBlockRootRollupOutputsFromWitnessMap,
-  convertRootParityInputsToWitnessMap,
-  convertRootParityOutputsFromWitnessMap,
-  convertRootRollupInputsToWitnessMap,
+  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,
-  convertSimulatedBlockRootRollupInputsToWitnessMap,
-  convertSimulatedBlockRootRollupOutputsFromWitnessMap,
-  convertSimulatedPrivateBaseRollupInputsToWitnessMap,
-  convertSimulatedPrivateBaseRollupOutputsFromWitnessMap,
-  convertSimulatedPublicBaseRollupInputsToWitnessMap,
-  convertSimulatedPublicBaseRollupOutputsFromWitnessMap,
-  convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap,
-  convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap,
+  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 type { WitnessMap } from '@aztec/noir-types';
 import { type CircuitSimulator, WASMSimulatorWithBlobs, emitCircuitSimulationStats } from '@aztec/simulator/server';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import {
-  type ProofAndVerificationKey,
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
-  makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
-import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
-import { type Proof, ProvingRequestType, makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
-import type {
-  BaseOrMergeRollupPublicInputs,
-  BlockMergeRollupInputs,
-  BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
-  MergeRollupInputs,
-  PaddingBlockRootRollupInputs,
-  PrivateBaseRollupInputs,
-  PublicBaseRollupInputs,
-  RootRollupInputs,
-  RootRollupPublicInputs,
-  SingleTxBlockRootRollupInputs,
-  TubeInputs,
+import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
+import {
+  type Proof,
+  ProvingRequestType,
+  RecursiveProof,
+  makeEmptyRecursiveProof,
+  makeRecursiveProof,
+} from '@aztec/stdlib/proofs';
+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 { VerificationKeyData } from '@aztec/stdlib/vks';
 import { type TelemetryClient, 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';
 
 type TestDelay =
@@ -109,15 +127,15 @@ export class TestCircuitProver implements ServerCircuitProver {
    */
   @trackSpan('TestCircuitProver.getBaseParityProof')
   public getBaseParityProof(
-    inputs: BaseParityInputs,
+    inputs: ParityBasePrivateInputs,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
-    return this.applyDelay(ProvingRequestType.BASE_PARITY, () =>
+    return this.applyDelay(ProvingRequestType.PARITY_BASE, () =>
       this.simulate(
         inputs,
-        'BaseParityArtifact',
+        'ParityBaseArtifact',
         RECURSIVE_PROOF_LENGTH,
-        convertBaseParityInputsToWitnessMap,
-        convertBaseParityOutputsFromWitnessMap,
+        convertParityBasePrivateInputsToWitnessMap,
+        convertParityBaseOutputsFromWitnessMap,
       ),
     );
   }
@@ -129,55 +147,59 @@ export class TestCircuitProver implements ServerCircuitProver {
    */
   @trackSpan('TestCircuitProver.getRootParityProof')
   public getRootParityProof(
-    inputs: RootParityInputs,
+    inputs: ParityRootPrivateInputs,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
-    return this.applyDelay(ProvingRequestType.ROOT_PARITY, () =>
+    return this.applyDelay(ProvingRequestType.PARITY_ROOT, () =>
       this.simulate(
         inputs,
-        'RootParityArtifact',
+        'ParityRootArtifact',
         NESTED_RECURSIVE_PROOF_LENGTH,
-        convertRootParityInputsToWitnessMap,
-        convertRootParityOutputsFromWitnessMap,
+        convertParityRootPrivateInputsToWitnessMap,
+        convertParityRootOutputsFromWitnessMap,
       ),
     );
   }
 
-  public getTubeProof(_tubeInput: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    return this.applyDelay(ProvingRequestType.TUBE_PROOF, () =>
-      makeProofAndVerificationKey(makeEmptyRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()),
+  public getPublicChonkVerifierProof(
+    inputs: PublicChonkVerifierPrivateInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return this.applyDelay(ProvingRequestType.PUBLIC_CHONK_VERIFIER, () =>
+      makePublicInputsAndRecursiveProof(
+        new PublicChonkVerifierPublicInputs(inputs.hidingKernelProofData.publicInputs, inputs.proverId),
+        makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        ProtocolCircuitVks.PublicChonkVerifier,
+      ),
     );
   }
 
-  @trackSpan('TestCircuitProver.getPrivateBaseRollupProof')
-  public getPrivateBaseRollupProof(
-    inputs: PrivateBaseRollupInputs,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
-    return this.applyDelay(ProvingRequestType.PRIVATE_BASE_ROLLUP, () =>
+  @trackSpan('TestCircuitProver.getPrivateTxBaseRollupProof')
+  public getPrivateTxBaseRollupProof(
+    inputs: PrivateTxBaseRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.applyDelay(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, () =>
       this.simulate(
         inputs,
-        'PrivateBaseRollupArtifact',
+        'PrivateTxBaseRollupArtifact',
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-        convertSimulatedPrivateBaseRollupInputsToWitnessMap,
-        convertSimulatedPrivateBaseRollupOutputsFromWitnessMap,
+        convertPrivateTxBaseRollupPrivateInputsToWitnessMap,
+        convertPrivateTxBaseRollupOutputsFromWitnessMap,
       ),
     );
   }
 
-  @trackSpan('TestCircuitProver.getPublicBaseRollupProof')
-  public getPublicBaseRollupProof(
-    inputs: PublicBaseRollupInputs,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
-    return this.applyDelay(ProvingRequestType.PUBLIC_BASE_ROLLUP, () =>
+  @trackSpan('TestCircuitProver.getPublicTxBaseRollupProof')
+  public getPublicTxBaseRollupProof(
+    inputs: PublicTxBaseRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.applyDelay(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP, () =>
       this.simulate(
         inputs,
-        'PublicBaseRollupArtifact',
+        'PublicTxBaseRollupArtifact',
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-        convertSimulatedPublicBaseRollupInputsToWitnessMap,
-        convertSimulatedPublicBaseRollupOutputsFromWitnessMap,
+        convertPublicTxBaseRollupPrivateInputsToWitnessMap,
+        convertPublicTxBaseRollupOutputsFromWitnessMap,
       ),
     );
   }
@@ -187,119 +209,175 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  @trackSpan('TestCircuitProver.getMergeRollupProof')
-  public getMergeRollupProof(
-    input: MergeRollupInputs,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
-    return this.applyDelay(ProvingRequestType.MERGE_ROLLUP, () =>
+  @trackSpan('TestCircuitProver.getTxMergeRollupProof')
+  public getTxMergeRollupProof(
+    input: TxMergeRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.applyDelay(ProvingRequestType.TX_MERGE_ROLLUP, () =>
       this.simulate(
         input,
-        'MergeRollupArtifact',
+        'TxMergeRollupArtifact',
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-        convertMergeRollupInputsToWitnessMap,
-        convertMergeRollupOutputsFromWitnessMap,
+        convertTxMergeRollupPrivateInputsToWitnessMap,
+        convertTxMergeRollupOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  @trackSpan('TestCircuitProver.getBlockRootFirstRollupProof')
+  public getBlockRootFirstRollupProof(
+    input: BlockRootFirstRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.applyDelay(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP, () =>
+      this.simulate(
+        input,
+        'BlockRootFirstRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertBlockRootFirstRollupPrivateInputsToWitnessMap,
+        convertBlockRootFirstRollupOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  @trackSpan('TestCircuitProver.getBlockRootSingleTxFirstRollupProof')
+  public async getBlockRootSingleTxFirstRollupProof(
+    input: BlockRootSingleTxFirstRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return await this.applyDelay(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP, () =>
+      this.simulate(
+        input,
+        'BlockRootSingleTxFirstRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertBlockRootSingleTxFirstRollupPrivateInputsToWitnessMap,
+        convertBlockRootSingleTxFirstRollupOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  @trackSpan('TestCircuitProver.getBlockRootEmptyTxFirstRollupProof')
+  public getBlockRootEmptyTxFirstRollupProof(
+    input: BlockRootEmptyTxFirstRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    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 root rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */
   @trackSpan('TestCircuitProver.getBlockRootRollupProof')
   public getBlockRootRollupProof(
-    input: BlockRootRollupInputs,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+    input: BlockRootRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return this.applyDelay(ProvingRequestType.BLOCK_ROOT_ROLLUP, () =>
       this.simulate(
         input,
         'BlockRootRollupArtifact',
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-        convertSimulatedBlockRootRollupInputsToWitnessMap,
-        convertSimulatedBlockRootRollupOutputsFromWitnessMap,
+        convertBlockRootRollupPrivateInputsToWitnessMap,
+        convertBlockRootRollupOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  @trackSpan('TestCircuitProver.getBlockRootSingleTxRollupProof')
+  public async getBlockRootSingleTxRollupProof(
+    input: BlockRootSingleTxRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return await this.applyDelay(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP, () =>
+      this.simulate(
+        input,
+        'BlockRootSingleTxRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertBlockRootSingleTxRollupPrivateInputsToWitnessMap,
+        convertBlockRootSingleTxRollupOutputsFromWitnessMap,
       ),
     );
   }
 
-  @trackSpan('TestCircuitProver.getSingleTxBlockRootRollupProof')
-  public async getSingleTxBlockRootRollupProof(
-    input: SingleTxBlockRootRollupInputs,
+  @trackSpan('TestCircuitProver.getBlockMergeRollupProof')
+  public getBlockMergeRollupProof(
+    input: BlockMergeRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.applyDelay(ProvingRequestType.BLOCK_MERGE_ROLLUP, () =>
+      this.simulate(
+        input,
+        'BlockMergeRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertBlockMergeRollupPrivateInputsToWitnessMap,
+        convertBlockMergeRollupOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  @trackSpan('TestCircuitProver.getCheckpointRootRollupProof')
+  public getCheckpointRootRollupProof(
+    input: CheckpointRootRollupPrivateInputs,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return await this.applyDelay(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP, () =>
+    return this.applyDelay(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP, () =>
       this.simulate(
         input,
-        'SingleTxBlockRootRollupArtifact',
+        'CheckpointRootRollupArtifact',
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-        convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap,
-        convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap,
+        convertCheckpointRootRollupPrivateInputsToWitnessMap,
+        convertCheckpointRootRollupOutputsFromWitnessMap,
       ),
     );
   }
 
-  /**
-   * 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.
-   */
-  @trackSpan('TestCircuitProver.getEmptyBlockRootRollupProof')
-  public getEmptyBlockRootRollupProof(
-    input: EmptyBlockRootRollupInputs,
+  @trackSpan('TestCircuitProver.getCheckpointRootSingleBlockRollupProof')
+  public getCheckpointRootSingleBlockRollupProof(
+    input: CheckpointRootSingleBlockRollupPrivateInputs,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return this.applyDelay(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, () =>
+    return this.applyDelay(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP, () =>
       this.simulate(
         input,
-        'EmptyBlockRootRollupArtifact',
+        'CheckpointRootSingleBlockRollupArtifact',
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-        convertEmptyBlockRootRollupInputsToWitnessMap,
-        convertEmptyBlockRootRollupOutputsFromWitnessMap,
+        convertCheckpointRootSingleBlockRollupPrivateInputsToWitnessMap,
+        convertCheckpointRootSingleBlockRollupOutputsFromWitnessMap,
       ),
     );
   }
 
-  @trackSpan('TestCircuitProver.getPaddingBlockRootRollupProof')
-  public getPaddingBlockRootRollupProof(
-    input: PaddingBlockRootRollupInputs,
+  @trackSpan('TestCircuitProver.getCheckpointPaddingRollupProof')
+  public getCheckpointPaddingRollupProof(
+    input: CheckpointPaddingRollupPrivateInputs,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return this.applyDelay(ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP, () =>
+    return this.applyDelay(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP, () =>
       this.simulate(
         input,
-        'PaddingBlockRootRollupArtifact',
+        'CheckpointPaddingRollupArtifact',
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-        convertPaddingBlockRootRollupInputsToWitnessMap,
-        convertPaddingBlockRootRollupOutputsFromWitnessMap,
+        convertCheckpointPaddingRollupPrivateInputsToWitnessMap,
+        convertCheckpointPaddingRollupOutputsFromWitnessMap,
       ),
     );
   }
 
-  /**
-   * Simulates the block merge rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */
-  @trackSpan('TestCircuitProver.getBlockMergeRollupProof')
-  public getBlockMergeRollupProof(
-    input: BlockMergeRollupInputs,
+  @trackSpan('TestCircuitProver.getCheckpointMergeRollupProof')
+  public getCheckpointMergeRollupProof(
+    input: CheckpointMergeRollupPrivateInputs,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return this.applyDelay(ProvingRequestType.BLOCK_MERGE_ROLLUP, () =>
+    return this.applyDelay(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP, () =>
       this.simulate(
         input,
-        'BlockMergeRollupArtifact',
+        'CheckpointMergeRollupArtifact',
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-        convertBlockMergeRollupInputsToWitnessMap,
-        convertBlockMergeRollupOutputsFromWitnessMap,
+        convertCheckpointMergeRollupPrivateInputsToWitnessMap,
+        convertCheckpointMergeRollupOutputsFromWitnessMap,
       ),
     );
   }
@@ -310,29 +388,26 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @returns The public inputs as outputs of the simulation.
    */
   @trackSpan('TestCircuitProver.getRootRollupProof')
-  public getRootRollupProof(input: RootRollupInputs): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
+  public getRootRollupProof(
+    input: RootRollupPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
     return this.applyDelay(ProvingRequestType.ROOT_ROLLUP, () =>
       this.simulate(
         input,
         'RootRollupArtifact',
         NESTED_RECURSIVE_PROOF_LENGTH,
-        convertRootRollupInputsToWitnessMap,
+        convertRootRollupPrivateInputsToWitnessMap,
         convertRootRollupOutputsFromWitnessMap,
       ),
     );
   }
 
-  public getAvmProof(
-    _inputs: AvmCircuitInputs,
-  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+  public getAvmProof(_inputs: AvmCircuitInputs): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
     // 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.
+    // We just return an empty proof.
     this.logger.debug('Skipping AVM simulation in TestCircuitProver.');
     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),
-      ),
+      makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
     );
   }
 
@@ -363,21 +438,20 @@ export class TestCircuitProver implements ServerCircuitProver {
     input: CircuitInputType,
     artifactName: ServerProtocolArtifact,
     proofLength: PROOF_LENGTH,
-    convertInput: (input: CircuitInputType) => WitnessMap,
-    convertOutput: (outputWitness: WitnessMap) => CircuitOutputType,
+    convertInput: (input: CircuitInputType, simulated?: boolean) => WitnessMap,
+    convertOutput: (outputWitness: WitnessMap, simulated?: boolean) => CircuitOutputType,
   ) {
     const timer = new Timer();
-    const witnessMap = convertInput(input);
+    const witnessMap = convertInput(input, true /* simulated */);
     const circuitName = mapProtocolArtifactNameToCircuitName(artifactName);
 
     let witness: WitnessMap;
     if (
-      ['BlockRootRollupArtifact', 'SingleTxBlockRootRollupArtifact'].includes(artifactName) ||
+      ['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 block root rollup and single tx block root rollup circuits or when the native ACVM simulator
-      // is not provided.
+      // when simulating checkpoint root rollup circuits or when the native ACVM simulator is not provided.
       witness = (
         await this.wasmSimulator.executeProtocolCircuit(
           witnessMap,
@@ -395,7 +469,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       ).witness;
     }
 
-    const result = convertOutput(witness);
+    const result = convertOutput(witness, true /* simulated */);
 
     this.instrumentation.recordDuration('simulationDuration', circuitName, timer);
     emitCircuitSimulationStats(circuitName, timer.ms(), input.toBuffer().length, result.toBuffer().length, this.logger);

package/src/test/test_verifier.ts

@@ -2,7 +2,15 @@ import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '
 import type { Tx } from '@aztec/stdlib/tx';
 
 export class TestCircuitVerifier implements ClientProtocolCircuitVerifier {
+  constructor(private verificationDelayMs?: number) {}
   verifyProof(_tx: Tx): Promise<IVCProofVerificationResult> {
+    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 });
   }