@aztec/prover-node 5.0.0-private.20260319 → 5.0.0-rc.2

package/dest/proof-publishing-service.d.ts

@@ -0,0 +1,161 @@
+import type { BatchedBlob } from '@aztec/blob-lib';
+import type { ViemCommitteeAttestation } from '@aztec/ethereum/contracts';
+import { BlockNumber, type CheckpointNumber, type EpochNumber } from '@aztec/foundation/branded-types';
+import { type LoggerBindings } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { Proof } from '@aztec/stdlib/proofs';
+import type { CheckpointHeader, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import type { ProverNodePublisher } from './prover-node-publisher.js';
+import type { ProverPublisherFactory } from './prover-publisher-factory.js';
+/** A single proof candidate offered to the publishing service by an `EpochSession`. */
+export type PublishCandidate = {
+    /** Stable id; matches the originating session so `withdraw` can target this entry. */
+    id: string;
+    epoch: EpochNumber;
+    /**
+     * Full vs partial. A `partial` candidate is an early-finish optimisation: if the chain's
+     * proven tip catches up to or past its `endBlock` before it publishes, it's superseded —
+     * publishing would be wasted L1 gas. A `full` candidate covers the entire epoch and is
+     * useful to publish even after some other prover-node has already submitted (the rollup
+     * contract records the submission per prover-id), so it is never auto-superseded by the
+     * proven tip alone.
+     */
+    kind: 'full' | 'partial';
+    /** First L2 block in the candidate's range. */
+    startBlock: BlockNumber;
+    /** Last L2 block in the candidate's range. */
+    endBlock: BlockNumber;
+    /**
+     * Wall-clock time after which the candidate is no longer worth publishing — typically
+     * the L1 proof-submission window deadline. If the candidate is still queued at this
+     * time it resolves as `'expired'`. If it's already in flight, the publish runs to
+     * completion (the L1 tx may still mine; the deadline only governs whether the service
+     * will start a publish). `undefined` disables the per-candidate timer.
+     */
+    deadline: Date | undefined;
+    /** Everything `ProverNodePublisher.submitEpochProof` needs. */
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+    batchedBlobInputs: BatchedBlob;
+    attestations: ViemCommitteeAttestation[];
+    /** Committee-attested checkpoint headers for the range, supplying the L1-verified fee recipient/value. */
+    headers: CheckpointHeader[];
+};
+/** Terminal outcome for a candidate. The promise from `submit()` resolves with one of these. */
+export type PublishOutcome = 'published' | 'superseded' | 'failed' | 'withdrawn' | 'expired';
+/** Subset of `ProverPublisherFactory` the service uses — single async `create()` call. */
+export type PublisherFactoryLike = Pick<ProverPublisherFactory, 'create'>;
+/** Subset of `ProverNodePublisher` the service drives — one publish per fresh publisher. */
+export type PublisherLike = Pick<ProverNodePublisher, 'submitEpochProof' | 'analyzeEpochProofSubmission'>;
+/** Config for the publishing service. */
+export type ProofPublishingServiceConfig = {
+    /** When true, submitting a candidate runs `analyzeEpochProofSubmission` instead of publishing. */
+    skipSubmitProof: boolean;
+};
+export type ProofPublishingServiceDeps = {
+    publisherFactory: PublisherFactoryLike;
+    l2BlockSource: Pick<L2BlockSource, 'getBlockNumber'>;
+    dateProvider: DateProvider;
+    config: ProofPublishingServiceConfig;
+    bindings?: LoggerBindings;
+};
+/**
+ * Central owner of L1 proof submission. Sessions offer their proofs here as
+ * `PublishCandidate`s; the service serialises one publish at a time, picks the
+ * longest candidate per epoch as the winner, and resolves the rest as
+ * `'superseded'` without spending L1 gas.
+ *
+ * Construction-time invariants:
+ * - Every publish runs against a freshly-created `ProverNodePublisher` from the factory.
+ * - Only one publish is ever in flight (`SerialQueue` drain) — no defensive locks.
+ * - Once an L1 publish starts, it runs to completion. `withdraw` is a queue-only
+ *   operation: it removes a candidate that has not yet started publishing. An in-flight
+ *   candidate is left alone and its outcome (`'published'` / `'failed'`) is reported as
+ *   usual — the originating session has already moved to a terminal state via `cancel()`
+ *   and ignores the late outcome.
+ *
+ * Eligibility for publication is decided against the proven block number read inside
+ * the drain (so the value is consistent with the publish that runs on the same drain
+ * pass): a candidate is eligible when its predecessor block is proven and (for partial
+ * candidates) the candidate's range extends past the proven tip. `onChainProven` is a
+ * wake-up signal; it does not pass state into the drain.
+ */
+export declare class ProofPublishingService {
+    private readonly deps;
+    private readonly log;
+    private readonly epochs;
+    /**
+     * One drain task at a time. Submits, withdrawals, chain-proven advances, and prunes
+     * all schedule a `drain` here, so the eligibility re-check and the L1 publish never
+     * interleave.
+     *
+     * Protected so unit tests can `await drainQueue.syncPoint()` to wait for pending
+     * drain work to settle deterministically (no sleeps).
+     */
+    protected readonly drainQueue: SerialQueue;
+    /** Tracks the candidate currently being published. Set while drain is awaiting the L1 publish. */
+    private inFlight;
+    private stopped;
+    constructor(deps: ProofPublishingServiceDeps);
+    /**
+     * Offers a proof candidate to the service. The returned promise resolves once the
+     * service settles the candidate's fate: `'published'` if it wins and L1 accepts it,
+     * `'superseded'` if a longer candidate for the same epoch wins, `'failed'` if the
+     * L1 submission errored, `'withdrawn'` if the originating session cancelled,
+     * `'expired'` if the candidate's `deadline` elapsed before publishing started.
+     */
+    submit(candidate: PublishCandidate): Promise<PublishOutcome>;
+    /**
+     * Pulls a queued candidate from the bucket and resolves its promise as `'withdrawn'`.
+     * If the candidate is already being published, the publish runs to completion and the
+     * outcome reports whatever L1 returned — callers that cancelled mid-publish must rely
+     * on their own terminal-state check to ignore the late outcome. No-op if the candidate
+     * is unknown.
+     */
+    withdraw(candidateId: string): void;
+    /**
+     * Signals that the L1 proven tip has advanced and the queue should be re-evaluated.
+     * The drain reads the proven block number from `l2BlockSource` itself rather than
+     * relying on the value passed here — that way the eligibility check uses a value read
+     * inside the serial drain, not one captured by a concurrent caller of `onChainProven`.
+     */
+    onChainProven(_provenBlock: BlockNumber): void;
+    /**
+     * Stops accepting new submissions, waits for any in-flight publish to settle, and
+     * resolves remaining queued candidates as `'withdrawn'`.
+     */
+    stop(): Promise<void>;
+    private scheduleDrain;
+    private drain;
+    /**
+     * Picks the winning candidate for a given epoch. Partial candidates whose `endBlock` is
+     * already proven on-chain resolve `'superseded'`.
+     * Full candidates are never auto-superseded by the proven tip — multiple prover-nodes
+     * legitimately submit redundant full epoch proofs (one per prover-id) and L1 records each.
+     * Among the remaining candidates with their predecessor proven, the one with the highest
+     * `endBlock` wins; the others resolve `'superseded'`.
+     */
+    private pickEpochWinner;
+    private publishWinner;
+    private runPublish;
+    private resolveCandidate;
+    /**
+     * Arms a per-candidate expiry timer if the candidate carries a deadline. When the timer
+     * fires, the candidate resolves as `'expired'` — unless it is already in flight, in
+     * which case the publish runs to completion (the timer becomes a no-op). The timer is
+     * cleared by `resolveCandidate` whenever the candidate settles for any other reason.
+     */
+    private scheduleExpiry;
+    /**
+     * Protected so unit tests can drive the deadline path without waiting on the real
+     * `setTimeout` to fire. Production code calls this only via the per-candidate timer
+     * armed in `scheduleExpiry`.
+     */
+    protected handleExpiry(candidateId: string): void;
+    private readProvenBlockNumber;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/proof-publishing-service.d.ts.map

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

package/dest/proof-publishing-service.js

@@ -0,0 +1,335 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { createLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { SerialQueue } from '@aztec/foundation/queue';
+/**
+ * Backoff after a transient `publisherFactory.create()` failure. The candidate stays
+ * in the queue and the drain is re-scheduled after this delay; if the failure persists
+ * the candidate's own `deadline` timer caps the total wait.
+ */ const PUBLISHER_ACQUIRE_RETRY_DELAY_MS = 1_000;
+/**
+ * Central owner of L1 proof submission. Sessions offer their proofs here as
+ * `PublishCandidate`s; the service serialises one publish at a time, picks the
+ * longest candidate per epoch as the winner, and resolves the rest as
+ * `'superseded'` without spending L1 gas.
+ *
+ * Construction-time invariants:
+ * - Every publish runs against a freshly-created `ProverNodePublisher` from the factory.
+ * - Only one publish is ever in flight (`SerialQueue` drain) — no defensive locks.
+ * - Once an L1 publish starts, it runs to completion. `withdraw` is a queue-only
+ *   operation: it removes a candidate that has not yet started publishing. An in-flight
+ *   candidate is left alone and its outcome (`'published'` / `'failed'`) is reported as
+ *   usual — the originating session has already moved to a terminal state via `cancel()`
+ *   and ignores the late outcome.
+ *
+ * Eligibility for publication is decided against the proven block number read inside
+ * the drain (so the value is consistent with the publish that runs on the same drain
+ * pass): a candidate is eligible when its predecessor block is proven and (for partial
+ * candidates) the candidate's range extends past the proven tip. `onChainProven` is a
+ * wake-up signal; it does not pass state into the drain.
+ */ export class ProofPublishingService {
+    deps;
+    log;
+    epochs;
+    /**
+   * One drain task at a time. Submits, withdrawals, chain-proven advances, and prunes
+   * all schedule a `drain` here, so the eligibility re-check and the L1 publish never
+   * interleave.
+   *
+   * Protected so unit tests can `await drainQueue.syncPoint()` to wait for pending
+   * drain work to settle deterministically (no sleeps).
+   */ drainQueue;
+    /** Tracks the candidate currently being published. Set while drain is awaiting the L1 publish. */ inFlight;
+    stopped;
+    constructor(deps){
+        this.deps = deps;
+        this.epochs = new Map();
+        this.drainQueue = new SerialQueue();
+        this.stopped = false;
+        this.log = createLogger('prover-node:proof-publishing-service', deps.bindings);
+        this.drainQueue.start();
+    }
+    /**
+   * Offers a proof candidate to the service. The returned promise resolves once the
+   * service settles the candidate's fate: `'published'` if it wins and L1 accepts it,
+   * `'superseded'` if a longer candidate for the same epoch wins, `'failed'` if the
+   * L1 submission errored, `'withdrawn'` if the originating session cancelled,
+   * `'expired'` if the candidate's `deadline` elapsed before publishing started.
+   */ submit(candidate) {
+        if (this.stopped) {
+            return Promise.resolve('withdrawn');
+        }
+        const { promise, resolve } = promiseWithResolvers();
+        let bucket = this.epochs.get(candidate.epoch);
+        if (!bucket) {
+            bucket = {
+                candidates: new Map(),
+                resolvers: new Map(),
+                expiryTimers: new Map()
+            };
+            this.epochs.set(candidate.epoch, bucket);
+        }
+        bucket.candidates.set(candidate.id, candidate);
+        bucket.resolvers.set(candidate.id, resolve);
+        this.scheduleExpiry(bucket, candidate);
+        this.log.info(`Candidate proof ${candidate.id} submitted for publishing`, {
+            candidateId: candidate.id,
+            epoch: candidate.epoch,
+            startBlock: candidate.startBlock,
+            endBlock: candidate.endBlock,
+            deadline: candidate.deadline?.toISOString()
+        });
+        this.scheduleDrain();
+        return promise;
+    }
+    /**
+   * Pulls a queued candidate from the bucket and resolves its promise as `'withdrawn'`.
+   * If the candidate is already being published, the publish runs to completion and the
+   * outcome reports whatever L1 returned — callers that cancelled mid-publish must rely
+   * on their own terminal-state check to ignore the late outcome. No-op if the candidate
+   * is unknown.
+   */ withdraw(candidateId) {
+        if (this.inFlight?.id === candidateId) {
+            this.log.debug(`Withdraw for in-flight candidate ${candidateId} ignored; publish will run to completion`, {
+                candidateId
+            });
+            return;
+        }
+        for (const bucket of this.epochs.values()){
+            if (bucket.candidates.has(candidateId)) {
+                this.log.info(`Candidate ${candidateId} withdrawn`, {
+                    candidateId
+                });
+                this.resolveCandidate(bucket, candidateId, 'withdrawn');
+                this.scheduleDrain();
+                return;
+            }
+        }
+    }
+    /**
+   * Signals that the L1 proven tip has advanced and the queue should be re-evaluated.
+   * The drain reads the proven block number from `l2BlockSource` itself rather than
+   * relying on the value passed here — that way the eligibility check uses a value read
+   * inside the serial drain, not one captured by a concurrent caller of `onChainProven`.
+   */ onChainProven(_provenBlock) {
+        this.scheduleDrain();
+    }
+    /**
+   * Stops accepting new submissions, waits for any in-flight publish to settle, and
+   * resolves remaining queued candidates as `'withdrawn'`.
+   */ async stop() {
+        this.stopped = true;
+        await this.drainQueue.end();
+        // Anything still parked in a bucket never ran through drain — resolve it as withdrawn so
+        // callers awaiting `submit()` aren't left hanging.
+        for (const bucket of Array.from(this.epochs.values())){
+            for (const id of Array.from(bucket.candidates.keys())){
+                this.resolveCandidate(bucket, id, 'withdrawn');
+            }
+        }
+        this.epochs.clear();
+    }
+    // ---------------- drain ----------------
+    scheduleDrain() {
+        if (this.stopped) {
+            return;
+        }
+        void this.drainQueue.put(()=>this.drain()).catch((err)=>{
+            this.log.error(`Drain task threw`, err);
+        });
+    }
+    async drain() {
+        if (this.stopped) {
+            return;
+        }
+        // Read the proven block number afresh inside the serial drain so the eligibility
+        // check is consistent with the publish that follows it on the same drain pass.
+        const proven = await this.readProvenBlockNumber();
+        // Process epochs in ascending order: the proven tip advances monotonically, so the lower
+        // epoch is the natural next eligible candidate.
+        const orderedEpochs = Array.from(this.epochs.keys()).sort((a, b)=>Number(a) - Number(b));
+        for (const epoch of orderedEpochs){
+            const bucket = this.epochs.get(epoch);
+            const eligible = this.pickEpochWinner(bucket, proven);
+            if (!eligible) {
+                continue;
+            }
+            await this.publishWinner(epoch, eligible.winner, bucket);
+        }
+        // Drop empty buckets
+        for (const [key, bucket] of Array.from(this.epochs.entries())){
+            if (bucket.candidates.size === 0) {
+                this.epochs.delete(key);
+            }
+        }
+    }
+    /**
+   * Picks the winning candidate for a given epoch. Partial candidates whose `endBlock` is
+   * already proven on-chain resolve `'superseded'`.
+   * Full candidates are never auto-superseded by the proven tip — multiple prover-nodes
+   * legitimately submit redundant full epoch proofs (one per prover-id) and L1 records each.
+   * Among the remaining candidates with their predecessor proven, the one with the highest
+   * `endBlock` wins; the others resolve `'superseded'`.
+   */ pickEpochWinner(bucket, proven) {
+        const now = this.deps.dateProvider.now();
+        // Resolve any candidate whose deadline has already passed.
+        for (const candidate of Array.from(bucket.candidates.values())){
+            if (candidate.deadline && candidate.deadline.getTime() <= now) {
+                this.resolveCandidate(bucket, candidate.id, 'expired');
+            }
+        }
+        // Drop partial candidates the proven chain has already caught up to.
+        for (const candidate of Array.from(bucket.candidates.values())){
+            if (candidate.kind === 'partial' && candidate.endBlock <= proven) {
+                this.resolveCandidate(bucket, candidate.id, 'superseded');
+            }
+        }
+        const remaining = Array.from(bucket.candidates.values()).filter((c)=>c.startBlock - 1 <= proven);
+        if (remaining.length === 0) {
+            return undefined;
+        }
+        const winner = remaining.reduce((best, c)=>c.endBlock > best.endBlock ? c : best);
+        // Every other same-epoch candidate is superseded by the winner.
+        for (const candidate of remaining){
+            if (candidate.id !== winner.id) {
+                this.resolveCandidate(bucket, candidate.id, 'superseded');
+            }
+        }
+        return {
+            winner
+        };
+    }
+    async publishWinner(epoch, winner, bucket) {
+        let publisher;
+        try {
+            publisher = await this.deps.publisherFactory.create();
+        } catch (err) {
+            // Treat this as transient: the publisher pool may be temporarily exhausted
+            // (every signer busy, funding tx in flight, etc.). Leave the candidate queued and
+            // schedule another drain after a short backoff. If the failure persists past the
+            // candidate's deadline the expiry timer will resolve it as `'expired'`.
+            this.log.warn(`Failed to acquire publisher for candidate ${winner.id}; retrying`, {
+                candidateId: winner.id,
+                epoch: winner.epoch,
+                retryDelayMs: PUBLISHER_ACQUIRE_RETRY_DELAY_MS,
+                err
+            });
+            setTimeout(()=>this.scheduleDrain(), PUBLISHER_ACQUIRE_RETRY_DELAY_MS);
+            return;
+        }
+        this.inFlight = {
+            id: winner.id
+        };
+        this.log.info(`Publishing candidate ${winner.id}`, {
+            candidateId: winner.id,
+            epoch: winner.epoch,
+            startBlock: winner.startBlock,
+            endBlock: winner.endBlock,
+            fromCheckpoint: winner.fromCheckpoint,
+            toCheckpoint: winner.toCheckpoint
+        });
+        const outcome = await this.runPublish(winner, publisher);
+        this.inFlight = undefined;
+        this.resolveCandidate(bucket, winner.id, outcome);
+        if (bucket.candidates.size === 0) {
+            this.epochs.delete(epoch);
+        }
+    }
+    async runPublish(candidate, publisher) {
+        const submitArgs = {
+            epochNumber: candidate.epoch,
+            fromCheckpoint: candidate.fromCheckpoint,
+            toCheckpoint: candidate.toCheckpoint,
+            publicInputs: candidate.publicInputs,
+            proof: candidate.proof,
+            batchedBlobInputs: candidate.batchedBlobInputs,
+            attestations: candidate.attestations,
+            headers: candidate.headers,
+            // Stop the L1 tx retrying past the candidate's submission-window deadline.
+            deadline: candidate.deadline
+        };
+        if (this.deps.config.skipSubmitProof) {
+            try {
+                await publisher.analyzeEpochProofSubmission(submitArgs);
+                return 'published';
+            } catch (err) {
+                this.log.warn(`Failed to analyze estimated L1 fees for candidate ${candidate.id}`, {
+                    err,
+                    candidateId: candidate.id,
+                    epoch: candidate.epoch
+                });
+                // Analyze-mode failures are recorded but the session shouldn't enter `failed` —
+                // the operator opted out of submission. Match the previous EpochSession behaviour.
+                return 'published';
+            }
+        }
+        try {
+            const success = await publisher.submitEpochProof(submitArgs);
+            return success ? 'published' : 'failed';
+        } catch (err) {
+            this.log.error(`Error publishing candidate ${candidate.id}`, err, {
+                candidateId: candidate.id,
+                epoch: candidate.epoch
+            });
+            return 'failed';
+        }
+    }
+    resolveCandidate(bucket, id, outcome) {
+        const resolve = bucket.resolvers.get(id);
+        const timer = bucket.expiryTimers.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            bucket.expiryTimers.delete(id);
+        }
+        bucket.candidates.delete(id);
+        bucket.resolvers.delete(id);
+        if (resolve) {
+            this.log.info(`Candidate ${id} resolved as ${outcome}`, {
+                candidateId: id,
+                outcome
+            });
+            resolve(outcome);
+        }
+    }
+    /**
+   * Arms a per-candidate expiry timer if the candidate carries a deadline. When the timer
+   * fires, the candidate resolves as `'expired'` — unless it is already in flight, in
+   * which case the publish runs to completion (the timer becomes a no-op). The timer is
+   * cleared by `resolveCandidate` whenever the candidate settles for any other reason.
+   */ scheduleExpiry(bucket, candidate) {
+        if (!candidate.deadline) {
+            return;
+        }
+        const delay = Math.max(candidate.deadline.getTime() - this.deps.dateProvider.now(), 0);
+        const timer = setTimeout(()=>this.handleExpiry(candidate.id), delay);
+        bucket.expiryTimers.set(candidate.id, timer);
+    }
+    /**
+   * Protected so unit tests can drive the deadline path without waiting on the real
+   * `setTimeout` to fire. Production code calls this only via the per-candidate timer
+   * armed in `scheduleExpiry`.
+   */ handleExpiry(candidateId) {
+        if (this.inFlight?.id === candidateId) {
+            this.log.debug(`Expiry for in-flight candidate ${candidateId} ignored; publish will run to completion`, {
+                candidateId
+            });
+            return;
+        }
+        for (const bucket of this.epochs.values()){
+            if (bucket.candidates.has(candidateId)) {
+                this.log.info(`Candidate ${candidateId} expired before publishing`, {
+                    candidateId
+                });
+                this.resolveCandidate(bucket, candidateId, 'expired');
+                this.scheduleDrain();
+                return;
+            }
+        }
+    }
+    async readProvenBlockNumber() {
+        const proven = await this.deps.l2BlockSource.getBlockNumber({
+            tag: 'proven'
+        });
+        return BlockNumber(proven ?? 0);
+    }
+}

package/dest/prover-node-publisher.d.ts

@@ -1,15 +1,13 @@
 import { BatchedBlob } from '@aztec/blob-lib';
-import { MAX_CHECKPOINTS_PER_EPOCH } from '@aztec/constants';
 import type { RollupContract, ViemCommitteeAttestation } from '@aztec/ethereum/contracts';
 import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import { CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
-import type { Tuple } from '@aztec/foundation/serialize';
 import type { PublisherConfig, TxSenderConfig } from '@aztec/sequencer-client';
 import type { Proof } from '@aztec/stdlib/proofs';
-import type { FeeRecipient, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import type { CheckpointHeader, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 /** Arguments to the submitEpochProof method of the rollup contract */
 export type L1SubmitEpochProofArgs = {
@@ -19,11 +17,10 @@ export type L1SubmitEpochProofArgs = {
     endTimestamp: Fr;
     outHash: Fr;
     proverId: Fr;
-    fees: Tuple<FeeRecipient, typeof MAX_CHECKPOINTS_PER_EPOCH>;
+    headers: CheckpointHeader[];
     proof: Proof;
 };
 export declare class ProverNodePublisher {
-    private interrupted;
     private metrics;
     protected log: Logger;
     protected rollupContract: RollupContract;
@@ -34,15 +31,6 @@ export declare class ProverNodePublisher {
         telemetry?: TelemetryClient;
     }, bindings?: LoggerBindings);
     getRollupContract(): RollupContract;
-    /**
-     * Calling `interrupt` will cause any in progress call to `publishRollup` to return `false` asap.
-     * Be warned, the call may return false even if the tx subsequently gets successfully mined.
-     * In practice this shouldn't matter, as we'll only ever be calling `interrupt` when we know it's going to fail.
-     * A call to `restart` is required before you can continue publishing.
-     */
-    interrupt(): void;
-    /** Restarts the publisher after calling `interrupt`. */
-    restart(): void;
     getSenderAddress(): EthAddress;
     submitEpochProof(args: {
         epochNumber: EpochNumber;
@@ -52,10 +40,29 @@ export declare class ProverNodePublisher {
         proof: Proof;
         batchedBlobInputs: BatchedBlob;
         attestations: ViemCommitteeAttestation[];
+        headers: CheckpointHeader[];
+        /** Wall-clock deadline (proof-submission window end) past which the L1 tx should stop retrying. */
+        deadline?: Date;
     }): Promise<boolean>;
     private validateEpochProofSubmission;
+    /**
+     * Estimates what submitting the epoch proof would have cost on L1 without actually sending it.
+     * Runs the same validation as `submitEpochProof`, encodes the calldata, estimates gas, and records metrics.
+     * Used when proof publishing is disabled (e.g. PROVER_NODE_DISABLE_PROOF_PUBLISH=true on mainnet).
+     */
+    analyzeEpochProofSubmission(args: {
+        epochNumber: EpochNumber;
+        fromCheckpoint: CheckpointNumber;
+        toCheckpoint: CheckpointNumber;
+        publicInputs: RootRollupPublicInputs;
+        proof: Proof;
+        batchedBlobInputs: BatchedBlob;
+        attestations: ViemCommitteeAttestation[];
+        headers: CheckpointHeader[];
+    }): Promise<void>;
+    private encodeSubmitEpochProofCalldata;
     private sendSubmitEpochProofTx;
     private getEpochProofPublicInputsArgs;
     private getSubmitEpochProofArgs;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/prover-node-publisher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prover-node-publisher.d.ts","sourceRoot":"","sources":["../src/prover-node-publisher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA8B,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAGzD,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEjF,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAOnF,sEAAsE;AACtE,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,EAAE,CAAC;IACpB,UAAU,EAAE,EAAE,CAAC;IACf,YAAY,EAAE,EAAE,CAAC;IACjB,OAAO,EAAE,EAAE,CAAC;IACZ,QAAQ,EAAE,EAAE,CAAC;IACb,IAAI,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,yBAAyB,CAAC,CAAC;IAC5D,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAA6B;IAE5C,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC;IAEtB,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC;IAEzC,SAAgB,SAAS,EAAE,SAAS,CAAC;IAErC,YACE,MAAM,EAAE,cAAc,GAAG,eAAe,EACxC,IAAI,EAAE;QACJ,cAAc,EAAE,cAAc,CAAC;QAC/B,SAAS,EAAE,SAAS,CAAC;QACrB,SAAS,CAAC,EAAE,eAAe,CAAC;KAC7B,EACD,QAAQ,CAAC,EAAE,cAAc,EAS1B;IAEM,iBAAiB,mBAEvB;IAED;;;;;OAKG;IACI,SAAS,SAGf;IAED,wDAAwD;IACjD,OAAO,SAGb;IAEM,gBAAgB,eAEtB;IAEY,gBAAgB,CAAC,IAAI,EAAE;QAClC,WAAW,EAAE,WAAW,CAAC;QACzB,cAAc,EAAE,gBAAgB,CAAC;QACjC,YAAY,EAAE,gBAAgB,CAAC;QAC/B,YAAY,EAAE,sBAAsB,CAAC;QACrC,KAAK,EAAE,KAAK,CAAC;QACb,iBAAiB,EAAE,WAAW,CAAC;QAC/B,YAAY,EAAE,wBAAwB,EAAE,CAAC;KAC1C,GAAG,OAAO,CAAC,OAAO,CAAC,CAiDnB;YAEa,4BAA4B;YA+D5B,sBAAsB;IA4CpC,OAAO,CAAC,6BAA6B;IA0BrC,OAAO,CAAC,uBAAuB;CAuBhC"}
+{"version":3,"file":"prover-node-publisher.d.ts","sourceRoot":"","sources":["../src/prover-node-publisher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA8B,MAAM,iBAAiB,CAAC;AAE1E,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAGvF,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAErF,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAOnF,sEAAsE;AACtE,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,EAAE,CAAC;IACpB,UAAU,EAAE,EAAE,CAAC;IACf,YAAY,EAAE,EAAE,CAAC;IACjB,OAAO,EAAE,EAAE,CAAC;IACZ,QAAQ,EAAE,EAAE,CAAC;IACb,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAA6B;IAE5C,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC;IAEtB,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC;IAEzC,SAAgB,SAAS,EAAE,SAAS,CAAC;IAErC,YACE,MAAM,EAAE,cAAc,GAAG,eAAe,EACxC,IAAI,EAAE;QACJ,cAAc,EAAE,cAAc,CAAC;QAC/B,SAAS,EAAE,SAAS,CAAC;QACrB,SAAS,CAAC,EAAE,eAAe,CAAC;KAC7B,EACD,QAAQ,CAAC,EAAE,cAAc,EAS1B;IAEM,iBAAiB,mBAEvB;IAEM,gBAAgB,eAEtB;IAEY,gBAAgB,CAAC,IAAI,EAAE;QAClC,WAAW,EAAE,WAAW,CAAC;QACzB,cAAc,EAAE,gBAAgB,CAAC;QACjC,YAAY,EAAE,gBAAgB,CAAC;QAC/B,YAAY,EAAE,sBAAsB,CAAC;QACrC,KAAK,EAAE,KAAK,CAAC;QACb,iBAAiB,EAAE,WAAW,CAAC;QAC/B,YAAY,EAAE,wBAAwB,EAAE,CAAC;QACzC,OAAO,EAAE,gBAAgB,EAAE,CAAC;QAC5B,mGAAmG;QACnG,QAAQ,CAAC,EAAE,IAAI,CAAC;KACjB,GAAG,OAAO,CAAC,OAAO,CAAC,CA6CnB;YAEa,4BAA4B;IAoE1C;;;;OAIG;IACU,2BAA2B,CAAC,IAAI,EAAE;QAC7C,WAAW,EAAE,WAAW,CAAC;QACzB,cAAc,EAAE,gBAAgB,CAAC;QACjC,YAAY,EAAE,gBAAgB,CAAC;QAC/B,YAAY,EAAE,sBAAsB,CAAC;QACrC,KAAK,EAAE,KAAK,CAAC;QACb,iBAAiB,EAAE,WAAW,CAAC;QAC/B,YAAY,EAAE,wBAAwB,EAAE,CAAC;QACzC,OAAO,EAAE,gBAAgB,EAAE,CAAC;KAC7B,GAAG,OAAO,CAAC,IAAI,CAAC,CAsChB;IAED,OAAO,CAAC,8BAA8B;YAgBxB,sBAAsB;IAiDpC,OAAO,CAAC,6BAA6B;IAuBrC,OAAO,CAAC,uBAAuB;CAwBhC"}