@aztec/sequencer-client 0.0.1-commit.2d9cb6034 → 0.0.1-commit.2e20a94

package/src/sequencer/checkpoint_proposal_job.ts

@@ -1,5 +1,5 @@
 import type { EpochCache } from '@aztec/epoch-cache';
-import { type FeeHeader, RollupContract } from '@aztec/ethereum/contracts';
+import type { SimulationOverridesPlan } from '@aztec/ethereum/contracts';
 import {
   BlockNumber,
   CheckpointNumber,
@@ -57,6 +57,11 @@ import { DutyAlreadySignedError, SlashingProtectionError } from '@aztec/validato
 
 import type { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import type { InvalidateCheckpointRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
+import {
+  buildPipelinedParentSimulationOverridesPlan,
+  buildSubmissionSimulationOverridesPlan,
+} from './chain_state_overrides.js';
+import type { CheckpointProposalJobMetricsRecorder } from './checkpoint_proposal_job_metrics.js';
 import { CheckpointVoter } from './checkpoint_voter.js';
 import { SequencerInterruptedError } from './errors.js';
 import type { SequencerEvents } from './events.js';
@@ -68,7 +73,14 @@ import { SequencerState } from './utils.js';
 /** How much time to sleep while waiting for min transactions to accumulate for a block */
 const TXS_POLLING_MS = 500;
 
-/** Result from proposeCheckpoint when a checkpoint was successfully built and attested. */
+/** Result from proposeCheckpoint when a checkpoint was successfully built and broadcast. */
+type CheckpointProposalBroadcast = {
+  checkpoint: Checkpoint;
+  proposal: CheckpointProposal;
+  blockProposedAt: number;
+};
+
+/** Result after attestation collection and signing, ready for L1 submission. */
 type CheckpointProposalResult = {
   checkpoint: Checkpoint;
   attestations: CommitteeAttestationsAndSigners;
@@ -87,8 +99,8 @@ export class CheckpointProposalJob implements Traceable {
   /** Tracks the fire-and-forget L1 submission promise so it can be awaited during shutdown. */
   private pendingL1Submission: Promise<void> | undefined;
 
-  /** Fee header override computed during proposeCheckpoint, reused in enqueueCheckpointForSubmission. */
-  private computedForceProposedFeeHeader?: { checkpointNumber: CheckpointNumber; feeHeader: FeeHeader };
+  /** Pipelined parent chain state used while building and later submitting this checkpoint. */
+  private pipelinedParentSimulationOverridesPlan?: SimulationOverridesPlan;
 
   constructor(
     private readonly slotNow: SlotNumber,
@@ -116,6 +128,7 @@ export class CheckpointProposalJob implements Traceable {
     private readonly epochCache: EpochCache,
     private readonly dateProvider: DateProvider,
     private readonly metrics: SequencerMetrics,
+    private readonly checkpointMetrics: CheckpointProposalJobMetricsRecorder,
     private readonly eventEmitter: TypedEventEmitter<SequencerEvents>,
     private readonly setStateFn: (state: SequencerState, slot?: SlotNumber) => void,
     public readonly tracer: Tracer,
@@ -136,8 +149,9 @@ export class CheckpointProposalJob implements Traceable {
 
   /**
    * Executes the checkpoint proposal job.
-   * Builds blocks, collects attestations, enqueues requests, and schedules L1 submission as a
-   * background task so the work loop can return to IDLE immediately.
+   * Builds blocks, assembles checkpoint, and broadcasts the proposal (blocking).
+   * Attestation collection, signing, and L1 submission are backgrounded so the
+   * work loop can return to IDLE immediately for consecutive slot proposals.
    * Returns the built checkpoint if successful, undefined otherwise.
    */
   @trackSpan('CheckpointProposalJob.execute')
@@ -157,73 +171,99 @@ export class CheckpointProposalJob implements Traceable {
       this.log,
     ).enqueueVotes();
 
-    // Build and propose the checkpoint. Builds blocks, broadcasts, collects attestations, and signs.
-    // Does NOT enqueue to L1 yet — that happens after the pipeline sleep.
-    const proposalResult = await this.proposeCheckpoint();
-    const checkpoint = proposalResult?.checkpoint;
+    // Build blocks, assemble checkpoint, and broadcast proposal (BLOCKING).
+    // Returns after broadcast — attestation collection is deferred.
+    const broadcast = await this.proposeCheckpoint();
 
-    // Wait until the voting promises have resolved, so all requests are enqueued (not sent)
-    await Promise.all(votesPromises);
-
-    if (checkpoint) {
-      this.metrics.recordCheckpointProposalSuccess();
+    if (!broadcast) {
+      await Promise.all(votesPromises);
+      // Still submit votes even without a checkpoint
+      if (!this.config.fishermanMode) {
+        this.pendingL1Submission = this.publisher.sendRequestsAt(this.dateProvider.nowAsDate()).then(() => {});
+      }
+      return undefined;
     }
 
+    const { checkpoint } = broadcast;
+    this.metrics.recordCheckpointProposalSuccess();
+
     // Do not post anything to L1 if we are fishermen, but do perform L1 fee analysis
     if (this.config.fishermanMode) {
       await this.handleCheckpointEndAsFisherman(checkpoint);
-      return;
+      return checkpoint;
     }
 
-    // Enqueue the checkpoint for L1 submission
-    if (proposalResult) {
+    // Background the attestation → signing → L1 pipeline so the work loop is unblocked
+    this.pendingL1Submission = this.waitForAttestationsAndEnqueueSubmissionAsync(broadcast, votesPromises);
+
+    // Return the built checkpoint immediately — the work loop is now unblocked
+    return checkpoint;
+  }
+
+  /**
+   * Background pipeline: collects attestations, signs them, enqueues the checkpoint, and submits to L1.
+   * Runs as a fire-and-forget task stored in `pendingL1Submission` so the work loop is unblocked.
+   */
+  private async waitForAttestationsAndEnqueueSubmissionAsync(
+    broadcast: CheckpointProposalBroadcast,
+    votesPromises: Promise<unknown>[],
+  ): Promise<void> {
+    const { checkpoint, proposal, blockProposedAt } = broadcast;
+    try {
+      await Promise.all(votesPromises);
+
+      this.setStateFn(SequencerState.COLLECTING_ATTESTATIONS, this.targetSlot);
+      const attestations = await this.waitForAttestations(proposal);
+
+      this.checkpointMetrics.recordCheckpointAttestationDelay(this.dateProvider.now() - blockProposedAt);
+
+      // Proposer must sign over the attestations before pushing them to L1
+      const signer = this.proposer ?? this.publisher.getSenderAddress();
+      let attestationsSignature: Signature;
       try {
-        await this.enqueueCheckpointForSubmission(proposalResult);
+        attestationsSignature = await this.validatorClient.signAttestationsAndSigners(
+          attestations,
+          signer,
+          this.targetSlot,
+          this.checkpointNumber,
+        );
       } catch (err) {
-        this.log.error(`Failed to enqueue checkpoint for L1 submission at slot ${this.targetSlot}`, err);
-        // Continue to sendRequestsAt so votes are still sent
+        if (this.handleHASigningError(err, 'Attestations signature')) {
+          return;
+        }
+        throw err;
       }
-    }
 
-    // Compute the earliest time to submit: pipeline slot start when pipelining, now otherwise.
-    const submitAfter = this.epochCache.isProposerPipeliningEnabled()
-      ? new Date(Number(getTimestampForSlot(this.targetSlot, this.l1Constants)) * 1000)
-      : new Date(this.dateProvider.now());
-
-    // TODO(https://github.com/AztecProtocol/aztec-packages/pull/21250): should discard the pending submission if a reorg occurs underneath
-
-    // Schedule L1 submission in the background so the work loop returns immediately.
-    // The publisher will sleep until submitAfter, then send the bundled requests.
-    // The promise is stored so it can be awaited during shutdown.
-    this.pendingL1Submission = this.publisher
-      .sendRequestsAt(submitAfter)
-      .then(async l1Response => {
-        const proposedAction = l1Response?.successfulActions.find(a => a === 'propose');
-        if (proposedAction) {
-          this.eventEmitter.emit('checkpoint-published', { checkpoint: this.checkpointNumber, slot: this.targetSlot });
-          const coinbase = checkpoint?.header.coinbase;
-          await this.metrics.incFilledSlot(this.publisher.getSenderAddress().toString(), coinbase);
-        } else if (checkpoint) {
-          this.eventEmitter.emit('checkpoint-publish-failed', { ...l1Response, slot: this.targetSlot });
-
-          if (this.epochCache.isProposerPipeliningEnabled()) {
-            this.metrics.recordPipelineDiscard();
-          }
-        }
-      })
-      .catch(err => {
-        this.log.error(`Background L1 submission failed for slot ${this.targetSlot}`, err);
-        if (checkpoint) {
-          this.eventEmitter.emit('checkpoint-publish-failed', { slot: this.targetSlot });
-
-          if (this.epochCache.isProposerPipeliningEnabled()) {
-            this.metrics.recordPipelineDiscard();
-          }
-        }
-      });
+      // Enqueue the checkpoint for L1 submission
+      await this.enqueueCheckpointForSubmission({ checkpoint, attestations, attestationsSignature });
 
-    // Return the built checkpoint immediately — the work loop is now unblocked
-    return checkpoint;
+      // Compute the earliest time to submit: pipeline slot start when pipelining, now otherwise.
+      const submitAfter = this.epochCache.isProposerPipeliningEnabled()
+        ? new Date(Number(getTimestampForSlot(this.targetSlot, this.l1Constants)) * 1000)
+        : new Date(this.dateProvider.now());
+
+      const l1Response = await this.publisher.sendRequestsAt(submitAfter);
+      const proposedAction = l1Response?.successfulActions.find(a => a === 'propose');
+      if (proposedAction) {
+        this.eventEmitter.emit('checkpoint-published', { checkpoint: this.checkpointNumber, slot: this.targetSlot });
+        const coinbase = checkpoint.header.coinbase;
+        await this.metrics.incFilledSlot(this.publisher.getSenderAddress().toString(), coinbase);
+      } else {
+        this.eventEmitter.emit('checkpoint-publish-failed', { ...l1Response, slot: this.targetSlot });
+        if (this.epochCache.isProposerPipeliningEnabled()) {
+          this.metrics.recordPipelineDiscard();
+        }
+      }
+    } catch (err) {
+      if (err instanceof SequencerInterruptedError) {
+        return;
+      }
+      this.log.error(`Background attestation/L1 pipeline failed for slot ${this.targetSlot}`, err);
+      this.eventEmitter.emit('checkpoint-publish-failed', { slot: this.targetSlot });
+      if (this.epochCache.isProposerPipeliningEnabled()) {
+        this.metrics.recordPipelineDiscard();
+      }
+    }
   }
 
   /** Enqueues the checkpoint for L1 submission. Called after pipeline sleep in execute(). */
@@ -249,10 +289,17 @@ export class CheckpointProposalJob implements Traceable {
       }
     }
 
+    const isPipelining = this.epochCache.isProposerPipeliningEnabled();
+    const submissionSimulationOverridesPlan = buildSubmissionSimulationOverridesPlan({
+      pipelinedParentPlan: this.pipelinedParentSimulationOverridesPlan,
+      invalidateToPendingCheckpointNumber: this.invalidateCheckpoint?.forcePendingCheckpointNumber,
+      lastArchiveRoot: checkpoint.header.lastArchiveRoot,
+      pipeliningEnabled: isPipelining,
+    });
+
     await this.publisher.enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, {
       txTimeoutAt,
-      forcePendingCheckpointNumber: this.invalidateCheckpoint?.forcePendingCheckpointNumber,
-      forceProposedFeeHeader: this.computedForceProposedFeeHeader,
+      ...(submissionSimulationOverridesPlan ? { simulationOverridesPlan: submissionSimulationOverridesPlan } : {}),
     });
   }
 
@@ -263,8 +310,18 @@ export class CheckpointProposalJob implements Traceable {
       [Attributes.SLOT_NUMBER]: this.targetSlot,
     };
   })
-  private async proposeCheckpoint(): Promise<CheckpointProposalResult | undefined> {
+  private async proposeCheckpoint(): Promise<CheckpointProposalBroadcast | undefined> {
     try {
+      const now = this.dateProvider.now();
+      if (this.epochCache.isProposerPipeliningEnabled() && this.proposedCheckpointData) {
+        // Measure against the wall-clock slot whose build window we are currently using.
+        // In pipelining mode `targetSlot` is intentionally one slot ahead, which makes the
+        // target-slot boundary a full slot away from the actual build start time.
+        const slotBoundaryMs = Number(getTimestampForSlot(this.slotNow, this.l1Constants)) * 1000;
+        this.checkpointMetrics.recordPipelinedCheckpointBuildStartOffsetFromSlotBoundary(now - slotBoundaryMs);
+      }
+      this.checkpointMetrics.startCheckpointTiming(now);
+
       // Get operator configured coinbase and fee recipient for this attestor
       const coinbase = this.validatorClient.getCoinbaseForAttestor(this.attestorAddress);
       const feeRecipient = this.validatorClient.getFeeRecipientForAttestor(this.attestorAddress);
@@ -289,21 +346,20 @@ export class CheckpointProposalJob implements Traceable {
       // When pipelining, force the proposed checkpoint number and fee header to our parent so the
       // fee computation sees the same chain tip that L1 will see once the previous pipelined checkpoint lands.
       const isPipelining = this.epochCache.isProposerPipeliningEnabled();
-      const parentCheckpointNumber = isPipelining ? CheckpointNumber(this.checkpointNumber - 1) : undefined;
-
-      // Compute the parent's fee header override when pipelining
-      if (isPipelining && this.proposedCheckpointData) {
-        this.computedForceProposedFeeHeader = await this.computeForceProposedFeeHeader(parentCheckpointNumber!);
-      }
+      this.pipelinedParentSimulationOverridesPlan = isPipelining
+        ? await buildPipelinedParentSimulationOverridesPlan({
+            checkpointNumber: this.checkpointNumber,
+            proposedCheckpointData: this.proposedCheckpointData,
+            rollup: this.publisher.rollupContract,
+            log: this.log,
+          })
+        : undefined;
 
       const checkpointGlobalVariables = await this.globalsBuilder.buildCheckpointGlobalVariables(
         coinbase,
         feeRecipient,
         this.targetSlot,
-        {
-          forcePendingCheckpointNumber: parentCheckpointNumber,
-          forceProposedFeeHeader: this.computedForceProposedFeeHeader,
-        },
+        this.pipelinedParentSimulationOverridesPlan,
       );
 
       // Collect L1 to L2 messages for the checkpoint and compute their hash
@@ -344,7 +400,7 @@ export class CheckpointProposalJob implements Traceable {
       };
 
       let blocksInCheckpoint: L2Block[] = [];
-      let blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined = undefined;
+      let blockPendingBroadcast: BlockProposal | undefined = undefined;
       const checkpointBuildTimer = new Timer();
 
       try {
@@ -405,14 +461,14 @@ export class CheckpointProposalJob implements Traceable {
       }
 
       // Record checkpoint-level build metrics
-      this.metrics.recordCheckpointBuild(
+      this.checkpointMetrics.recordCheckpointBuild(
         checkpointBuildTimer.ms(),
         blocksInCheckpoint.length,
         checkpoint.getStats().txCount,
         Number(checkpoint.header.totalManaUsed.toBigInt()),
       );
 
-      // Do not collect attestations nor publish to L1 in fisherman mode
+      // In fisherman mode, return the checkpoint without broadcasting or collecting attestations
       if (this.config.fishermanMode) {
         this.log.info(
           `Built checkpoint for slot ${this.targetSlot} with ${blocksInCheckpoint.length} blocks. ` +
@@ -424,60 +480,27 @@ export class CheckpointProposalJob implements Traceable {
           },
         );
         this.metrics.recordCheckpointSuccess();
-        return {
-          checkpoint,
-          attestations: CommitteeAttestationsAndSigners.empty(),
-          attestationsSignature: Signature.empty(),
-        };
+        // Return a broadcast result with a dummy proposal — fisherman mode skips attestation collection
+        return { checkpoint, proposal: undefined!, blockProposedAt: this.dateProvider.now() };
       }
 
-      // Include the block pending broadcast in the checkpoint proposal if any
-      const lastBlock = blockPendingBroadcast && {
-        blockHeader: blockPendingBroadcast.block.header,
-        indexWithinCheckpoint: blockPendingBroadcast.block.indexWithinCheckpoint,
-        txs: blockPendingBroadcast.txs,
-      };
-
       // Create the checkpoint proposal and broadcast it
       const proposal = await this.validatorClient.createCheckpointProposal(
         checkpoint.header,
         checkpoint.archive.root,
+        this.checkpointNumber,
         feeAssetPriceModifier,
-        lastBlock,
+        blockPendingBroadcast,
         this.proposer,
         checkpointProposalOptions,
       );
 
       const blockProposedAt = this.dateProvider.now();
       await this.p2pClient.broadcastCheckpointProposal(proposal);
+      this.checkpointMetrics.noteCheckpointBroadcast(this.dateProvider.now());
 
-      this.setStateFn(SequencerState.COLLECTING_ATTESTATIONS, this.targetSlot);
-      const attestations = await this.waitForAttestations(proposal);
-      const blockAttestedAt = this.dateProvider.now();
-
-      this.metrics.recordCheckpointAttestationDelay(blockAttestedAt - blockProposedAt);
-
-      // Proposer must sign over the attestations before pushing them to L1
-      const signer = this.proposer ?? this.publisher.getSenderAddress();
-      let attestationsSignature: Signature;
-      try {
-        attestationsSignature = await this.validatorClient.signAttestationsAndSigners(
-          attestations,
-          signer,
-          this.targetSlot,
-          this.checkpointNumber,
-        );
-      } catch (err) {
-        // We shouldn't really get here since we yield to another HA node
-        // as soon as we see these errors when creating block or checkpoint proposals.
-        if (this.handleHASigningError(err, 'Attestations signature')) {
-          return undefined;
-        }
-        throw err;
-      }
-
-      // Return the result for the caller to enqueue after the pipeline sleep
-      return { checkpoint, attestations, attestationsSignature };
+      // Return immediately after broadcast — attestation collection happens in the background
+      return { checkpoint, proposal, blockProposedAt };
     } catch (err) {
       if (err && (err instanceof DutyAlreadySignedError || err instanceof SlashingProtectionError)) {
         // swallow this error. It's already been logged by a function deeper in the stack
@@ -500,14 +523,14 @@ export class CheckpointProposalJob implements Traceable {
     blockProposalOptions: BlockProposalOptions,
   ): Promise<{
     blocksInCheckpoint: L2Block[];
-    blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined;
+    blockPendingBroadcast: BlockProposal | undefined;
   }> {
     const blocksInCheckpoint: L2Block[] = [];
     const txHashesAlreadyIncluded = new Set<string>();
     const initialBlockNumber = BlockNumber(this.syncedToBlockNumber + 1);
 
     // Last block in the checkpoint will usually be flagged as pending broadcast, so we send it along with the checkpoint proposal
-    let blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined = undefined;
+    let blockPendingBroadcast: BlockProposal | undefined = undefined;
 
     while (true) {
       const blocksBuilt = blocksInCheckpoint.length;
@@ -540,19 +563,20 @@ export class CheckpointProposalJob implements Traceable {
         txHashesAlreadyIncluded,
       });
 
-      // TODO(palla/mbps): Review these conditions. We may want to keep trying in some scenarios.
-      if (!buildResult && timingInfo.isLastBlock) {
-        // If no block was produced due to not enough txs and this was the last subslot, exit
-        break;
-      } else if (!buildResult && timingInfo.deadline !== undefined) {
-        // But if there is still time for more blocks, wait until the next subslot and try again
+      // If we failed to build the block due to insufficient txs, we try again if there is still time left in the slot
+      if ('failure' in buildResult) {
+        // If this was the last subslot, or we're running with a single block per slot, we're done
+        if (timingInfo.isLastBlock || timingInfo.deadline === undefined) {
+          break;
+        }
+        // Otherwise, if there is still time for more blocks, we wait until the next subslot and try again
         await this.waitUntilNextSubslot(timingInfo.deadline);
         continue;
-      } else if (!buildResult) {
-        // Exit if there is no possibility of building more blocks
-        break;
-      } else if ('error' in buildResult) {
-        // If there was an error building the block, just exit the loop and give up the rest of the slot
+      }
+
+      // If there was an error building the block, we just exit the loop and give up the rest of the slot.
+      // We don't want to risk building more blocks if something went wrong.
+      if ('error' in buildResult) {
         if (!(buildResult.error instanceof SequencerInterruptedError)) {
           this.log.warn(`Halting block building for slot ${this.targetSlot}`, {
             slot: this.targetSlot,
@@ -564,33 +588,35 @@ export class CheckpointProposalJob implements Traceable {
       }
 
       const { block, usedTxs } = buildResult;
+      this.checkpointMetrics.noteCheckpointBlockBuilt(this.dateProvider.now(), {
+        isFirstBlock: blocksBuilt === 0,
+        isLastBlock: timingInfo.isLastBlock,
+      });
+
       blocksInCheckpoint.push(block);
       usedTxs.forEach(tx => txHashesAlreadyIncluded.add(tx.txHash.toString()));
 
-      // If this is the last block, sync it to the archiver and exit the loop
-      // so we can build the checkpoint and start collecting attestations.
+      // Sign the block proposal. This will throw if HA signing fails.
+      const proposal = await this.createBlockProposal(block, inHash, usedTxs, blockProposalOptions);
+
+      // Sync the proposed block to the archiver to make it available, only after we've managed to sign the proposal,
+      // so we avoid polluting our archive with a block that would fail.
+      // We wait for the sync to succeed, as this helps catch consistency errors, even if it means we lose some time for block-building.
+      // If this throws, we abort the entire checkpoint.
+      await this.syncProposedBlockToArchiver(block);
+
+      // If this is the last block, do not broadcast it, since it will be included in the checkpoint proposal.
       if (timingInfo.isLastBlock) {
-        await this.syncProposedBlockToArchiver(block);
         this.log.verbose(`Completed final block ${blockNumber} for slot ${this.targetSlot}`, {
           slot: this.targetSlot,
           blockNumber,
           blocksBuilt,
         });
-        blockPendingBroadcast = { block, txs: usedTxs };
+
+        blockPendingBroadcast = proposal;
         break;
       }
 
-      // Broadcast the block proposal (unless we're in fisherman mode) unless the block is the last one,
-      // in which case we'll broadcast it along with the checkpoint at the end of the loop.
-      // Note that we only send the block to the archiver if we manage to create the proposal, so if there's
-      // a HA error we don't pollute our archiver with a block that won't make it to the chain.
-      const proposal = await this.createBlockProposal(block, inHash, usedTxs, blockProposalOptions);
-
-      // Sync the proposed block to the archiver to make it available, only after we've managed to sign the proposal.
-      // We wait for the sync to succeed, as this helps catch consistency errors, even if it means we lose some time for block-building.
-      // If this throws, we abort the entire checkpoint.
-      await this.syncProposedBlockToArchiver(block);
-
       // Once we have a signed proposal and the archiver agreed with our proposed block, then we broadcast it.
       proposal && (await this.p2pClient.broadcastProposal(proposal));
 
@@ -619,6 +645,7 @@ export class CheckpointProposalJob implements Traceable {
     }
     return this.validatorClient.createBlockProposal(
       block.header,
+      this.checkpointNumber,
       block.indexWithinCheckpoint,
       inHash,
       block.archive.root,
@@ -650,7 +677,9 @@ export class CheckpointProposalJob implements Traceable {
       buildDeadline: Date | undefined;
       txHashesAlreadyIncluded: Set<string>;
     },
-  ): Promise<{ block: L2Block; usedTxs: Tx[] } | { error: Error } | undefined> {
+  ): Promise<
+    { block: L2Block; usedTxs: Tx[] } | { failure: 'insufficient-txs' | 'insufficient-valid-txs' } | { error: Error }
+  > {
     const { blockTimestamp, forceCreate, blockNumber, indexWithinCheckpoint, buildDeadline, txHashesAlreadyIncluded } =
       opts;
 
@@ -669,7 +698,7 @@ export class CheckpointProposalJob implements Traceable {
         );
         this.eventEmitter.emit('block-tx-count-check-failed', { minTxs, availableTxs, slot: this.targetSlot });
         this.metrics.recordBlockProposalFailed('insufficient_txs');
-        return undefined;
+        return { failure: 'insufficient-txs' };
       }
 
       // Create iterator to pending txs. We filter out txs already included in previous blocks in the checkpoint
@@ -732,7 +761,7 @@ export class CheckpointProposalJob implements Traceable {
           slot: this.targetSlot,
         });
         this.metrics.recordBlockProposalFailed('insufficient_valid_txs');
-        return undefined;
+        return { failure: 'insufficient-valid-txs' };
       }
 
       // Block creation succeeded, emit stats and metrics
@@ -761,7 +790,7 @@ export class CheckpointProposalJob implements Traceable {
         slot: this.targetSlot,
         buildSlot: this.slotNow,
       });
-      this.metrics.recordBuiltBlock(blockBuildDuration, block.header.totalManaUsed.toNumberUnsafe());
+      this.metrics.recordBuiltBlock(blockBuildDuration, block.header.totalManaUsed.toNumberUnsafe(), this.targetSlot);
 
       return { block, usedTxs };
     } catch (err: any) {
@@ -868,12 +897,12 @@ export class CheckpointProposalJob implements Traceable {
 
     if (this.config.skipCollectingAttestations) {
       this.log.warn('Skipping attestation collection as per config (attesting with own keys only)');
-      const attestations = await this.validatorClient?.collectOwnAttestations(proposal);
+      const attestations = await this.validatorClient?.collectOwnAttestations(proposal, this.checkpointNumber);
       return new CommitteeAttestationsAndSigners(orderAttestations(attestations ?? [], committee));
     }
 
     const attestationTimeAllowed = this.config.enforceTimeTable
-      ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_CHECKPOINT)!
+      ? this.timetable.getCheckpointAttestationDeadline()
       : this.l1Constants.slotDuration;
     const attestationDeadline = new Date((this.getSlotStartBuildTimestamp() + attestationTimeAllowed) * 1000);
 
@@ -886,6 +915,7 @@ export class CheckpointProposalJob implements Traceable {
         proposal,
         numberOfRequiredAttestations,
         attestationDeadline,
+        this.checkpointNumber,
       );
 
       collectedAttestationsCount = attestations.length;
@@ -1012,9 +1042,13 @@ export class CheckpointProposalJob implements Traceable {
    * Adds the proposed block to the archiver so it's available via P2P.
    * Gossip doesn't echo messages back to the sender, so the proposer's archiver/world-state
    * would never receive its own block without this explicit sync.
+   *
+   * In fisherman mode we skip this push: the fisherman builds blocks locally for validation
+   * and fee analysis only, and pushing them to the archiver causes spurious reorg cascades
+   * whenever the real proposer's block arrives from L1.
    */
   private async syncProposedBlockToArchiver(block: L2Block): Promise<void> {
-    if (this.config.skipPushProposedBlocksToArchiver) {
+    if (this.config.skipPushProposedBlocksToArchiver || this.config.fishermanMode) {
       this.log.warn(`Skipping push of proposed block ${block.number} to archiver`, {
         blockNumber: block.number,
         slot: block.header.globalVariables.slotNumber,
@@ -1075,56 +1109,6 @@ export class CheckpointProposalJob implements Traceable {
     return false;
   }
 
-  /**
-   * In times of congestion we need to simulate using the correct fee header override for the previous block
-   * We calculate the correct fee header values.
-   *
-   * If we are in block 1, or the checkpoint we are querying does not exist, we return undefined. However
-   * If we are pipelining - where this function is called, the grandparentCheckpointNumber should always exist
-   * @param parentCheckpointNumber
-   * @returns
-   */
-  protected async computeForceProposedFeeHeader(parentCheckpointNumber: CheckpointNumber): Promise<
-    | {
-        checkpointNumber: CheckpointNumber;
-        feeHeader: FeeHeader;
-      }
-    | undefined
-  > {
-    if (!this.proposedCheckpointData) {
-      return undefined;
-    }
-
-    const rollup = this.publisher.rollupContract;
-    const grandparentCheckpointNumber = CheckpointNumber(this.checkpointNumber - 2);
-    try {
-      const [grandparentCheckpoint, manaTarget] = await Promise.all([
-        rollup.getCheckpoint(grandparentCheckpointNumber),
-        rollup.getManaTarget(),
-      ]);
-
-      if (!grandparentCheckpoint || !grandparentCheckpoint.feeHeader) {
-        this.log.error(
-          `Grandparent checkpoint or its feeHeader is undefined for checkpointNumber=${grandparentCheckpointNumber.toString()}`,
-        );
-        return undefined;
-      } else {
-        const parentFeeHeader = RollupContract.computeChildFeeHeader(
-          grandparentCheckpoint.feeHeader,
-          this.proposedCheckpointData.totalManaUsed,
-          this.proposedCheckpointData.feeAssetPriceModifier,
-          manaTarget,
-        );
-        return { checkpointNumber: parentCheckpointNumber, feeHeader: parentFeeHeader };
-      }
-    } catch (err) {
-      this.log.error(
-        `Failed to fetch grandparent checkpoint or mana target for checkpointNumber=${grandparentCheckpointNumber.toString()}: ${err}`,
-      );
-      return undefined;
-    }
-  }
-
   /** Waits until a specific time within the current slot */
   @trackSpan('CheckpointProposalJob.waitUntilTimeInSlot')
   protected async waitUntilTimeInSlot(targetSecondsIntoSlot: number): Promise<void> {