@aztec/prover-client 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/test/mock_prover.ts

@@ -4,12 +4,10 @@ import {
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 import { times } from '@aztec/foundation/collection';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import {
-  type ProofAndVerificationKey,
   type ProvingJob,
   type ProvingJobId,
   type ProvingJobProducer,
@@ -19,27 +17,37 @@ import {
   makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
-import type { BaseParityInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import type { ParityBasePrivateInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
 import { makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
 import type {
-  BaseOrMergeRollupPublicInputs,
-  BlockMergeRollupInputs,
-  BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
-  MergeRollupInputs,
-  PaddingBlockRootRollupInputs,
-  PrivateBaseRollupInputs,
-  PublicBaseRollupInputs,
-  RootRollupInputs,
+  BlockMergeRollupPrivateInputs,
+  BlockRollupPublicInputs,
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+  CheckpointMergeRollupPrivateInputs,
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRollupPublicInputs,
+  CheckpointRootRollupPrivateInputs,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+  PrivateTxBaseRollupPrivateInputs,
+  PublicChonkVerifierPrivateInputs,
+  PublicChonkVerifierPublicInputs,
+  PublicTxBaseRollupPrivateInputs,
+  RootRollupPrivateInputs,
   RootRollupPublicInputs,
-  SingleTxBlockRootRollupInputs,
+  TxMergeRollupPrivateInputs,
+  TxRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 import {
-  makeBaseOrMergeRollupPublicInputs,
-  makeBlockRootOrBlockMergeRollupPublicInputs,
+  makeBlockRollupPublicInputs,
+  makeCheckpointRollupPublicInputs,
   makeParityPublicInputs,
+  makePublicChonkVerifierPublicInputs,
   makeRootRollupPublicInputs,
+  makeTxRollupPublicInputs,
 } from '@aztec/stdlib/testing';
 import { VerificationKeyData } from '@aztec/stdlib/vks';
 
@@ -97,12 +105,7 @@ export class TestBroker implements ProvingJobProducer {
 export class MockProver implements ServerCircuitProver {
   constructor() {}
 
-  getAvmProof(
-    _inputs: AvmCircuitInputs,
-    _skipPublicInputsValidation?: boolean, // TODO(#14234)[Unconditional PIs validation]: Remove.
-    _signal?: AbortSignal,
-    _epochNumber?: number,
-  ) {
+  getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makeProofAndVerificationKey(
         makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
@@ -111,7 +114,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBaseParityProof(_inputs: BaseParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -121,7 +124,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getRootParityProof(_inputs: RootParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getRootParityProof(_inputs: ParityRootPrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -131,130 +134,210 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getPrivateBaseRollupProof(
-    _baseRollupInput: PrivateBaseRollupInputs,
+  getPublicChonkVerifierProof(
+    _inputs: PublicChonkVerifierPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBaseOrMergeRollupPublicInputs(),
+        makePublicChonkVerifierPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getPublicBaseRollupProof(
-    _inputs: PublicBaseRollupInputs,
+  getPrivateTxBaseRollupProof(
+    _baseRollupInput: PrivateTxBaseRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBaseOrMergeRollupPublicInputs(),
+        makeTxRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getMergeRollupProof(
-    _input: MergeRollupInputs,
+  getPublicTxBaseRollupProof(
+    _inputs: PublicTxBaseRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBaseOrMergeRollupPublicInputs(),
+        makeTxRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getBlockMergeRollupProof(_input: BlockMergeRollupInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getTxMergeRollupProof(
+    _input: TxMergeRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeTxRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getBlockRootFirstRollupProof(
+    _input: BlockRootFirstRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeBlockRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getEmptyBlockRootRollupProof(
-    _input: EmptyBlockRootRollupInputs,
+  getBlockRootSingleTxFirstRollupProof(
+    _input: BlockRootSingleTxFirstRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getBlockRootEmptyTxFirstRollupProof(
+    _input: BlockRootEmptyTxFirstRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getBlockRootRollupProof(
+    _input: BlockRootRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getBlockRootSingleTxRollupProof(
+    _input: BlockRootSingleTxRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getBlockMergeRollupProof(_input: BlockMergeRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getCheckpointRootRollupProof(
+    _input: CheckpointRootRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getPaddingBlockRootRollupProof(
-    _input: PaddingBlockRootRollupInputs,
+  getCheckpointRootSingleBlockRollupProof(
+    _input: CheckpointRootSingleBlockRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getBlockRootRollupProof(
-    _input: BlockRootRollupInputs,
+  getCheckpointMergeRollupProof(
+    _input: CheckpointMergeRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getSingleTxBlockRootRollupProof(
-    _input: SingleTxBlockRootRollupInputs,
+  getCheckpointPaddingRollupProof(
+    _input: CheckpointPaddingRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-        VerificationKeyData.makeFakeHonk(),
+        VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
   getRootRollupProof(
-    _input: RootRollupInputs,
+    _input: RootRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
@@ -266,10 +349,4 @@ export class MockProver implements ServerCircuitProver {
       ),
     );
   }
-
-  getTubeProof(): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    return Promise.resolve(
-      makeProofAndVerificationKey(makeRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()),
-    );
-  }
 }

package/dest/bin/get-proof-inputs.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=get-proof-inputs.d.ts.map

package/dest/bin/get-proof-inputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-proof-inputs.d.ts","sourceRoot":"","sources":["../../src/bin/get-proof-inputs.ts"],"names":[],"mappings":""}

package/dest/bin/get-proof-inputs.js

@@ -1,51 +0,0 @@
-/* eslint-disable no-console */ import { AVM_INPUTS_FILENAME } from '@aztec/bb-prover';
-import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
-import { createLogger } from '@aztec/foundation/log';
-import { ProvingJobInputs } from '@aztec/stdlib/interfaces/server';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
-import { mkdirSync, writeFileSync } from 'fs';
-import { createProofStoreForUri } from '../proving_broker/index.js';
-const logger = createLogger('prover-client:get-proof-inputs');
-function printUsage() {
-    console.error('Usage: get-proof-inputs <proof-uri> [out-dir=.]');
-}
-async function main() {
-    if (process.argv[2] === '--help') {
-        printUsage();
-        return;
-    }
-    const uri = process.argv[2];
-    const outDir = process.argv[3] || '.';
-    if (!uri) {
-        printUsage();
-        throw new Error('Missing proof URI');
-    }
-    mkdirSync(outDir, {
-        recursive: true
-    });
-    const proofStore = createProofStoreForUri(uri);
-    logger.info(`Processing uri ${uri}`);
-    const input = await proofStore.getProofInput(uri);
-    logger.info(`Found inputs for ${ProvingRequestType[input.type]}`);
-    writeProofInputs(input, outDir);
-    console.log(jsonParseWithSchema(jsonStringify(input), ProvingJobInputs).inputs);
-}
-// This mimics the behavior of bb-prover/src/bb/execute.ts
-function writeProofInputs(input, outDir) {
-    switch(input.type){
-        case ProvingRequestType.PUBLIC_VM:
-            {
-                writeFileSync(`${outDir}/${AVM_INPUTS_FILENAME}`, input.inputs.serializeWithMessagePack());
-                logger.info(`Wrote AVM inputs to ${AVM_INPUTS_FILENAME}`);
-                break;
-            }
-        default:
-            {
-                throw new Error(`Unimplemented proving request type: ${ProvingRequestType[input.type]}`);
-            }
-    }
-}
-main().catch((err)=>{
-    console.error(err);
-    process.exit(1);
-});

package/dest/proving_broker/proving_agent_instrumentation.d.ts

@@ -1,8 +0,0 @@
-import type { Timer } from '@aztec/foundation/timer';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-export declare class ProvingAgentInstrumentation {
-    private idleTime;
-    constructor(client: TelemetryClient, name?: string);
-    recordIdleTime(msOrTimer: Timer | number): void;
-}
-//# sourceMappingURL=proving_agent_instrumentation.d.ts.map

package/dest/proving_broker/proving_agent_instrumentation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proving_agent_instrumentation.d.ts","sourceRoot":"","sources":["../../src/proving_broker/proving_agent_instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAA2B,KAAK,eAAe,EAAa,MAAM,yBAAyB,CAAC;AAEnG,qBAAa,2BAA2B;IACtC,OAAO,CAAC,QAAQ,CAAY;gBAEhB,MAAM,EAAE,eAAe,EAAE,IAAI,SAAiB;IAU1D,cAAc,CAAC,SAAS,EAAE,KAAK,GAAG,MAAM;CAIzC"}

package/dest/proving_broker/proving_agent_instrumentation.js

@@ -1,16 +0,0 @@
-import { Metrics, ValueType } from '@aztec/telemetry-client';
-export class ProvingAgentInstrumentation {
-    idleTime;
-    constructor(client, name = 'ProvingAgent'){
-        const meter = client.getMeter(name);
-        this.idleTime = meter.createHistogram(Metrics.PROVING_AGENT_IDLE, {
-            description: 'Records how long an agent was idle',
-            unit: 's',
-            valueType: ValueType.DOUBLE
-        });
-    }
-    recordIdleTime(msOrTimer) {
-        const duration = typeof msOrTimer === 'number' ? msOrTimer : msOrTimer.ms();
-        this.idleTime.record(duration / 1000);
-    }
-}

package/src/bin/get-proof-inputs.ts

@@ -1,59 +0,0 @@
-/* eslint-disable no-console */
-import { AVM_INPUTS_FILENAME } from '@aztec/bb-prover';
-import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
-import { createLogger } from '@aztec/foundation/log';
-import { type ProofUri, ProvingJobInputs } from '@aztec/stdlib/interfaces/server';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
-
-import { mkdirSync, writeFileSync } from 'fs';
-
-import { createProofStoreForUri } from '../proving_broker/index.js';
-
-const logger = createLogger('prover-client:get-proof-inputs');
-
-function printUsage() {
-  console.error('Usage: get-proof-inputs <proof-uri> [out-dir=.]');
-}
-
-async function main() {
-  if (process.argv[2] === '--help') {
-    printUsage();
-    return;
-  }
-
-  const uri = process.argv[2];
-  const outDir = process.argv[3] || '.';
-  if (!uri) {
-    printUsage();
-    throw new Error('Missing proof URI');
-  }
-
-  mkdirSync(outDir, { recursive: true });
-
-  const proofStore = createProofStoreForUri(uri);
-  logger.info(`Processing uri ${uri}`);
-  const input = await proofStore.getProofInput(uri as ProofUri);
-  logger.info(`Found inputs for ${ProvingRequestType[input.type]}`);
-  writeProofInputs(input, outDir);
-
-  console.log(jsonParseWithSchema(jsonStringify(input), ProvingJobInputs).inputs);
-}
-
-// This mimics the behavior of bb-prover/src/bb/execute.ts
-function writeProofInputs(input: ProvingJobInputs, outDir: string) {
-  switch (input.type) {
-    case ProvingRequestType.PUBLIC_VM: {
-      writeFileSync(`${outDir}/${AVM_INPUTS_FILENAME}`, input.inputs.serializeWithMessagePack());
-      logger.info(`Wrote AVM inputs to ${AVM_INPUTS_FILENAME}`);
-      break;
-    }
-    default: {
-      throw new Error(`Unimplemented proving request type: ${ProvingRequestType[input.type]}`);
-    }
-  }
-}
-
-main().catch(err => {
-  console.error(err);
-  process.exit(1);
-});

package/src/proving_broker/proving_agent_instrumentation.ts

@@ -1,21 +0,0 @@
-import type { Timer } from '@aztec/foundation/timer';
-import { type Histogram, Metrics, type TelemetryClient, ValueType } from '@aztec/telemetry-client';
-
-export class ProvingAgentInstrumentation {
-  private idleTime: Histogram;
-
-  constructor(client: TelemetryClient, name = 'ProvingAgent') {
-    const meter = client.getMeter(name);
-
-    this.idleTime = meter.createHistogram(Metrics.PROVING_AGENT_IDLE, {
-      description: 'Records how long an agent was idle',
-      unit: 's',
-      valueType: ValueType.DOUBLE,
-    });
-  }
-
-  recordIdleTime(msOrTimer: Timer | number) {
-    const duration = typeof msOrTimer === 'number' ? msOrTimer : msOrTimer.ms();
-    this.idleTime.record(duration / 1000);
-  }
-}