@aztec/prover-node 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

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

@@ -1,42 +1,262 @@
-import { createArchiverStore } from '@aztec/archiver';
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+import { createArchiverStore, createContractDataSource } from '@aztec/archiver';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { DateProvider } from '@aztec/foundation/timer';
 import { createProverClient } from '@aztec/prover-client';
 import { 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 { getEpochAtSlot, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 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 } 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(localPath, log, config) {
+ */ export async function rerunEpochProvingJob(localPath, log, config, genesis) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const ctx = _ts_add_disposable_resource(env, await createRerunContext(localPath, log, config, genesis), true);
+        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 l1Constants = {
+            epochDuration: config.aztecEpochDuration
+        };
+        const [fromSlot, toSlot] = getSlotRangeForEpoch(jobData.epochNumber, l1Constants);
+        const spec = {
+            kind: 'full',
+            epochNumber: jobData.epochNumber,
+            fromSlot,
+            toSlot
+        };
+        const session = new EpochSession(spec, provers, {
+            proverFactory: prover,
+            proverId: prover.getProverId(),
+            publishingService,
+            metrics,
+            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;
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+/**
+ * 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 env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const ctx = _ts_add_disposable_resource(env, await createRerunContext(localPath, log, config, genesis), true);
+        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();
+        }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+/**
+ * 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);
-    const archiver = await createArchiverStore(config, {
-        epochDuration: config.aztecEpochDuration
+    const worldState = await createWorldState(config, genesis);
+    const initialBlockHash = await worldState.getInitialHeader().hash();
+    const archiver = await createArchiverStore(config, initialBlockHash);
+    const avmSimulator = await AvmSimulatorPool.spawn({
+        wsdbIpcPath: worldState.getIpcPath()
     });
-    const publicProcessorFactory = new PublicProcessorFactory(archiver, undefined, undefined, log.getBindings());
-    const publisher = {
-        submitEpochProof: ()=>Promise.resolve(true)
-    };
-    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 publicProcessorFactory = new PublicProcessorFactory(createContractDataSource(archiver), avmSimulator, undefined, undefined, log.getBindings());
     const broker = await createAndStartProvingBroker(config, telemetry);
     const prover = await createProverClient(config, worldState, broker, telemetry);
-    const provingJob = new EpochProvingJob(jobData, worldState, prover.createEpochProver(), publicProcessorFactory, publisher, l2BlockSourceForReorgDetection, metrics, deadline, {
-        skipEpochCheck: true
-    }, log.getBindings());
-    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();
+    const chonkCache = new ChonkCache(log.getBindings());
+    const txProvider = makeReplayingTxProvider(jobData.txs);
+    return {
+        jobData,
+        metrics,
+        worldState,
+        publicProcessorFactory,
+        prover,
+        chonkCache,
+        txProvider,
+        async [Symbol.asyncDispose] () {
+            await avmSimulator[Symbol.asyncDispose]();
+            await worldState[Symbol.asyncDispose]();
+        }
+    };
+}
+/** 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 = [];
+        const missing = [];
+        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)=>Promise.resolve(lookup(block.body.txEffects.map((e)=>e.txHash)))
+    };
 }

package/dest/actions/upload-epoch-proof-failure.d.ts

@@ -1,8 +1,8 @@
 import { type Archiver } from '@aztec/archiver';
 import type { Logger } from '@aztec/foundation/log';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import { type EpochProvingJobData } from '../job/epoch-proving-job-data.js';
 type UploadEpochProofConfig = Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> & Pick<DataStoreConfig, 'dataDirectory'>;
 /**
@@ -12,4 +12,4 @@ type UploadEpochProofConfig = Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> &
  */
 export declare function uploadEpochProofFailure(location: string, jobId: string, jobData: EpochProvingJobData, archiver: Archiver, worldState: WorldStateSynchronizer, config: UploadEpochProofConfig, log: Logger): Promise<string>;
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBsb2FkLWVwb2NoLXByb29mLWZhaWx1cmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hY3Rpb25zL3VwbG9hZC1lcG9jaC1wcm9vZi1mYWlsdXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBdUIsS0FBSyxRQUFRLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUdyRSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUU5RCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV4RCxPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBUTlFLE9BQU8sRUFBRSxLQUFLLG1CQUFtQixFQUFnQyxNQUFNLGtDQUFrQyxDQUFDO0FBRTFHLEtBQUssc0JBQXNCLEdBQUcsSUFBSSxDQUFDLFdBQVcsRUFBRSxXQUFXLEdBQUcsZUFBZSxDQUFDLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxlQUFlLENBQUMsQ0FBQztBQUt4SDs7OztHQUlHO0FBQ0gsd0JBQXNCLHVCQUF1QixDQUMzQyxRQUFRLEVBQUUsTUFBTSxFQUNoQixLQUFLLEVBQUUsTUFBTSxFQUNiLE9BQU8sRUFBRSxtQkFBbUIsRUFDNUIsUUFBUSxFQUFFLFFBQVEsRUFDbEIsVUFBVSxFQUFFLHNCQUFzQixFQUNsQyxNQUFNLEVBQUUsc0JBQXNCLEVBQzlCLEdBQUcsRUFBRSxNQUFNLG1CQXVDWiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBsb2FkLWVwb2NoLXByb29mLWZhaWx1cmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hY3Rpb25zL3VwbG9hZC1lcG9jaC1wcm9vZi1mYWlsdXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBdUIsS0FBSyxRQUFRLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUdyRSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUdwRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV4RCxPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzlFLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBUTlELE9BQU8sRUFBRSxLQUFLLG1CQUFtQixFQUFnQyxNQUFNLGtDQUFrQyxDQUFDO0FBRTFHLEtBQUssc0JBQXNCLEdBQUcsSUFBSSxDQUFDLFdBQVcsRUFBRSxXQUFXLEdBQUcsZUFBZSxDQUFDLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxlQUFlLENBQUMsQ0FBQztBQUt4SDs7OztHQUlHO0FBQ0gsd0JBQXNCLHVCQUF1QixDQUMzQyxRQUFRLEVBQUUsTUFBTSxFQUNoQixLQUFLLEVBQUUsTUFBTSxFQUNiLE9BQU8sRUFBRSxtQkFBbUIsRUFDNUIsUUFBUSxFQUFFLFFBQVEsRUFDbEIsVUFBVSxFQUFFLHNCQUFzQixFQUNsQyxNQUFNLEVBQUUsc0JBQXNCLEVBQzlCLEdBQUcsRUFBRSxNQUFNLG1CQXVDWiJ9

package/dest/actions/upload-epoch-proof-failure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upload-epoch-proof-failure.d.ts","sourceRoot":"","sources":["../../src/actions/upload-epoch-proof-failure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAGrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAQ9E,OAAO,EAAE,KAAK,mBAAmB,EAAgC,MAAM,kCAAkC,CAAC;AAE1G,KAAK,sBAAsB,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,eAAe,CAAC,GAAG,IAAI,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;AAKxH;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,sBAAsB,EAClC,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,MAAM,mBAuCZ"}
+{"version":3,"file":"upload-epoch-proof-failure.d.ts","sourceRoot":"","sources":["../../src/actions/upload-epoch-proof-failure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAGrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAQ9D,OAAO,EAAE,KAAK,mBAAmB,EAAgC,MAAM,kCAAkC,CAAC;AAE1G,KAAK,sBAAsB,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,eAAe,CAAC,GAAG,IAAI,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;AAKxH;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,sBAAsB,EAClC,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,MAAM,mBAuCZ"}

package/dest/bin/run-failed-epoch.js

@@ -1,4 +1,5 @@
-/* eslint-disable no-console */ import { EthAddress } from '@aztec/foundation/eth-address';
+/* eslint-disable no-console */ import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 import { downloadEpochProvingJob, getProverNodeConfigFromEnv, rerunEpochProvingJob } from '@aztec/prover-node';
@@ -15,8 +16,10 @@ async function rerunFailedEpoch(provingJobUrl, baseLocalDir) {
     const jobPath = join(localDir, 'data.bin');
     const dataDir = join(localDir, 'state');
     const env = getProverNodeConfigFromEnv();
+    const l1Config = getL1ContractsConfigEnvVars();
     const config = {
-        ...getProverNodeConfigFromEnv(),
+        ...env,
+        ...l1Config,
         dataDirectory: dataDir,
         dataStoreMapSizeKb: env.dataStoreMapSizeKb ?? 1024 * 1024,
         proverId: env.proverId ?? EthAddress.random()
@@ -38,9 +41,7 @@ async function rerunFailedEpoch(provingJobUrl, baseLocalDir) {
     logger.info(`Rerunning proving job from ${jobPath} with state from ${dataDir}`, metadata);
     const result = await rerunEpochProvingJob(jobPath, logger, {
         ...config,
-        l1Contracts: {
-            rollupAddress: metadata.rollupAddress
-        },
+        rollupAddress: metadata.rollupAddress,
         rollupVersion: metadata.rollupVersion
     });
     console.error(`Epoch proving job complete with result ${result}`);

package/dest/checkpoint-store.d.ts

@@ -0,0 +1,95 @@
+import type { BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+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, 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. */
+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:
+ *  - its checkpoint is pruned by an L1 reorg (`cancelAndRemoveAboveBlock`), or
+ *  - its epoch's proof-submission window has closed (`reapExpired`), so the proof could no
+ *    longer be accepted on L1 even if produced.
+ *
+ * A prover's sub-tree work forks world-state per block and does not survive a prune of a base
+ * block, so there is nothing to preserve across a reorg: a pruned prover is cancelled and
+ * dropped, and a re-add (even of identical content) constructs a fresh prover.
+ */
+export declare class CheckpointStore {
+    private readonly l2BlockSource;
+    private readonly proverDeps;
+    private readonly proverFactoryFn;
+    private readonly provers;
+    /**
+     * Teardowns of provers already removed from `provers` (by prune or reap), awaited on `stop()`.
+     * Keyed by a monotonic id rather than the prover's content id: a prune-then-re-add can leave two
+     * teardowns for the same content id in flight at once, which a content-id key would clobber.
+     */
+    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>;
+    stop(): Promise<void>;
+    /**
+     * Tracks the teardown of a prover just removed from the store so `stop()` can await it. The entry
+     * removes itself once teardown settles, so the map stays bounded by the number in flight.
+     */
+    private trackTeardown;
+    /**
+     * Registers a checkpoint with the store. If a prover already exists for the
+     * `(number, slot, archive root)` content key it is reused (an at-least-once re-registration of
+     * 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
+     * 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.
+     *
+     * The prover's in-flight sub-tree work forks world-state per block and faults once its base block is pruned, so it
+     * cannot be reused; it is cancelled (aborting the fork reads) and dropped. A subsequent re-add constructs a fresh
+     * prover. Returns the removed provers.
+     */
+    cancelAndRemoveAboveBlock(targetBlockNumber: BlockNumber): CheckpointProver[];
+    /**
+     * Drops 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.
+     */
+    reapExpired(expiredEpoch: EpochNumber): void;
+    /** Returns the prover with the supplied id, or undefined. */
+    get(id: string): CheckpointProver | undefined;
+    /** Returns the prover for the supplied checkpoint (by its content-addressed id), or undefined. */
+    getByCheckpoint(checkpoint: Checkpoint): CheckpointProver | undefined;
+    /** Every prover currently in the store, in insertion order. */
+    listAll(): CheckpointProver[];
+    /** Provers in the store, sorted by checkpoint number. */
+    list(): CheckpointProver[];
+    /**
+     * Provers whose slot is in the supplied epoch's slot range, sorted by checkpoint number.
+     */
+    listForEpoch(epoch: EpochNumber): Promise<CheckpointProver[]>;
+    /** Provers whose slot falls within `[fromSlot, toSlot]`, sorted by checkpoint number. */
+    listInSlotRange(fromSlot: SlotNumber, toSlot: SlotNumber): CheckpointProver[];
+}
+/** 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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

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

@@ -0,0 +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,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

@@ -0,0 +1,178 @@
+import { createLogger } from '@aztec/foundation/log';
+import { getEpochAtSlot, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { CheckpointProver } from './job/checkpoint-prover.js';
+/**
+ * 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:
+ *  - its checkpoint is pruned by an L1 reorg (`cancelAndRemoveAboveBlock`), or
+ *  - its epoch's proof-submission window has closed (`reapExpired`), so the proof could no
+ *    longer be accepted on L1 even if produced.
+ *
+ * A prover's sub-tree work forks world-state per block and does not survive a prune of a base
+ * block, so there is nothing to preserve across a reorg: a pruned prover is cancelled and
+ * dropped, and a re-add (even of identical content) constructs a fresh prover.
+ */ export class CheckpointStore {
+    l2BlockSource;
+    proverDeps;
+    proverFactoryFn;
+    provers;
+    /**
+   * Teardowns of provers already removed from `provers` (by prune or reap), awaited on `stop()`.
+   * Keyed by a monotonic id rather than the prover's content id: a prune-then-re-add can leave two
+   * 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;
+        this.proverDeps = proverDeps;
+        this.proverFactoryFn = proverFactoryFn;
+        this.provers = new Map();
+        this.pendingTeardowns = new Map();
+        this.nextTeardownId = 0;
+        this.testHooks = {};
+        this.log = createLogger('prover-node:checkpoint-store', bindings);
+    }
+    start() {
+        return Promise.resolve();
+    }
+    async stop() {
+        // Cancel every live prover, then await both their teardown and any still in flight for provers
+        // already removed by a prune or reap.
+        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()),
+            ...this.pendingTeardowns.values()
+        ]);
+    }
+    /**
+   * Tracks the teardown of a prover just removed from the store so `stop()` can await it. The entry
+   * removes itself once teardown settles, so the map stays bounded by the number in flight.
+   */ trackTeardown(prover) {
+        const id = this.nextTeardownId++;
+        const done = prover.whenDone();
+        this.pendingTeardowns.set(id, done);
+        void done.finally(()=>this.pendingTeardowns.delete(id));
+    }
+    /**
+   * Registers a checkpoint with the store. If a prover already exists for the
+   * `(number, slot, archive root)` content key it is reused (an at-least-once re-registration of
+   * still-canonical content); otherwise a new prover is constructed.
+   */ async addOrUpdate(checkpoint, data) {
+        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) {
+            return existing;
+        }
+        // At most one canonical checkpoint per slot. A different 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. A pruned checkpoint has already been removed,
+        // so every prover still in the store is canonical.
+        for (const prover of this.provers.values()){
+            if (prover.slotNumber === checkpoint.header.slotNumber) {
+                throw new Error(`Cannot add checkpoint ${checkpoint.number} (archive ${checkpoint.archive.root}) at slot ${checkpoint.header.slotNumber}: ` + `a different checkpoint already occupies this slot. Prune it first.`);
+            }
+        }
+        const prover = this.proverFactoryFn({
+            ...data,
+            checkpoint,
+            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
+   * 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.
+   *
+   * The prover's in-flight sub-tree work forks world-state per block and faults once its base block is pruned, so it
+   * cannot be reused; it is cancelled (aborting the fork reads) and dropped. A subsequent re-add constructs a fresh
+   * prover. Returns the removed provers.
+   */ cancelAndRemoveAboveBlock(targetBlockNumber) {
+        const affected = [];
+        for (const [id, prover] of Array.from(this.provers.entries())){
+            const lastBlockNumber = prover.checkpoint.blocks.at(-1).number;
+            if (lastBlockNumber > targetBlockNumber) {
+                prover.cancel();
+                this.trackTeardown(prover);
+                this.provers.delete(id);
+                affected.push(prover);
+            }
+        }
+        return affected;
+    }
+    /**
+   * Drops 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.
+   */ reapExpired(expiredEpoch) {
+        const reaped = [];
+        for (const [id, prover] of Array.from(this.provers.entries())){
+            if (prover.epochNumber <= expiredEpoch) {
+                reaped.push({
+                    id,
+                    checkpointNumber: prover.checkpoint.number,
+                    epochNumber: prover.epochNumber
+                });
+                prover.cancel({
+                    routine: true
+                });
+                this.trackTeardown(prover);
+                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. */ get(id) {
+        return this.provers.get(id);
+    }
+    /** Returns the prover for the supplied checkpoint (by its content-addressed id), or undefined. */ getByCheckpoint(checkpoint) {
+        return this.provers.get(CheckpointProver.idFor(checkpoint));
+    }
+    /** Every prover currently in the store, in insertion order. */ listAll() {
+        return Array.from(this.provers.values());
+    }
+    /** Provers in the store, sorted by checkpoint number. */ list() {
+        return Array.from(this.provers.values()).sort((a, b)=>a.checkpoint.number - b.checkpoint.number);
+    }
+    /**
+   * Provers whose slot is in the supplied epoch's slot range, sorted by checkpoint number.
+   */ async listForEpoch(epoch) {
+        const l1Constants = await this.l2BlockSource.getL1Constants();
+        const [fromSlot, toSlot] = getSlotRangeForEpoch(epoch, l1Constants);
+        return this.listInSlotRange(fromSlot, toSlot);
+    }
+    /** Provers whose slot falls within `[fromSlot, toSlot]`, sorted by checkpoint number. */ listInSlotRange(fromSlot, toSlot) {
+        return this.list().filter((p)=>p.slotNumber >= fromSlot && p.slotNumber <= toSlot);
+    }
+}