@aztec/sequencer-client 0.0.1-commit.03f7ef2 → 0.0.1-commit.0658669b3

package/src/sequencer/checkpoint_proposal_job.ts

@@ -1,42 +1,53 @@
+import { NUM_CHECKPOINT_END_MARKER_FIELDS, getNumBlockEndBlobFields } from '@aztec/blob-lib/encoding';
 import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import {
+  BlockNumber,
+  CheckpointNumber,
+  EpochNumber,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
 import { randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { filter } from '@aztec/foundation/iterator';
-import type { Logger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { sleep, sleepUntil } from '@aztec/foundation/sleep';
 import { type DateProvider, Timer } from '@aztec/foundation/timer';
-import { type TypedEventEmitter, unfreeze } from '@aztec/foundation/types';
+import { type TypedEventEmitter, isErrorClass, unfreeze } from '@aztec/foundation/types';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
 import {
   CommitteeAttestation,
   CommitteeAttestationsAndSigners,
-  L2BlockNew,
+  L2Block,
+  type L2BlockSink,
+  type L2BlockSource,
   MaliciousCommitteeAttestationsAndSigners,
 } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
-import type {
-  PublicProcessorLimits,
-  ResolvedSequencerConfig,
-  WorldStateSynchronizer,
+import {
+  NoValidTxsError,
+  type PublicProcessorLimits,
+  type ResolvedSequencerConfig,
+  type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import type { BlockProposal, BlockProposalOptions } from '@aztec/stdlib/p2p';
-import { orderAttestations } from '@aztec/stdlib/p2p';
-import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import type { BlockProposalOptions, CheckpointProposal, CheckpointProposalOptions } from '@aztec/stdlib/p2p';
+import { orderAttestations, trimAttestations } from '@aztec/stdlib/p2p';
 import type { L2BlockBuiltStats } from '@aztec/stdlib/stats';
 import { type FailedTx, Tx } from '@aztec/stdlib/tx';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
-import type { ValidatorClient } from '@aztec/validator-client';
+import { Attributes, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import { CheckpointBuilder, type FullNodeCheckpointsBuilder, type ValidatorClient } from '@aztec/validator-client';
+import { DutyAlreadySignedError, SlashingProtectionError } from '@aztec/validator-ha-signer/errors';
 
 import type { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import type { InvalidateBlockRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
-import { CheckpointBuilder, type FullNodeCheckpointsBuilder } from './checkpoint_builder.js';
+import type { InvalidateCheckpointRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
 import { CheckpointVoter } from './checkpoint_voter.js';
 import { SequencerInterruptedError } from './errors.js';
 import type { SequencerEvents } from './events.js';
@@ -54,8 +65,11 @@ const TXS_POLLING_MS = 500;
  * as well as enqueueing votes for slashing and governance proposals. This class is created from
  * the Sequencer once the check for being the proposer for the slot has succeeded.
  */
-export class CheckpointProposalJob {
+export class CheckpointProposalJob implements Traceable {
+  protected readonly log: Logger;
+
   constructor(
+    private readonly epoch: EpochNumber,
     private readonly slot: SlotNumber,
     private readonly checkpointNumber: CheckpointNumber,
     private readonly syncedToBlockNumber: BlockNumber,
@@ -63,13 +77,15 @@ export class CheckpointProposalJob {
     private readonly proposer: EthAddress | undefined,
     private readonly publisher: SequencerPublisher,
     private readonly attestorAddress: EthAddress,
-    private readonly invalidateBlock: InvalidateBlockRequest | undefined,
+    private readonly invalidateCheckpoint: InvalidateCheckpointRequest | undefined,
     private readonly validatorClient: ValidatorClient,
     private readonly globalsBuilder: GlobalVariableBuilder,
     private readonly p2pClient: P2P,
     private readonly worldState: WorldStateSynchronizer,
     private readonly l1ToL2MessageSource: L1ToL2MessageSource,
+    private readonly l2BlockSource: L2BlockSource,
     private readonly checkpointsBuilder: FullNodeCheckpointsBuilder,
+    private readonly blockSink: L2BlockSink,
     private readonly l1Constants: SequencerRollupConstants,
     protected config: ResolvedSequencerConfig,
     protected timetable: SequencerTimetable,
@@ -79,13 +95,17 @@ export class CheckpointProposalJob {
     private readonly metrics: SequencerMetrics,
     private readonly eventEmitter: TypedEventEmitter<SequencerEvents>,
     private readonly setStateFn: (state: SequencerState, slot?: SlotNumber) => void,
-    protected readonly log: Logger,
-  ) {}
+    public readonly tracer: Tracer,
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('sequencer:checkpoint-proposal', { ...bindings, instanceId: `slot-${slot}` });
+  }
 
   /**
    * Executes the checkpoint proposal job.
    * Returns the published checkpoint if successful, undefined otherwise.
    */
+  @trackSpan('CheckpointProposalJob.execute')
   public async execute(): Promise<Checkpoint | undefined> {
     // Enqueue governance and slashing votes (returns promises that will be awaited later)
     // In fisherman mode, we simulate slashing but don't actually publish to L1
@@ -108,6 +128,10 @@ export class CheckpointProposalJob {
     // Wait until the voting promises have resolved, so all requests are enqueued (not sent)
     await Promise.all(votesPromises);
 
+    if (checkpoint) {
+      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);
@@ -128,6 +152,13 @@ export class CheckpointProposalJob {
     }
   }
 
+  @trackSpan('CheckpointProposalJob.proposeCheckpoint', function () {
+    return {
+      // nullish operator needed for tests
+      [Attributes.COINBASE]: this.validatorClient.getCoinbaseForAttestor(this.attestorAddress)?.toString(),
+      [Attributes.SLOT_NUMBER]: this.slot,
+    };
+  })
   private async proposeCheckpoint(): Promise<Checkpoint | undefined> {
     try {
       // Get operator configured coinbase and fee recipient for this attestor
@@ -138,9 +169,9 @@ export class CheckpointProposalJob {
       this.setStateFn(SequencerState.INITIALIZING_CHECKPOINT, this.slot);
       this.metrics.incOpenSlot(this.slot, this.proposer?.toString() ?? 'unknown');
 
-      // Enqueues block invalidation (constant for the whole slot)
-      if (this.invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
-        this.publisher.enqueueInvalidateBlock(this.invalidateBlock);
+      // Enqueues checkpoint invalidation (constant for the whole slot)
+      if (this.invalidateCheckpoint && !this.config.skipInvalidateBlockAsProposer) {
+        this.publisher.enqueueInvalidateCheckpoint(this.invalidateCheckpoint);
       }
 
       // Create checkpoint builder for the slot
@@ -150,18 +181,30 @@ export class CheckpointProposalJob {
         this.slot,
       );
 
-      // Collect L1 to L2 messages for the checkpoint
+      // Collect L1 to L2 messages for the checkpoint and compute their hash
       const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(this.checkpointNumber);
+      const inHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
+
+      // Collect the out hashes of all the checkpoints before this one in the same epoch
+      const previousCheckpointOutHashes = (await this.l2BlockSource.getCheckpointsDataForEpoch(this.epoch))
+        .filter(c => c.checkpointNumber < this.checkpointNumber)
+        .map(c => c.checkpointOutHash);
+
+      // Get the fee asset price modifier from the oracle
+      const feeAssetPriceModifier = await this.publisher.getFeeAssetPriceModifier();
 
       // Create a long-lived forked world state for the checkpoint builder
-      using fork = await this.worldState.fork(this.syncedToBlockNumber, { closeDelayMs: 12_000 });
+      await using fork = await this.worldState.fork(this.syncedToBlockNumber, { closeDelayMs: 12_000 });
 
       // Create checkpoint builder for the entire slot
       const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(
         this.checkpointNumber,
         checkpointGlobalVariables,
+        feeAssetPriceModifier,
         l1ToL2Messages,
+        previousCheckpointOutHashes,
         fork,
+        this.log.getBindings(),
       );
 
       // Options for the validator client when creating block and checkpoint proposals
@@ -170,12 +213,34 @@ export class CheckpointProposalJob {
         broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal,
       };
 
-      // Main loop: build blocks for the checkpoint
-      const { blocksInCheckpoint, pendingBroadcast } = await this.buildBlocksForCheckpoint(
-        checkpointBuilder,
-        checkpointGlobalVariables.timestamp,
-        blockProposalOptions,
-      );
+      const checkpointProposalOptions: CheckpointProposalOptions = {
+        publishFullTxs: !!this.config.publishTxsWithProposals,
+        broadcastInvalidCheckpointProposal: this.config.broadcastInvalidBlockProposal,
+      };
+
+      let blocksInCheckpoint: L2Block[] = [];
+      let blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined = undefined;
+      const checkpointBuildTimer = new Timer();
+
+      try {
+        // Main loop: build blocks for the checkpoint
+        const result = await this.buildBlocksForCheckpoint(
+          checkpointBuilder,
+          checkpointGlobalVariables.timestamp,
+          inHash,
+          blockProposalOptions,
+        );
+        blocksInCheckpoint = result.blocksInCheckpoint;
+        blockPendingBroadcast = result.blockPendingBroadcast;
+      } catch (err) {
+        // These errors are expected in HA mode, so we yield and let another HA node handle the slot
+        // The only distinction between the 2 errors is SlashingProtectionError throws when the payload is different,
+        // which is normal for block building (may have picked different txs)
+        if (this.handleHASigningError(err, 'Block proposal')) {
+          return undefined;
+        }
+        throw err;
+      }
 
       if (blocksInCheckpoint.length === 0) {
         this.log.warn(`No blocks were built for slot ${this.slot}`, { slot: this.slot });
@@ -183,11 +248,28 @@ export class CheckpointProposalJob {
         return undefined;
       }
 
+      const minBlocksForCheckpoint = this.config.minBlocksForCheckpoint;
+      if (minBlocksForCheckpoint !== undefined && blocksInCheckpoint.length < minBlocksForCheckpoint) {
+        this.log.warn(
+          `Checkpoint has fewer blocks than minimum (${blocksInCheckpoint.length} < ${minBlocksForCheckpoint}), skipping proposal`,
+          { slot: this.slot, blocksBuilt: blocksInCheckpoint.length, minBlocksForCheckpoint },
+        );
+        return undefined;
+      }
+
       // Assemble and broadcast the checkpoint proposal, including the last block that was not
       // broadcasted yet, and wait to collect the committee attestations.
       this.setStateFn(SequencerState.ASSEMBLING_CHECKPOINT, this.slot);
       const checkpoint = await checkpointBuilder.completeCheckpoint();
 
+      // Record checkpoint-level build metrics
+      this.metrics.recordCheckpointBuild(
+        checkpointBuildTimer.ms(),
+        blocksInCheckpoint.length,
+        checkpoint.getStats().txCount,
+        Number(checkpoint.header.totalManaUsed.toBigInt()),
+      );
+
       // Do not collect attestations nor publish to L1 in fisherman mode
       if (this.config.fishermanMode) {
         this.log.info(
@@ -203,39 +285,83 @@ export class CheckpointProposalJob {
         return checkpoint;
       }
 
-      // TODO(palla/mbps): Wire this to the new p2p API once available, including the pendingBroadcast.block
+      // 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,
-        pendingBroadcast?.txs ?? [],
+        feeAssetPriceModifier,
+        lastBlock,
         this.proposer,
-        blockProposalOptions,
+        checkpointProposalOptions,
       );
+
       const blockProposedAt = this.dateProvider.now();
-      await this.p2pClient.broadcastProposal(proposal);
+      await this.p2pClient.broadcastCheckpointProposal(proposal);
 
       this.setStateFn(SequencerState.COLLECTING_ATTESTATIONS, this.slot);
       const attestations = await this.waitForAttestations(proposal);
       const blockAttestedAt = this.dateProvider.now();
 
-      this.metrics.recordBlockAttestationDelay(blockAttestedAt - blockProposedAt);
+      this.metrics.recordCheckpointAttestationDelay(blockAttestedAt - blockProposedAt);
 
       // Proposer must sign over the attestations before pushing them to L1
       const signer = this.proposer ?? this.publisher.getSenderAddress();
-      const attestationsSignature = await this.validatorClient.signAttestationsAndSigners(attestations, signer);
+      let attestationsSignature: Signature;
+      try {
+        attestationsSignature = await this.validatorClient.signAttestationsAndSigners(
+          attestations,
+          signer,
+          this.slot,
+          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;
+      }
 
       // Enqueue publishing the checkpoint to L1
       this.setStateFn(SequencerState.PUBLISHING_CHECKPOINT, this.slot);
       const aztecSlotDuration = this.l1Constants.slotDuration;
       const slotStartBuildTimestamp = this.getSlotStartBuildTimestamp();
       const txTimeoutAt = new Date((slotStartBuildTimestamp + aztecSlotDuration) * 1000);
+
+      // If we have been configured to potentially skip publishing checkpoint then roll the dice here
+      if (
+        this.config.skipPublishingCheckpointsPercent !== undefined &&
+        this.config.skipPublishingCheckpointsPercent > 0
+      ) {
+        const result = Math.max(0, randomInt(100));
+        if (result < this.config.skipPublishingCheckpointsPercent) {
+          this.log.warn(
+            `Skipping publishing proposal for checkpoint ${checkpoint.number}. Configured percentage: ${this.config.skipPublishingCheckpointsPercent}, generated value: ${result}`,
+          );
+          return checkpoint;
+        }
+      }
+
       await this.publisher.enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, {
         txTimeoutAt,
-        forcePendingBlockNumber: this.invalidateBlock?.forcePendingBlockNumber,
+        forcePendingCheckpointNumber: this.invalidateCheckpoint?.forcePendingCheckpointNumber,
       });
 
       return checkpoint;
     } 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
+        return undefined;
+      }
+
       this.log.error(`Error building checkpoint at slot ${this.slot}`, err);
       return undefined;
     }
@@ -244,24 +370,29 @@ export class CheckpointProposalJob {
   /**
    * Builds blocks for a checkpoint within the current slot.
    */
+  @trackSpan('CheckpointProposalJob.buildBlocksForCheckpoint')
   private async buildBlocksForCheckpoint(
     checkpointBuilder: CheckpointBuilder,
     timestamp: bigint,
+    inHash: Fr,
     blockProposalOptions: BlockProposalOptions,
   ): Promise<{
-    blocksInCheckpoint: L2BlockNew[];
-    pendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined;
+    blocksInCheckpoint: L2Block[];
+    blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined;
   }> {
-    const blocksInCheckpoint: L2BlockNew[] = [];
+    const blocksInCheckpoint: L2Block[] = [];
     const txHashesAlreadyIncluded = new Set<string>();
     const initialBlockNumber = BlockNumber(this.syncedToBlockNumber + 1);
 
+    // Remaining blob fields available for blocks (checkpoint end marker already subtracted)
+    let remainingBlobFields = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS;
+
     // Last block in the checkpoint will usually be flagged as pending broadcast, so we send it along with the checkpoint proposal
-    let pendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined = undefined;
+    let blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined = undefined;
 
     while (true) {
       const blocksBuilt = blocksInCheckpoint.length;
-      const indexWithinCheckpoint = blocksBuilt;
+      const indexWithinCheckpoint = IndexWithinCheckpoint(blocksBuilt);
       const blockNumber = BlockNumber(initialBlockNumber + blocksBuilt);
 
       const secondsIntoSlot = this.getSecondsIntoSlot();
@@ -288,8 +419,10 @@ export class CheckpointProposalJob {
         blockNumber,
         indexWithinCheckpoint,
         txHashesAlreadyIncluded,
+        remainingBlobFields,
       });
 
+      // 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;
@@ -312,13 +445,21 @@ export class CheckpointProposalJob {
         break;
       }
 
-      const { block, usedTxs } = buildResult;
+      const { block, usedTxs, remainingBlobFields: newRemainingBlobFields } = buildResult;
       blocksInCheckpoint.push(block);
 
+      // Update remaining blob fields for the next block
+      remainingBlobFields = newRemainingBlobFields;
+
       // Sync the proposed block to the archiver to make it available
       // Note that the checkpoint builder uses its own fork so it should not need to wait for this syncing
       // Eventually we should refactor the checkpoint builder to not need a separate long-lived fork
-      await this.syncProposedBlockToArchiver(block);
+      // Fire and forget - don't block the critical path, but log errors
+      this.syncProposedBlockToArchiver(block).catch(err => {
+        this.log.error(`Failed to sync proposed block ${block.number} to archiver`, { blockNumber: block.number, err });
+      });
+
+      usedTxs.forEach(tx => txHashesAlreadyIncluded.add(tx.txHash.toString()));
 
       // If this is the last block, exit the loop now so we start collecting attestations
       if (timingInfo.isLastBlock) {
@@ -327,17 +468,17 @@ export class CheckpointProposalJob {
           blockNumber,
           blocksBuilt,
         });
-        pendingBroadcast = { block, txs: usedTxs };
+        blockPendingBroadcast = { block, txs: usedTxs };
         break;
       }
 
       // For non-last blocks, broadcast the block proposal (unless we're in fisherman mode)
       // If the block is the last one, we'll broadcast it along with the checkpoint at the end of the loop
       if (!this.config.fishermanMode) {
-        // TODO(palla/mbps): Wire this to the new p2p API once available
         const proposal = await this.validatorClient.createBlockProposal(
-          block.header.globalVariables.blockNumber,
-          (await checkpointBuilder.getCheckpoint()).header,
+          block.header,
+          block.indexWithinCheckpoint,
+          inHash,
           block.archive.root,
           usedTxs,
           this.proposer,
@@ -355,13 +496,11 @@ export class CheckpointProposalJob {
       blocksBuilt: blocksInCheckpoint.length,
     });
 
-    return {
-      blocksInCheckpoint,
-      pendingBroadcast,
-    };
+    return { blocksInCheckpoint, blockPendingBroadcast };
   }
 
   /** Sleeps until it is time to produce the next block in the slot */
+  @trackSpan('CheckpointProposalJob.waitUntilNextSubslot')
   private async waitUntilNextSubslot(nextSubslotStart: number) {
     this.setStateFn(SequencerState.WAITING_UNTIL_NEXT_BLOCK, this.slot);
     this.log.verbose(`Waiting until time for the next block at ${nextSubslotStart}s into slot`, { slot: this.slot });
@@ -369,19 +508,28 @@ export class CheckpointProposalJob {
   }
 
   /** Builds a single block. Called from the main block building loop. */
-  private async buildSingleBlock(
+  @trackSpan('CheckpointProposalJob.buildSingleBlock')
+  protected async buildSingleBlock(
     checkpointBuilder: CheckpointBuilder,
     opts: {
       forceCreate?: boolean;
       blockTimestamp: bigint;
       blockNumber: BlockNumber;
-      indexWithinCheckpoint: number;
+      indexWithinCheckpoint: IndexWithinCheckpoint;
       buildDeadline: Date | undefined;
       txHashesAlreadyIncluded: Set<string>;
+      remainingBlobFields: number;
     },
-  ): Promise<{ block: L2BlockNew; usedTxs: Tx[] } | { error: Error } | undefined> {
-    const { blockTimestamp, forceCreate, blockNumber, indexWithinCheckpoint, buildDeadline, txHashesAlreadyIncluded } =
-      opts;
+  ): Promise<{ block: L2Block; usedTxs: Tx[]; remainingBlobFields: number } | { error: Error } | undefined> {
+    const {
+      blockTimestamp,
+      forceCreate,
+      blockNumber,
+      indexWithinCheckpoint,
+      buildDeadline,
+      txHashesAlreadyIncluded,
+      remainingBlobFields,
+    } = opts;
 
     this.log.verbose(
       `Preparing block ${blockNumber} index ${indexWithinCheckpoint} at checkpoint ${this.checkpointNumber} for slot ${this.slot}`,
@@ -405,7 +553,7 @@ export class CheckpointProposalJob {
       // Create iterator to pending txs. We filter out txs already included in previous blocks in the checkpoint
       // just in case p2p failed to sync the provisional block and didn't get to remove those txs from the mempool yet.
       const pendingTxs = filter(
-        this.p2pClient.iteratePendingTxs(),
+        this.p2pClient.iterateEligiblePendingTxs(),
         tx => !txHashesAlreadyIncluded.has(tx.txHash.toString()),
       );
 
@@ -414,46 +562,52 @@ export class CheckpointProposalJob {
         { slot: this.slot, blockNumber, indexWithinCheckpoint },
       );
       this.setStateFn(SequencerState.CREATING_BLOCK, this.slot);
+
+      // Calculate blob fields limit for txs (remaining capacity - this block's end overhead)
+      const blockEndOverhead = getNumBlockEndBlobFields(indexWithinCheckpoint === 0);
+      const maxBlobFieldsForTxs = remainingBlobFields - blockEndOverhead;
+
       const blockBuilderOptions: PublicProcessorLimits = {
         maxTransactions: this.config.maxTxsPerBlock,
         maxBlockSize: this.config.maxBlockSizeInBytes,
         maxBlockGas: new Gas(this.config.maxDABlockGas, this.config.maxL2BlockGas),
-        maxBlobFields: BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB,
+        maxBlobFields: maxBlobFieldsForTxs,
         deadline: buildDeadline,
       };
 
       // Actually build the block by executing txs
-      const workTimer = new Timer();
-      const { publicGas, block, publicProcessorDuration, numTxs, blockBuildingTimer, usedTxs, failedTxs } =
-        await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
-      const blockBuildDuration = workTimer.ms();
+      const buildResult = await this.buildSingleBlockWithCheckpointBuilder(
+        checkpointBuilder,
+        pendingTxs,
+        blockNumber,
+        blockTimestamp,
+        blockBuilderOptions,
+      );
 
       // If any txs failed during execution, drop them from the mempool so we don't pick them up again
-      await this.dropFailedTxsFromP2P(failedTxs);
+      await this.dropFailedTxsFromP2P(buildResult.failedTxs);
 
       // Check if we have created a block with enough txs. If there were invalid txs in the pool, or if execution took
       // too long, then we may not get to minTxsPerBlock after executing public functions.
       const minValidTxs = this.config.minValidTxsPerBlock ?? minTxs;
-      if (!forceCreate && numTxs < minValidTxs) {
+      const numTxs = buildResult.status === 'no-valid-txs' ? 0 : buildResult.numTxs;
+      if (buildResult.status === 'no-valid-txs' || (!forceCreate && numTxs < minValidTxs)) {
         this.log.warn(
-          `Block ${blockNumber} at index ${indexWithinCheckpoint} on slot ${this.slot} has too few valid txs to be proposed (got ${numTxs} but required ${minValidTxs})`,
-          { slot: this.slot, blockNumber, numTxs, indexWithinCheckpoint },
+          `Block ${blockNumber} at index ${indexWithinCheckpoint} on slot ${this.slot} has too few valid txs to be proposed`,
+          { slot: this.slot, blockNumber, numTxs, indexWithinCheckpoint, minValidTxs, buildResult: buildResult.status },
         );
-        this.eventEmitter.emit('block-tx-count-check-failed', {
-          minTxs: minValidTxs,
-          availableTxs: numTxs,
-          slot: this.slot,
-        });
+        this.eventEmitter.emit('block-build-failed', { reason: `Insufficient valid txs`, slot: this.slot });
         this.metrics.recordBlockProposalFailed('insufficient_valid_txs');
         return undefined;
       }
 
       // Block creation succeeded, emit stats and metrics
+      const { publicGas, block, publicProcessorDuration, usedTxs, usedTxBlobFields, blockBuildDuration } = buildResult;
+
       const blockStats = {
         eventName: 'l2-block-built',
         duration: blockBuildDuration,
         publicProcessDuration: publicProcessorDuration,
-        rollupCircuitsDuration: blockBuildingTimer.ms(),
         ...block.getStats(),
       } satisfies L2BlockBuiltStats;
 
@@ -469,7 +623,7 @@ export class CheckpointProposalJob {
       this.eventEmitter.emit('block-proposed', { blockNumber: block.number, slot: this.slot });
       this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
 
-      return { block, usedTxs };
+      return { block, usedTxs, remainingBlobFields: maxBlobFieldsForTxs - usedTxBlobFields };
     } catch (err: any) {
       this.eventEmitter.emit('block-build-failed', { reason: err.message, slot: this.slot });
       this.log.error(`Error building block`, err, { blockNumber, slot: this.slot });
@@ -479,16 +633,40 @@ export class CheckpointProposalJob {
     }
   }
 
+  /** Uses the checkpoint builder to build a block, catching specific txs */
+  private async buildSingleBlockWithCheckpointBuilder(
+    checkpointBuilder: CheckpointBuilder,
+    pendingTxs: AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    blockTimestamp: bigint,
+    blockBuilderOptions: PublicProcessorLimits,
+  ) {
+    try {
+      const workTimer = new Timer();
+      const result = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
+      const blockBuildDuration = workTimer.ms();
+      return { ...result, blockBuildDuration, status: 'success' as const };
+    } catch (err: unknown) {
+      if (isErrorClass(err, NoValidTxsError)) {
+        return { failedTxs: err.failedTxs, status: 'no-valid-txs' as const };
+      }
+      throw err;
+    }
+  }
+
   /** Waits until minTxs are available on the pool for building a block. */
+  @trackSpan('CheckpointProposalJob.waitForMinTxs')
   private async waitForMinTxs(opts: {
     forceCreate?: boolean;
     blockNumber: BlockNumber;
-    indexWithinCheckpoint: number;
+    indexWithinCheckpoint: IndexWithinCheckpoint;
     buildDeadline: Date | undefined;
   }): Promise<{ canStartBuilding: boolean; availableTxs: number }> {
-    const minTxs = this.config.minTxsPerBlock;
     const { indexWithinCheckpoint, blockNumber, buildDeadline, forceCreate } = opts;
 
+    // We only allow a block with 0 txs in the first block of the checkpoint
+    const minTxs = indexWithinCheckpoint > 0 && this.config.minTxsPerBlock === 0 ? 1 : this.config.minTxsPerBlock;
+
     // Deadline is undefined if we are not enforcing the timetable, meaning we'll exit immediately when out of time
     const startBuildingDeadline = buildDeadline
       ? new Date(buildDeadline.getTime() - this.timetable.minExecutionTime * 1000)
@@ -509,7 +687,7 @@ export class CheckpointProposalJob {
         `Waiting for enough txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.slot} (have ${availableTxs} but need ${minTxs})`,
         { blockNumber, slot: this.slot, indexWithinCheckpoint },
       );
-      await sleep(TXS_POLLING_MS);
+      await this.waitForTxsPollingInterval();
       availableTxs = await this.p2pClient.getPendingTxCount();
     }
 
@@ -520,7 +698,8 @@ export class CheckpointProposalJob {
    * Waits for enough attestations to be collected via p2p.
    * This is run after all blocks for the checkpoint have been built.
    */
-  private async waitForAttestations(proposal: BlockProposal): Promise<CommitteeAttestationsAndSigners> {
+  @trackSpan('CheckpointProposalJob.waitForAttestations')
+  private async waitForAttestations(proposal: CheckpointProposal): Promise<CommitteeAttestationsAndSigners> {
     if (this.config.fishermanMode) {
       this.log.debug('Skipping attestation collection in fisherman mode');
       return CommitteeAttestationsAndSigners.empty();
@@ -549,7 +728,7 @@ export class CheckpointProposalJob {
     const attestationTimeAllowed = this.config.enforceTimeTable
       ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_CHECKPOINT)!
       : this.l1Constants.slotDuration;
-    const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
+    const attestationDeadline = new Date((this.getSlotStartBuildTimestamp() + attestationTimeAllowed) * 1000);
 
     this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, attestationTimeAllowed);
 
@@ -564,13 +743,24 @@ export class CheckpointProposalJob {
 
       collectedAttestationsCount = attestations.length;
 
+      // Trim attestations to minimum required to save L1 calldata gas
+      const localAddresses = this.validatorClient.getValidatorAddresses();
+      const trimmed = trimAttestations(
+        attestations,
+        numberOfRequiredAttestations,
+        this.attestorAddress,
+        localAddresses,
+      );
+      if (trimmed.length < attestations.length) {
+        this.log.debug(`Trimmed attestations from ${attestations.length} to ${trimmed.length} for L1 submission`);
+      }
+
       // Rollup contract requires that the signatures are provided in the order of the committee
-      const sorted = orderAttestations(attestations, committee);
+      const sorted = orderAttestations(trimmed, committee);
 
       // Manipulate the attestations if we've been configured to do so
       if (this.config.injectFakeAttestation || this.config.shuffleAttestationOrdering) {
-        const checkpoint = proposal.payload.header;
-        return this.manipulateAttestations(checkpoint, epoch, seed, committee, sorted);
+        return this.manipulateAttestations(proposal.slotNumber, epoch, seed, committee, sorted);
       }
 
       return new CommitteeAttestationsAndSigners(sorted);
@@ -586,7 +776,7 @@ export class CheckpointProposalJob {
 
   /** Breaks the attestations before publishing based on attack configs */
   private manipulateAttestations(
-    checkpoint: CheckpointHeader,
+    slotNumber: SlotNumber,
     epoch: EpochNumber,
     seed: bigint,
     committee: EthAddress[],
@@ -594,7 +784,6 @@ export class CheckpointProposalJob {
   ) {
     // Compute the proposer index in the committee, since we dont want to tweak it.
     // Otherwise, the L1 rollup contract will reject the block outright.
-    const { slotNumber } = checkpoint;
     const proposerIndex = Number(
       this.epochCache.computeProposerIndex(slotNumber, epoch, seed, BigInt(committee.length)),
     );
@@ -639,20 +828,27 @@ export class CheckpointProposalJob {
     const failedTxData = failedTxs.map(fail => fail.tx);
     const failedTxHashes = failedTxData.map(tx => tx.getTxHash());
     this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
-    await this.p2pClient.deleteTxs(failedTxHashes);
+    await this.p2pClient.handleFailedExecution(failedTxHashes);
   }
 
   /**
-   * Placeholder for pushing block to archiver and waiting for sync.
-   * To be implemented when archiver and world-state support proposed blocks.
+   * 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.
    */
-  private async syncProposedBlockToArchiver(block: L2BlockNew): Promise<void> {
-    this.log.debug(`Syncing proposed block ${block.number}`, {
+  private async syncProposedBlockToArchiver(block: L2Block): Promise<void> {
+    if (this.config.skipPushProposedBlocksToArchiver !== false) {
+      this.log.warn(`Skipping push of proposed block ${block.number} to archiver`, {
+        blockNumber: block.number,
+        slot: block.header.globalVariables.slotNumber,
+      });
+      return;
+    }
+    this.log.debug(`Syncing proposed block ${block.number} to archiver`, {
       blockNumber: block.number,
       slot: block.header.globalVariables.slotNumber,
     });
-    // TODO(palla/mbps): Implement actual sync to archiver and world-state
-    await Promise.resolve();
+    await this.blockSink.addBlock(block);
   }
 
   /** Runs fee analysis and logs checkpoint outcome as fisherman */
@@ -669,25 +865,52 @@ export class CheckpointProposalJob {
         ...checkpoint.getStats(),
         feeAnalysisId: feeAnalysis?.id,
       });
-      this.metrics.recordBlockProposalSuccess();
     } else {
       this.log.warn(`Validation block building FAILED for slot ${this.slot}`, {
         slot: this.slot,
         feeAnalysisId: feeAnalysis?.id,
       });
-      this.metrics.recordBlockProposalFailed('block_build_failed');
+      this.metrics.recordCheckpointProposalFailed('block_build_failed');
     }
 
     this.publisher.clearPendingRequests();
   }
 
+  /**
+   * Helper to handle HA double-signing errors. Returns true if the error was handled (caller should yield).
+   */
+  private handleHASigningError(err: any, errorContext: string): boolean {
+    if (err instanceof DutyAlreadySignedError) {
+      this.log.info(`${errorContext} for slot ${this.slot} already signed by another HA node, yielding`, {
+        slot: this.slot,
+        signedByNode: err.signedByNode,
+      });
+      return true;
+    }
+    if (err instanceof SlashingProtectionError) {
+      this.log.info(`${errorContext} for slot ${this.slot} blocked by slashing protection, yielding`, {
+        slot: this.slot,
+        existingMessageHash: err.existingMessageHash,
+        attemptedMessageHash: err.attemptedMessageHash,
+      });
+      return true;
+    }
+    return false;
+  }
+
   /** Waits until a specific time within the current slot */
+  @trackSpan('CheckpointProposalJob.waitUntilTimeInSlot')
   protected async waitUntilTimeInSlot(targetSecondsIntoSlot: number): Promise<void> {
     const slotStartTimestamp = this.getSlotStartBuildTimestamp();
     const targetTimestamp = slotStartTimestamp + targetSecondsIntoSlot;
     await sleepUntil(new Date(targetTimestamp * 1000), this.dateProvider.nowAsDate());
   }
 
+  /** Waits the polling interval for transactions. Extracted for test overriding. */
+  protected async waitForTxsPollingInterval(): Promise<void> {
+    await sleep(TXS_POLLING_MS);
+  }
+
   private getSlotStartBuildTimestamp(): number {
     return getSlotStartBuildTimestamp(this.slot, this.l1Constants);
   }