@aztec/prover-node 5.1.0 → 5.2.0-nightly.20260724

package/README.md

@@ -48,10 +48,12 @@ The prover-node splits responsibility between four classes:
 
 - **`ProverNode`** — owns the long-lived collections, wires the L2BlockStream, and
   translates each chain event into a single method call on the `SessionManager` or
-  `ProofPublishingService`. It also performs the per-event side effects that don't
-  belong on an `EpochSession` (registering new checkpoints with the store, sweeping
-  expired epochs out of the cache and the store, etc.) and runs the failure-upload
-  action when an `EpochSession` exits with `failed`.
+  `ProofPublishingService`. It also performs side effects that don't belong on an
+  `EpochSession`: registering new checkpoints with the store per event, and sweeping expired
+  epochs out of the cache and the store on a periodic ticker (see below). It uploads post-mortem
+  snapshots on failure at two levels: per checkpoint when a `CheckpointProver` fails (its `onFailed`
+  callback), and per session when a full session fails on its own account (`onSessionFailed` /
+  `EpochSession.hasFailed()`).
 - **`CheckpointStore`** — a registry of `CheckpointProver` instances keyed by
   `(checkpointNumber, slot, archiveRoot)`. Each `CheckpointProver` runs its own sub-tree pipeline
   (tx gather → block processing → block-rollup proofs), starting eagerly the moment a
@@ -64,8 +66,12 @@ The prover-node splits responsibility between four classes:
   translated into a `reconcile(trigger)` call, a single idempotent function that walks
   all `EpochSession`s, cancels any whose canonical content has shifted, re-creates them with
   the new content, and opens fresh full `EpochSession`s for any epoch that has become provable.
-  Reconcile runs on a `SerialQueue` (from `@aztec/foundation/queue`), so two concurrent
-  triggers can never interleave on an `await` and race on the `EpochSession` maps.
+  It never builds a session over a **failed** `CheckpointProver` (one whose block proofs rejected —
+  a sub-tree fault or a prune-induced fork fault): a session over it could only fail, so the epoch is
+  cheaply skipped until a prune/re-add installs a fresh prover in its place, at which point a rebuilt
+  session reuses every already-completed sub-proof from the content-addressed broker. Reconcile runs on
+  a `SerialQueue` (from `@aztec/foundation/queue`), so two concurrent triggers can never interleave on an
+  `await` and race on the `EpochSession` maps.
 - **`ProofPublishingService`** — central owner of L1 proof submission. `EpochSession`s hand
   their top-tree proofs to the service as `PublishCandidate`s; the service serialises
   one publish at a time against a freshly-created `ProverNodePublisher`, gates eligibility
@@ -150,9 +156,9 @@ stateDiagram-v2
   awaiting_root --> publishing_proof: epoch proof ready, submit to L1
   publishing_proof --> completed: publish succeeds
   publishing_proof --> superseded: longer same-epoch candidate wins
-  publishing_proof --> failed: L1 submission errored
-  awaiting_checkpoints --> failed: top-tree prove errored
-  awaiting_root --> failed: top-tree prove errored
+  publishing_proof --> failed: L1 submission errored (provers healthy)
+  awaiting_checkpoints --> stopped: a checkpoint prover failed
+  awaiting_root --> failed: top-tree prove errored (provers healthy)
   initialized --> timed_out: deadline
   awaiting_checkpoints --> timed_out: deadline (EpochSession or candidate)
   awaiting_root --> timed_out: deadline (EpochSession or candidate)
@@ -162,9 +168,22 @@ stateDiagram-v2
   superseded --> [*]
   cancelled --> [*]
   timed_out --> [*]
+  stopped --> [*]
   failed --> [*]
 ```
 
+A fault settles the `EpochSession` in one of two terminal states:
+
+- **`stopped`** — a `CheckpointProver` under the session failed (its block proofs rejected). This may
+  be a prune-induced fork fault, so it is *not* a verdict on the epoch and is *not* uploaded. The
+  reconciler drops the session and, guarded by `isFailed()`, does not rebuild over the failed prover;
+  a prune/re-add installs a fresh prover and the epoch is retried.
+- **`failed`** — the session's own work (top-tree prove or L1 submit) failed while *every* checkpoint
+  prover succeeded. Because healthy provers rule out a prune, this is a genuine, race-free failure
+  (`EpochSession.hasFailed()`). The reconciler retains such a full session (so the tick does not
+  re-prove a deterministically-failing epoch) and uploads a post-mortem exactly once. No prune/fault
+  classification is needed — the two states carry it.
+
 The non-terminal states track the window between `start()` and the L1 submission:
 
 - `awaiting-checkpoints` — a `TopTreeJob` is awaiting each checkpoint's sub-tree result
@@ -323,44 +342,57 @@ sequenceDiagram
   PS->>PS: drain reads proven afresh, re-checks eligibility
 ```
 
-### Per-event expiry sweep
+### Periodic expiry sweep
 
 ```mermaid
 sequenceDiagram
-  participant L2 as L2BlockStream
+  participant T as expiryTicker (RunningPromise)
   participant PN as ProverNode
+  participant L2 as L2BlockStream
   participant CC as ChonkCache
   participant CS as CheckpointStore
 
-  L2->>PN: any event
+  T->>PN: checkEpochExpiry() (every poll interval)
   PN->>L2: getSyncedL2SlotNumber()
   PN->>PN: latestEpoch = getEpochAtSlot(latestSlot)
   PN->>PN: newlyExpiredUpTo = latestEpoch - (proofSubmissionEpochs + 1)
   loop for each newly-expired epoch
-    PN->>L2: getCheckpointsData({epoch}) + getBlocks(...)
+    PN->>L2: getBlocks({epoch, onlyCheckpointed})
     PN->>CC: releaseForBlocks(blocks)
     PN->>CS: reapExpired(epoch)
   end
 ```
 
-Expiry runs at the end of every `handleBlockStreamEvent` call (not on any specific
-event type). An epoch `E` is expired once the chain reaches the start of epoch
-`E + proofSubmissionEpochs + 1` — the deadline beyond which an L1 submission for
-`E` would be rejected. A monotonic high-water mark (`lastExpiredEpoch`) makes the
-sweep cheap: it advances per event and never revisits an epoch. It is seeded at
-`start()` from the last fully-proven epoch (computed in `computeStartupState`),
-so on a restart we never re-sweep epochs that already reached L1.
+The sweep is driven solely by the `expiryTicker` (a `RunningPromise` armed in `start()`), which
+calls `checkEpochExpiry()` every poll interval whether or not block-stream events arrive. It is
+deliberately **not** run from `handleBlockStreamEvent` — expiry is a background sweep keyed off the
+archiver's synced slot, not part of event processing — and because a `RunningPromise` never overlaps
+its own runs, no two sweeps can race. An epoch `E` is expired once the chain reaches the start of epoch
+`E + proofSubmissionEpochs + 1` — the deadline beyond which an L1 submission for `E` would be rejected.
+Expiry only releases the chonk cache and reaps `E`'s provers.
+A monotonic high-water mark (`lastExpiredEpoch`) makes the sweep cheap: it only
+advances after a sweep completes and never revisits an epoch. It is seeded at `start()` from the last
+fully-proven epoch (`resolveLastFullyProvenEpoch`), so on a restart we never re-sweep epochs that already
+reached L1.
 
 ### Periodic tick
 
 `SessionManager.start()` arms a `RunningPromise` that fires
 `reconcile({ kind: 'tick' })` every `tickIntervalMs`. The tick picks up epochs that
 became complete by time alone (no fresh checkpoint event) and advances to the
-next unproven epoch once the previous one lands on L1. A monotonic high-water
-mark (`lastTickEpoch`) prevents the tick from re-opening an epoch whose `EpochSession`
-already terminated; the mark advances only after an `EpochSession` actually exists for
-the epoch, so transient blockers (max-pending-jobs reached, archiver still
-indexing) leave the mark in place and the next tick retries.
+next unproven epoch once the previous one lands on L1. The tick is not gated by any per-epoch
+bookkeeping; two things keep it from re-proving a doomed epoch:
+
+- `openFullSessionIfReady` refuses to build a session when any `CheckpointProver` in the set has
+  **failed** (`isFailed()`). So a prover fault (possibly a prune) skips the epoch cheaply each tick —
+  no session, no proving — until a prune/re-add installs a fresh prover.
+- A session that failed on its own account (`hasFailed()` — top-tree/submit failed with every prover
+  healthy) is **retained** by `recreateInvalidSessions` rather than deleted, so the tick's
+  `fullSessions.has(epoch)` check skips it. It is replaced only when its canonical content changes (a
+  re-add), so a deterministically-failing epoch is not re-proved every tick.
+
+Transient blockers (max-pending-jobs reached, archiver still indexing) create no session and no failed
+prover, so the next tick simply tries again.
 
 ## Walkthroughs
 
@@ -467,6 +499,20 @@ by keeping the prover around.  Removing it on prune and rebuilding on re-add is
 correct and simpler; the expensive block-rollup proofs are still reused when content re-appears,
 because the proving broker is content-addressed independently of the prover's lifetime.
 
+### How is a genuine failure told apart from a prune, without a racy classification?
+
+Knowledge of an L1 reorg reaches the prover-node on two causally unordered channels: the control
+plane (`chain-pruned` → `onPrune`) and the data plane (world-state unwinds, and an in-flight fork
+read faults inside a `CheckpointProver` mid-proof). If the `EpochSession` reacted to a fault by asking
+"was this a prune or a genuine failure?", every answer would sample control-plane state that lags the
+data-plane unwind — racy by construction. We remove the question by pushing the fact down to where it
+is unambiguous: a `CheckpointProver` records `isFailed()` when *its* block proofs reject. The session
+then reads a clean signal: if any prover failed, the fault might be a prune (`stopped`) — don't upload,
+don't rebuild over it, recover on re-add; if *no* prover failed yet the session's own top-tree/submit
+work failed, that is definitively **not** a prune (`failed`) — a genuine, race-free failure that is
+retained (so a deterministic failure isn't re-proved every tick) and uploaded once. No control-plane
+sampling, no timing race — the two prover-level and session-level facts carry the whole decision.
+
 ## Configuration
 
 | Env var | Description |
@@ -475,7 +521,7 @@ because the proving broker is content-addressed independently of the prover's li
 | `PROVER_NODE_MAX_PENDING_JOBS` | Cap on the number of non-terminal `EpochSession`s (full + partial).  When at limit, reconcile defers opening new full `EpochSession`s; explicit `startProof` calls throw. |
 | `PROVER_NODE_EPOCH_PROVING_DELAY_MS` | Optional sleep at the start of each `EpochSession`, before the TopTreeJob is constructed.  Used in tests to give late events time to land. |
 | `TX_GATHERING_TIMEOUT_MS` | Per-block tx gather deadline used by each `CheckpointProver`. |
-| `PROVER_NODE_FAILED_EPOCH_STORE` | If set, failed `EpochSession`s upload their proving data (every `CheckpointProver`'s txs + register-time data, regardless of sub-tree completion) to this file store. |
+| `PROVER_NODE_FAILED_EPOCH_STORE` | If set, a full session that fails on its own account (top-tree/submit, provers healthy) uploads its proving data (every `CheckpointProver`'s txs + register-time data, regardless of sub-tree completion) to this file store. |
 | `PROVER_NODE_DISABLE_PROOF_PUBLISH` | If true, the publishing service runs `analyzeEpochProofSubmission` (estimates L1 fees) instead of actually submitting. |
 
 ## Failure handling and observability
@@ -493,14 +539,29 @@ Loggers:
 - `prover-node:checkpoint-prover` — sub-tree pipeline (gather, block processing).
 - `prover-client:chonk-cache` — chonk-verifier cache enqueue / release events.
 
-On `failed` exit, `SessionManager.runSession` invokes the `onSessionFailed` callback
-the manager was constructed with. `ProverNode` wires this to `tryUploadSessionFailure`,
-which calls `SessionManager.buildSessionProvingData(session)` to walk every `CheckpointProver`
-referenced by the `EpochSession` and assemble an `EpochProvingJobData` snapshot — including
-every `CheckpointProver`'s txs and register-time data even if its sub-tree never reached
-`isCompleted()`. This snapshot is what `uploadEpochProofFailure` ships to the
-configured file store along with a world-state + archiver backup, so the failure
-can be reproduced offline via `rerunEpochProvingJob`.
+Failed proving data is uploaded to the configured file store (`PROVER_NODE_FAILED_EPOCH_STORE`) at two
+levels, and re-proved offline by the matching downloader/rerunner: an epoch job via
+`downloadEpochProvingJob` + `rerunEpochProvingJob`, and a single checkpoint via the same download plus
+`rerunCheckpointProvingJob` (which rebuilds just that checkpoint's sub-tree prover and awaits its block
+proofs — no epoch top-tree or L1 submit). Both upload levels build an `EpochProvingJobData` snapshot with
+`SessionManager.buildProvingData(...)` — every `CheckpointProver`'s txs and register-time data, even if
+its sub-tree never reached `isCompleted()` — and ship it via `uploadEpochProofFailure` alongside a
+world-state + archiver backup:
+
+- **Per checkpoint.** When a `CheckpointProver`'s block proofs reject for a non-cancel reason (a sub-tree
+  fault or a prune-induced fork fault), it fires its `onFailed` callback and `ProverNode` uploads that one
+  checkpoint via `tryUploadCheckpointFailure(prover)`. This fires for prune-induced faults too — that is
+  intentional; a prune-caused checkpoint snapshot is harmless, and *not* trying to tell prune from genuine
+  failure is exactly what keeps this race-free. A cancelled prover (control-plane prune / shutdown) is not
+  a failure and does not upload.
+- **Per session.** When a full session ends in its own genuine failure (`EpochSession.hasFailed()` —
+  top-tree/submit failed with every prover healthy), the session manager fires `onSessionFailed` and
+  `ProverNode` uploads all the session's checkpoints via `tryUploadEpochFailure(...)`. This is race-free
+  (healthy provers rule out a prune) and fires once, since the failed session is retained and never re-run.
+
+A `stopped` session (a prover under it failed) does not upload at the session level — its failed checkpoint
+already uploaded itself. Each backup is a full world-state + archiver snapshot, so a prune that faults
+several in-flight provers produces several uploads; this is accepted for the diagnostic value.
 
 Metrics emitted by `EpochSession`s:
 

package/dest/actions/rerun-epoch-proving-job.d.ts

@@ -4,10 +4,19 @@ import { type ProverClientConfig } from '@aztec/prover-client';
 import { ProverBrokerConfig } from '@aztec/prover-client/broker';
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import type { GenesisData } from '@aztec/stdlib/world-state';
+type RerunConfig = DataStoreConfig & ProverBrokerConfig & ProverClientConfig & Pick<L1ContractsConfig, 'aztecEpochDuration'>;
 /**
  * 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 session to prove the downloaded proving job.
  * Proving is done with a local proving broker and agents as specified by the config.
  */
-export declare function rerunEpochProvingJob(localPath: string, log: Logger, config: DataStoreConfig & ProverBrokerConfig & ProverClientConfig & Pick<L1ContractsConfig, 'aztecEpochDuration'>, genesis?: GenesisData): Promise<"awaiting-checkpoints" | "awaiting-predecessor" | "awaiting-root" | "cancelled" | "completed" | "failed" | "initialized" | "publishing-proof" | "stopped" | "superseded" | "timed-out">;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVydW4tZXBvY2gtcHJvdmluZy1qb2IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hY3Rpb25zL3JlcnVuLWVwb2NoLXByb3Zpbmctam9iLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFaEUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFcEQsT0FBTyxFQUFFLEtBQUssa0JBQWtCLEVBQXNCLE1BQU0sc0JBQXNCLENBQUM7QUFDbkYsT0FBTyxFQUFFLGtCQUFrQixFQUErQixNQUFNLDZCQUE2QixDQUFDO0FBTzlGLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRzlELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBVzdEOzs7O0dBSUc7QUFDSCx3QkFBc0Isb0JBQW9CLENBQ3hDLFNBQVMsRUFBRSxNQUFNLEVBQ2pCLEdBQUcsRUFBRSxNQUFNLEVBQ1gsTUFBTSxFQUFFLGVBQWUsR0FBRyxrQkFBa0IsR0FBRyxrQkFBa0IsR0FBRyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsb0JBQW9CLENBQUMsRUFDakgsT0FBTyxDQUFDLEVBQUUsV0FBVyxtTUF5RnRCIn0=
+export declare function rerunEpochProvingJob(localPath: string, log: Logger, config: RerunConfig, genesis?: GenesisData): Promise<"awaiting-checkpoints" | "awaiting-predecessor" | "awaiting-root" | "cancelled" | "completed" | "failed" | "initialized" | "publishing-proof" | "stopped" | "superseded" | "timed-out">;
+/**
+ * Re-proves a single downloaded checkpoint proving job (as uploaded by a `CheckpointProver` failure).
+ * Reconstructs just that checkpoint's sub-tree prover from the snapshot and awaits its block proofs — no
+ * epoch top-tree, no L1 submission — so a checkpoint-level failure can be reproduced offline in isolation.
+ * Returns the block-rollup proof outputs on success; throws if the checkpoint fails to prove again.
+ */
+export declare function rerunCheckpointProvingJob(localPath: string, log: Logger, config: RerunConfig, genesis?: GenesisData): Promise<import("@aztec/stdlib/interfaces/server").PublicInputsAndRecursiveProof<import("@aztec/stdlib/rollup").BlockRollupPublicInputs, 480>[]>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVydW4tZXBvY2gtcHJvdmluZy1qb2IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hY3Rpb25zL3JlcnVuLWVwb2NoLXByb3Zpbmctam9iLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFaEUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFcEQsT0FBTyxFQUFFLEtBQUssa0JBQWtCLEVBQXNCLE1BQU0sc0JBQXNCLENBQUM7QUFDbkYsT0FBTyxFQUFFLGtCQUFrQixFQUErQixNQUFNLDZCQUE2QixDQUFDO0FBTzlGLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRzlELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBVzdELEtBQUssV0FBVyxHQUFHLGVBQWUsR0FDaEMsa0JBQWtCLEdBQ2xCLGtCQUFrQixHQUNsQixJQUFJLENBQUMsaUJBQWlCLEVBQUUsb0JBQW9CLENBQUMsQ0FBQztBQUVoRDs7OztHQUlHO0FBQ0gsd0JBQXNCLG9CQUFvQixDQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLE9BQU8sQ0FBQyxFQUFFLFdBQVcsbU1Bc0NwSDtBQUVEOzs7OztHQUtHO0FBQ0gsd0JBQXNCLHlCQUF5QixDQUM3QyxTQUFTLEVBQUUsTUFBTSxFQUNqQixHQUFHLEVBQUUsTUFBTSxFQUNYLE1BQU0sRUFBRSxXQUFXLEVBQ25CLE9BQU8sQ0FBQyxFQUFFLFdBQVcsbUpBaUJ0QiJ9

package/dest/actions/rerun-epoch-proving-job.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rerun-epoch-proving-job.d.ts","sourceRoot":"","sources":["../../src/actions/rerun-epoch-proving-job.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAA+B,MAAM,6BAA6B,CAAC;AAO9F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAW7D;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,eAAe,GAAG,kBAAkB,GAAG,kBAAkB,GAAG,IAAI,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,EACjH,OAAO,CAAC,EAAE,WAAW,mMAyFtB"}
+{"version":3,"file":"rerun-epoch-proving-job.d.ts","sourceRoot":"","sources":["../../src/actions/rerun-epoch-proving-job.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAA+B,MAAM,6BAA6B,CAAC;AAO9F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAW7D,KAAK,WAAW,GAAG,eAAe,GAChC,kBAAkB,GAClB,kBAAkB,GAClB,IAAI,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,CAAC;AAEhD;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,WAAW,mMAsCpH;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,WAAW,mJAiBtB"}

package/dest/actions/rerun-epoch-proving-job.js

@@ -20,53 +20,19 @@ import { ProverNodeJobMetrics } from '../metrics.js';
  * 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(localPath, log, config, genesis) {
-    const jobData = deserializeEpochProvingJobData(readFileSync(localPath));
-    log.info(`Loaded proving job data for epoch ${jobData.epochNumber}`);
-    const telemetry = getTelemetryClient();
-    const metrics = new ProverNodeJobMetrics(telemetry.getMeter('prover-job'), telemetry.getTracer('prover-job'));
-    const worldState = await createWorldState(config, genesis);
-    const initialBlockHash = await worldState.getInitialHeader().hash();
-    const archiver = await createArchiverStore(config, initialBlockHash);
-    const publicProcessorFactory = new PublicProcessorFactory(createContractDataSource(archiver), undefined, undefined, log.getBindings());
+    const ctx = await createRerunContext(localPath, log, config, genesis);
+    const { jobData, prover, metrics } = ctx;
+    log.info(`Rerunning epoch proving for epoch ${jobData.epochNumber}`);
+    const provers = [];
+    for(let i = 0; i < jobData.checkpoints.length; i++){
+        provers.push(await buildCheckpointProver(ctx, i, log));
+    }
     // Local rerun never publishes — stub the service so submit() always resolves 'published'
     // and withdraw is a no-op.
     const publishingService = {
         submit: ()=>Promise.resolve('published'),
         withdraw: ()=>{}
     };
-    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 provers = [];
-    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
     };
@@ -93,6 +59,82 @@ import { ProverNodeJobMetrics } from '../metrics.js';
     });
     return finalState;
 }
+/**
+ * Re-proves a single downloaded checkpoint proving job (as uploaded by a `CheckpointProver` failure).
+ * Reconstructs just that checkpoint's sub-tree prover from the snapshot and awaits its block proofs — no
+ * epoch top-tree, no L1 submission — so a checkpoint-level failure can be reproduced offline in isolation.
+ * Returns the block-rollup proof outputs on success; throws if the checkpoint fails to prove again.
+ */ export async function rerunCheckpointProvingJob(localPath, log, config, genesis) {
+    const ctx = await createRerunContext(localPath, log, config, genesis);
+    const { jobData } = ctx;
+    const checkpointNumber = jobData.checkpoints[0].number;
+    log.info(`Rerunning checkpoint proving for checkpoint ${checkpointNumber} (epoch ${jobData.epochNumber})`);
+    const prover = await buildCheckpointProver(ctx, 0, log);
+    try {
+        const blockProofs = await prover.whenBlockProofsReady();
+        log.info(`Completed proving for checkpoint ${checkpointNumber} with ${blockProofs.length} block proof(s)`);
+        return blockProofs;
+    } finally{
+        prover.cancel({
+            routine: true
+        });
+        await prover.whenDone();
+    }
+}
+/**
+ * Rebuilds the offline proving environment from a downloaded job: world state + archiver from the
+ * snapshots, a local proving broker + client, a chonk cache, and a tx provider that replays the job's txs.
+ */ async function createRerunContext(localPath, log, config, genesis) {
+    const jobData = deserializeEpochProvingJobData(readFileSync(localPath));
+    log.info(`Loaded proving job data for epoch ${jobData.epochNumber}`);
+    const telemetry = getTelemetryClient();
+    const metrics = new ProverNodeJobMetrics(telemetry.getMeter('prover-job'), telemetry.getTracer('prover-job'));
+    const worldState = await createWorldState(config, genesis);
+    const initialBlockHash = await worldState.getInitialHeader().hash();
+    const archiver = await createArchiverStore(config, initialBlockHash);
+    const publicProcessorFactory = new PublicProcessorFactory(createContractDataSource(archiver), undefined, undefined, log.getBindings());
+    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);
+    return {
+        jobData,
+        metrics,
+        worldState,
+        publicProcessorFactory,
+        prover,
+        chonkCache,
+        txProvider
+    };
+}
+/** Reconstructs the `CheckpointProver` for the checkpoint at `index` in the job, ready to prove. */ async function buildCheckpointProver(ctx, index, log) {
+    const { jobData, worldState, prover, chonkCache, publicProcessorFactory, txProvider, metrics } = ctx;
+    const checkpoint = jobData.checkpoints[index];
+    const previousBlockHeader = index === 0 ? jobData.previousBlockHeader : jobData.checkpoints[index - 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 : [];
+    return 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
+    });
+}
 /** Build a synthetic ITxProvider that returns the supplied txs map by lookup. */ function makeReplayingTxProvider(txs) {
     const lookup = (hashes)=>{
         const found = [];

package/dest/checkpoint-store.d.ts

@@ -3,7 +3,7 @@ import { type LoggerBindings } from '@aztec/foundation/log';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
-import { CheckpointProver, type CheckpointProverArgs, type CheckpointProverDeps } from './job/checkpoint-prover.js';
+import { CheckpointProver, type CheckpointProverArgs, type CheckpointProverDeps, type CheckpointProverTestHooks } 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. */
@@ -34,6 +34,8 @@ export declare class CheckpointStore {
      */
     private readonly pendingTeardowns;
     private nextTeardownId;
+    /** Test-only hooks injected into every prover this store constructs. */
+    private testHooks;
     private readonly log;
     constructor(l2BlockSource: Pick<L2BlockSource, 'getL1Constants'>, proverDeps: Omit<CheckpointProverDeps, 'log'>, bindings?: LoggerBindings, proverFactoryFn?: CheckpointProverFactory);
     start(): Promise<void>;
@@ -49,6 +51,11 @@ export declare class CheckpointStore {
      * still-canonical content); otherwise a new prover is constructed.
      */
     addOrUpdate(checkpoint: Checkpoint, data: RegisterCheckpointData): Promise<CheckpointProver>;
+    /**
+     * Installs test-only hooks applied to every prover constructed from now on. Used by the e2e harness to
+     * force a checkpoint sub-tree failure without monkey-patching the prover factory.
+     */
+    setTestHooks(hooks: CheckpointProverTestHooks): void;
     /**
      * Cancels and removes every prover that holds a block above the prune target. A checkpoint is orphaned by a prune to
      * block `targetBlockNumber` iff its last block sits above the target — including a checkpoint whose range straddles
@@ -85,4 +92,4 @@ export declare class CheckpointStore {
 }
 /** Sub-set of `L1RollupConstants` actually consumed by the store's slot helpers. */
 export type CheckpointStoreL1Constants = Pick<L1RollupConstants, 'epochDuration'>;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/checkpoint-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkpoint-store.d.ts","sourceRoot":"","sources":["../src/checkpoint-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAoB,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC9G,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,6BAA6B,CAAC;AAE3G,OAAO,EAAE,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEpH,8GAA8G;AAC9G,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,oBAAoB,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC;AAE9F,mFAAmF;AACnF,MAAM,MAAM,uBAAuB,GAAG,CAAC,IAAI,EAAE,oBAAoB,EAAE,IAAI,EAAE,oBAAoB,KAAK,gBAAgB,CAAC;AAEnH;;;;;;;;;;;;;GAaG;AACH,qBAAa,eAAe;IAYxB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAE3B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAdlC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoC;IACrE,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YACmB,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,gBAAgB,CAAC,EACpD,UAAU,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,EAC9D,QAAQ,CAAC,EAAE,cAAc,EACR,eAAe,GAAE,uBAA0E,EAG7G;IAEM,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE5B;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CASjC;IAED;;;OAGG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;OAIG;IACU,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA0BxG;IAED;;;;;;;;;;;OAWG;IACI,yBAAyB,CAAC,iBAAiB,EAAE,WAAW,GAAG,gBAAgB,EAAE,CAYnF;IAED;;;;OAIG;IACI,WAAW,CAAC,YAAY,EAAE,WAAW,GAAG,IAAI,CAiBlD;IAED,6DAA6D;IACtD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEnD;IAED,kGAAkG;IAC3F,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAE3E;IAED,+DAA+D;IACxD,OAAO,IAAI,gBAAgB,EAAE,CAEnC;IAED,yDAAyD;IAClD,IAAI,IAAI,gBAAgB,EAAE,CAEhC;IAED;;OAEG;IACU,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAIzE;IAED,yFAAyF;IAClF,eAAe,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,gBAAgB,EAAE,CAEnF;CACF;AAED,oFAAoF;AACpF,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAC"}
+{"version":3,"file":"checkpoint-store.d.ts","sourceRoot":"","sources":["../src/checkpoint-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAoB,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC9G,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,6BAA6B,CAAC;AAE3G,OAAO,EACL,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,4BAA4B,CAAC;AAEpC,8GAA8G;AAC9G,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,oBAAoB,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC;AAE9F,mFAAmF;AACnF,MAAM,MAAM,uBAAuB,GAAG,CAAC,IAAI,EAAE,oBAAoB,EAAE,IAAI,EAAE,oBAAoB,KAAK,gBAAgB,CAAC;AAEnH;;;;;;;;;;;;;GAaG;AACH,qBAAa,eAAe;IAcxB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAE3B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAhBlC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoC;IACrE,OAAO,CAAC,cAAc,CAAK;IAC3B,wEAAwE;IACxE,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YACmB,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,gBAAgB,CAAC,EACpD,UAAU,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,EAC9D,QAAQ,CAAC,EAAE,cAAc,EACR,eAAe,GAAE,uBAA0E,EAG7G;IAEM,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE5B;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CASjC;IAED;;;OAGG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;OAIG;IACU,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6BxG;IAED;;;OAGG;IACI,YAAY,CAAC,KAAK,EAAE,yBAAyB,GAAG,IAAI,CAE1D;IAED;;;;;;;;;;;OAWG;IACI,yBAAyB,CAAC,iBAAiB,EAAE,WAAW,GAAG,gBAAgB,EAAE,CAYnF;IAED;;;;OAIG;IACI,WAAW,CAAC,YAAY,EAAE,WAAW,GAAG,IAAI,CAiBlD;IAED,6DAA6D;IACtD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEnD;IAED,kGAAkG;IAC3F,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAE3E;IAED,+DAA+D;IACxD,OAAO,IAAI,gBAAgB,EAAE,CAEnC;IAED,yDAAyD;IAClD,IAAI,IAAI,gBAAgB,EAAE,CAEhC;IAED;;OAEG;IACU,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAIzE;IAED,yFAAyF;IAClF,eAAe,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,gBAAgB,EAAE,CAEnF;CACF;AAED,oFAAoF;AACpF,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAC"}

package/dest/checkpoint-store.js

@@ -25,6 +25,7 @@ import { CheckpointProver } from './job/checkpoint-prover.js';
    * teardowns for the same content id in flight at once, which a content-id key would clobber.
    */ pendingTeardowns;
     nextTeardownId;
+    /** Test-only hooks injected into every prover this store constructs. */ testHooks;
     log;
     constructor(l2BlockSource, proverDeps, bindings, proverFactoryFn = (args, deps)=>new CheckpointProver(args, deps)){
         this.l2BlockSource = l2BlockSource;
@@ -33,6 +34,7 @@ import { CheckpointProver } from './job/checkpoint-prover.js';
         this.provers = new Map();
         this.pendingTeardowns = new Map();
         this.nextTeardownId = 0;
+        this.testHooks = {};
         this.log = createLogger('prover-node:checkpoint-store', bindings);
     }
     start() {
@@ -87,12 +89,19 @@ import { CheckpointProver } from './job/checkpoint-prover.js';
             epochNumber
         }, {
             ...this.proverDeps,
+            checkpointProveOverride: this.testHooks.checkpointProveOverride,
             log: this.log
         });
         this.provers.set(id, prover);
         return prover;
     }
     /**
+   * Installs test-only hooks applied to every prover constructed from now on. Used by the e2e harness to
+   * force a checkpoint sub-tree failure without monkey-patching the prover factory.
+   */ setTestHooks(hooks) {
+        this.testHooks = hooks;
+    }
+    /**
    * Cancels and removes every prover that holds a block above the prune target. 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

package/dest/job/checkpoint-prover.d.ts

@@ -29,8 +29,23 @@ export type CheckpointProverDeps = {
     txGatheringTimeoutMs: number;
     /** Public processor deadline. */
     deadline: Date | undefined;
+    /**
+     * Fired once when the prover's block proofs reject for a genuine (non-cancel) reason — a sub-tree
+     * fault or a prune-induced fork fault. Useful for performing post mortem on failures.
+     */
+    onFailed?: (prover: CheckpointProver) => void;
+    /**
+     * Test-only hook: if set, invoked at the start of checkpoint execution instead of proving. Lets e2e
+     * tests force a sub-tree failure (it should throw) to exercise the checkpoint failure/upload path.
+     */
+    checkpointProveOverride?: () => Promise<never>;
     log: Logger;
 };
+/** Test-only hooks the store injects into every `CheckpointProver` it constructs. */
+export type CheckpointProverTestHooks = {
+    /** If set, invoked at the start of checkpoint execution instead of proving; should throw to fail. */
+    checkpointProveOverride?: () => Promise<never>;
+};
 /** Inputs that fully describe a checkpoint at register time. */
 export type CheckpointProverArgs = {
     checkpoint: Checkpoint;
@@ -76,9 +91,13 @@ export declare class CheckpointProver {
     readonly txs: Map<string, Tx>;
     /** Resolved by the sub-tree on success, rejected on cancel/failure. */
     private readonly blockProofs;
+    /** Block-level proving was fully *enqueued* (a progress marker; the sub-tree may still be proving). */
+    private completed;
+    /** Block proofs rejected for a genuine (non-cancel) reason — a sub-tree or prune-induced fork fault. */
+    private failed;
+    /** The prover was torn down (prune / reap / shutdown). */
     private cancelled;
     private subTree?;
-    private completed;
     private readonly abortController;
     /** Tracks the eager gather+execute task so `cancel()` and `whenDone()` can await its unwind. */
     private readonly runPromise;
@@ -92,8 +111,13 @@ export declare class CheckpointProver {
      */
     static idFor(checkpoint: Checkpoint): string;
     isCancelled(): boolean;
-    /** True once block-level proving has been fully *enqueued* (sub-tree completion may still be pending). */
-    isCompleted(): boolean;
+    /**
+     * True once this prover's block proofs have rejected for a genuine (non-cancel) reason — a sub-tree
+     * proving fault or a prune-induced world-state fork fault. A failed prover cannot produce its block
+     * proofs, so the reconciler must not build (or rebuild) an EpochSession over it; it is cleared only by
+     * a prune/re-add replacing it with a fresh prover, or by expiry reaping it.
+     */
+    isFailed(): boolean;
     /** AbortSignal that fires on cancel — for callers that want to wire their own tasks. */
     getAbortSignal(): AbortSignal;
     /** Promise that resolves with the block-rollup proofs for this checkpoint (or rejects on cancel/failure). */
@@ -101,6 +125,12 @@ export declare class CheckpointProver {
     /** Resolves when all in-flight work for this prover has fully unwound. */
     whenDone(): Promise<void>;
     private gatherAndExecute;
+    /**
+     * Rejects the block-proof promise and, unless this is a cancellation, records the prover as failed so
+     * the reconciler won't build an EpochSession over it. First rejection wins, so a later duplicate reject
+     * (e.g. the executeCheckpoint `finally`) is a harmless no-op.
+     */
+    private failBlockProofs;
     private gatherTxs;
     private executeCheckpoint;
     /**
@@ -121,4 +151,4 @@ export declare class CheckpointProver {
     private processTxs;
     private createFork;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/job/checkpoint-prover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkpoint-prover.d.ts","sourceRoot":"","sources":["../../src/job/checkpoint-prover.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"checkpoint-prover.d.ts","sourceRoot":"","sources":["../../src/job/checkpoint-prover.ts"],"names":[],"mappings":"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"}