@aztec/prover-node 5.0.0-rc.1 → 5.0.0

package/src/checkpoint-store.ts

@@ -1,6 +1,5 @@
-import type { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/promise';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants, getEpochAtSlot, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
@@ -19,54 +18,64 @@ export type CheckpointProverFactory = (args: CheckpointProverArgs, deps: Checkpo
  *
  * The store survives every epoch / session boundary. A prover lives from its first
  * `addOrUpdate` call until either:
- *  - it has been pruned and the L2 chain has moved past its slot (no re-add possible), or
+ *  - its checkpoint is pruned by an L1 reorg (`cancelAndRemoveAboveBlock`), or
  *  - its epoch's proof-submission window has closed (`reapExpired`), so the proof could no
  *    longer be accepted on L1 even if produced.
  *
- * A re-add of a checkpoint that matches an existing prover's content key reuses the
- * existing prover (and flips it back to canonical); the in-flight sub-tree work never
- * stops, so a prune-then-re-add of the same content avoids re-proving entirely.
+ * A prover's sub-tree work forks world-state per block and does not survive a prune of a base
+ * block, so there is nothing to preserve across a reorg: a pruned prover is cancelled and
+ * dropped, and a re-add (even of identical content) constructs a fresh prover.
  */
 export class CheckpointStore {
   private readonly provers = new Map<string, CheckpointProver>();
-  private readonly slotWatcher: RunningPromise;
+  /**
+   * Teardowns of provers already removed from `provers` (by prune or reap), awaited on `stop()`.
+   * Keyed by a monotonic id rather than the prover's content id: a prune-then-re-add can leave two
+   * teardowns for the same content id in flight at once, which a content-id key would clobber.
+   */
+  private readonly pendingTeardowns = new Map<number, Promise<void>>();
+  private nextTeardownId = 0;
   private readonly log: Logger;
 
   constructor(
-    private readonly l2BlockSource: Pick<L2BlockSource, 'getSyncedL2SlotNumber' | 'getL1Constants'>,
+    private readonly l2BlockSource: Pick<L2BlockSource, 'getL1Constants'>,
     private readonly proverDeps: Omit<CheckpointProverDeps, 'log'>,
-    private readonly options: { slotWatcherPollIntervalMs: number },
     bindings?: LoggerBindings,
     private readonly proverFactoryFn: CheckpointProverFactory = (args, deps) => new CheckpointProver(args, deps),
   ) {
     this.log = createLogger('prover-node:checkpoint-store', bindings);
-    this.slotWatcher = new RunningPromise(
-      () => this.reapPrunedPastSlot(),
-      this.log,
-      this.options.slotWatcherPollIntervalMs,
-    );
   }
 
   public start(): Promise<void> {
-    this.slotWatcher.start();
     return Promise.resolve();
   }
 
   public async stop(): Promise<void> {
-    await this.slotWatcher.stop();
-    // Cancel every live prover; await teardown.
+    // Cancel every live prover, then await both their teardown and any still in flight for provers
+    // already removed by a prune or reap.
     const provers = Array.from(this.provers.values());
     this.provers.clear();
     for (const prover of provers) {
       prover.cancel();
     }
-    await Promise.allSettled(provers.map(p => p.whenDone()));
+    await Promise.allSettled([...provers.map(p => p.whenDone()), ...this.pendingTeardowns.values()]);
+  }
+
+  /**
+   * Tracks the teardown of a prover just removed from the store so `stop()` can await it. The entry
+   * removes itself once teardown settles, so the map stays bounded by the number in flight.
+   */
+  private trackTeardown(prover: CheckpointProver): void {
+    const id = this.nextTeardownId++;
+    const done = prover.whenDone();
+    this.pendingTeardowns.set(id, done);
+    void done.finally(() => this.pendingTeardowns.delete(id));
   }
 
   /**
    * Registers a checkpoint with the store. If a prover already exists for the
-   * `(number, slot, archive root)` content key, it is reused and marked canonical;
-   * otherwise a new prover is constructed.
+   * `(number, slot, archive root)` content key it is reused (an at-least-once re-registration of
+   * still-canonical content); otherwise a new prover is constructed.
    */
   public async addOrUpdate(checkpoint: Checkpoint, data: RegisterCheckpointData): Promise<CheckpointProver> {
     const l1Constants = await this.l2BlockSource.getL1Constants();
@@ -75,18 +84,18 @@ export class CheckpointStore {
 
     const existing = this.provers.get(id);
     if (existing) {
-      existing.markCanonical();
       return existing;
     }
 
-    // At most one canonical checkpoint per slot. A different canonical checkpoint at the
-    // same slot means the caller forgot to prune the old chain before adding the replacement
-    // — surface it rather than silently creating a parallel canonical chain.
+    // At most one canonical checkpoint per slot. A different checkpoint at the same slot means the
+    // caller forgot to prune the old chain before adding the replacement — surface it rather than
+    // silently creating a parallel canonical chain. A pruned checkpoint has already been removed,
+    // so every prover still in the store is canonical.
     for (const prover of this.provers.values()) {
-      if (prover.slotNumber === checkpoint.header.slotNumber && !prover.isPruned()) {
+      if (prover.slotNumber === checkpoint.header.slotNumber) {
         throw new Error(
           `Cannot add checkpoint ${checkpoint.number} (archive ${checkpoint.archive.root}) at slot ${checkpoint.header.slotNumber}: ` +
-            `a different canonical checkpoint already occupies this slot. Prune it first.`,
+            `a different checkpoint already occupies this slot. Prune it first.`,
         );
       }
     }
@@ -97,15 +106,25 @@ export class CheckpointStore {
   }
 
   /**
-   * Marks every canonical prover whose checkpoint number is strictly greater than
-   * `prunedNumber` as pruned. Sub-tree work keeps running so a re-add of the same
-   * content can pick it up. Returns the affected provers.
+   * Cancels and removes every prover that holds a block above the prune target. A checkpoint is orphaned by a prune to
+   * block `targetBlockNumber` iff its last block sits above the target — including a checkpoint whose range straddles
+   * the target (partially orphaned), which block-range marking catches without boundary ambiguity. Keying off the
+   * surviving block number (rather than a checkpoint number) is correct even when the source has already
+   * re-checkpointed past the divergence: the prune event reports the highest surviving block, which by construction
+   * survives on the source, whereas the source's current checkpointed tip can sit above the prune target.
+   *
+   * The prover's in-flight sub-tree work forks world-state per block and faults once its base block is pruned, so it
+   * cannot be reused; it is cancelled (aborting the fork reads) and dropped. A subsequent re-add constructs a fresh
+   * prover. Returns the removed provers.
    */
-  public markPrunedAfter(prunedNumber: CheckpointNumber): CheckpointProver[] {
+  public cancelAndRemoveAboveBlock(targetBlockNumber: BlockNumber): CheckpointProver[] {
     const affected: CheckpointProver[] = [];
-    for (const prover of this.provers.values()) {
-      if (prover.checkpoint.number > prunedNumber && !prover.isPruned()) {
-        prover.markPruned();
+    for (const [id, prover] of Array.from(this.provers.entries())) {
+      const lastBlockNumber = prover.checkpoint.blocks.at(-1)!.number;
+      if (lastBlockNumber > targetBlockNumber) {
+        prover.cancel();
+        this.trackTeardown(prover);
+        this.provers.delete(id);
         affected.push(prover);
       }
     }
@@ -113,20 +132,17 @@ export class CheckpointStore {
   }
 
   /**
-   * Drops canonical (non-pruned) provers whose epoch is at or below the supplied expired
-   * epoch. Once an epoch's proof-submission window has closed, its proof can no longer be
-   * accepted on L1, so the prover is no longer needed.
+   * Drops provers whose epoch is at or below the supplied expired epoch. Once an epoch's
+   * proof-submission window has closed, its proof can no longer be accepted on L1, so the
+   * prover is no longer needed.
    */
   public reapExpired(expiredEpoch: EpochNumber): void {
     const reaped: { id: string; checkpointNumber: CheckpointNumber; epochNumber: EpochNumber }[] = [];
     for (const [id, prover] of Array.from(this.provers.entries())) {
-      if (prover.isPruned()) {
-        continue;
-      }
       if (prover.epochNumber <= expiredEpoch) {
         reaped.push({ id, checkpointNumber: prover.checkpoint.number, epochNumber: prover.epochNumber });
         prover.cancel({ routine: true });
-        void prover.whenDone();
+        this.trackTeardown(prover);
         this.provers.delete(id);
       }
     }
@@ -149,63 +165,28 @@ export class CheckpointStore {
     return this.provers.get(CheckpointProver.idFor(checkpoint));
   }
 
-  /** Every prover currently in the store (canonical and pruned), in insertion order. */
+  /** Every prover currently in the store, in insertion order. */
   public listAll(): CheckpointProver[] {
     return Array.from(this.provers.values());
   }
 
-  /** Canonical (non-pruned) provers in the store, sorted by checkpoint number. */
-  public listCanonical(): CheckpointProver[] {
-    return Array.from(this.provers.values())
-      .filter(p => !p.isPruned())
-      .sort((a, b) => a.checkpoint.number - b.checkpoint.number);
+  /** Provers in the store, sorted by checkpoint number. */
+  public list(): CheckpointProver[] {
+    return Array.from(this.provers.values()).sort((a, b) => a.checkpoint.number - b.checkpoint.number);
   }
 
   /**
-   * Canonical provers whose slot is in the supplied epoch's slot range, sorted by
-   * checkpoint number.
+   * Provers whose slot is in the supplied epoch's slot range, sorted by checkpoint number.
    */
-  public async listCanonicalForEpoch(epoch: EpochNumber): Promise<CheckpointProver[]> {
+  public async listForEpoch(epoch: EpochNumber): Promise<CheckpointProver[]> {
     const l1Constants = await this.l2BlockSource.getL1Constants();
     const [fromSlot, toSlot] = getSlotRangeForEpoch(epoch, l1Constants);
-    return this.listCanonicalInSlotRange(fromSlot, toSlot);
+    return this.listInSlotRange(fromSlot, toSlot);
   }
 
-  /** Canonical provers whose slot falls within `[fromSlot, toSlot]`, sorted by checkpoint number. */
-  public listCanonicalInSlotRange(fromSlot: SlotNumber, toSlot: SlotNumber): CheckpointProver[] {
-    return this.listCanonical().filter(p => p.slotNumber >= fromSlot && p.slotNumber <= toSlot);
-  }
-
-  /**
-   * SlotWatcher tick: reap pruned provers whose slot has passed the chain's synced
-   * slot. Once the chain has moved past, no re-add can revive the prover and its
-   * content key is unique enough that an actual re-add would create a new entry.
-   *
-   * Protected so unit tests can drive a single tick without spinning up the
-   * `RunningPromise` and waiting on its interval.
-   */
-  protected async reapPrunedPastSlot(): Promise<void> {
-    let syncedSlot: SlotNumber | undefined;
-    try {
-      syncedSlot = await this.l2BlockSource.getSyncedL2SlotNumber();
-    } catch (err) {
-      this.log.debug(`SlotWatcher could not read synced slot`, { error: `${err}` });
-      return;
-    }
-    if (syncedSlot === undefined) {
-      return;
-    }
-    for (const [id, prover] of Array.from(this.provers.entries())) {
-      if (prover.isPruned() && prover.slotNumber < syncedSlot) {
-        this.log.info(`Reaping pruned CheckpointProver ${id}: slot ${prover.slotNumber} < synced ${syncedSlot}`, {
-          checkpointNumber: prover.checkpoint.number,
-          slotNumber: prover.slotNumber,
-        });
-        prover.cancel();
-        void prover.whenDone();
-        this.provers.delete(id);
-      }
-    }
+  /** Provers whose slot falls within `[fromSlot, toSlot]`, sorted by checkpoint number. */
+  public listInSlotRange(fromSlot: SlotNumber, toSlot: SlotNumber): CheckpointProver[] {
+    return this.list().filter(p => p.slotNumber >= fromSlot && p.slotNumber <= toSlot);
   }
 }
 

package/src/job/checkpoint-prover.ts

@@ -59,16 +59,16 @@ export type CheckpointProverArgs = {
  * 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.
+ * predecessor but with different content, keys to a distinct prover.
  *
  * 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.
+ * A CheckpointProver does not survive a prune: its sub-tree work forks world-state per
+ * block, and an L1 prune of a base block faults those reads. The store therefore cancels and
+ * discards a prover when its checkpoint is pruned, and a re-add (even of identical content)
+ * constructs a fresh prover.
  *
  * `cancel()` is idempotent. It aborts the gather + sub-tree, rejects the block-proof
  * promise, and exposes a `whenDone()` that resolves once teardown has unwound.
@@ -92,8 +92,6 @@ export class CheckpointProver {
   private cancelled = false;
   private subTree?: CheckpointSubTreeOrchestrator;
   private completed = false;
-  /** Pruned in the canonical chain but not yet reaped — sub-tree continues running. */
-  private pruned = false;
   private readonly abortController = new AbortController();
 
   /** Tracks the eager gather+execute task so `cancel()` and `whenDone()` can await its unwind. */
@@ -146,37 +144,6 @@ export class CheckpointProver {
     return this.completed;
   }
 
-  public isPruned(): boolean {
-    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.
-   */
-  public markPruned(): void {
-    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. */
-  public markCanonical(): void {
-    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. */
   public getAbortSignal(): AbortSignal {
     return this.abortController.signal;
@@ -277,6 +244,8 @@ export class CheckpointProver {
             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),
@@ -344,7 +313,8 @@ export class CheckpointProver {
       }
 
       this.completed = true;
-      this.deps.metrics.recordCheckpointProcessing(checkpointTimer.ms());
+      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`,
         {
@@ -429,7 +399,14 @@ export class CheckpointProver {
   }
 
   private async processTxs(publicProcessor: PublicProcessor, txs: Tx[]): Promise<ProcessedTx[]> {
-    const [processedTxs, failedTxs] = await publicProcessor.process(txs, { deadline: this.deps.deadline });
+    // Pass the abort signal so a prune-driven cancel stops the current block's public execution
+    // immediately, rather than running it to completion before the next `signal.aborted` check.
+    // On abort `process` returns a partial result, the length check below throws, and
+    // `gatherAndExecute` swallows it via its `cancelled` guard.
+    const [processedTxs, failedTxs] = await publicProcessor.process(txs, {
+      deadline: this.deps.deadline,
+      signal: this.abortController.signal,
+    });
 
     if (failedTxs.length) {
       const failedTxHashes = await Promise.all(failedTxs.map(({ tx }) => tx.getTxHash()));

package/src/job/epoch-session.ts

@@ -92,7 +92,7 @@ export type EpochSessionDeps = {
  *
  * Lifecycle (happy path):
  *
- *   initialized → awaiting-checkpoints → completed
+ *   initialized → awaiting-checkpoints → awaiting-root → publishing-proof → completed
  *
  * Terminal states map the publishing outcome: `published` → `completed`, `superseded` →
  * `superseded`, `failed` → `failed`, `expired` → `timed-out`, `withdrawn` → `cancelled`.
@@ -320,6 +320,12 @@ export class EpochSession implements Traceable {
       0,
     );
 
+    // Reflect the publish phase. Guard against a terminal state set concurrently by cancel() — the
+    // post-submit isTerminal() check below relies on cancel still winning.
+    if (!this.isTerminal()) {
+      this.state = 'publishing-proof';
+    }
+
     const outcome = await this.deps.publishingService.submit({
       id: this.uuid,
       epoch: this.spec.epochNumber,
@@ -333,6 +339,7 @@ export class EpochSession implements Traceable {
       proof: proof.proof,
       batchedBlobInputs: proof.batchedBlobInputs,
       attestations,
+      headers: this.checkpoints.map(c => c.checkpoint.header),
     });
 
     if (this.isTerminal()) {
@@ -347,7 +354,7 @@ export class EpochSession implements Traceable {
           { uuid: this.uuid, ...this.spec },
         );
         this.state = 'completed';
-        this.deps.metrics.recordProvingJob(timer.ms(), timer.ms(), checkpointCount, epochSizeBlocks, epochSizeTxs);
+        this.deps.metrics.recordProvingJob(timer.ms(), checkpointCount, epochSizeBlocks, epochSizeTxs);
         return;
       case 'superseded':
         this.log.info(`EpochSession ${this.uuid} superseded by a longer candidate`, {
@@ -410,15 +417,20 @@ export class EpochSession implements Traceable {
     }
   }
 
-  private toTopTreeHooks(): TopTreeJobHooks | undefined {
+  private toTopTreeHooks(): TopTreeJobHooks {
     const hooks = this.deps.hooks;
-    if (!hooks?.beforeTopTreeProve && !hooks?.afterTopTreeProve && !hooks?.topTreeProveOverride) {
-      return undefined;
-    }
     return {
-      beforeProve: hooks.beforeTopTreeProve,
-      afterProve: hooks.afterTopTreeProve,
-      proveOverride: hooks.topTreeProveOverride,
+      // `beforeProve` fires once the sub-tree (checkpoint block) proofs are ready and the root prove is
+      // about to start — the boundary between `awaiting-checkpoints` and proving the top tree. Don't
+      // clobber a terminal state set concurrently by cancel().
+      beforeProve: async () => {
+        if (!this.isTerminal()) {
+          this.state = 'awaiting-root';
+        }
+        await hooks?.beforeTopTreeProve?.();
+      },
+      afterProve: hooks?.afterTopTreeProve,
+      proveOverride: hooks?.topTreeProveOverride,
     };
   }
 }

package/src/metrics.ts

@@ -22,7 +22,6 @@ import type { CheckpointStore } from './checkpoint-store.js';
 import type { SessionManager } from './session-manager.js';
 
 export class ProverNodeJobMetrics {
-  proverEpochExecutionDuration: Histogram;
   provingJobDuration: Histogram;
   provingJobCheckpoints: Gauge;
   provingJobBlocks: Gauge;
@@ -31,6 +30,9 @@ export class ProverNodeJobMetrics {
   private blobProcessingDuration: Gauge;
   private blockProcessingDuration: Histogram;
   private checkpointProcessingDuration: Histogram;
+  private checkpointProvingDuration: Histogram;
+  private checkpointBlocks: Histogram;
+  private checkpointTransactions: Histogram;
 
   /** Observable gauges for live state. Registered via `observeState(...)` once the
    *  CheckpointStore and SessionManager are available. */
@@ -44,7 +46,6 @@ export class ProverNodeJobMetrics {
     public readonly tracer: Tracer,
     private logger = createLogger('prover-node:publisher:metrics'),
   ) {
-    this.proverEpochExecutionDuration = this.meter.createHistogram(Metrics.PROVER_NODE_EXECUTION_DURATION);
     this.provingJobDuration = this.meter.createHistogram(Metrics.PROVER_NODE_JOB_DURATION);
     this.provingJobCheckpoints = this.meter.createGauge(Metrics.PROVER_NODE_JOB_CHECKPOINTS);
     this.provingJobBlocks = this.meter.createGauge(Metrics.PROVER_NODE_JOB_BLOCKS);
@@ -53,16 +54,12 @@ export class ProverNodeJobMetrics {
     this.blobProcessingDuration = this.meter.createGauge(Metrics.PROVER_NODE_BLOB_PROCESSING_LAST_DURATION);
     this.blockProcessingDuration = this.meter.createHistogram(Metrics.PROVER_NODE_BLOCK_PROCESSING_DURATION);
     this.checkpointProcessingDuration = this.meter.createHistogram(Metrics.PROVER_NODE_CHECKPOINT_PROCESSING_DURATION);
+    this.checkpointProvingDuration = this.meter.createHistogram(Metrics.PROVER_NODE_CHECKPOINT_PROVING_DURATION);
+    this.checkpointBlocks = this.meter.createHistogram(Metrics.PROVER_NODE_CHECKPOINT_BLOCKS);
+    this.checkpointTransactions = this.meter.createHistogram(Metrics.PROVER_NODE_CHECKPOINT_TRANSACTIONS);
   }
 
-  public recordProvingJob(
-    executionTimeMs: number,
-    totalTimeMs: number,
-    numCheckpoints: number,
-    numBlocks: number,
-    numTxs: number,
-  ) {
-    this.proverEpochExecutionDuration.record(Math.ceil(executionTimeMs));
+  public recordProvingJob(totalTimeMs: number, numCheckpoints: number, numBlocks: number, numTxs: number) {
     this.provingJobDuration.record(totalTimeMs / 1000);
     this.provingJobCheckpoints.record(Math.floor(numCheckpoints));
     this.provingJobBlocks.record(Math.floor(numBlocks));
@@ -77,8 +74,14 @@ export class ProverNodeJobMetrics {
     this.blockProcessingDuration.record(Math.ceil(durationMs));
   }
 
-  public recordCheckpointProcessing(durationMs: number) {
+  public recordCheckpointProcessing(durationMs: number, numBlocks: number, numTxs: number) {
     this.checkpointProcessingDuration.record(Math.ceil(durationMs));
+    this.checkpointBlocks.record(Math.floor(numBlocks));
+    this.checkpointTransactions.record(Math.floor(numTxs));
+  }
+
+  public recordCheckpointProving(durationMs: number) {
+    this.checkpointProvingDuration.record(Math.ceil(durationMs));
   }
 
   /**
@@ -93,7 +96,7 @@ export class ProverNodeJobMetrics {
     this.activeCheckpoints = this.meter.createObservableGauge(Metrics.PROVER_NODE_ACTIVE_CHECKPOINTS);
     this.activeEpochSessions = this.meter.createObservableGauge(Metrics.PROVER_NODE_ACTIVE_EPOCH_SESSIONS);
     this.stateObserver = (observer: BatchObservableResult) => {
-      observer.observe(this.activeCheckpoints!, checkpointStore.listCanonical().length);
+      observer.observe(this.activeCheckpoints!, checkpointStore.listAll().length);
       let full = 0;
       let partial = 0;
       for (const session of sessionManager.allSessions()) {

package/src/proof-publishing-service.ts

@@ -7,7 +7,7 @@ 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 { RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import type { CheckpointHeader, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
 
 import type { ProverNodePublisher } from './prover-node-publisher.js';
 import type { ProverPublisherFactory } from './prover-publisher-factory.js';
@@ -45,6 +45,8 @@ export type PublishCandidate = {
   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. */
@@ -333,6 +335,7 @@ export class ProofPublishingService {
       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,
     };

package/src/prover-node-publisher.ts

@@ -2,19 +2,17 @@ import { BatchedBlob, getEthBlobEvaluationInputs } 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 { makeTuple } from '@aztec/foundation/array';
 import { CheckpointNumber, EpochNumber } 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 { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
-import type { Tuple } from '@aztec/foundation/serialize';
 import { Timer } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts';
 import type { PublisherConfig, TxSenderConfig } from '@aztec/sequencer-client';
 import { CommitteeAttestation, CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
 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 { L1PublishProofStats } from '@aztec/stdlib/stats';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
@@ -31,7 +29,7 @@ export type L1SubmitEpochProofArgs = {
   endTimestamp: Fr;
   outHash: Fr;
   proverId: Fr;
-  fees: Tuple<FeeRecipient, typeof MAX_CHECKPOINTS_PER_EPOCH>;
+  headers: CheckpointHeader[];
   proof: Proof;
 };
 
@@ -78,6 +76,7 @@ export 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> {
@@ -134,6 +133,7 @@ export class ProverNodePublisher {
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
+    headers: CheckpointHeader[];
   }) {
     const { fromCheckpoint, toCheckpoint, publicInputs, batchedBlobInputs } = args;
 
@@ -207,6 +207,7 @@ export class ProverNodePublisher {
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
+    headers: CheckpointHeader[];
   }): Promise<void> {
     const { epochNumber, fromCheckpoint, toCheckpoint } = args;
 
@@ -254,6 +255,7 @@ export class ProverNodePublisher {
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
+    headers: CheckpointHeader[];
   }): Hex {
     return encodeFunctionData({
       abi: RollupAbi,
@@ -270,6 +272,7 @@ export class ProverNodePublisher {
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
+    headers: CheckpointHeader[];
   }): Promise<TransactionReceipt | undefined> {
     const txArgs = [this.getSubmitEpochProofArgs(args)] as const;
 
@@ -316,6 +319,7 @@ export class ProverNodePublisher {
     publicInputs: RootRollupPublicInputs;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
+    headers: CheckpointHeader[];
   }) {
     // Returns arguments for EpochProofLib.sol -> getEpochProofPublicInputs()
     return [
@@ -327,11 +331,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(),
-      ) /*_fees*/,
+      args.headers.map(header => header.toViem()) /*_headers*/,
       getEthBlobEvaluationInputs(args.batchedBlobInputs) /*_blobPublicInputs*/,
     ] as const;
   }
@@ -343,6 +343,7 @@ export class ProverNodePublisher {
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
+    headers: CheckpointHeader[];
   }) {
     // Returns arguments for EpochProofLib.sol -> submitEpochRootProof()
     const proofHex: Hex = `0x${args.proof.withoutPublicInputs().toString('hex')}`;
@@ -351,7 +352,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)),
       ),