@aztec/prover-node 0.67.1 → 0.68.1

package/src/factory.ts

@@ -1,5 +1,6 @@
 import { type Archiver, createArchiver } from '@aztec/archiver';
 import { type ProverCoordination, type ProvingJobBroker } from '@aztec/circuit-types';
+import { EpochCache } from '@aztec/epoch-cache';
 import { createEthereumChain } from '@aztec/ethereum';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -12,14 +13,12 @@ import { type TelemetryClient } from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
 
-import { join } from 'path';
 import { createPublicClient, getAddress, getContract, http } from 'viem';
 
 import { createBondManager } from './bond/factory.js';
 import { type ProverNodeConfig, type QuoteProviderConfig } from './config.js';
 import { ClaimsMonitor } from './monitors/claims-monitor.js';
 import { EpochMonitor } from './monitors/epoch-monitor.js';
-import { ProverCacheManager } from './prover-cache/cache_manager.js';
 import { createProverCoordination } from './prover-coordination/factory.js';
 import { ProverNode, type ProverNodeOptions } from './prover-node.js';
 import { HttpQuoteProvider } from './quote-provider/http.js';
@@ -53,12 +52,15 @@ export async function createProverNode(
   // REFACTOR: Move publisher out of sequencer package and into an L1-related package
   const publisher = deps.publisher ?? new L1Publisher(config, telemetry);
 
+  const epochCache = await EpochCache.create(config.l1Contracts.rollupAddress, config);
+
   // If config.p2pEnabled is true, createProverCoordination will create a p2p client where quotes will be shared and tx's requested
   // If config.p2pEnabled is false, createProverCoordination request information from the AztecNode
   const proverCoordination = await createProverCoordination(config, {
     aztecNodeTxProvider: deps.aztecNodeTxProvider,
     worldStateSynchronizer,
     archiver,
+    epochCache,
     telemetry,
   });
 
@@ -71,16 +73,13 @@ export async function createProverNode(
     maxParallelBlocksPerEpoch: config.proverNodeMaxParallelBlocksPerEpoch,
   };
 
-  const claimsMonitor = new ClaimsMonitor(publisher, proverNodeConfig);
-  const epochMonitor = new EpochMonitor(archiver, proverNodeConfig);
+  const claimsMonitor = new ClaimsMonitor(publisher, telemetry, proverNodeConfig);
+  const epochMonitor = new EpochMonitor(archiver, telemetry, proverNodeConfig);
 
   const rollupContract = publisher.getRollupContract();
   const walletClient = publisher.getClient();
   const bondManager = await createBondManager(rollupContract, walletClient, config);
 
-  const cacheDir = config.cacheDir ? join(config.cacheDir, `prover_${config.proverId}`) : undefined;
-  const cacheManager = new ProverCacheManager(cacheDir);
-
   return new ProverNode(
     prover,
     publisher,
@@ -95,7 +94,6 @@ export async function createProverNode(
     epochMonitor,
     bondManager,
     telemetry,
-    cacheManager,
     proverNodeConfig,
   );
 }

package/src/job/epoch-proving-job.ts

@@ -17,6 +17,7 @@ import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { Timer } from '@aztec/foundation/timer';
 import { type L1Publisher } from '@aztec/sequencer-client';
 import { type PublicProcessor, type PublicProcessorFactory } from '@aztec/simulator';
+import { Attributes, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
 import * as crypto from 'node:crypto';
 
@@ -27,13 +28,15 @@ import { type ProverNodeMetrics } from '../metrics.js';
  * re-executes their public calls, generates a rollup proof, and submits it to L1. This job will update the
  * world state as part of public call execution via the public processor.
  */
-export class EpochProvingJob {
+export class EpochProvingJob implements Traceable {
   private state: EpochProvingJobState = 'initialized';
   private log = createLogger('prover-node:epoch-proving-job');
   private uuid: string;
 
   private runPromise: Promise<void> | undefined;
 
+  public readonly tracer: Tracer;
+
   constructor(
     private dbProvider: ForkMerkleTreeOperations,
     private epochNumber: bigint,
@@ -49,6 +52,7 @@ export class EpochProvingJob {
     private cleanUp: (job: EpochProvingJob) => Promise<void> = () => Promise.resolve(),
   ) {
     this.uuid = crypto.randomUUID();
+    this.tracer = metrics.client.getTracer('EpochProvingJob');
   }
 
   public getId(): string {
@@ -62,11 +66,21 @@ export class EpochProvingJob {
   /**
    * Proves the given epoch and submits the proof to L1.
    */
+  @trackSpan('EpochProvingJob.run', function () {
+    return { [Attributes.EPOCH_NUMBER]: Number(this.epochNumber) };
+  })
   public async run() {
     const epochNumber = Number(this.epochNumber);
-    const epochSize = this.blocks.length;
-    const firstBlockNumber = this.blocks[0].number;
-    this.log.info(`Starting epoch proving job`, { firstBlockNumber, epochSize, epochNumber, uuid: this.uuid });
+    const epochSizeBlocks = this.blocks.length;
+    const epochSizeTxs = this.blocks.reduce((total, current) => total + current.body.numberOfTxsIncludingPadded, 0);
+    const [fromBlock, toBlock] = [this.blocks[0].number, this.blocks.at(-1)!.number];
+    this.log.info(`Starting epoch ${epochNumber} proving job with blocks ${fromBlock} to ${toBlock}`, {
+      fromBlock,
+      toBlock,
+      epochSizeBlocks,
+      epochNumber,
+      uuid: this.uuid,
+    });
     this.state = 'processing';
     const timer = new Timer();
 
@@ -74,17 +88,17 @@ export class EpochProvingJob {
     this.runPromise = promise;
 
     try {
-      this.prover.startNewEpoch(epochNumber, firstBlockNumber, epochSize);
+      this.prover.startNewEpoch(epochNumber, fromBlock, epochSizeBlocks);
 
       await asyncPool(this.config.parallelBlockLimit, this.blocks, async block => {
         const globalVariables = block.header.globalVariables;
         const txHashes = block.body.txEffects.map(tx => tx.txHash);
         const txCount = block.body.numberOfTxsIncludingPadded;
         const l1ToL2Messages = await this.getL1ToL2Messages(block);
-        const txs = await this.getTxs(txHashes);
+        const txs = await this.getTxs(txHashes, block.number);
         const previousHeader = await this.getBlockHeader(block.number - 1);
 
-        this.log.verbose(`Starting block processing`, {
+        this.log.verbose(`Starting processing block ${block.number}`, {
           number: block.number,
           blockHash: block.hash().toString(),
           lastArchive: block.header.lastArchive.root,
@@ -95,16 +109,16 @@ export class EpochProvingJob {
           uuid: this.uuid,
           ...globalVariables,
         });
-
         // Start block proving
-        await this.prover.startNewBlock(txCount, globalVariables, l1ToL2Messages);
+        await this.prover.startNewBlock(globalVariables, l1ToL2Messages);
 
         // Process public fns
         const db = await this.dbProvider.fork(block.number - 1);
-        const publicProcessor = this.publicProcessorFactory.create(db, previousHeader, globalVariables);
-        await this.processTxs(publicProcessor, txs, txCount);
+        const publicProcessor = this.publicProcessorFactory.create(db, previousHeader, globalVariables, true);
+        const processed = await this.processTxs(publicProcessor, txs, txCount);
+        await this.prover.addTxs(processed);
         await db.close();
-        this.log.verbose(`Processed all txs for block`, {
+        this.log.verbose(`Processed all ${txs.length} txs for block ${block.number}`, {
           blockNumber: block.number,
           blockHash: block.hash().toString(),
           uuid: this.uuid,
@@ -116,17 +130,16 @@ export class EpochProvingJob {
 
       this.state = 'awaiting-prover';
       const { publicInputs, proof } = await this.prover.finaliseEpoch();
-      this.log.info(`Finalised proof for epoch`, { epochNumber, uuid: this.uuid, duration: timer.ms() });
+      this.log.info(`Finalised proof for epoch ${epochNumber}`, { epochNumber, uuid: this.uuid, duration: timer.ms() });
 
       this.state = 'publishing-proof';
-      const [fromBlock, toBlock] = [this.blocks[0].number, this.blocks.at(-1)!.number];
       await this.publisher.submitEpochProof({ fromBlock, toBlock, epochNumber, publicInputs, proof });
       this.log.info(`Submitted proof for epoch`, { epochNumber, uuid: this.uuid });
 
       this.state = 'completed';
-      this.metrics.recordProvingJob(timer);
+      this.metrics.recordProvingJob(timer, epochSizeBlocks, epochSizeTxs);
     } catch (err) {
-      this.log.error(`Error running epoch prover job`, err, { uuid: this.uuid });
+      this.log.error(`Error running epoch ${epochNumber} prover job`, err, { uuid: this.uuid, epochNumber });
       this.state = 'failed';
     } finally {
       await this.cleanUp(this);
@@ -149,13 +162,15 @@ export class EpochProvingJob {
     return this.l2BlockSource.getBlockHeader(blockNumber);
   }
 
-  private async getTxs(txHashes: TxHash[]): Promise<Tx[]> {
+  private async getTxs(txHashes: TxHash[], blockNumber: number): Promise<Tx[]> {
     const txs = await Promise.all(
       txHashes.map(txHash => this.coordination.getTxByHash(txHash).then(tx => [txHash, tx] as const)),
     );
     const notFound = txs.filter(([_, tx]) => !tx);
     if (notFound.length) {
-      throw new Error(`Txs not found: ${notFound.map(([txHash]) => txHash.toString()).join(', ')}`);
+      throw new Error(
+        `Txs not found for block ${blockNumber}: ${notFound.map(([txHash]) => txHash.toString()).join(', ')}`,
+      );
     }
     return txs.map(([_, tx]) => tx!);
   }
@@ -169,12 +184,7 @@ export class EpochProvingJob {
     txs: Tx[],
     totalNumberOfTxs: number,
   ): Promise<ProcessedTx[]> {
-    const [processedTxs, failedTxs] = await publicProcessor.process(
-      txs,
-      totalNumberOfTxs,
-      this.prover,
-      new EmptyTxValidator(),
-    );
+    const [processedTxs, failedTxs] = await publicProcessor.process(txs, totalNumberOfTxs, new EmptyTxValidator());
 
     if (failedTxs.length) {
       throw new Error(

package/src/metrics.ts

@@ -3,18 +3,30 @@ import { type Histogram, Metrics, type TelemetryClient, ValueType } from '@aztec
 
 export class ProverNodeMetrics {
   provingJobDuration: Histogram;
+  provingJobBlocks: Histogram;
+  provingJobTransactions: Histogram;
 
-  constructor(client: TelemetryClient, name = 'ProverNode') {
+  constructor(public readonly client: TelemetryClient, name = 'ProverNode') {
     const meter = client.getMeter(name);
     this.provingJobDuration = meter.createHistogram(Metrics.PROVER_NODE_JOB_DURATION, {
       description: 'Duration of proving job',
       unit: 'ms',
       valueType: ValueType.INT,
     });
+    this.provingJobBlocks = meter.createHistogram(Metrics.PROVER_NODE_JOB_BLOCKS, {
+      description: 'Number of blocks in a proven epoch',
+      valueType: ValueType.INT,
+    });
+    this.provingJobTransactions = meter.createHistogram(Metrics.PROVER_NODE_JOB_TRANSACTIONS, {
+      description: 'Number of transactions in a proven epoch',
+      valueType: ValueType.INT,
+    });
   }
 
-  public recordProvingJob(timerOrMs: Timer | number) {
+  public recordProvingJob(timerOrMs: Timer | number, numBlocks: number, numTxs: number) {
     const ms = Math.ceil(typeof timerOrMs === 'number' ? timerOrMs : timerOrMs.ms());
     this.provingJobDuration.record(ms);
+    this.provingJobBlocks.record(Math.floor(numBlocks));
+    this.provingJobTransactions.record(Math.floor(numTxs));
   }
 }

package/src/monitors/claims-monitor.ts

@@ -3,20 +3,28 @@ import { type EthAddress } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { type L1Publisher } from '@aztec/sequencer-client';
+import { type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
 export interface ClaimsMonitorHandler {
   handleClaim(proofClaim: EpochProofClaim): Promise<void>;
 }
 
-export class ClaimsMonitor {
+export class ClaimsMonitor implements Traceable {
   private runningPromise: RunningPromise;
   private log = createLogger('prover-node:claims-monitor');
 
   private handler: ClaimsMonitorHandler | undefined;
   private lastClaimEpochNumber: bigint | undefined;
 
-  constructor(private readonly l1Publisher: L1Publisher, private options: { pollingIntervalMs: number }) {
-    this.runningPromise = new RunningPromise(this.work.bind(this), this.options.pollingIntervalMs);
+  public readonly tracer: Tracer;
+
+  constructor(
+    private readonly l1Publisher: L1Publisher,
+    telemetry: TelemetryClient,
+    private options: { pollingIntervalMs: number },
+  ) {
+    this.tracer = telemetry.getTracer('ClaimsMonitor');
+    this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.options.pollingIntervalMs);
   }
 
   public start(handler: ClaimsMonitorHandler) {
@@ -31,9 +39,11 @@ export class ClaimsMonitor {
     this.log.info('Stopped ClaimsMonitor');
   }
 
+  @trackSpan('ClaimsMonitor.work')
   public async work() {
     const proofClaim = await this.l1Publisher.getProofClaim();
     if (!proofClaim) {
+      this.log.trace(`Found no proof claim`);
       return;
     }
 

package/src/monitors/epoch-monitor.ts

@@ -1,22 +1,29 @@
 import { type L2BlockSource } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import { type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
 export interface EpochMonitorHandler {
   handleInitialEpochSync(epochNumber: bigint): Promise<void>;
   handleEpochCompleted(epochNumber: bigint): Promise<void>;
 }
 
-export class EpochMonitor {
+export class EpochMonitor implements Traceable {
   private runningPromise: RunningPromise;
   private log = createLogger('prover-node:epoch-monitor');
+  public readonly tracer: Tracer;
 
   private handler: EpochMonitorHandler | undefined;
 
   private latestEpochNumber: bigint | undefined;
 
-  constructor(private readonly l2BlockSource: L2BlockSource, private options: { pollingIntervalMs: number }) {
-    this.runningPromise = new RunningPromise(this.work.bind(this), this.options.pollingIntervalMs);
+  constructor(
+    private readonly l2BlockSource: L2BlockSource,
+    telemetry: TelemetryClient,
+    private options: { pollingIntervalMs: number },
+  ) {
+    this.tracer = telemetry.getTracer('EpochMonitor');
+    this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.options.pollingIntervalMs);
   }
 
   public start(handler: EpochMonitorHandler) {
@@ -30,6 +37,7 @@ export class EpochMonitor {
     this.log.info('Stopped EpochMonitor');
   }
 
+  @trackSpan('EpochMonitor.work')
   public async work() {
     if (!this.latestEpochNumber) {
       const epochNumber = await this.l2BlockSource.getL2EpochNumber();

package/src/prover-coordination/factory.ts

@@ -1,6 +1,12 @@
 import { type ArchiveSource, type Archiver } from '@aztec/archiver';
 import { BBCircuitVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
-import { type ProverCoordination, type WorldStateSynchronizer, createAztecNodeClient } from '@aztec/circuit-types';
+import {
+  P2PClientType,
+  type ProverCoordination,
+  type WorldStateSynchronizer,
+  createAztecNodeClient,
+} from '@aztec/circuit-types';
+import { type EpochCache } from '@aztec/epoch-cache';
 import { createLogger } from '@aztec/foundation/log';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { createP2PClient } from '@aztec/p2p';
@@ -14,6 +20,7 @@ type ProverCoordinationDeps = {
   worldStateSynchronizer?: WorldStateSynchronizer;
   archiver?: Archiver | ArchiveSource;
   telemetry?: TelemetryClient;
+  epochCache?: EpochCache;
 };
 
 /**
@@ -36,16 +43,18 @@ export async function createProverCoordination(
   if (config.p2pEnabled) {
     log.info('Using prover coordination via p2p');
 
-    if (!deps.archiver || !deps.worldStateSynchronizer || !deps.telemetry) {
+    if (!deps.archiver || !deps.worldStateSynchronizer || !deps.telemetry || !deps.epochCache) {
       throw new Error('Missing dependencies for p2p prover coordination');
     }
 
     const proofVerifier = config.realProofs ? await BBCircuitVerifier.new(config) : new TestCircuitVerifier();
     const p2pClient = await createP2PClient(
+      P2PClientType.Prover,
       config,
       deps.archiver,
       proofVerifier,
       deps.worldStateSynchronizer,
+      deps.epochCache,
       deps.telemetry,
     );
     await p2pClient.start();

package/src/prover-node.ts

@@ -6,7 +6,7 @@ import {
   type L1ToL2MessageSource,
   type L2Block,
   type L2BlockSource,
-  type ProverCache,
+  type P2PClientType,
   type ProverCoordination,
   type ProverNodeApi,
   type Service,
@@ -15,20 +15,19 @@ import {
 } from '@aztec/circuit-types';
 import { type ContractDataSource } from '@aztec/circuits.js';
 import { compact } from '@aztec/foundation/collection';
-import { sha256 } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 import { type Maybe } from '@aztec/foundation/types';
 import { type P2P } from '@aztec/p2p';
 import { type L1Publisher } from '@aztec/sequencer-client';
 import { PublicProcessorFactory } from '@aztec/simulator';
-import { type TelemetryClient } from '@aztec/telemetry-client';
+import { Attributes, type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
 import { type BondManager } from './bond/bond-manager.js';
 import { EpochProvingJob, type EpochProvingJobState } from './job/epoch-proving-job.js';
 import { ProverNodeMetrics } from './metrics.js';
 import { type ClaimsMonitor, type ClaimsMonitorHandler } from './monitors/claims-monitor.js';
 import { type EpochMonitor, type EpochMonitorHandler } from './monitors/epoch-monitor.js';
-import { type ProverCacheManager } from './prover-cache/cache_manager.js';
 import { type QuoteProvider } from './quote-provider/index.js';
 import { type QuoteSigner } from './quote-signer.js';
 
@@ -44,14 +43,17 @@ export type ProverNodeOptions = {
  * from a tx source in the p2p network or an external node, re-executes their public functions, creates a rollup
  * proof for the epoch, and submits it to L1.
  */
-export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, ProverNodeApi {
+export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, ProverNodeApi, Traceable {
   private log = createLogger('prover-node');
+  private dateProvider = new DateProvider();
 
   private latestEpochWeAreProving: bigint | undefined;
   private jobs: Map<string, EpochProvingJob> = new Map();
   private options: ProverNodeOptions;
   private metrics: ProverNodeMetrics;
 
+  public readonly tracer: Tracer;
+
   constructor(
     private readonly prover: EpochProverManager,
     private readonly publisher: L1Publisher,
@@ -66,7 +68,6 @@ export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, Pr
     private readonly epochsMonitor: EpochMonitor,
     private readonly bondManager: BondManager,
     private readonly telemetryClient: TelemetryClient,
-    private readonly proverCacheManager: ProverCacheManager,
     options: Partial<ProverNodeOptions> = {},
   ) {
     this.options = {
@@ -77,10 +78,11 @@ export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, Pr
     };
 
     this.metrics = new ProverNodeMetrics(telemetryClient, 'ProverNode');
+    this.tracer = telemetryClient.getTracer('ProverNode');
   }
 
   public getP2P() {
-    const asP2PClient = this.coordination as P2P;
+    const asP2PClient = this.coordination as P2P<P2PClientType.Prover>;
     if (typeof asP2PClient.isP2PClient === 'function' && asP2PClient.isP2PClient()) {
       return asP2PClient;
     }
@@ -93,6 +95,12 @@ export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, Pr
       return;
     }
 
+    const provenEpoch = await this.l2BlockSource.getProvenL2EpochNumber();
+    if (provenEpoch !== undefined && proofClaim.epochToProve <= provenEpoch) {
+      this.log.verbose(`Claim for epoch ${proofClaim.epochToProve} is already proven`);
+      return;
+    }
+
     try {
       await this.startProof(proofClaim.epochToProve);
       this.latestEpochWeAreProving = proofClaim.epochToProve;
@@ -117,12 +125,8 @@ export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, Pr
     try {
       const claim = await this.publisher.getProofClaim();
       if (!claim || claim.epochToProve < epochNumber) {
+        this.log.verbose(`Handling epoch ${epochNumber} completed as initial sync`);
         await this.handleEpochCompleted(epochNumber);
-      } else if (claim && claim.bondProvider.equals(this.publisher.getSenderAddress())) {
-        const lastEpochProven = await this.l2BlockSource.getProvenL2EpochNumber();
-        if (lastEpochProven === undefined || lastEpochProven < claim.epochToProve) {
-          await this.handleClaim(claim);
-        }
       }
     } catch (err) {
       this.log.error(`Error handling initial epoch sync`, err);
@@ -245,6 +249,7 @@ export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, Pr
     return maxPendingJobs === 0 || this.jobs.size < maxPendingJobs;
   }
 
+  @trackSpan('ProverNode.createProvingJob', epochNumber => ({ [Attributes.EPOCH_NUMBER]: Number(epochNumber) }))
   private async createProvingJob(epochNumber: bigint) {
     if (!this.checkMaximumPendingJobs()) {
       throw new Error(`Maximum pending proving jobs ${this.options.maxPendingJobs} reached. Cannot create new job.`);
@@ -263,18 +268,18 @@ export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, Pr
     await this.worldState.syncImmediate(fromBlock - 1);
 
     // Create a processor using the forked world state
-    const publicProcessorFactory = new PublicProcessorFactory(this.contractDataSource, this.telemetryClient);
-
-    const epochHash = sha256(Buffer.concat(blocks.map(block => block.hash().toBuffer())));
-    const proverCache = await this.proverCacheManager.openCache(epochNumber, epochHash);
+    const publicProcessorFactory = new PublicProcessorFactory(
+      this.contractDataSource,
+      this.dateProvider,
+      this.telemetryClient,
+    );
 
-    const cleanUp = async () => {
-      await proverCache.close();
-      await this.proverCacheManager.removeStaleCaches(epochNumber);
+    const cleanUp = () => {
       this.jobs.delete(job.getId());
+      return Promise.resolve();
     };
 
-    const job = this.doCreateEpochProvingJob(epochNumber, blocks, proverCache, publicProcessorFactory, cleanUp);
+    const job = this.doCreateEpochProvingJob(epochNumber, blocks, publicProcessorFactory, cleanUp);
     this.jobs.set(job.getId(), job);
     return job;
   }
@@ -283,7 +288,6 @@ export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, Pr
   protected doCreateEpochProvingJob(
     epochNumber: bigint,
     blocks: L2Block[],
-    proverCache: ProverCache,
     publicProcessorFactory: PublicProcessorFactory,
     cleanUp: () => Promise<void>,
   ) {
@@ -291,7 +295,7 @@ export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, Pr
       this.worldState,
       epochNumber,
       blocks,
-      this.prover.createEpochProver(proverCache),
+      this.prover.createEpochProver(),
       publicProcessorFactory,
       this.publisher,
       this.l2BlockSource,

package/dest/prover-cache/cache_manager.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import { type ProverCache } from '@aztec/circuit-types';
-export declare class ProverCacheManager {
-    private cacheDir?;
-    private log;
-    constructor(cacheDir?: string | undefined, log?: import("@aztec/foundation/log").Logger);
-    openCache(epochNumber: bigint, epochHash: Buffer): Promise<ProverCache>;
-    /**
-     * Removes all caches for epochs older than the given epoch (including)
-     * @param upToAndIncludingEpoch - The epoch number up to which to remove caches
-     */
-    removeStaleCaches(upToAndIncludingEpoch: bigint): Promise<void>;
-}
-//# sourceMappingURL=cache_manager.d.ts.map

package/dest/prover-cache/cache_manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache_manager.d.ts","sourceRoot":"","sources":["../../src/prover-cache/cache_manager.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAexD,qBAAa,kBAAkB;IACjB,OAAO,CAAC,QAAQ,CAAC;IAAU,OAAO,CAAC,GAAG;gBAA9B,QAAQ,CAAC,oBAAQ,EAAU,GAAG,yCAA4C;IAEjF,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAsBpF;;;OAGG;IACU,iBAAiB,CAAC,qBAAqB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAwB7E"}

package/dest/prover-cache/cache_manager.js

@@ -1,57 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { AztecLmdbStore } from '@aztec/kv-store/lmdb';
-import { InMemoryProverCache } from '@aztec/prover-client';
-import { mkdir, readFile, readdir, rm, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { KVProverCache } from './kv_cache.js';
-const EPOCH_DIR_PREFIX = 'epoch';
-const EPOCH_DIR_SEPARATOR = '_';
-const EPOCH_HASH_FILENAME = 'epoch_hash.txt';
-export class ProverCacheManager {
-    constructor(cacheDir, log = createLogger('prover-node:cache-manager')) {
-        this.cacheDir = cacheDir;
-        this.log = log;
-    }
-    async openCache(epochNumber, epochHash) {
-        if (!this.cacheDir) {
-            return new InMemoryProverCache();
-        }
-        const epochDir = EPOCH_DIR_PREFIX + EPOCH_DIR_SEPARATOR + epochNumber;
-        const dataDir = join(this.cacheDir, epochDir);
-        const storedEpochHash = await readFile(join(dataDir, EPOCH_HASH_FILENAME), 'hex').catch(() => Buffer.alloc(0));
-        if (storedEpochHash.toString() !== epochHash.toString()) {
-            await rm(dataDir, { recursive: true, force: true });
-        }
-        await mkdir(dataDir, { recursive: true });
-        await writeFile(join(dataDir, EPOCH_HASH_FILENAME), epochHash.toString('hex'));
-        const store = AztecLmdbStore.open(dataDir);
-        this.log.debug(`Created new database for epoch ${epochNumber} at ${dataDir}`);
-        const cleanup = () => store.close();
-        return new KVProverCache(store, cleanup);
-    }
-    /**
-     * Removes all caches for epochs older than the given epoch (including)
-     * @param upToAndIncludingEpoch - The epoch number up to which to remove caches
-     */
-    async removeStaleCaches(upToAndIncludingEpoch) {
-        if (!this.cacheDir) {
-            return;
-        }
-        const entries = await readdir(this.cacheDir, { withFileTypes: true }).catch(() => []);
-        for (const item of entries) {
-            if (!item.isDirectory()) {
-                continue;
-            }
-            const [prefix, epochNumber] = item.name.split(EPOCH_DIR_SEPARATOR);
-            if (prefix !== EPOCH_DIR_PREFIX) {
-                continue;
-            }
-            const epochNumberInt = BigInt(epochNumber);
-            if (epochNumberInt <= upToAndIncludingEpoch) {
-                this.log.info(`Removing old epoch database for epoch ${epochNumberInt} at ${join(this.cacheDir, item.name)}`);
-                await rm(join(this.cacheDir, item.name), { recursive: true });
-            }
-        }
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dest/prover-cache/kv_cache.d.ts

@@ -1,11 +0,0 @@
-import type { ProverCache, ProvingJobStatus } from '@aztec/circuit-types';
-import type { AztecKVStore } from '@aztec/kv-store';
-export declare class KVProverCache implements ProverCache {
-    private cleanup?;
-    private proofs;
-    constructor(store: AztecKVStore, cleanup?: (() => Promise<void>) | undefined);
-    getProvingJobStatus(jobId: string): Promise<ProvingJobStatus>;
-    setProvingJobStatus(jobId: string, status: ProvingJobStatus): Promise<void>;
-    close(): Promise<void>;
-}
-//# sourceMappingURL=kv_cache.d.ts.map

package/dest/prover-cache/kv_cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kv_cache.d.ts","sourceRoot":"","sources":["../../src/prover-cache/kv_cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAY,MAAM,iBAAiB,CAAC;AAE9D,qBAAa,aAAc,YAAW,WAAW;IAGd,OAAO,CAAC,OAAO,CAAC;IAFjD,OAAO,CAAC,MAAM,CAA2B;gBAE7B,KAAK,EAAE,YAAY,EAAU,OAAO,CAAC,SAAQ,QAAQ,IAAI,CAAC,aAAA;IAItE,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAS7D,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dest/prover-cache/kv_cache.js

@@ -1,20 +0,0 @@
-export class KVProverCache {
-    constructor(store, cleanup) {
-        this.cleanup = cleanup;
-        this.proofs = store.openMap('prover_node_proof_status');
-    }
-    getProvingJobStatus(jobId) {
-        const item = this.proofs.get(jobId);
-        if (!item) {
-            return Promise.resolve({ status: 'not-found' });
-        }
-        return Promise.resolve(JSON.parse(item));
-    }
-    setProvingJobStatus(jobId, status) {
-        return this.proofs.set(jobId, JSON.stringify(status));
-    }
-    async close() {
-        await this.cleanup?.();
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia3ZfY2FjaGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmVyLWNhY2hlL2t2X2NhY2hlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyxhQUFhO0lBR3hCLFlBQVksS0FBbUIsRUFBVSxPQUE2QjtRQUE3QixZQUFPLEdBQVAsT0FBTyxDQUFzQjtRQUNwRSxJQUFJLENBQUMsTUFBTSxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsMEJBQTBCLENBQUMsQ0FBQztJQUMxRCxDQUFDO0lBRUQsbUJBQW1CLENBQUMsS0FBYTtRQUMvQixNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNwQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDVixPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLENBQUMsQ0FBQztRQUNsRCxDQUFDO1FBRUQsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBRUQsbUJBQW1CLENBQUMsS0FBYSxFQUFFLE1BQXdCO1FBQ3pELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztJQUN4RCxDQUFDO0lBRUQsS0FBSyxDQUFDLEtBQUs7UUFDVCxNQUFNLElBQUksQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDO0lBQ3pCLENBQUM7Q0FDRiJ9