@aztec/sequencer-client 0.0.1-commit.6d63667d → 0.0.1-commit.7ac86ea28

package/src/publisher/sequencer-publisher-factory.ts

@@ -3,7 +3,7 @@ import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { BlobClientInterface } from '@aztec/blob-client/client';
 import type { EpochCache } from '@aztec/epoch-cache';
 import type { GovernanceProposerContract, RollupContract } from '@aztec/ethereum/contracts';
-import type { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import type { PublisherFilter, PublisherManager } from '@aztec/ethereum/publisher-manager';
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import type { DateProvider } from '@aztec/foundation/timer';
@@ -26,13 +26,15 @@ export class SequencerPublisherFactory {
   /** Stores the last slot in which every action was carried out by a publisher */
   private lastActions: Partial<Record<Action, SlotNumber>> = {};
 
+  private nodeKeyStore: NodeKeystoreAdapter;
+
   private logger: Logger;
 
   constructor(
     private sequencerConfig: SequencerClientConfig,
     private deps: {
       telemetry: TelemetryClient;
-      publisherManager: PublisherManager<L1TxUtilsWithBlobs>;
+      publisherManager: PublisherManager<L1TxUtils>;
       blobClient: BlobClientInterface;
       dateProvider: DateProvider;
       epochCache: EpochCache;
@@ -45,7 +47,17 @@ export class SequencerPublisherFactory {
   ) {
     this.publisherMetrics = new SequencerPublisherMetrics(deps.telemetry, 'SequencerPublisher');
     this.logger = deps.logger ?? createLogger('sequencer');
+    this.nodeKeyStore = this.deps.nodeKeyStore;
+  }
+
+  /**
+   * Updates the node keystore adapter used for publisher lookups.
+   * Called when the keystore is reloaded at runtime to reflect new validator-publisher mappings.
+   */
+  public updateNodeKeyStore(adapter: NodeKeystoreAdapter): void {
+    this.nodeKeyStore = adapter;
   }
+
   /**
    * Creates a new SequencerPublisher instance.
    * @param _validatorAddress - The address of the validator that will be using the publisher.
@@ -54,17 +66,17 @@ export class SequencerPublisherFactory {
   public async create(validatorAddress?: EthAddress): Promise<AttestorPublisherPair> {
     // If we have been given an attestor address we must only allow publishers permitted for that attestor
 
-    const allowedPublishers = !validatorAddress ? [] : this.deps.nodeKeyStore.getPublisherAddresses(validatorAddress);
-    const filter: PublisherFilter<L1TxUtilsWithBlobs> = !validatorAddress
+    const allowedPublishers = !validatorAddress ? [] : this.nodeKeyStore.getPublisherAddresses(validatorAddress);
+    const filter: PublisherFilter<L1TxUtils> = !validatorAddress
       ? () => true
-      : (utils: L1TxUtilsWithBlobs) => {
+      : (utils: L1TxUtils) => {
           const publisherAddress = utils.getSenderAddress();
           return allowedPublishers.some(allowedPublisher => allowedPublisher.equals(publisherAddress));
         };
 
     const l1Publisher = await this.deps.publisherManager.getAvailablePublisher(filter);
     const attestorAddress =
-      validatorAddress ?? this.deps.nodeKeyStore.getAttestorForPublisher(l1Publisher.getSenderAddress());
+      validatorAddress ?? this.nodeKeyStore.getAttestorForPublisher(l1Publisher.getSenderAddress());
 
     const rollup = this.deps.rollupContract;
     const slashingProposerContract = await rollup.getSlashingProposer();
@@ -89,4 +101,9 @@ export class SequencerPublisherFactory {
       publisher,
     };
   }
+
+  /** Interrupts all publishers managed by this factory. Used during sequencer shutdown. */
+  public interruptAll(): void {
+    this.deps.publisherManager.interrupt();
+  }
 }

package/src/publisher/sequencer-publisher.ts

@@ -4,6 +4,7 @@ import type { EpochCache } from '@aztec/epoch-cache';
 import type { L1ContractsConfig } from '@aztec/ethereum/config';
 import {
   type EmpireSlashingProposerContract,
+  FeeAssetPriceOracle,
   type GovernanceProposerContract,
   type IEmpireBase,
   MULTI_CALL_3_ADDRESS,
@@ -18,11 +19,11 @@ import {
   type L1BlobInputs,
   type L1TxConfig,
   type L1TxRequest,
+  type L1TxUtils,
   MAX_L1_TX_LIMIT,
   type TransactionStats,
   WEI_CONST,
 } from '@aztec/ethereum/l1-tx-utils';
-import type { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
 import { FormattedViemError, formatViemError, mergeAbis, tryExtractEvent } from '@aztec/ethereum/utils';
 import { sumBigint } from '@aztec/foundation/bigint';
 import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
@@ -32,6 +33,7 @@ import type { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature, type ViemSignature } from '@aztec/foundation/eth-signature';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { bufferToHex } from '@aztec/foundation/string';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import { EmpireBaseAbi, ErrorsAbi, RollupAbi } from '@aztec/l1-artifacts';
@@ -45,7 +47,7 @@ import { type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from
 
 import { type StateOverride, type TransactionReceipt, type TypedDataDefinition, encodeFunctionData, toHex } from 'viem';
 
-import type { PublisherConfig, TxSenderConfig } from './config.js';
+import type { SequencerPublisherConfig } from './config.js';
 import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
 
 /** Arguments to the process method of the rollup contract */
@@ -60,6 +62,8 @@ type L1ProcessArgs = {
   attestationsAndSigners: CommitteeAttestationsAndSigners;
   /** Attestations and signers signature */
   attestationsAndSignersSignature: Signature;
+  /** The fee asset price modifier in basis points (from oracle) */
+  feeAssetPriceModifier: bigint;
 };
 
 export const Actions = [
@@ -112,6 +116,7 @@ export class SequencerPublisher {
   protected lastActions: Partial<Record<Action, SlotNumber>> = {};
 
   private isPayloadEmptyCache: Map<string, boolean> = new Map<string, boolean>();
+  private payloadProposedCache: Set<string> = new Set<string>();
 
   protected log: Logger;
   protected ethereumSlotDuration: bigint;
@@ -123,13 +128,17 @@ export class SequencerPublisher {
 
   /** L1 fee analyzer for fisherman mode */
   private l1FeeAnalyzer?: L1FeeAnalyzer;
+
+  /** Fee asset price oracle for computing price modifiers from Uniswap V4 */
+  private feeAssetPriceOracle: FeeAssetPriceOracle;
+
   // A CALL to a cold address is 2700 gas
   public static MULTICALL_OVERHEAD_GAS_GUESS = 5000n;
 
   // Gas report for VotingWithSigTest shows a max gas of 100k, but we've seen it cost 700k+ in testnet
   public static VOTE_GAS_GUESS: bigint = 800_000n;
 
-  public l1TxUtils: L1TxUtilsWithBlobs;
+  public l1TxUtils: L1TxUtils;
   public rollupContract: RollupContract;
   public govProposerContract: GovernanceProposerContract;
   public slashingProposerContract: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
@@ -140,11 +149,12 @@ export class SequencerPublisher {
   protected requests: RequestWithExpiry[] = [];
 
   constructor(
-    private config: TxSenderConfig & PublisherConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'>,
+    private config: Pick<SequencerPublisherConfig, 'fishermanMode'> &
+      Pick<L1ContractsConfig, 'ethereumSlotDuration'> & { l1ChainId: number },
     deps: {
       telemetry?: TelemetryClient;
       blobClient: BlobClientInterface;
-      l1TxUtils: L1TxUtilsWithBlobs;
+      l1TxUtils: L1TxUtils;
       rollupContract: RollupContract;
       slashingProposerContract: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
       governanceProposerContract: GovernanceProposerContract;
@@ -188,12 +198,27 @@ export class SequencerPublisher {
         createLogger('sequencer:publisher:fee-analyzer'),
       );
     }
+
+    // Initialize fee asset price oracle
+    this.feeAssetPriceOracle = new FeeAssetPriceOracle(
+      this.l1TxUtils.client,
+      this.rollupContract,
+      createLogger('sequencer:publisher:price-oracle'),
+    );
   }
 
   public getRollupContract(): RollupContract {
     return this.rollupContract;
   }
 
+  /**
+   * Gets the fee asset price modifier from the oracle.
+   * Returns 0n if the oracle query fails.
+   */
+  public getFeeAssetPriceModifier(): Promise<bigint> {
+    return this.feeAssetPriceOracle.computePriceModifier();
+  }
+
   public getSenderAddress() {
     return this.l1TxUtils.getSenderAddress();
   }
@@ -617,24 +642,8 @@ export class SequencerPublisher {
     options: { forcePendingCheckpointNumber?: CheckpointNumber },
   ): Promise<bigint> {
     const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
-
-    // TODO(palla/mbps): This should not be needed, there's no flow where we propose with zero attestations. Or is there?
-    // If we have no attestations, we still need to provide the empty attestations
-    // so that the committee is recalculated correctly
-    // const ignoreSignatures = attestationsAndSigners.attestations.length === 0;
-    // if (ignoreSignatures) {
-    //   const { committee } = await this.epochCache.getCommittee(block.header.globalVariables.slotNumber);
-    //   if (!committee) {
-    //     this.log.warn(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
-    //     throw new Error(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
-    //   }
-    //   attestationsAndSigners.attestations = committee.map(committeeMember =>
-    //     CommitteeAttestation.fromAddress(committeeMember),
-    //   );
-    // }
-
     const blobFields = checkpoint.toBlobFields();
-    const blobs = getBlobsPerL1Block(blobFields);
+    const blobs = await getBlobsPerL1Block(blobFields);
     const blobInput = getPrefixedEthBlobCommitments(blobs);
 
     const args = [
@@ -642,7 +651,7 @@ export class SequencerPublisher {
         header: checkpoint.header.toViem(),
         archive: toHex(checkpoint.archive.root.toBuffer()),
         oracleInput: {
-          feeAssetPriceModifier: 0n,
+          feeAssetPriceModifier: checkpoint.feeAssetPriceModifier,
         },
       },
       attestationsAndSigners.getPackedAttestations(),
@@ -691,6 +700,32 @@ export class SequencerPublisher {
       return false;
     }
 
+    // Check if payload was already submitted to governance
+    const cacheKey = payload.toString();
+    if (!this.payloadProposedCache.has(cacheKey)) {
+      try {
+        const l1StartBlock = await this.rollupContract.getL1StartBlock();
+        const proposed = await retry(
+          () => base.hasPayloadBeenProposed(payload.toString(), l1StartBlock),
+          'Check if payload was proposed',
+          makeBackoff([0, 1, 2]),
+          this.log,
+          true,
+        );
+        if (proposed) {
+          this.payloadProposedCache.add(cacheKey);
+        }
+      } catch (err) {
+        this.log.warn(`Failed to check if payload ${payload} was proposed after retries, skipping signal`, err);
+        return false;
+      }
+    }
+
+    if (this.payloadProposedCache.has(cacheKey)) {
+      this.log.info(`Payload ${payload} was already proposed to governance, stopping signals`);
+      return false;
+    }
+
     const cachedLastVote = this.lastActions[signalType];
     this.lastActions[signalType] = slotNumber;
     const action = signalType;
@@ -918,14 +953,15 @@ export class SequencerPublisher {
     const checkpointHeader = checkpoint.header;
 
     const blobFields = checkpoint.toBlobFields();
-    const blobs = getBlobsPerL1Block(blobFields);
+    const blobs = await getBlobsPerL1Block(blobFields);
 
-    const proposeTxArgs = {
+    const proposeTxArgs: L1ProcessArgs = {
       header: checkpointHeader,
       archive: checkpoint.archive.root.toBuffer(),
       blobs,
       attestationsAndSigners,
       attestationsAndSignersSignature,
+      feeAssetPriceModifier: checkpoint.feeAssetPriceModifier,
     };
 
     let ts: bigint;
@@ -1113,8 +1149,7 @@ export class SequencerPublisher {
         header: encodedData.header.toViem(),
         archive: toHex(encodedData.archive),
         oracleInput: {
-          // We are currently not modifying these. See #9963
-          feeAssetPriceModifier: 0n,
+          feeAssetPriceModifier: encodedData.feeAssetPriceModifier,
         },
       },
       encodedData.attestationsAndSigners.getPackedAttestations(),
@@ -1140,7 +1175,7 @@ export class SequencerPublisher {
         readonly header: ViemHeader;
         readonly archive: `0x${string}`;
         readonly oracleInput: {
-          readonly feeAssetPriceModifier: 0n;
+          readonly feeAssetPriceModifier: bigint;
         };
       },
       ViemCommitteeAttestations,

package/src/sequencer/checkpoint_proposal_job.ts

@@ -129,7 +129,7 @@ export class CheckpointProposalJob implements Traceable {
     await Promise.all(votesPromises);
 
     if (checkpoint) {
-      this.metrics.recordBlockProposalSuccess();
+      this.metrics.recordCheckpointProposalSuccess();
     }
 
     // Do not post anything to L1 if we are fishermen, but do perform L1 fee analysis
@@ -186,18 +186,21 @@ export class CheckpointProposalJob implements Traceable {
       const inHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
 
       // Collect the out hashes of all the checkpoints before this one in the same epoch
-      const previousCheckpoints = (await this.l2BlockSource.getCheckpointsForEpoch(this.epoch)).filter(
-        c => c.number < this.checkpointNumber,
-      );
-      const previousCheckpointOutHashes = previousCheckpoints.map(c => c.getCheckpointOutHash());
+      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,
@@ -217,6 +220,7 @@ export class CheckpointProposalJob implements Traceable {
 
       let blocksInCheckpoint: L2Block[] = [];
       let blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined = undefined;
+      const checkpointBuildTimer = new Timer();
 
       try {
         // Main loop: build blocks for the checkpoint
@@ -244,11 +248,28 @@ export class CheckpointProposalJob implements Traceable {
         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(
@@ -275,6 +296,7 @@ export class CheckpointProposalJob implements Traceable {
       const proposal = await this.validatorClient.createCheckpointProposal(
         checkpoint.header,
         checkpoint.archive.root,
+        feeAssetPriceModifier,
         lastBlock,
         this.proposer,
         checkpointProposalOptions,
@@ -313,6 +335,21 @@ export class CheckpointProposalJob implements Traceable {
       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,
         forcePendingCheckpointNumber: this.invalidateCheckpoint?.forcePendingCheckpointNumber,
@@ -516,7 +553,7 @@ export class CheckpointProposalJob implements Traceable {
       // 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()),
       );
 
@@ -779,7 +816,7 @@ export class CheckpointProposalJob implements Traceable {
     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);
   }
 
   /**
@@ -821,7 +858,7 @@ export class CheckpointProposalJob implements Traceable {
         slot: this.slot,
         feeAnalysisId: feeAnalysis?.id,
       });
-      this.metrics.recordBlockProposalFailed('block_build_failed');
+      this.metrics.recordCheckpointProposalFailed('block_build_failed');
     }
 
     this.publisher.clearPendingRequests();

package/src/sequencer/metrics.ts

@@ -18,7 +18,6 @@ import { type Hex, formatUnits } from 'viem';
 
 import type { SequencerState } from './utils.js';
 
-// TODO(palla/mbps): Review all metrics and add any missing ones per checkpoint
 export class SequencerMetrics {
   public readonly tracer: Tracer;
   private meter: Meter;
@@ -40,17 +39,26 @@ export class SequencerMetrics {
   private filledSlots: UpDownCounter;
 
   private blockProposalFailed: UpDownCounter;
-  private blockProposalSuccess: UpDownCounter;
-  private blockProposalPrecheckFailed: UpDownCounter;
+  private checkpointProposalSuccess: UpDownCounter;
+  private checkpointPrecheckFailed: UpDownCounter;
+  private checkpointProposalFailed: UpDownCounter;
   private checkpointSuccess: UpDownCounter;
   private slashingAttempts: UpDownCounter;
   private checkpointAttestationDelay: Histogram;
+  private checkpointBuildDuration: Histogram;
+  private checkpointBlockCount: Gauge;
+  private checkpointTxCount: Gauge;
+  private checkpointTotalMana: Gauge;
 
   // Fisherman fee analysis metrics
   private fishermanWouldBeIncluded: UpDownCounter;
   private fishermanTimeBeforeBlock: Histogram;
   private fishermanPendingBlobTxCount: Histogram;
   private fishermanIncludedBlobTxCount: Histogram;
+  private fishermanPendingBlobCount: Histogram;
+  private fishermanIncludedBlobCount: Histogram;
+  private fishermanBlockBlobsFull: UpDownCounter;
+  private fishermanMaxBlobCapacity: Histogram;
   private fishermanCalculatedPriorityFee: Histogram;
   private fishermanPriorityFeeDelta: Histogram;
   private fishermanEstimatedCost: Histogram;
@@ -80,7 +88,7 @@ export class SequencerMetrics {
 
     this.checkpointAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY);
 
-    this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS);
+    this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_SLOT_REWARDS);
 
     this.slots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLOT_COUNT);
 
@@ -103,16 +111,16 @@ export class SequencerMetrics {
       Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT,
     );
 
-    this.blockProposalSuccess = createUpDownCounterWithDefault(
+    this.checkpointProposalSuccess = createUpDownCounterWithDefault(
       this.meter,
-      Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT,
+      Metrics.SEQUENCER_CHECKPOINT_PROPOSAL_SUCCESS_COUNT,
     );
 
     this.checkpointSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
 
-    this.blockProposalPrecheckFailed = createUpDownCounterWithDefault(
+    this.checkpointPrecheckFailed = createUpDownCounterWithDefault(
       this.meter,
-      Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT,
+      Metrics.SEQUENCER_CHECKPOINT_PRECHECK_FAILED_COUNT,
       {
         [Attributes.ERROR_TYPE]: [
           'slot_already_taken',
@@ -123,6 +131,16 @@ export class SequencerMetrics {
       },
     );
 
+    this.checkpointProposalFailed = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_CHECKPOINT_PROPOSAL_FAILED_COUNT,
+    );
+
+    this.checkpointBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_BUILD_DURATION);
+    this.checkpointBlockCount = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_BLOCK_COUNT);
+    this.checkpointTxCount = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TX_COUNT);
+    this.checkpointTotalMana = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TOTAL_MANA);
+
     this.slashingAttempts = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
 
     // Fisherman fee analysis metrics
@@ -131,6 +149,7 @@ export class SequencerMetrics {
       Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED,
       {
         [Attributes.OK]: [true, false],
+        [Attributes.BLOCK_FULL]: ['true', 'false'],
       },
     );
 
@@ -161,6 +180,20 @@ export class SequencerMetrics {
     this.fishermanMinedBlobTxTotalCost = this.meter.createHistogram(
       Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_TOTAL_COST,
     );
+
+    this.fishermanPendingBlobCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_COUNT);
+
+    this.fishermanIncludedBlobCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_INCLUDED_BLOB_COUNT);
+
+    this.fishermanBlockBlobsFull = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.FISHERMAN_FEE_ANALYSIS_BLOCK_BLOBS_FULL,
+      {
+        [Attributes.OK]: [true, false],
+      },
+    );
+
+    this.fishermanMaxBlobCapacity = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_MAX_BLOB_CAPACITY);
   }
 
   public recordRequiredAttestations(requiredAttestationsCount: number, allowanceMs: number) {
@@ -243,18 +276,30 @@ export class SequencerMetrics {
     });
   }
 
-  recordBlockProposalSuccess() {
-    this.blockProposalSuccess.add(1);
+  recordCheckpointProposalSuccess() {
+    this.checkpointProposalSuccess.add(1);
   }
 
-  recordBlockProposalPrecheckFailed(
+  recordCheckpointPrecheckFailed(
     checkType: 'slot_already_taken' | 'rollup_contract_check_failed' | 'slot_mismatch' | 'block_number_mismatch',
   ) {
-    this.blockProposalPrecheckFailed.add(1, {
-      [Attributes.ERROR_TYPE]: checkType,
+    this.checkpointPrecheckFailed.add(1, { [Attributes.ERROR_TYPE]: checkType });
+  }
+
+  recordCheckpointProposalFailed(reason?: string) {
+    this.checkpointProposalFailed.add(1, {
+      ...(reason && { [Attributes.ERROR_TYPE]: reason }),
     });
   }
 
+  /** Records aggregate metrics for a completed checkpoint build. */
+  recordCheckpointBuild(durationMs: number, blockCount: number, txCount: number, totalMana: number) {
+    this.checkpointBuildDuration.record(Math.ceil(durationMs));
+    this.checkpointBlockCount.record(blockCount);
+    this.checkpointTxCount.record(txCount);
+    this.checkpointTotalMana.record(totalMana);
+  }
+
   recordSlashingAttempt(actionCount: number) {
     this.slashingAttempts.add(actionCount);
   }
@@ -281,10 +326,12 @@ export class SequencerMetrics {
 
       // Record pending block snapshot data (once per strategy for comparison)
       this.fishermanPendingBlobTxCount.record(analysis.pendingSnapshot.pendingBlobTxCount, strategyAttributes);
+      this.fishermanPendingBlobCount.record(analysis.pendingSnapshot.pendingBlobCount, strategyAttributes);
 
       // Record mined block data if available
       if (analysis.minedBlock) {
         this.fishermanIncludedBlobTxCount.record(analysis.minedBlock.includedBlobTxCount, strategyAttributes);
+        this.fishermanIncludedBlobCount.record(analysis.minedBlock.includedBlobCount, strategyAttributes);
 
         // Record actual fees from blob transactions in the mined block
         for (const blobTx of analysis.minedBlock.includedBlobTxs) {
@@ -318,13 +365,28 @@ export class SequencerMetrics {
       if (analysis.analysis) {
         this.fishermanTimeBeforeBlock.record(Math.ceil(analysis.analysis.timeBeforeBlockMs), strategyAttributes);
 
+        // Record whether the block reached 100% blob capacity
+        if (analysis.analysis.blockBlobsFull) {
+          this.fishermanBlockBlobsFull.add(1, { ...strategyAttributes, [Attributes.OK]: true });
+        } else {
+          this.fishermanBlockBlobsFull.add(1, { ...strategyAttributes, [Attributes.OK]: false });
+        }
+
+        // Record the max blob capacity for this block
+        this.fishermanMaxBlobCapacity.record(analysis.analysis.maxBlobCapacity, strategyAttributes);
+
         // Record strategy-specific inclusion result
         if (strategyResult.wouldBeIncluded !== undefined) {
+          const inclusionAttributes = {
+            ...strategyAttributes,
+            [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false',
+          };
+
           if (strategyResult.wouldBeIncluded) {
-            this.fishermanWouldBeIncluded.add(1, { ...strategyAttributes, [Attributes.OK]: true });
+            this.fishermanWouldBeIncluded.add(1, { ...inclusionAttributes, [Attributes.OK]: true });
           } else {
             this.fishermanWouldBeIncluded.add(1, {
-              ...strategyAttributes,
+              ...inclusionAttributes,
               [Attributes.OK]: false,
               ...(strategyResult.exclusionReason && { [Attributes.ERROR_TYPE]: strategyResult.exclusionReason }),
             });
@@ -334,17 +396,29 @@ export class SequencerMetrics {
         // Record strategy-specific priority fee delta
         if (strategyResult.priorityFeeDelta !== undefined) {
           const priorityFeeDeltaGwei = Number(strategyResult.priorityFeeDelta) / 1e9;
-          this.fishermanPriorityFeeDelta.record(priorityFeeDeltaGwei, strategyAttributes);
+          const deltaAttributes = {
+            ...strategyAttributes,
+            [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false',
+          };
+          this.fishermanPriorityFeeDelta.record(priorityFeeDeltaGwei, deltaAttributes);
         }
 
         // Record estimated cost if available
         if (strategyResult.estimatedCostEth !== undefined) {
-          this.fishermanEstimatedCost.record(strategyResult.estimatedCostEth, strategyAttributes);
+          const costAttributes = {
+            ...strategyAttributes,
+            [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false',
+          };
+          this.fishermanEstimatedCost.record(strategyResult.estimatedCostEth, costAttributes);
         }
 
         // Record estimated overpayment if available
         if (strategyResult.estimatedOverpaymentEth !== undefined) {
-          this.fishermanEstimatedOverpayment.record(strategyResult.estimatedOverpaymentEth, strategyAttributes);
+          const overpaymentAttributes = {
+            ...strategyAttributes,
+            [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false',
+          };
+          this.fishermanEstimatedOverpayment.record(strategyResult.estimatedOverpaymentEth, overpaymentAttributes);
         }
       }
     }