@aztec/bb-prover 0.76.4 → 0.77.0-testnet-ignition.21

package/src/prover/bb_prover.ts

@@ -1,45 +1,14 @@
 /* eslint-disable require-await */
-import {
-  type ProofAndVerificationKey,
-  ProvingError,
-  type PublicInputsAndRecursiveProof,
-  type ServerCircuitProver,
-  makeProofAndVerificationKey,
-  makePublicInputsAndRecursiveProof,
-} from '@aztec/circuit-types';
-import { type CircuitProvingStats, type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
   AGGREGATION_OBJECT_LENGTH,
   AVM_PROOF_LENGTH_IN_FIELDS,
-  type AvmCircuitInputs,
-  type BaseParityInputs,
-  Fr,
   IPA_CLAIM_LENGTH,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-  type ParityPublicInputs,
-  Proof,
   RECURSIVE_PROOF_LENGTH,
-  RecursiveProof,
-  type RootParityInputs,
   TUBE_PROOF_LENGTH,
-  type VerificationKeyData,
-  makeRecursiveProofFromBinary,
-} from '@aztec/circuits.js';
-import {
-  type BaseOrMergeRollupPublicInputs,
-  type BlockMergeRollupInputs,
-  type BlockRootOrBlockMergePublicInputs,
-  type BlockRootRollupInputs,
-  type EmptyBlockRootRollupInputs,
-  type MergeRollupInputs,
-  type PrivateBaseRollupInputs,
-  type PublicBaseRollupInputs,
-  type RootRollupInputs,
-  type RootRollupPublicInputs,
-  type SingleTxBlockRootRollupInputs,
-  type TubeInputs,
-} from '@aztec/circuits.js/rollup';
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
@@ -68,11 +37,38 @@ import {
   convertSingleTxBlockRootRollupInputsToWitnessMap,
   convertSingleTxBlockRootRollupOutputsFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types/server';
-import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
+import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
 import { NativeACVMSimulator } from '@aztec/simulator/server';
+import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
+import { ProvingError } from '@aztec/stdlib/errors';
+import {
+  type ProofAndVerificationKey,
+  type PublicInputsAndRecursiveProof,
+  type ServerCircuitProver,
+  makeProofAndVerificationKey,
+  makePublicInputsAndRecursiveProof,
+} from '@aztec/stdlib/interfaces/server';
+import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import { Proof, RecursiveProof, makeRecursiveProofFromBinary } from '@aztec/stdlib/proofs';
+import type {
+  BaseOrMergeRollupPublicInputs,
+  BlockMergeRollupInputs,
+  BlockRootOrBlockMergePublicInputs,
+  BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
+  MergeRollupInputs,
+  PrivateBaseRollupInputs,
+  PublicBaseRollupInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+  SingleTxBlockRootRollupInputs,
+  TubeInputs,
+} from '@aztec/stdlib/rollup';
+import type { CircuitProvingStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
+import type { VerificationKeyData } from '@aztec/stdlib/vks';
 import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import { type WitnessMap } from '@noir-lang/types';
+import type { WitnessMap } from '@noir-lang/types';
 import { assert } from 'console';
 import crypto from 'crypto';
 import { promises as fs } from 'fs';
@@ -90,7 +86,6 @@ import {
   generateTubeProof,
   verifyAvmProof,
   verifyProof,
-  writeProofAsFields,
 } from '../bb/execute.js';
 import type { ACVMConfig, BBConfig } from '../config.js';
 import { type UltraHonkFlavor, getUltraHonkFlavorForCircuit } from '../honk.js';
@@ -561,7 +556,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
           duration: provingResult.durationMs,
           proofSize: avmProof.binaryProof.buffer.length,
           eventName: 'circuit-proving',
-          inputSize: input.toBuffer().length,
+          inputSize: input.serializeWithMessagePack().length,
           circuitSize: verificationKey.circuitSize, // FIX: wrong in VK
           numPublicInputs: verificationKey.numPublicInputs, // FIX: wrong in VK
         } satisfies CircuitProvingStats,
@@ -710,69 +705,6 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     await this.runInDirectory(operation);
   }
 
-  /**
-   * Will check a recursive proof argument for validity of it's 'fields' format of proof and convert if required
-   * @param proof - The input proof that may need converting
-   * @returns - The valid proof
-   */
-  public async ensureValidProof(
-    proof: RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>, // WORKTODO
-    circuit: ServerProtocolArtifact,
-    vk: VerificationKeyData,
-  ) {
-    // If the 'fields' proof is already valid then simply return
-    // This will be false for proofs coming from clients
-    if (proof.fieldsValid) {
-      return proof;
-    }
-
-    const operation = async (bbWorkingDirectory: string) => {
-      const numPublicInputs = vk.numPublicInputs - AGGREGATION_OBJECT_LENGTH - IPA_CLAIM_LENGTH;
-      const proofFullFilename = path.join(bbWorkingDirectory, PROOF_FILENAME);
-      const vkFullFilename = path.join(bbWorkingDirectory, VK_FILENAME);
-
-      logger.debug(
-        `Converting proof to fields format for circuit ${circuit}, directory ${bbWorkingDirectory}, num public inputs: ${vk.numPublicInputs}, proof length ${proof.binaryProof.buffer.length}, vk length ${vk.keyAsBytes.length}`,
-      );
-
-      await fs.writeFile(proofFullFilename, proof.binaryProof.buffer);
-      await fs.writeFile(vkFullFilename, vk.keyAsBytes);
-
-      const logFunction = (message: string) => {
-        logger.debug(`${circuit} BB out - ${message}`);
-      };
-
-      const result = await writeProofAsFields(
-        this.config.bbBinaryPath,
-        bbWorkingDirectory,
-        PROOF_FILENAME,
-        vkFullFilename,
-        logFunction,
-      );
-
-      if (result.status === BB_RESULT.FAILURE) {
-        const errorMessage = `Failed to convert ${circuit} proof to fields, ${result.reason}`;
-        throw new ProvingError(errorMessage, result, result.retry);
-      }
-
-      const proofString = await fs.readFile(path.join(bbWorkingDirectory, PROOF_FIELDS_FILENAME), {
-        encoding: 'utf-8',
-      });
-      const json = JSON.parse(proofString);
-      const fields = json
-        .slice(0, 3)
-        .map(Fr.fromHexString)
-        .concat(json.slice(3 + numPublicInputs).map(Fr.fromHexString));
-      return new RecursiveProof(
-        fields,
-        new Proof(proof.binaryProof.buffer, vk.numPublicInputs),
-        true,
-        NESTED_RECURSIVE_PROOF_LENGTH, // WORKTODO
-      );
-    };
-    return await this.runInDirectory(operation);
-  }
-
   /**
    * Returns the verification key data for a circuit.
    * @param circuitType - The type of circuit for which the verification key is required
@@ -843,6 +775,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
           throw err;
         }),
       this.config.bbSkipCleanup,
+      logger,
     );
   }
 }

package/src/prover/client_ivc_proof_utils.ts

@@ -1,10 +1,10 @@
-import { ClientIvcProof } from '@aztec/circuits.js';
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
 
 import { promises as fs } from 'fs';
 import { join } from 'path';
 
-export const CLIENT_IVC_VK_FILE_NAME = 'client_ivc_vk';
-export const CLIENT_IVC_PROOF_FILE_NAME = 'client_ivc_proof';
+export const CLIENT_IVC_VK_FILE_NAME = 'vk';
+export const CLIENT_IVC_PROOF_FILE_NAME = 'proof';
 
 /**
  * TODO(#7371): eventually remove client_ivc_prove_output_all_msgpack and properly handle these accumulators and VKs

package/src/stats.ts

@@ -1,5 +1,5 @@
-import type { CircuitName } from '@aztec/circuit-types/stats';
-import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+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) {

package/src/test/delay_values.ts

@@ -0,0 +1,31 @@
+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.PUBLIC_VM]: 0,
+};
+
+export const PROOF_DELAY_MS: Record<ProvingRequestType, number> = {
+  [ProvingRequestType.BASE_PARITY]: 3_000,
+  [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.PUBLIC_VM]: 0,
+};

package/src/test/test_circuit_prover.ts

@@ -1,40 +1,11 @@
-import {
-  type ProofAndVerificationKey,
-  type PublicInputsAndRecursiveProof,
-  type ServerCircuitProver,
-  makeProofAndVerificationKey,
-  makePublicInputsAndRecursiveProof,
-} from '@aztec/circuit-types';
 import {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
-  type AvmCircuitInputs,
-  type BaseParityInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-  type ParityPublicInputs,
-  type Proof,
   RECURSIVE_PROOF_LENGTH,
-  type RootParityInputs,
   TUBE_PROOF_LENGTH,
-  VerificationKeyData,
-  makeEmptyRecursiveProof,
-  makeRecursiveProof,
-} from '@aztec/circuits.js';
-import {
-  type BaseOrMergeRollupPublicInputs,
-  type BlockMergeRollupInputs,
-  type BlockRootOrBlockMergePublicInputs,
-  type BlockRootRollupInputs,
-  type EmptyBlockRootRollupInputs,
-  type MergeRollupInputs,
-  type PrivateBaseRollupInputs,
-  type PublicBaseRollupInputs,
-  type RootRollupInputs,
-  type RootRollupPublicInputs,
-  type SingleTxBlockRootRollupInputs,
-  type TubeInputs,
-} from '@aztec/circuits.js/rollup';
+} from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
@@ -62,14 +33,50 @@ import {
   convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap,
   convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types/server';
-import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
+import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
 import { type SimulationProvider, 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,
+  PrivateBaseRollupInputs,
+  PublicBaseRollupInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+  SingleTxBlockRootRollupInputs,
+  TubeInputs,
+} 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 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 =
+  | {
+      proverTestDelayType: 'fixed';
+      proverTestDelayMs?: number;
+    }
+  | {
+      proverTestDelayType: 'realistic';
+      proverTestDelayFactor?: number;
+    };
 
 /**
  * A class for use in testing situations (e2e, unit test, etc) and temporarily for assembling a block in the sequencer.
@@ -82,7 +89,7 @@ export class TestCircuitProver implements ServerCircuitProver {
 
   constructor(
     private simulationProvider?: SimulationProvider,
-    private opts: { proverTestDelayMs: number } = { proverTestDelayMs: 0 },
+    private opts: TestDelay = { proverTestDelayType: 'fixed', proverTestDelayMs: 0 },
     telemetry: TelemetryClient = getTelemetryClient(),
   ) {
     this.instrumentation = new ProverInstrumentation(telemetry, 'TestCircuitProver');
@@ -98,15 +105,17 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @returns The public inputs of the parity circuit.
    */
   @trackSpan('TestCircuitProver.getBaseParityProof')
-  public async getBaseParityProof(
+  public getBaseParityProof(
     inputs: BaseParityInputs,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
-    return await this.simulate(
-      inputs,
-      'BaseParityArtifact',
-      RECURSIVE_PROOF_LENGTH,
-      convertBaseParityInputsToWitnessMap,
-      convertBaseParityOutputsFromWitnessMap,
+    return this.applyDelay(ProvingRequestType.BASE_PARITY, () =>
+      this.simulate(
+        inputs,
+        'BaseParityArtifact',
+        RECURSIVE_PROOF_LENGTH,
+        convertBaseParityInputsToWitnessMap,
+        convertBaseParityOutputsFromWitnessMap,
+      ),
     );
   }
 
@@ -116,53 +125,57 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @returns The public inputs of the parity circuit.
    */
   @trackSpan('TestCircuitProver.getRootParityProof')
-  public async getRootParityProof(
+  public getRootParityProof(
     inputs: RootParityInputs,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
-    return await this.simulate(
-      inputs,
-      'RootParityArtifact',
-      NESTED_RECURSIVE_PROOF_LENGTH,
-      convertRootParityInputsToWitnessMap,
-      convertRootParityOutputsFromWitnessMap,
+    return this.applyDelay(ProvingRequestType.ROOT_PARITY, () =>
+      this.simulate(
+        inputs,
+        'RootParityArtifact',
+        NESTED_RECURSIVE_PROOF_LENGTH,
+        convertRootParityInputsToWitnessMap,
+        convertRootParityOutputsFromWitnessMap,
+      ),
     );
   }
 
-  public async getTubeProof(_tubeInput: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    await this.delay();
-    return makeProofAndVerificationKey(
-      makeEmptyRecursiveProof(TUBE_PROOF_LENGTH),
-      VerificationKeyData.makeFakeRollupHonk(),
+  public getTubeProof(_tubeInput: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
+    return this.applyDelay(ProvingRequestType.TUBE_PROOF, () =>
+      makeProofAndVerificationKey(makeEmptyRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()),
     );
   }
 
   @trackSpan('TestCircuitProver.getPrivateBaseRollupProof')
-  public async getPrivateBaseRollupProof(
+  public getPrivateBaseRollupProof(
     inputs: PrivateBaseRollupInputs,
   ): Promise<
     PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return await this.simulate(
-      inputs,
-      'PrivateBaseRollupArtifact',
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      convertSimulatedPrivateBaseRollupInputsToWitnessMap,
-      convertSimulatedPrivateBaseRollupOutputsFromWitnessMap,
+    return this.applyDelay(ProvingRequestType.PRIVATE_BASE_ROLLUP, () =>
+      this.simulate(
+        inputs,
+        'PrivateBaseRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertSimulatedPrivateBaseRollupInputsToWitnessMap,
+        convertSimulatedPrivateBaseRollupOutputsFromWitnessMap,
+      ),
     );
   }
 
   @trackSpan('TestCircuitProver.getPublicBaseRollupProof')
-  public async getPublicBaseRollupProof(
+  public getPublicBaseRollupProof(
     inputs: PublicBaseRollupInputs,
   ): Promise<
     PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return await this.simulate(
-      inputs,
-      'PublicBaseRollupArtifact',
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      convertSimulatedPublicBaseRollupInputsToWitnessMap,
-      convertSimulatedPublicBaseRollupOutputsFromWitnessMap,
+    return this.applyDelay(ProvingRequestType.PUBLIC_BASE_ROLLUP, () =>
+      this.simulate(
+        inputs,
+        'PublicBaseRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertSimulatedPublicBaseRollupInputsToWitnessMap,
+        convertSimulatedPublicBaseRollupOutputsFromWitnessMap,
+      ),
     );
   }
 
@@ -172,17 +185,19 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @returns The public inputs as outputs of the simulation.
    */
   @trackSpan('TestCircuitProver.getMergeRollupProof')
-  public async getMergeRollupProof(
+  public getMergeRollupProof(
     input: MergeRollupInputs,
   ): Promise<
     PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return await this.simulate(
-      input,
-      'MergeRollupArtifact',
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      convertMergeRollupInputsToWitnessMap,
-      convertMergeRollupOutputsFromWitnessMap,
+    return this.applyDelay(ProvingRequestType.MERGE_ROLLUP, () =>
+      this.simulate(
+        input,
+        'MergeRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertMergeRollupInputsToWitnessMap,
+        convertMergeRollupOutputsFromWitnessMap,
+      ),
     );
   }
 
@@ -192,17 +207,19 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @returns The public inputs as outputs of the simulation.
    */
   @trackSpan('TestCircuitProver.getBlockRootRollupProof')
-  public async getBlockRootRollupProof(
+  public getBlockRootRollupProof(
     input: BlockRootRollupInputs,
   ): Promise<
     PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return await this.simulate(
-      input,
-      'BlockRootRollupArtifact',
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      convertSimulatedBlockRootRollupInputsToWitnessMap,
-      convertSimulatedBlockRootRollupOutputsFromWitnessMap,
+    return this.applyDelay(ProvingRequestType.BLOCK_ROOT_ROLLUP, () =>
+      this.simulate(
+        input,
+        'BlockRootRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertSimulatedBlockRootRollupInputsToWitnessMap,
+        convertSimulatedBlockRootRollupOutputsFromWitnessMap,
+      ),
     );
   }
 
@@ -212,12 +229,14 @@ export class TestCircuitProver implements ServerCircuitProver {
   ): Promise<
     PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return await this.simulate(
-      input,
-      'SingleTxBlockRootRollupArtifact',
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap,
-      convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap,
+    return await this.applyDelay(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP, () =>
+      this.simulate(
+        input,
+        'SingleTxBlockRootRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap,
+        convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap,
+      ),
     );
   }
 
@@ -227,17 +246,19 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @returns The public inputs as outputs of the simulation.
    */
   @trackSpan('TestCircuitProver.getEmptyBlockRootRollupProof')
-  public async getEmptyBlockRootRollupProof(
+  public getEmptyBlockRootRollupProof(
     input: EmptyBlockRootRollupInputs,
   ): Promise<
     PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return await this.simulate(
-      input,
-      'EmptyBlockRootRollupArtifact',
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      convertEmptyBlockRootRollupInputsToWitnessMap,
-      convertEmptyBlockRootRollupOutputsFromWitnessMap,
+    return this.applyDelay(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, () =>
+      this.simulate(
+        input,
+        'EmptyBlockRootRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertEmptyBlockRootRollupInputsToWitnessMap,
+        convertEmptyBlockRootRollupOutputsFromWitnessMap,
+      ),
     );
   }
 
@@ -247,17 +268,19 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @returns The public inputs as outputs of the simulation.
    */
   @trackSpan('TestCircuitProver.getBlockMergeRollupProof')
-  public async getBlockMergeRollupProof(
+  public getBlockMergeRollupProof(
     input: BlockMergeRollupInputs,
   ): Promise<
     PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
-    return await this.simulate(
-      input,
-      'BlockMergeRollupArtifact',
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      convertBlockMergeRollupInputsToWitnessMap,
-      convertBlockMergeRollupOutputsFromWitnessMap,
+    return this.applyDelay(ProvingRequestType.BLOCK_MERGE_ROLLUP, () =>
+      this.simulate(
+        input,
+        'BlockMergeRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertBlockMergeRollupInputsToWitnessMap,
+        convertBlockMergeRollupOutputsFromWitnessMap,
+      ),
     );
   }
 
@@ -267,35 +290,42 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @returns The public inputs as outputs of the simulation.
    */
   @trackSpan('TestCircuitProver.getRootRollupProof')
-  public async getRootRollupProof(
-    input: RootRollupInputs,
-  ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
-    return await this.simulate(
-      input,
-      'RootRollupArtifact',
-      NESTED_RECURSIVE_PROOF_LENGTH,
-      convertRootRollupInputsToWitnessMap,
-      convertRootRollupOutputsFromWitnessMap,
+  public getRootRollupProof(input: RootRollupInputs): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
+    return this.applyDelay(ProvingRequestType.ROOT_ROLLUP, () =>
+      this.simulate(
+        input,
+        'RootRollupArtifact',
+        NESTED_RECURSIVE_PROOF_LENGTH,
+        convertRootRollupInputsToWitnessMap,
+        convertRootRollupOutputsFromWitnessMap,
+      ),
     );
   }
 
-  public async getAvmProof(
-    _inputs: AvmCircuitInputs,
-  ): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>> {
+  public getAvmProof(_inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>> {
     // 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.');
-    await this.delay();
-    return makeProofAndVerificationKey(
-      makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
-      VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS),
+    return this.applyDelay(ProvingRequestType.PUBLIC_VM, () =>
+      makeProofAndVerificationKey(
+        makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
+        VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS),
+      ),
     );
   }
 
-  private async delay(): Promise<void> {
-    if (this.opts.proverTestDelayMs > 0) {
-      await sleep(this.opts.proverTestDelayMs);
+  private async applyDelay<F extends () => any>(type: ProvingRequestType, fn: F): Promise<Awaited<ReturnType<F>>> {
+    const timer = new Timer();
+    const res = await fn();
+    const duration = timer.ms();
+    if (this.opts.proverTestDelayType === 'fixed') {
+      await sleep(Math.max(0, (this.opts.proverTestDelayMs ?? 0) - duration));
+    } else if (this.opts.proverTestDelayType === 'realistic') {
+      const delay = WITGEN_DELAY_MS[type] + PROOF_DELAY_MS[type];
+      await sleep(Math.max(0, delay * (this.opts.proverTestDelayFactor ?? 1) - duration));
     }
+
+    return res;
   }
 
   // Not implemented for test circuits
@@ -333,7 +363,6 @@ export class TestCircuitProver implements ServerCircuitProver {
 
     this.instrumentation.recordDuration('simulationDuration', circuitName, timer);
     emitCircuitSimulationStats(circuitName, timer.ms(), input.toBuffer().length, result.toBuffer().length, this.logger);
-    await this.delay();
     return makePublicInputsAndRecursiveProof(result, makeRecursiveProof(proofLength), ProtocolCircuitVks[artifactName]);
   }
 }

package/src/test/test_verifier.ts

@@ -1,4 +1,5 @@
-import { type ClientProtocolCircuitVerifier, type Tx } from '@aztec/circuit-types';
+import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import type { Tx } from '@aztec/stdlib/tx';
 
 export class TestCircuitVerifier implements ClientProtocolCircuitVerifier {
   verifyProof(_tx: Tx): Promise<boolean> {

package/src/verification_key/verification_key_data.ts

@@ -1,10 +1,7 @@
-import {
-  AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
-  Fr,
-  VerificationKeyAsFields,
-  VerificationKeyData,
-} from '@aztec/circuits.js';
-import { hashVK } from '@aztec/circuits.js/hash';
+import { AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { hashVK } from '@aztec/stdlib/hash';
+import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
 
 import { strict as assert } from 'assert';
 import { promises as fs } from 'fs';