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

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,16 +1,15 @@
 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';
+import { type Hex } from 'viem';
 /** Arguments to the submitEpochProof method of the rollup contract */
 export type L1SubmitEpochProofArgs = {
     epochSize: number;
@@ -19,30 +18,22 @@ 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;
+    protected proofSubmissionTarget: Hex;
     readonly l1TxUtils: L1TxUtils;
     constructor(config: TxSenderConfig & PublisherConfig, deps: {
         rollupContract: RollupContract;
         l1TxUtils: L1TxUtils;
+        proofSubmissionTarget?: EthAddress;
         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,11 +43,10 @@ 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 waitUntilStartBuildsOnProven;
-    private getProvenCheckpoint;
-    private isStartBuildingOnProven;
-    private getSecondsUntilProofSubmissionWindowEnd;
     private validateEpochProofSubmission;
     /**
      * Estimates what submitting the epoch proof would have cost on L1 without actually sending it.
@@ -71,10 +61,11 @@ export declare class ProverNodePublisher {
         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":"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"}
+{"version":3,"file":"prover-node-publisher.d.ts","sourceRoot":"","sources":["../src/prover-node-publisher.ts"],"names":[],"mappings":"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"}

package/dest/prover-node-publisher.js

@@ -1,49 +1,34 @@
 import { getEthBlobEvaluationInputs } from '@aztec/blob-lib';
 import { MAX_CHECKPOINTS_PER_EPOCH } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { areArraysEqual } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import { retryUntil } from '@aztec/foundation/retry';
 import { Timer } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts';
 import { CommitteeAttestation, CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
-import { getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 import { inspect } from 'util';
 import { encodeFunctionData, formatEther, formatGwei } from 'viem';
 import { ProverNodePublisherMetrics } from './metrics.js';
 export class ProverNodePublisher {
-    interrupted = false;
     metrics;
     log;
     rollupContract;
+    proofSubmissionTarget;
     l1TxUtils;
     constructor(config, deps, bindings){
         const telemetry = deps.telemetry ?? getTelemetryClient();
         this.metrics = new ProverNodePublisherMetrics(telemetry, 'ProverNode');
         this.log = createLogger('prover-node:l1-tx-publisher', bindings);
         this.rollupContract = deps.rollupContract;
+        this.proofSubmissionTarget = deps.proofSubmissionTarget?.toString() ?? deps.rollupContract.address;
         this.l1TxUtils = deps.l1TxUtils;
     }
     getRollupContract() {
         return this.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() {
-        this.interrupted = true;
-        this.l1TxUtils.interrupt();
-    }
-    /** Restarts the publisher after calling `interrupt`. */ restart() {
-        this.interrupted = false;
-        this.l1TxUtils.restart();
-    }
     getSenderAddress() {
         return this.l1TxUtils.getSenderAddress();
     }
@@ -54,86 +39,43 @@ export class ProverNodePublisher {
             fromCheckpoint,
             toCheckpoint
         };
-        if (!this.interrupted) {
-            if (!await this.waitUntilStartBuildsOnProven(args)) {
-                this.log.verbose('Checkpoint data syncing interrupted', ctx);
-                return false;
-            }
-            const timer = new Timer();
-            // Validate epoch proof range and hashes are correct before submitting
-            await this.validateEpochProofSubmission(args);
-            const txReceipt = await this.sendSubmitEpochProofTx(args);
-            if (!txReceipt) {
-                this.log.error(`Failed to mine submitEpochProof tx`, undefined, ctx);
-                return false;
-            }
-            try {
-                this.metrics.recordSenderBalance(await this.l1TxUtils.getSenderBalance(), this.l1TxUtils.getSenderAddress().toString());
-            } catch (err) {
-                this.log.warn(`Failed to record the ETH balance of the prover node: ${err}`);
-            }
-            // Tx was mined successfully
-            if (txReceipt.status === 'success') {
-                const tx = await this.l1TxUtils.getTransactionStats(txReceipt.transactionHash);
-                const stats = {
-                    gasPrice: txReceipt.effectiveGasPrice,
-                    gasUsed: txReceipt.gasUsed,
-                    transactionHash: txReceipt.transactionHash,
-                    calldataGas: tx.calldataGas,
-                    calldataSize: tx.calldataSize,
-                    sender: tx.sender,
-                    blobDataGas: 0n,
-                    blobGasUsed: 0n,
-                    eventName: 'proof-published-to-l1'
-                };
-                this.log.info(`Published epoch proof to L1 rollup contract`, {
-                    ...stats,
-                    ...ctx
-                });
-                this.metrics.recordSubmitProof(timer.ms(), stats);
-                return true;
-            }
-            this.metrics.recordFailedTx();
-            this.log.error(`Rollup submitEpochProof tx reverted ${txReceipt.transactionHash}`, undefined, ctx);
+        const timer = new Timer();
+        // Validate epoch proof range and hashes are correct before submitting
+        await this.validateEpochProofSubmission(args);
+        const txReceipt = await this.sendSubmitEpochProofTx(args);
+        if (!txReceipt) {
+            this.log.error(`Failed to mine submitEpochProof tx`, undefined, ctx);
+            return false;
         }
-        this.log.verbose('Checkpoint data syncing interrupted', ctx);
-        return false;
-    }
-    async waitUntilStartBuildsOnProven(args) {
-        const { epochNumber, fromCheckpoint } = args;
-        const provenCheckpoint = await this.getProvenCheckpoint();
-        if (this.isStartBuildingOnProven(fromCheckpoint, provenCheckpoint)) {
-            return true;
+        try {
+            this.metrics.recordSenderBalance(await this.l1TxUtils.getSenderBalance(), this.l1TxUtils.getSenderAddress().toString());
+        } catch (err) {
+            this.log.warn(`Failed to record the ETH balance of the prover node: ${err}`);
         }
-        const timeout = await this.getSecondsUntilProofSubmissionWindowEnd(epochNumber);
-        this.log.info(`Waiting for proven checkpoint to reach proof start`, {
-            epochNumber,
-            fromCheckpoint,
-            provenCheckpoint,
-            timeout
-        });
-        await retryUntil(async ()=>{
-            if (this.interrupted) {
-                return true;
-            }
-            const proven = await this.getProvenCheckpoint();
-            this.log.verbose(`Proven checkpoint is at ${proven} (waiting for ${fromCheckpoint - 1})`, {
-                epochNumber
+        // Tx was mined successfully
+        if (txReceipt.status === 'success') {
+            const tx = await this.l1TxUtils.getTransactionStats(txReceipt.transactionHash);
+            const stats = {
+                gasPrice: txReceipt.effectiveGasPrice,
+                gasUsed: txReceipt.gasUsed,
+                transactionHash: txReceipt.transactionHash,
+                calldataGas: tx.calldataGas,
+                calldataSize: tx.calldataSize,
+                sender: tx.sender,
+                blobDataGas: 0n,
+                blobGasUsed: 0n,
+                eventName: 'proof-published-to-l1'
+            };
+            this.log.info(`Published epoch proof to L1 rollup contract`, {
+                ...stats,
+                ...ctx
             });
-            return this.isStartBuildingOnProven(fromCheckpoint, proven) ? true : undefined;
-        }, `proven checkpoint to reach ${fromCheckpoint - 1}`, timeout, 4);
-        return !this.interrupted;
-    }
-    async getProvenCheckpoint() {
-        return (await this.rollupContract.getTips()).proven;
-    }
-    isStartBuildingOnProven(fromCheckpoint, provenCheckpoint) {
-        return fromCheckpoint - 1 <= provenCheckpoint;
-    }
-    async getSecondsUntilProofSubmissionWindowEnd(epochNumber) {
-        const deadline = getProofSubmissionDeadlineTimestamp(epochNumber, await this.rollupContract.getRollupConstants());
-        const now = BigInt(Math.floor(Date.now() / 1000));
-        return Math.max(Number(deadline - now), 0.001);
+            this.metrics.recordSubmitProof(timer.ms(), stats);
+            return true;
+        }
+        this.metrics.recordFailedTx();
+        this.log.error(`Rollup submitEpochProof tx reverted ${txReceipt.transactionHash}`, undefined, ctx);
+        return false;
     }
     async validateEpochProofSubmission(args) {
         const { fromCheckpoint, toCheckpoint, publicInputs, batchedBlobInputs } = args;
@@ -189,7 +131,7 @@ export class ProverNodePublisher {
         const senderAddress = this.l1TxUtils.getSenderAddress();
         const [gasLimit, gasPrice, latestBlock] = await Promise.all([
             this.l1TxUtils.estimateGas(senderAddress.toString(), {
-                to: this.rollupContract.address,
+                to: this.proofSubmissionTarget,
                 data
             }),
             this.l1TxUtils.getGasPrice(),
@@ -243,8 +185,10 @@ export class ProverNodePublisher {
         });
         try {
             const { receipt } = await this.l1TxUtils.sendAndMonitorTransaction({
-                to: this.rollupContract.address,
+                to: this.proofSubmissionTarget,
                 data
+            }, {
+                txTimeoutAt: args.deadline
             });
             if (receipt.status !== 'success') {
                 const errorMsg = await this.l1TxUtils.tryGetErrorFromRevertedTx(data, {
@@ -253,7 +197,7 @@ export class ProverNodePublisher {
                     ],
                     functionName: 'submitEpochRootProof',
                     abi: RollupAbi,
-                    address: this.rollupContract.address
+                    address: this.proofSubmissionTarget
                 }, /*blobInputs*/ undefined, /*stateOverride*/ []);
                 this.log.error(`Rollup submit epoch proof tx reverted with ${errorMsg ?? 'unknown error'}`);
                 return undefined;
@@ -275,7 +219,7 @@ export class ProverNodePublisher {
                 outHash: args.publicInputs.outHash.toString(),
                 proverId: EthAddress.fromField(args.publicInputs.constants.proverId).toString()
             } /*_args*/ ,
-            makeTuple(MAX_CHECKPOINTS_PER_EPOCH * 2, (i)=>i % 2 === 0 ? args.publicInputs.fees[i / 2].recipient.toField().toString() : args.publicInputs.fees[(i - 1) / 2].value.toString()),
+            args.headers.map((header)=>header.toViem()),
             getEthBlobEvaluationInputs(args.batchedBlobInputs)
         ];
     }
@@ -287,7 +231,7 @@ export class ProverNodePublisher {
             start: argsArray[0],
             end: argsArray[1],
             args: argsArray[2],
-            fees: argsArray[3],
+            headers: argsArray[3],
             attestations: CommitteeAttestationsAndSigners.packAttestations(args.attestations.map((a)=>CommitteeAttestation.fromViem(a))),
             blobInputs: argsArray[4],
             proof: proofHex