@aztec/bb-prover 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/src/test/delay_values.ts

@@ -1,31 +1,43 @@
 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.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.PARITY_BASE]: 2_000,
+  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 30,
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 45,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 27,
+  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 18,
+  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 40_000,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 20_000,
+  [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 40_000,
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 36_600,
+  [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 30,
+  [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 2_500, // Guess based on public
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 2_500,
+  [ProvingRequestType.PARITY_ROOT]: 40,
+  [ProvingRequestType.ROOT_ROLLUP]: 35,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 60,
   [ProvingRequestType.PUBLIC_VM]: 0,
 };
 
 export const PROOF_DELAY_MS: Record<ProvingRequestType, number> = {
-  [ProvingRequestType.BASE_PARITY]: 3_000,
+  [ProvingRequestType.PARITY_BASE]: 16_300,
   [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 15_000,
-  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 55_000,
-  [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: 0,
-  [ProvingRequestType.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.BLOCK_ROOT_FIRST_ROLLUP]: 16_500,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 9_210,
+  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 4_560,
+  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 35_000,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 15_000,
+  [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 35_000,
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 38_800,
+  [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 9_760,
+  [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 45_000, // Guess based on public
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 45_000,
+  [ProvingRequestType.PARITY_ROOT]: 18_600,
+  [ProvingRequestType.ROOT_ROLLUP]: 84_000,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 16_300,
   [ProvingRequestType.PUBLIC_VM]: 0,
 };

package/src/test/test_circuit_prover.ts

@@ -1,40 +1,54 @@
 import {
-  AVM_PROOF_LENGTH_IN_FIELDS,
-  AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
+  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,
-  SimulatedServerCircuitArtifacts,
-  convertBaseParityInputsToWitnessMap,
-  convertBaseParityOutputsFromWitnessMap,
-  convertBlockMergeRollupInputsToWitnessMap,
   convertBlockMergeRollupOutputsFromWitnessMap,
-  convertEmptyBlockRootRollupInputsToWitnessMap,
-  convertEmptyBlockRootRollupOutputsFromWitnessMap,
-  convertMergeRollupInputsToWitnessMap,
-  convertMergeRollupOutputsFromWitnessMap,
-  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 { type SimulationProvider, WASMSimulatorWithBlobs, emitCircuitSimulationStats } from '@aztec/simulator/server';
+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,
@@ -43,29 +57,34 @@ import {
   makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
-import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
 import { type Proof, ProvingRequestType, makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
-import type {
-  BaseOrMergeRollupPublicInputs,
-  BlockMergeRollupInputs,
-  BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
-  MergeRollupInputs,
-  PrivateBaseRollupInputs,
-  PublicBaseRollupInputs,
-  RootRollupInputs,
-  RootRollupPublicInputs,
-  SingleTxBlockRootRollupInputs,
-  TubeInputs,
+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 type { WitnessMap } from '@noir-lang/types';
-
 import { ProverInstrumentation } from '../instrumentation.js';
-import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { PROOF_DELAY_MS, WITGEN_DELAY_MS } from './delay_values.js';
 
 type TestDelay =
@@ -88,7 +107,7 @@ export class TestCircuitProver implements ServerCircuitProver {
   private logger = createLogger('bb-prover:test-prover');
 
   constructor(
-    private simulationProvider?: SimulationProvider,
+    private simulator?: CircuitSimulator,
     private opts: TestDelay = { proverTestDelayType: 'fixed', proverTestDelayMs: 0 },
     telemetry: TelemetryClient = getTelemetryClient(),
   ) {
@@ -106,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,
       ),
     );
   }
@@ -126,55 +145,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,
       ),
     );
   }
@@ -184,102 +207,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.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.getSingleTxBlockRootRollupProof')
-  public async getSingleTxBlockRootRollupProof(
-    input: SingleTxBlockRootRollupInputs,
+  @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,
       ),
     );
   }
 
-  /**
-   * 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.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.BLOCK_MERGE_ROLLUP, () =>
+    return this.applyDelay(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP, () =>
       this.simulate(
         input,
-        'BlockMergeRollupArtifact',
+        'CheckpointPaddingRollupArtifact',
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-        convertBlockMergeRollupInputsToWitnessMap,
-        convertBlockMergeRollupOutputsFromWitnessMap,
+        convertCheckpointPaddingRollupPrivateInputsToWitnessMap,
+        convertCheckpointPaddingRollupOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  @trackSpan('TestCircuitProver.getCheckpointMergeRollupProof')
+  public getCheckpointMergeRollupProof(
+    input: CheckpointMergeRollupPrivateInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return this.applyDelay(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP, () =>
+      this.simulate(
+        input,
+        'CheckpointMergeRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertCheckpointMergeRollupPrivateInputsToWitnessMap,
+        convertCheckpointMergeRollupOutputsFromWitnessMap,
       ),
     );
   }
@@ -290,26 +386,30 @@ 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_PROOF_LENGTH_IN_FIELDS>> {
+  public getAvmProof(
+    _inputs: AvmCircuitInputs,
+  ): Promise<ProofAndVerificationKey<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.
     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),
+        makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
+        VerificationKeyData.makeFake(AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED),
       ),
     );
   }
@@ -341,25 +441,38 @@ 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 simulationProvider = this.simulationProvider ?? this.wasmSimulator;
-    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;
+    let witness: WitnessMap;
+    if (
+      ['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, // Native ACM simulator does not support foreign call handler
+        )
+      ).witness;
     }
-    const witness = await simulationProvider.executeProtocolCircuit(
-      witnessMap,
-      SimulatedServerCircuitArtifacts[artifactName],
-    );
 
-    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

@@ -1,8 +1,20 @@
-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 class TestCircuitVerifier implements ClientProtocolCircuitVerifier {
-  verifyProof(_tx: Tx): Promise<boolean> {
-    return Promise.resolve(true);
+  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 });
+  }
+
+  public stop(): Promise<void> {
+    return Promise.resolve();
   }
 }