@aztec/prover-node 0.0.1-commit.b9865e97 → 0.0.1-commit.be03c316

package/dest/test/index.d.ts

@@ -1,12 +1,13 @@
+import type { EpochProverFactory } from '@aztec/prover-client';
 import type { EpochProverManager } from '@aztec/stdlib/interfaces/server';
-import type { EpochProvingJob } from '../job/epoch-proving-job.js';
-import type { ProverNodePublisher } from '../prover-node-publisher.js';
+import type { ProofPublishingService } from '../proof-publishing-service.js';
 import { ProverNode } from '../prover-node.js';
+import type { SessionManager } from '../session-manager.js';
 declare abstract class TestProverNodeClass extends ProverNode {
-    prover: EpochProverManager;
-    publisher: ProverNodePublisher;
-    abstract tryUploadEpochFailure(job: EpochProvingJob): Promise<string | undefined>;
+    prover: EpochProverManager & EpochProverFactory;
+    publishingService: ProofPublishingService;
+    sessionManager: SessionManager;
 }
 export type TestProverNode = TestProverNodeClass;
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFMUUsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDbkUsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUN2RSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFL0MsdUJBQWUsbUJBQW9CLFNBQVEsVUFBVTtJQUNwQyxNQUFNLEVBQUUsa0JBQWtCLENBQUM7SUFDM0IsU0FBUyxFQUFFLG1CQUFtQixDQUFDO0lBRTlDLFNBQXlCLHFCQUFxQixDQUFDLEdBQUcsRUFBRSxlQUFlLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FBQztDQUNuRztBQUVELE1BQU0sTUFBTSxjQUFjLEdBQUcsbUJBQW1CLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDL0QsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUUxRSxPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzdFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUU1RCx1QkFBZSxtQkFBb0IsU0FBUSxVQUFVO0lBQ3BDLE1BQU0sRUFBRSxrQkFBa0IsR0FBRyxrQkFBa0IsQ0FBQztJQUNoRCxpQkFBaUIsRUFBRSxzQkFBc0IsQ0FBQztJQUMxQyxjQUFjLEVBQUUsY0FBYyxDQUFDO0NBQy9DO0FBRUQsTUFBTSxNQUFNLGNBQWMsR0FBRyxtQkFBbUIsQ0FBQyJ9

package/dest/test/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,uBAAe,mBAAoB,SAAQ,UAAU;IACpC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,SAAS,EAAE,mBAAmB,CAAC;IAE9C,SAAyB,qBAAqB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CACnG;AAED,MAAM,MAAM,cAAc,GAAG,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,uBAAe,mBAAoB,SAAQ,UAAU;IACpC,MAAM,EAAE,kBAAkB,GAAG,kBAAkB,CAAC;IAChD,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,cAAc,EAAE,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,cAAc,GAAG,mBAAmB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/prover-node",
-  "version": "0.0.1-commit.b9865e97",
+  "version": "0.0.1-commit.be03c316",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -56,28 +56,29 @@
     ]
   },
   "dependencies": {
-    "@aztec/archiver": "0.0.1-commit.b9865e97",
-    "@aztec/bb-prover": "0.0.1-commit.b9865e97",
-    "@aztec/blob-client": "0.0.1-commit.b9865e97",
-    "@aztec/blob-lib": "0.0.1-commit.b9865e97",
-    "@aztec/constants": "0.0.1-commit.b9865e97",
-    "@aztec/epoch-cache": "0.0.1-commit.b9865e97",
-    "@aztec/ethereum": "0.0.1-commit.b9865e97",
-    "@aztec/foundation": "0.0.1-commit.b9865e97",
-    "@aztec/kv-store": "0.0.1-commit.b9865e97",
-    "@aztec/l1-artifacts": "0.0.1-commit.b9865e97",
-    "@aztec/native": "0.0.1-commit.b9865e97",
-    "@aztec/node-keystore": "0.0.1-commit.b9865e97",
-    "@aztec/node-lib": "0.0.1-commit.b9865e97",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.b9865e97",
-    "@aztec/p2p": "0.0.1-commit.b9865e97",
-    "@aztec/protocol-contracts": "0.0.1-commit.b9865e97",
-    "@aztec/prover-client": "0.0.1-commit.b9865e97",
-    "@aztec/sequencer-client": "0.0.1-commit.b9865e97",
-    "@aztec/simulator": "0.0.1-commit.b9865e97",
-    "@aztec/stdlib": "0.0.1-commit.b9865e97",
-    "@aztec/telemetry-client": "0.0.1-commit.b9865e97",
-    "@aztec/world-state": "0.0.1-commit.b9865e97",
+    "@aztec/archiver": "0.0.1-commit.be03c316",
+    "@aztec/bb-prover": "0.0.1-commit.be03c316",
+    "@aztec/bb.js": "0.0.1-commit.be03c316",
+    "@aztec/blob-client": "0.0.1-commit.be03c316",
+    "@aztec/blob-lib": "0.0.1-commit.be03c316",
+    "@aztec/constants": "0.0.1-commit.be03c316",
+    "@aztec/epoch-cache": "0.0.1-commit.be03c316",
+    "@aztec/ethereum": "0.0.1-commit.be03c316",
+    "@aztec/foundation": "0.0.1-commit.be03c316",
+    "@aztec/kv-store": "0.0.1-commit.be03c316",
+    "@aztec/l1-artifacts": "0.0.1-commit.be03c316",
+    "@aztec/native": "0.0.1-commit.be03c316",
+    "@aztec/node-keystore": "0.0.1-commit.be03c316",
+    "@aztec/node-lib": "0.0.1-commit.be03c316",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.be03c316",
+    "@aztec/p2p": "0.0.1-commit.be03c316",
+    "@aztec/protocol-contracts": "0.0.1-commit.be03c316",
+    "@aztec/prover-client": "0.0.1-commit.be03c316",
+    "@aztec/sequencer-client": "0.0.1-commit.be03c316",
+    "@aztec/simulator": "0.0.1-commit.be03c316",
+    "@aztec/stdlib": "0.0.1-commit.be03c316",
+    "@aztec/telemetry-client": "0.0.1-commit.be03c316",
+    "@aztec/world-state": "0.0.1-commit.be03c316",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
     "viem": "npm:@aztec/viem@2.38.2"

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

@@ -1,23 +1,33 @@
 import { createArchiverStore, createContractDataSource } from '@aztec/archiver';
 import type { L1ContractsConfig } from '@aztec/ethereum/config';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 import { type ProverClientConfig, createProverClient } from '@aztec/prover-client';
 import { ProverBrokerConfig, createAndStartProvingBroker } from '@aztec/prover-client/broker';
-import { PublicProcessorFactory } from '@aztec/simulator/server';
+import { getLastSiblingPath } from '@aztec/prover-client/helpers';
+import { ChonkCache } from '@aztec/prover-client/orchestrator';
+import { AvmSimulatorPool, PublicProcessorFactory } from '@aztec/simulator/server';
+import type { L2Block } from '@aztec/stdlib/block';
+import { getEpochAtSlot, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import type { ITxProvider } from '@aztec/stdlib/interfaces/server';
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
 import type { GenesisData } from '@aztec/stdlib/world-state';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 import { createWorldState } from '@aztec/world-state';
 
 import { readFileSync } from 'fs';
 
+import { CheckpointProver } from '../job/checkpoint-prover.js';
 import { deserializeEpochProvingJobData } from '../job/epoch-proving-job-data.js';
-import { EpochProvingJob } from '../job/epoch-proving-job.js';
+import { EpochSession, type SessionSpec } from '../job/epoch-session.js';
 import { ProverNodeJobMetrics } from '../metrics.js';
 
 /**
  * Given a local folder where `downloadEpochProvingJob` was called, creates a new archiver and world state
- * using the state snapshots, and creates a new epoch proving job to prove the downloaded proving job.
+ * using the state snapshots, and creates a new epoch proving session to prove the downloaded proving job.
  * Proving is done with a local proving broker and agents as specified by the config.
  */
 export async function rerunEpochProvingJob(
@@ -34,41 +44,108 @@ export async function rerunEpochProvingJob(
   await using worldState = await createWorldState(config, genesis);
   const initialBlockHash = await worldState.getInitialHeader().hash();
   const archiver = await createArchiverStore(config, initialBlockHash);
+  await using avmSimulator = await AvmSimulatorPool.spawn({ wsdbIpcPath: worldState.getIpcPath() });
   const publicProcessorFactory = new PublicProcessorFactory(
     createContractDataSource(archiver),
+    avmSimulator,
     undefined,
     undefined,
     log.getBindings(),
   );
 
-  const publisher = {
-    submitEpochProof: () => Promise.resolve(true),
-    analyzeEpochProofSubmission: () => Promise.resolve(),
+  // Local rerun never publishes — stub the service so submit() always resolves 'published'
+  // and withdraw is a no-op.
+  const publishingService = {
+    submit: () => Promise.resolve('published' as const),
+    withdraw: () => {},
   };
-  const l2BlockSourceForReorgDetection = undefined;
-  const deadline = undefined;
-
-  // This starts a local proving broker that does not get exposed as a service. This should be good enough for
-  // smallish epochs to be proven if we run on a large machine, but as epochs grow larger, we may want to switch
-  // this out for a live proving broker with multiple agents that we can connect to.
   const broker = await createAndStartProvingBroker(config, telemetry);
   const prover = await createProverClient(config, worldState, broker, telemetry);
+  const chonkCache = new ChonkCache(log.getBindings());
+
+  const txProvider = makeReplayingTxProvider(jobData.txs);
+
+  log.info(`Rerunning epoch proving for epoch ${jobData.epochNumber}`);
 
-  const provingJob = new EpochProvingJob(
-    jobData,
-    worldState,
-    prover.createEpochProver(),
-    publicProcessorFactory,
-    publisher,
-    l2BlockSourceForReorgDetection,
+  const provers: CheckpointProver[] = [];
+  for (let i = 0; i < jobData.checkpoints.length; i++) {
+    const checkpoint = jobData.checkpoints[i];
+    const previousBlockHeader =
+      i === 0 ? jobData.previousBlockHeader : jobData.checkpoints[i - 1].blocks.at(-1)!.header;
+    const l1ToL2Messages = jobData.l1ToL2Messages[checkpoint.number] ?? [];
+    const previousArchiveSiblingPath = await getLastSiblingPath(
+      MerkleTreeId.ARCHIVE,
+      worldState.getSnapshot(BlockNumber(checkpoint.blocks[0].number - 1)),
+    );
+    const attestations = checkpoint.number === jobData.checkpoints.at(-1)!.number ? jobData.attestations : [];
+    provers.push(
+      new CheckpointProver(
+        {
+          checkpoint,
+          epochNumber: jobData.epochNumber,
+          attestations,
+          previousBlockHeader,
+          l1ToL2Messages,
+          previousArchiveSiblingPath,
+        },
+        {
+          proverFactory: prover,
+          chonkCache,
+          publicProcessorFactory,
+          dbProvider: worldState,
+          txProvider,
+          dateProvider: new DateProvider(),
+          proverId: prover.getProverId(),
+          metrics,
+          txGatheringTimeoutMs: 120_000,
+          deadline: undefined,
+          log,
+        },
+      ),
+    );
+  }
+
+  const l1Constants = { epochDuration: config.aztecEpochDuration };
+  const [fromSlot, toSlot] = getSlotRangeForEpoch(jobData.epochNumber, l1Constants);
+  const spec: SessionSpec = { kind: 'full', epochNumber: jobData.epochNumber, fromSlot, toSlot };
+
+  const session = new EpochSession(spec, provers, {
+    proverFactory: prover,
+    proverId: prover.getProverId(),
+    publishingService,
     metrics,
-    deadline,
-    { skipEpochCheck: true },
-    log.getBindings(),
-  );
+    dateProvider: new DateProvider(),
+    deadline: undefined,
+    config: {},
+    bindings: log.getBindings(),
+  });
+
+  const finalState = await session.start();
+  log.info(`Completed proving for epoch ${jobData.epochNumber} with status ${finalState}`, {
+    derivedEpoch: getEpochAtSlot(provers[0].slotNumber, l1Constants),
+  });
+  return finalState;
+}
 
-  log.info(`Rerunning epoch proving job for epoch ${jobData.epochNumber}`);
-  await provingJob.run();
-  log.info(`Completed job for epoch ${jobData.epochNumber} with status ${provingJob.getState()}`);
-  return provingJob.getState();
+/** Build a synthetic ITxProvider that returns the supplied txs map by lookup. */
+function makeReplayingTxProvider(txs: Map<string, Tx>): ITxProvider {
+  const lookup = (hashes: TxHash[]) => {
+    const found: Tx[] = [];
+    const missing: TxHash[] = [];
+    for (const hash of hashes) {
+      const tx = txs.get(hash.toString());
+      if (tx) {
+        found.push(tx);
+      } else {
+        missing.push(hash);
+      }
+    }
+    return { txs: found, missingTxs: missing };
+  };
+  return {
+    getAvailableTxs: hashes => Promise.resolve(lookup(hashes)),
+    hasTxs: hashes => Promise.resolve(hashes.map(h => txs.has(h.toString()))),
+    getTxsForBlockProposal: () => Promise.resolve({ txs: [], missingTxs: [] }),
+    getTxsForBlock: (block: L2Block) => Promise.resolve(lookup(block.body.txEffects.map(e => e.txHash))),
+  };
 }

package/src/checkpoint-store.ts

@@ -0,0 +1,218 @@
+import type { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/promise';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { type L1RollupConstants, getEpochAtSlot, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+
+import { CheckpointProver, type CheckpointProverArgs, type CheckpointProverDeps } from './job/checkpoint-prover.js';
+
+/** Register-time data needed to construct a `CheckpointProver` (everything except the checkpoint + epoch). */
+export type RegisterCheckpointData = Omit<CheckpointProverArgs, 'checkpoint' | 'epochNumber'>;
+
+/** Factory used by the store to construct new provers. Tests can inject a stub. */
+export type CheckpointProverFactory = (args: CheckpointProverArgs, deps: CheckpointProverDeps) => CheckpointProver;
+
+/**
+ * Prover-node-wide registry of `CheckpointProver` instances, content-addressed by
+ * `(checkpoint number, slot, checkpoint archive root)`.
+ *
+ * The store survives every epoch / session boundary. A prover lives from its first
+ * `addOrUpdate` call until either:
+ *  - it has been pruned and the L2 chain has moved past its slot (no re-add possible), or
+ *  - its epoch's proof-submission window has closed (`reapExpired`), so the proof could no
+ *    longer be accepted on L1 even if produced.
+ *
+ * A re-add of a checkpoint that matches an existing prover's content key reuses the
+ * existing prover (and flips it back to canonical); the in-flight sub-tree work never
+ * stops, so a prune-then-re-add of the same content avoids re-proving entirely.
+ */
+export class CheckpointStore {
+  private readonly provers = new Map<string, CheckpointProver>();
+  private readonly slotWatcher: RunningPromise;
+  private readonly log: Logger;
+
+  constructor(
+    private readonly l2BlockSource: Pick<L2BlockSource, 'getSyncedL2SlotNumber' | 'getL1Constants'>,
+    private readonly proverDeps: Omit<CheckpointProverDeps, 'log'>,
+    private readonly options: { slotWatcherPollIntervalMs: number },
+    bindings?: LoggerBindings,
+    private readonly proverFactoryFn: CheckpointProverFactory = (args, deps) => new CheckpointProver(args, deps),
+  ) {
+    this.log = createLogger('prover-node:checkpoint-store', bindings);
+    this.slotWatcher = new RunningPromise(
+      () => this.reapPrunedPastSlot(),
+      this.log,
+      this.options.slotWatcherPollIntervalMs,
+    );
+  }
+
+  public start(): Promise<void> {
+    this.slotWatcher.start();
+    return Promise.resolve();
+  }
+
+  public async stop(): Promise<void> {
+    await this.slotWatcher.stop();
+    // Cancel every live prover; await teardown.
+    const provers = Array.from(this.provers.values());
+    this.provers.clear();
+    for (const prover of provers) {
+      prover.cancel();
+    }
+    await Promise.allSettled(provers.map(p => p.whenDone()));
+  }
+
+  /**
+   * Registers a checkpoint with the store. If a prover already exists for the
+   * `(number, slot, archive root)` content key, it is reused and marked canonical;
+   * otherwise a new prover is constructed.
+   */
+  public async addOrUpdate(checkpoint: Checkpoint, data: RegisterCheckpointData): Promise<CheckpointProver> {
+    const l1Constants = await this.l2BlockSource.getL1Constants();
+    const epochNumber = getEpochAtSlot(checkpoint.header.slotNumber, l1Constants);
+    const id = CheckpointProver.idFor(checkpoint);
+
+    const existing = this.provers.get(id);
+    if (existing) {
+      existing.markCanonical();
+      return existing;
+    }
+
+    // At most one canonical checkpoint per slot. A different canonical checkpoint at the
+    // same slot means the caller forgot to prune the old chain before adding the replacement
+    // — surface it rather than silently creating a parallel canonical chain.
+    for (const prover of this.provers.values()) {
+      if (prover.slotNumber === checkpoint.header.slotNumber && !prover.isPruned()) {
+        throw new Error(
+          `Cannot add checkpoint ${checkpoint.number} (archive ${checkpoint.archive.root}) at slot ${checkpoint.header.slotNumber}: ` +
+            `a different canonical checkpoint already occupies this slot. Prune it first.`,
+        );
+      }
+    }
+
+    const prover = this.proverFactoryFn({ ...data, checkpoint, epochNumber }, { ...this.proverDeps, log: this.log });
+    this.provers.set(id, prover);
+    return prover;
+  }
+
+  /**
+   * Marks every canonical prover that holds a block above the prune target as pruned. A checkpoint is orphaned by a
+   * prune to block `targetBlockNumber` iff its last block sits above the target — including a checkpoint whose range
+   * straddles the target (partially orphaned), which block-range marking catches without boundary ambiguity. Keying
+   * off the surviving block number (rather than a checkpoint number) is correct even when the source has already
+   * re-checkpointed past the divergence: the prune event reports the highest surviving block, which by construction
+   * survives on the source, whereas the source's current checkpointed tip can sit above the prune target.
+   * Sub-tree work keeps running so a re-add of the same content can pick it up. Returns the affected provers.
+   */
+  public markPrunedAboveBlock(targetBlockNumber: BlockNumber): CheckpointProver[] {
+    const affected: CheckpointProver[] = [];
+    for (const prover of this.provers.values()) {
+      const lastBlockNumber = prover.checkpoint.blocks.at(-1)!.number;
+      if (lastBlockNumber > targetBlockNumber && !prover.isPruned()) {
+        prover.markPruned();
+        affected.push(prover);
+      }
+    }
+    return affected;
+  }
+
+  /**
+   * Drops canonical (non-pruned) provers whose epoch is at or below the supplied expired
+   * epoch. Once an epoch's proof-submission window has closed, its proof can no longer be
+   * accepted on L1, so the prover is no longer needed.
+   */
+  public reapExpired(expiredEpoch: EpochNumber): void {
+    const reaped: { id: string; checkpointNumber: CheckpointNumber; epochNumber: EpochNumber }[] = [];
+    for (const [id, prover] of Array.from(this.provers.entries())) {
+      if (prover.isPruned()) {
+        continue;
+      }
+      if (prover.epochNumber <= expiredEpoch) {
+        reaped.push({ id, checkpointNumber: prover.checkpoint.number, epochNumber: prover.epochNumber });
+        prover.cancel({ routine: true });
+        void prover.whenDone();
+        this.provers.delete(id);
+      }
+    }
+    if (reaped.length > 0) {
+      this.log.info(`Reaped ${reaped.length} expired CheckpointProver(s) for expiredEpoch ${expiredEpoch}`, {
+        expiredEpoch,
+        reapedCount: reaped.length,
+        reaped,
+      });
+    }
+  }
+
+  /** Returns the prover with the supplied id, or undefined. */
+  public get(id: string): CheckpointProver | undefined {
+    return this.provers.get(id);
+  }
+
+  /** Returns the prover for the supplied checkpoint (by its content-addressed id), or undefined. */
+  public getByCheckpoint(checkpoint: Checkpoint): CheckpointProver | undefined {
+    return this.provers.get(CheckpointProver.idFor(checkpoint));
+  }
+
+  /** Every prover currently in the store (canonical and pruned), in insertion order. */
+  public listAll(): CheckpointProver[] {
+    return Array.from(this.provers.values());
+  }
+
+  /** Canonical (non-pruned) provers in the store, sorted by checkpoint number. */
+  public listCanonical(): CheckpointProver[] {
+    return Array.from(this.provers.values())
+      .filter(p => !p.isPruned())
+      .sort((a, b) => a.checkpoint.number - b.checkpoint.number);
+  }
+
+  /**
+   * Canonical provers whose slot is in the supplied epoch's slot range, sorted by
+   * checkpoint number.
+   */
+  public async listCanonicalForEpoch(epoch: EpochNumber): Promise<CheckpointProver[]> {
+    const l1Constants = await this.l2BlockSource.getL1Constants();
+    const [fromSlot, toSlot] = getSlotRangeForEpoch(epoch, l1Constants);
+    return this.listCanonicalInSlotRange(fromSlot, toSlot);
+  }
+
+  /** Canonical provers whose slot falls within `[fromSlot, toSlot]`, sorted by checkpoint number. */
+  public listCanonicalInSlotRange(fromSlot: SlotNumber, toSlot: SlotNumber): CheckpointProver[] {
+    return this.listCanonical().filter(p => p.slotNumber >= fromSlot && p.slotNumber <= toSlot);
+  }
+
+  /**
+   * SlotWatcher tick: reap pruned provers whose slot has passed the chain's synced
+   * slot. Once the chain has moved past, no re-add can revive the prover and its
+   * content key is unique enough that an actual re-add would create a new entry.
+   *
+   * Protected so unit tests can drive a single tick without spinning up the
+   * `RunningPromise` and waiting on its interval.
+   */
+  protected async reapPrunedPastSlot(): Promise<void> {
+    let syncedSlot: SlotNumber | undefined;
+    try {
+      syncedSlot = await this.l2BlockSource.getSyncedL2SlotNumber();
+    } catch (err) {
+      this.log.debug(`SlotWatcher could not read synced slot`, { error: `${err}` });
+      return;
+    }
+    if (syncedSlot === undefined) {
+      return;
+    }
+    for (const [id, prover] of Array.from(this.provers.entries())) {
+      if (prover.isPruned() && prover.slotNumber < syncedSlot) {
+        this.log.info(`Reaping pruned CheckpointProver ${id}: slot ${prover.slotNumber} < synced ${syncedSlot}`, {
+          checkpointNumber: prover.checkpoint.number,
+          slotNumber: prover.slotNumber,
+        });
+        prover.cancel();
+        void prover.whenDone();
+        this.provers.delete(id);
+      }
+    }
+  }
+}
+
+/** Sub-set of `L1RollupConstants` actually consumed by the store's slot helpers. */
+export type CheckpointStoreL1Constants = Pick<L1RollupConstants, 'epochDuration'>;

package/src/config.ts

@@ -6,6 +6,7 @@ import {
   numberConfigHelper,
   pickConfigMappings,
 } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { type KeyStoreConfig, keyStoreConfigMappings } from '@aztec/node-keystore/config';
 import { ethPrivateKeySchema } from '@aztec/node-keystore/schemas';
 import type { KeyStore } from '@aztec/node-keystore/types';
@@ -44,6 +45,7 @@ export type SpecificProverNodeConfig = {
   txGatheringIntervalMs: number;
   txGatheringBatchSize: number;
   txGatheringMaxParallelRequestsPerNode: number;
+  proofSubmissionTargetAddress?: EthAddress;
 };
 
 export const specificProverNodeConfigMappings: ConfigMappingsType<SpecificProverNodeConfig> = {
@@ -68,7 +70,8 @@ export const specificProverNodeConfigMappings: ConfigMappingsType<SpecificProver
     defaultValue: undefined,
   },
   proverNodeEpochProvingDelayMs: {
-    description: 'Optional delay in milliseconds to wait before proving a new epoch',
+    description:
+      'Optional delay in milliseconds to wait for late-arriving events (e.g. reorgs) to settle before starting top-tree proving for an epoch',
     defaultValue: undefined,
   },
   txGatheringIntervalMs: {
@@ -96,6 +99,14 @@ export const specificProverNodeConfigMappings: ConfigMappingsType<SpecificProver
     description: 'Whether the prover node skips publishing proofs to L1',
     ...booleanConfigHelper(false),
   },
+  proofSubmissionTargetAddress: {
+    env: 'PROVER_NODE_PROOF_SUBMISSION_TARGET_ADDRESS',
+    description:
+      'Optional L1 address the submitEpochRootProof tx is sent to. Must expose the identical submitEpochRootProof ABI ' +
+      'and forward to the rollup. Defaults to the rollup address.',
+    parseEnv: (val: string) => EthAddress.fromString(val),
+    defaultValue: undefined,
+  },
 };
 
 export const proverNodeConfigMappings: ConfigMappingsType<ProverNodeConfig> = {

package/src/factory.ts

@@ -19,6 +19,7 @@ import {
   type ProverTxSenderConfig,
   getPublisherConfigFromProverConfig,
 } from '@aztec/sequencer-client';
+import type { AvmSimulator } from '@aztec/simulator/server';
 import type {
   ITxProvider,
   ProverConfig,
@@ -31,7 +32,6 @@ import { L1Metrics, type TelemetryClient, getTelemetryClient } from '@aztec/tele
 import { createPublicClient } from 'viem';
 
 import type { SpecificProverNodeConfig } from './config.js';
-import { EpochMonitor } from './monitors/epoch-monitor.js';
 import { ProverNode } from './prover-node.js';
 import { ProverPublisherFactory } from './prover-publisher-factory.js';
 
@@ -48,6 +48,8 @@ export type ProverNodeDeps = {
   epochCache: EpochCacheInterface;
   blobClient: BlobClientInterface;
   keyStoreManager?: KeystoreManager;
+  /** AVM execution backend (simulator pool + CDB server) for public simulation. */
+  avmSimulator: AvmSimulator;
 };
 
 /** Creates a new prover node subsystem given a config and dependencies */
@@ -136,6 +138,7 @@ export async function createProverNode(
     deps.publisherFactory ??
     new ProverPublisherFactory(config, {
       rollupContract,
+      proofSubmissionTarget: config.proofSubmissionTargetAddress,
       publisherManager: new PublisherManager(l1TxUtils, getPublisherConfigFromProverConfig(config), {
         bindings: log.getBindings(),
         funder: funderL1TxUtils,
@@ -161,12 +164,6 @@ export async function createProverNode(
     ),
   };
 
-  const epochMonitor = await EpochMonitor.create(
-    archiver,
-    { pollingIntervalMs: config.proverNodePollingIntervalMs, provingDelayMs: config.proverNodeEpochProvingDelayMs },
-    telemetry,
-  );
-
   const l1Metrics = new L1Metrics(
     telemetry.getMeter('ProverNodeL1Metrics'),
     publicClient,
@@ -184,9 +181,9 @@ export async function createProverNode(
     archiver,
     worldStateSynchronizer,
     p2pClient,
-    epochMonitor,
     rollupContract,
     l1Metrics,
+    deps.avmSimulator,
     proverNodeConfig,
     telemetry,
     delayer,

package/src/index.ts

@@ -2,5 +2,6 @@ export * from './actions/index.js';
 export * from './config.js';
 export * from './factory.js';
 export * from './monitors/index.js';
+export * from './proof-publishing-service.js';
 export * from './prover-node-publisher.js';
 export * from './prover-node.js';