@aztec/bb-prover 3.0.0-nightly.20250917 → 3.0.0-nightly.20250919

package/src/test/test_circuit_prover.ts

@@ -10,32 +10,43 @@ 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';
@@ -47,28 +58,33 @@ import {
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
 import type { PrivateToPublicKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
-import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } 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,
+  BlockMergeRollupPrivateInputs,
+  BlockRollupPublicInputs,
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+  CheckpointMergeRollupPrivateInputs,
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRollupPublicInputs,
+  CheckpointRootRollupPrivateInputs,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+  PrivateTxBaseRollupPrivateInputs,
   PublicTubePrivateInputs,
-  RootRollupInputs,
+  PublicTxBaseRollupPrivateInputs,
+  RootRollupPrivateInputs,
   RootRollupPublicInputs,
-  SingleTxBlockRootRollupInputs,
+  TxMergeRollupPrivateInputs,
+  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 +125,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,15 +145,15 @@ 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,
       ),
     );
   }
@@ -159,36 +175,32 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
-  @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,
       ),
     );
   }
@@ -198,119 +210,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.getSingleTxBlockRootRollupProof')
-  public async getSingleTxBlockRootRollupProof(
-    input: SingleTxBlockRootRollupInputs,
+  @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.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,
       ),
     );
   }
@@ -321,13 +389,15 @@ 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,
       ),
     );
@@ -374,21 +444,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,
@@ -406,7 +475,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/verifier/bb_verifier.ts

@@ -2,10 +2,11 @@ import { runInDirectory } from '@aztec/foundation/fs';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
-import type {
-  ClientProtocolArtifact,
-  ProtocolArtifact,
-  ServerProtocolArtifact,
+import {
+  type ClientProtocolArtifact,
+  type ProtocolArtifact,
+  type ServerProtocolArtifact,
+  mapProtocolArtifactNameToCircuitName,
 } from '@aztec/noir-protocol-circuits-types/types';
 import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
@@ -27,7 +28,6 @@ import {
 import type { BBConfig } from '../config.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
 import { writeClientIVCProofToPath } from '../prover/proof_utils.js';
-import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 
 export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
   private constructor(

package/dest/stats.d.ts

@@ -1,4 +0,0 @@
-import type { ProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
-import type { CircuitName } from '@aztec/stdlib/stats';
-export declare function mapProtocolArtifactNameToCircuitName(artifact: ProtocolArtifact): CircuitName;
-//# sourceMappingURL=stats.d.ts.map

package/dest/stats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../src/stats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,gBAAgB,GAAG,WAAW,CA6C5F"}

package/dest/stats.js

@@ -1,47 +0,0 @@
-export function mapProtocolArtifactNameToCircuitName(artifact) {
-    switch(artifact){
-        case 'BaseParityArtifact':
-            return 'base-parity';
-        case 'RootParityArtifact':
-            return 'root-parity';
-        case 'PublicTube':
-            return 'public-tube';
-        case 'PrivateBaseRollupArtifact':
-            return 'private-base-rollup';
-        case 'PublicBaseRollupArtifact':
-            return 'public-base-rollup';
-        case 'MergeRollupArtifact':
-            return 'merge-rollup';
-        case 'BlockRootRollupArtifact':
-            return 'block-root-rollup';
-        case 'SingleTxBlockRootRollupArtifact':
-            return 'single-tx-block-root-rollup';
-        case 'EmptyBlockRootRollupArtifact':
-            return 'empty-block-root-rollup';
-        case 'PaddingBlockRootRollupArtifact':
-            return 'padding-block-root-rollup';
-        case 'BlockMergeRollupArtifact':
-            return 'block-merge-rollup';
-        case 'RootRollupArtifact':
-            return 'root-rollup';
-        case 'PrivateKernelInitArtifact':
-            return 'private-kernel-init';
-        case 'PrivateKernelInnerArtifact':
-            return 'private-kernel-inner';
-        case 'PrivateKernelTailArtifact':
-            return 'private-kernel-tail';
-        case 'PrivateKernelTailToPublicArtifact':
-            return 'private-kernel-tail-to-public';
-        case 'HidingKernelToRollup':
-            return 'hiding-kernel-to-rollup';
-        case 'HidingKernelToPublic':
-            return 'hiding-kernel-to-public';
-        default:
-            {
-                if (artifact.startsWith('PrivateKernelReset')) {
-                    return 'private-kernel-reset';
-                }
-                throw new Error(`Unknown circuit type: ${artifact}`);
-            }
-    }
-}

package/src/stats.ts

@@ -1,49 +0,0 @@
-import type { ProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
-import type { CircuitName } from '@aztec/stdlib/stats';
-
-export function mapProtocolArtifactNameToCircuitName(artifact: ProtocolArtifact): CircuitName {
-  switch (artifact) {
-    case 'BaseParityArtifact':
-      return 'base-parity';
-    case 'RootParityArtifact':
-      return 'root-parity';
-    case 'PublicTube':
-      return 'public-tube';
-    case 'PrivateBaseRollupArtifact':
-      return 'private-base-rollup';
-    case 'PublicBaseRollupArtifact':
-      return 'public-base-rollup';
-    case 'MergeRollupArtifact':
-      return 'merge-rollup';
-    case 'BlockRootRollupArtifact':
-      return 'block-root-rollup';
-    case 'SingleTxBlockRootRollupArtifact':
-      return 'single-tx-block-root-rollup';
-    case 'EmptyBlockRootRollupArtifact':
-      return 'empty-block-root-rollup';
-    case 'PaddingBlockRootRollupArtifact':
-      return 'padding-block-root-rollup';
-    case 'BlockMergeRollupArtifact':
-      return 'block-merge-rollup';
-    case 'RootRollupArtifact':
-      return 'root-rollup';
-    case 'PrivateKernelInitArtifact':
-      return 'private-kernel-init';
-    case 'PrivateKernelInnerArtifact':
-      return 'private-kernel-inner';
-    case 'PrivateKernelTailArtifact':
-      return 'private-kernel-tail';
-    case 'PrivateKernelTailToPublicArtifact':
-      return 'private-kernel-tail-to-public';
-    case 'HidingKernelToRollup':
-      return 'hiding-kernel-to-rollup';
-    case 'HidingKernelToPublic':
-      return 'hiding-kernel-to-public';
-    default: {
-      if (artifact.startsWith('PrivateKernelReset')) {
-        return 'private-kernel-reset';
-      }
-      throw new Error(`Unknown circuit type: ${artifact}`);
-    }
-  }
-}