@aztec/prover-node 0.0.1-commit.9ef841308 → 0.0.1-commit.a4600f49

package/dest/factory.js

@@ -12,7 +12,6 @@ import { createAndStartProvingBroker } from '@aztec/prover-client/broker';
 import { getPublisherConfigFromProverConfig } from '@aztec/sequencer-client';
 import { L1Metrics, getTelemetryClient } from '@aztec/telemetry-client';
 import { createPublicClient } from 'viem';
-import { EpochMonitor } from './monitors/epoch-monitor.js';
 import { ProverNode } from './prover-node.js';
 import { ProverPublisherFactory } from './prover-publisher-factory.js';
 /** Creates a new prover node subsystem given a config and dependencies */ export async function createProverNode(userConfig, deps) {
@@ -52,7 +51,7 @@ import { ProverPublisherFactory } from './prover-publisher-factory.js';
         }),
         pollingInterval: config.viemPollingIntervalMS
     });
-    const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
+    const rollupContract = new RollupContract(publicClient, config.rollupAddress.toString());
     const l1TxUtils = deps.l1TxUtils ? [
         deps.l1TxUtils
     ] : config.proverPublisherForwarderAddress ? await createForwarderL1TxUtilsFromSigners(publicClient, proverSigners.signers, config.proverPublisherForwarderAddress, {
@@ -89,6 +88,7 @@ import { ProverPublisherFactory } from './prover-publisher-factory.js';
     }
     const publisherFactory = deps.publisherFactory ?? new ProverPublisherFactory(config, {
         rollupContract,
+        proofSubmissionTarget: config.proofSubmissionTargetAddress,
         publisherManager: new PublisherManager(l1TxUtils, getPublisherConfigFromProverConfig(config), {
             bindings: log.getBindings(),
             funder: funderL1TxUtils
@@ -98,12 +98,8 @@ import { ProverPublisherFactory } from './prover-publisher-factory.js';
     const proverNodeConfig = {
         ...pick(config, 'proverNodeMaxPendingJobs', 'proverNodeMaxParallelBlocksPerEpoch', 'proverNodePollingIntervalMs', 'proverNodeEpochProvingDelayMs', 'txGatheringMaxParallelRequests', 'txGatheringIntervalMs', 'txGatheringTimeoutMs', 'proverNodeFailedEpochStore', 'proverNodeDisableProofPublish', 'dataDirectory', 'l1ChainId', 'rollupVersion')
     };
-    const epochMonitor = await EpochMonitor.create(archiver, {
-        pollingIntervalMs: config.proverNodePollingIntervalMs,
-        provingDelayMs: config.proverNodeEpochProvingDelayMs
-    }, telemetry);
     const l1Metrics = new L1Metrics(telemetry.getMeter('ProverNodeL1Metrics'), publicClient, l1TxUtils.map((utils)=>utils.getSenderAddress()));
     // Extract the shared delayer from the first L1TxUtils instance (all instances share the same delayer)
     const delayer = l1TxUtils[0]?.delayer;
-    return new ProverNode(prover, publisherFactory, archiver, archiver, archiver, worldStateSynchronizer, p2pClient, epochMonitor, rollupContract, l1Metrics, proverNodeConfig, telemetry, delayer, dateProvider);
+    return new ProverNode(prover, publisherFactory, archiver, archiver, archiver, worldStateSynchronizer, p2pClient, rollupContract, l1Metrics, deps.avmSimulator, proverNodeConfig, telemetry, delayer, dateProvider);
 }

package/dest/index.d.ts

@@ -2,6 +2,7 @@ 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';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGtCQUFrQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsa0JBQWtCLENBQUMifQ==

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC"}

package/dest/index.js

@@ -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';

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

@@ -0,0 +1,134 @@
+import { type ARCHIVE_HEIGHT } from '@aztec/constants';
+import { type EpochNumber, type SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { type DateProvider } from '@aztec/foundation/timer';
+import type { EpochProverFactory } from '@aztec/prover-client';
+import type { ChonkCache, SubTreeResult } from '@aztec/prover-client/orchestrator';
+import type { PublicProcessorFactory } from '@aztec/simulator/server';
+import type { CommitteeAttestation } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { ForkMerkleTreeOperations, ITxProvider } from '@aztec/stdlib/interfaces/server';
+import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
+import type { ProverNodeJobMetrics } from '../metrics.js';
+/** Dependencies a `CheckpointProver` needs at construction. */
+export type CheckpointProverDeps = {
+    proverFactory: EpochProverFactory;
+    /** Shared chonk-verifier cache. Survives across all sessions / epochs. */
+    chonkCache: ChonkCache;
+    publicProcessorFactory: PublicProcessorFactory;
+    dbProvider: Pick<ForkMerkleTreeOperations, 'fork'>;
+    txProvider: ITxProvider;
+    /** Clock the prover-node operates against — e2e fixtures inject a cheat-controlled one. */
+    dateProvider: DateProvider;
+    proverId: EthAddress;
+    metrics: ProverNodeJobMetrics;
+    /** Tx gathering deadline. */
+    txGatheringTimeoutMs: number;
+    /** Public processor deadline. */
+    deadline: Date | undefined;
+    log: Logger;
+};
+/** Inputs that fully describe a checkpoint at register time. */
+export type CheckpointProverArgs = {
+    checkpoint: Checkpoint;
+    /** Epoch the checkpoint belongs to (derivable from slot + L1 constants; cached at register time). */
+    epochNumber: EpochNumber;
+    attestations: CommitteeAttestation[];
+    previousBlockHeader: BlockHeader;
+    l1ToL2Messages: Fr[];
+    previousArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>;
+};
+/**
+ * Self-contained per-checkpoint prover, content-addressed by
+ * `(checkpoint number, slot number, checkpoint archive root)`.
+ *
+ * The store creates a CheckpointProver once per content-key. Keying on the checkpoint's
+ * own archive root (its post-state) means two checkpoints are "the same" iff they
+ * produce the same archive — so a reorg branch, or a replacement built on the same
+ * predecessor but with different content, keys to a distinct prover; an identical
+ * re-add keys to the same one and reuses its in-flight sub-tree work.
+ *
+ * The prover eagerly starts its own tx gather and sub-tree work in the constructor, so
+ * callers only need to call `whenBlockProofsReady()` to obtain the resulting block-rollup
+ * proofs.
+ *
+ * The prover survives prune/re-add cycles via `markPruned()` / `markCanonical()` —
+ * sub-tree proving keeps running underneath, so a checkpoint that is re-added after
+ * a brief reorg can be re-consumed with no re-proving.
+ *
+ * `cancel()` is idempotent. It aborts the gather + sub-tree, rejects the block-proof
+ * promise, and exposes a `whenDone()` that resolves once teardown has unwound.
+ */
+export declare class CheckpointProver {
+    private readonly deps;
+    readonly id: string;
+    readonly checkpoint: Checkpoint;
+    readonly epochNumber: EpochNumber;
+    readonly slotNumber: SlotNumber;
+    readonly attestations: CommitteeAttestation[];
+    readonly previousBlockHeader: BlockHeader;
+    readonly l1ToL2Messages: Fr[];
+    readonly previousArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>;
+    /** Per-prover tx map — populated by the internal gather. Empty until then. */
+    readonly txs: Map<string, Tx>;
+    /** Resolved by the sub-tree on success, rejected on cancel/failure. */
+    private readonly blockProofs;
+    private cancelled;
+    private subTree?;
+    private completed;
+    /** Pruned in the canonical chain but not yet reaped — sub-tree continues running. */
+    private pruned;
+    private readonly abortController;
+    /** Tracks the eager gather+execute task so `cancel()` and `whenDone()` can await its unwind. */
+    private readonly runPromise;
+    /** Tracks the cancel-driven teardown so `whenDone()` can await it. */
+    private cancelPromise?;
+    constructor(args: CheckpointProverArgs, deps: CheckpointProverDeps);
+    /**
+     * Stable content-addressed identifier: `${checkpoint number}:${slot}:${archive root}`.
+     * The archive root is the checkpoint's post-state, so it distinguishes any two
+     * checkpoints that differ in history or content while collapsing identical re-adds.
+     */
+    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;
+    isPruned(): boolean;
+    /**
+     * Mark this prover as no longer present in the canonical chain. Sub-tree proving keeps
+     * running so the work survives if the checkpoint is re-added. Idempotent.
+     */
+    markPruned(): void;
+    /** Mark this prover as part of the canonical chain again after a re-add. Idempotent. */
+    markCanonical(): void;
+    /** 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). */
+    whenBlockProofsReady(): Promise<SubTreeResult['blockProofOutputs']>;
+    /** Resolves when all in-flight work for this prover has fully unwound. */
+    whenDone(): Promise<void>;
+    private gatherAndExecute;
+    private gatherTxs;
+    private executeCheckpoint;
+    /**
+     * Mark cancelled. Idempotent. Aborts in-flight work, rejects the block-proof promise,
+     * and kicks off a background teardown of the sub-tree. The teardown promise is exposed
+     * via `whenDone()`.
+     *
+     * `routine` distinguishes a post-finalize teardown (sub-tree already proven, fires
+     * once at prover exit) from a real abort (reorg, prune, deadline). Behaviour is
+     * identical either way; the flag only adjusts log verbosity.
+     */
+    cancel({ routine }?: {
+        routine?: boolean;
+    }): void;
+    private runCancel;
+    private teardownSubTree;
+    private getTxsForBlock;
+    private processTxs;
+    private createFork;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dest/job/checkpoint-prover.js

@@ -0,0 +1,353 @@
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { Timer } from '@aztec/foundation/timer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import { CheckpointConstantData } from '@aztec/stdlib/rollup';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+/**
+ * Self-contained per-checkpoint prover, content-addressed by
+ * `(checkpoint number, slot number, checkpoint archive root)`.
+ *
+ * The store creates a CheckpointProver once per content-key. Keying on the checkpoint's
+ * own archive root (its post-state) means two checkpoints are "the same" iff they
+ * produce the same archive — so a reorg branch, or a replacement built on the same
+ * predecessor but with different content, keys to a distinct prover; an identical
+ * re-add keys to the same one and reuses its in-flight sub-tree work.
+ *
+ * The prover eagerly starts its own tx gather and sub-tree work in the constructor, so
+ * callers only need to call `whenBlockProofsReady()` to obtain the resulting block-rollup
+ * proofs.
+ *
+ * The prover survives prune/re-add cycles via `markPruned()` / `markCanonical()` —
+ * sub-tree proving keeps running underneath, so a checkpoint that is re-added after
+ * a brief reorg can be re-consumed with no re-proving.
+ *
+ * `cancel()` is idempotent. It aborts the gather + sub-tree, rejects the block-proof
+ * promise, and exposes a `whenDone()` that resolves once teardown has unwound.
+ */ export class CheckpointProver {
+    deps;
+    id;
+    checkpoint;
+    epochNumber;
+    slotNumber;
+    attestations;
+    previousBlockHeader;
+    l1ToL2Messages;
+    previousArchiveSiblingPath;
+    /** Per-prover tx map — populated by the internal gather. Empty until then. */ txs;
+    /** Resolved by the sub-tree on success, rejected on cancel/failure. */ blockProofs;
+    cancelled;
+    subTree;
+    completed;
+    /** Pruned in the canonical chain but not yet reaped — sub-tree continues running. */ pruned;
+    abortController;
+    /** Tracks the eager gather+execute task so `cancel()` and `whenDone()` can await its unwind. */ runPromise;
+    /** Tracks the cancel-driven teardown so `whenDone()` can await it. */ cancelPromise;
+    constructor(args, deps){
+        this.deps = deps;
+        this.txs = new Map();
+        this.blockProofs = promiseWithResolvers();
+        this.cancelled = false;
+        this.completed = false;
+        this.pruned = false;
+        this.abortController = new AbortController();
+        this.checkpoint = args.checkpoint;
+        this.epochNumber = args.epochNumber;
+        this.slotNumber = args.checkpoint.header.slotNumber;
+        this.attestations = args.attestations;
+        this.previousBlockHeader = args.previousBlockHeader;
+        this.l1ToL2Messages = args.l1ToL2Messages;
+        this.previousArchiveSiblingPath = args.previousArchiveSiblingPath;
+        this.id = CheckpointProver.idFor(args.checkpoint);
+        // Mark blockProofs as observed so a cancel that lands before any consumer awaits
+        // does not surface as an unhandled rejection.
+        this.blockProofs.promise.catch(()=>{});
+        deps.log.info(`Created CheckpointProver ${this.id}`, {
+            checkpointNumber: this.checkpoint.number,
+            epochNumber: this.epochNumber,
+            slotNumber: this.slotNumber,
+            blockCount: this.checkpoint.blocks.length,
+            l1ToL2MessageCount: this.l1ToL2Messages.length,
+            archiveRoot: this.checkpoint.archive.root.toString()
+        });
+        // Kick off the eager gather + sub-tree pipeline.
+        this.runPromise = this.gatherAndExecute();
+    }
+    /**
+   * Stable content-addressed identifier: `${checkpoint number}:${slot}:${archive root}`.
+   * The archive root is the checkpoint's post-state, so it distinguishes any two
+   * checkpoints that differ in history or content while collapsing identical re-adds.
+   */ static idFor(checkpoint) {
+        return `${checkpoint.number}:${checkpoint.header.slotNumber}:${checkpoint.archive.root.toString()}`;
+    }
+    isCancelled() {
+        return this.cancelled;
+    }
+    /** True once block-level proving has been fully *enqueued* (sub-tree completion may still be pending). */ isCompleted() {
+        return this.completed;
+    }
+    isPruned() {
+        return this.pruned;
+    }
+    /**
+   * Mark this prover as no longer present in the canonical chain. Sub-tree proving keeps
+   * running so the work survives if the checkpoint is re-added. Idempotent.
+   */ markPruned() {
+        if (this.pruned) {
+            return;
+        }
+        this.pruned = true;
+        this.deps.log.info(`Marking CheckpointProver ${this.id} as pruned`, {
+            checkpointNumber: this.checkpoint.number,
+            slotNumber: this.slotNumber
+        });
+    }
+    /** Mark this prover as part of the canonical chain again after a re-add. Idempotent. */ markCanonical() {
+        if (!this.pruned) {
+            return;
+        }
+        this.pruned = false;
+        this.deps.log.info(`Marking CheckpointProver ${this.id} as canonical`, {
+            checkpointNumber: this.checkpoint.number,
+            slotNumber: this.slotNumber
+        });
+    }
+    /** AbortSignal that fires on cancel — for callers that want to wire their own tasks. */ getAbortSignal() {
+        return this.abortController.signal;
+    }
+    /** Promise that resolves with the block-rollup proofs for this checkpoint (or rejects on cancel/failure). */ whenBlockProofsReady() {
+        return this.blockProofs.promise;
+    }
+    /** Resolves when all in-flight work for this prover has fully unwound. */ async whenDone() {
+        await this.runPromise.catch(()=>{});
+        if (this.cancelPromise) {
+            await this.cancelPromise;
+        }
+    }
+    async gatherAndExecute() {
+        try {
+            const txs = await this.gatherTxs();
+            if (this.cancelled) {
+                return;
+            }
+            await this.executeCheckpoint(txs);
+        } catch (err) {
+            if (this.cancelled) {
+                this.deps.log.debug(`CheckpointProver ${this.id} cancelled during gather/execute`, {
+                    checkpointNumber: this.checkpoint.number
+                });
+                return;
+            }
+            this.deps.log.error(`Error in CheckpointProver ${this.id}`, err, {
+                checkpointNumber: this.checkpoint.number
+            });
+            this.blockProofs.reject(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    async gatherTxs() {
+        const deadline = new Date(this.deps.dateProvider.now() + this.deps.txGatheringTimeoutMs);
+        const txsByBlock = await Promise.all(this.checkpoint.blocks.map((block)=>this.deps.txProvider.getTxsForBlock(block, {
+                deadline
+            })));
+        const txs = txsByBlock.map(({ txs })=>txs).flat();
+        const missingTxs = txsByBlock.map(({ missingTxs })=>missingTxs).flat();
+        if (missingTxs.length > 0) {
+            throw new Error(`Txs not found for checkpoint ${this.checkpoint.number}: ${missingTxs.map((hash)=>hash.toString()).join(', ')}`);
+        }
+        return new Map(txs.map((tx)=>[
+                tx.getTxHash().toString(),
+                tx
+            ]));
+    }
+    async executeCheckpoint(txs) {
+        const signal = this.abortController.signal;
+        const checkpointTimer = new Timer();
+        let subTreeStarted = false;
+        try {
+            for (const [hash, tx] of txs){
+                this.txs.set(hash, tx);
+            }
+            const { chainId, version } = this.checkpoint.blocks[0].header.globalVariables;
+            const checkpointConstants = CheckpointConstantData.from({
+                chainId,
+                version,
+                vkTreeRoot: getVKTreeRoot(),
+                protocolContractsHash: protocolContractsHash,
+                proverId: this.deps.proverId.toField(),
+                slotNumber: this.checkpoint.header.slotNumber,
+                coinbase: this.checkpoint.header.coinbase,
+                feeRecipient: this.checkpoint.header.feeRecipient,
+                gasFees: this.checkpoint.header.gasFees
+            });
+            this.deps.log.info(`Starting processing checkpoint ${this.checkpoint.number}`, {
+                checkpointNumber: this.checkpoint.number,
+                checkpointHash: this.checkpoint.hash().toString(),
+                blockCount: this.checkpoint.blocks.length
+            });
+            this.subTree = await this.deps.proverFactory.createCheckpointSubTreeOrchestrator(this.deps.chonkCache, this.epochNumber, checkpointConstants, this.l1ToL2Messages, this.checkpoint.blocks.length, this.previousBlockHeader);
+            subTreeStarted = true;
+            // Bridge the sub-tree's result onto blockProofs.
+            void this.subTree.getSubTreeResult().then((result)=>{
+                this.deps.log.info(`Sub-tree block proofs ready for checkpoint ${this.checkpoint.number}`, {
+                    checkpointNumber: this.checkpoint.number,
+                    blockProofCount: result.blockProofOutputs.length
+                });
+                // Spans processing + proving (from executeCheckpoint start, after tx gathering) to proofs ready.
+                this.deps.metrics.recordCheckpointProving(checkpointTimer.ms());
+                this.blockProofs.resolve(result.blockProofOutputs);
+            }, (err)=>this.blockProofs.reject(err));
+            if (signal.aborted) {
+                return;
+            }
+            const allTxs = this.checkpoint.blocks.flatMap((block)=>block.body.txEffects.map((txEffect)=>txs.get(txEffect.txHash.toString())));
+            const publicTxs = allTxs.filter((tx)=>tx?.data.forPublic);
+            if (publicTxs.length > 0) {
+                await this.subTree.startChonkVerifierCircuits(publicTxs);
+                if (signal.aborted) {
+                    return;
+                }
+            }
+            for(let blockIndex = 0; blockIndex < this.checkpoint.blocks.length; blockIndex++){
+                const blockTimer = new Timer();
+                const block = this.checkpoint.blocks[blockIndex];
+                const globalVariables = block.header.globalVariables;
+                const blockTxs = this.getTxsForBlock(block, txs);
+                await this.subTree.startNewBlock(block.number, globalVariables.timestamp, blockTxs.length);
+                if (signal.aborted) {
+                    return;
+                }
+                const db = await this.createFork(BlockNumber(block.number - 1), blockIndex === 0 ? this.l1ToL2Messages : undefined);
+                try {
+                    if (signal.aborted) {
+                        return;
+                    }
+                    const config = PublicSimulatorConfig.from({
+                        proverId: this.deps.proverId.toField(),
+                        skipFeeEnforcement: false,
+                        collectDebugLogs: false,
+                        collectHints: true,
+                        collectPublicInputs: true,
+                        collectStatistics: false
+                    });
+                    const publicProcessor = this.deps.publicProcessorFactory.create(db, globalVariables, config);
+                    const processed = await this.processTxs(publicProcessor, blockTxs);
+                    if (signal.aborted) {
+                        return;
+                    }
+                    await this.subTree.addTxs(processed);
+                } finally{
+                    await db.close();
+                }
+                if (signal.aborted) {
+                    return;
+                }
+                await this.subTree.setBlockCompleted(block.number, block.header);
+                this.deps.metrics.recordBlockProcessing(blockTimer.ms());
+                if (signal.aborted) {
+                    return;
+                }
+            }
+            this.completed = true;
+            const numTxs = this.checkpoint.blocks.reduce((acc, block)=>acc + block.body.txEffects.length, 0);
+            this.deps.metrics.recordCheckpointProcessing(checkpointTimer.ms(), this.checkpoint.blocks.length, numTxs);
+            this.deps.log.info(`Finished enqueueing block-level proving for checkpoint ${this.checkpoint.number} in ${checkpointTimer.ms()}ms`, {
+                checkpointNumber: this.checkpoint.number,
+                blockCount: this.checkpoint.blocks.length,
+                durationMs: checkpointTimer.ms()
+            });
+        } finally{
+            if (!this.completed) {
+                if (subTreeStarted) {
+                    await this.teardownSubTree();
+                }
+                this.blockProofs.reject(new Error(`Checkpoint ${this.id} did not complete block processing`));
+            }
+        }
+    }
+    /**
+   * Mark cancelled. Idempotent. Aborts in-flight work, rejects the block-proof promise,
+   * and kicks off a background teardown of the sub-tree. The teardown promise is exposed
+   * via `whenDone()`.
+   *
+   * `routine` distinguishes a post-finalize teardown (sub-tree already proven, fires
+   * once at prover exit) from a real abort (reorg, prune, deadline). Behaviour is
+   * identical either way; the flag only adjusts log verbosity.
+   */ cancel({ routine = false } = {}) {
+        if (this.cancelled) {
+            return;
+        }
+        this.cancelled = true;
+        // A teardown of a completed prover is routine regardless of the caller's flag —
+        // we logged the work as done already, so don't relabel it as a mid-flight cancel.
+        if (routine || this.completed) {
+            this.deps.log.verbose(`Tearing down CheckpointProver ${this.id}`, {
+                checkpointNumber: this.checkpoint.number,
+                wasCompleted: this.completed
+            });
+        } else {
+            this.deps.log.info(`Cancelling in-flight CheckpointProver ${this.id}`, {
+                checkpointNumber: this.checkpoint.number,
+                wasCompleted: this.completed
+            });
+        }
+        this.abortController.abort();
+        this.blockProofs.reject(new Error(`Checkpoint ${this.id} cancelled`));
+        this.cancelPromise = this.runCancel().catch(()=>{});
+    }
+    async runCancel() {
+        if (this.subTree) {
+            try {
+                this.subTree.cancel();
+            } catch (err) {
+                this.deps.log.error('Error cancelling sub-tree', err);
+            }
+        }
+        await this.runPromise.catch(()=>{});
+        if (this.subTree) {
+            await this.teardownSubTree();
+        }
+    }
+    async teardownSubTree() {
+        const { subTree } = this;
+        this.subTree = undefined;
+        if (subTree) {
+            this.deps.log.debug(`Tearing down sub-tree for checkpoint ${this.checkpoint.number}`, {
+                checkpointNumber: this.checkpoint.number
+            });
+            try {
+                await subTree.stop();
+            } catch (err) {
+                this.deps.log.error('Error stopping sub-tree', err);
+            }
+        }
+    }
+    getTxsForBlock(block, txs) {
+        return block.body.txEffects.map((txEffect)=>txs.get(txEffect.txHash.toString()));
+    }
+    async processTxs(publicProcessor, txs) {
+        const [processedTxs, failedTxs] = await publicProcessor.process(txs, {
+            deadline: this.deps.deadline
+        });
+        if (failedTxs.length) {
+            const failedTxHashes = await Promise.all(failedTxs.map(({ tx })=>tx.getTxHash()));
+            throw new Error(`Txs failed processing: ${failedTxs.map(({ error }, index)=>`${failedTxHashes[index]} (${error})`).join(', ')}`);
+        }
+        if (processedTxs.length !== txs.length) {
+            throw new Error(`Failed to process all txs: processed ${processedTxs.length} out of ${txs.length}`);
+        }
+        return processedTxs;
+    }
+    async createFork(blockNumber, l1ToL2Messages) {
+        const db = await this.deps.dbProvider.fork(blockNumber);
+        if (l1ToL2Messages !== undefined) {
+            const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, 'Too many L1 to L2 messages');
+            await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+        }
+        return db;
+    }
+}