@aztec/sequencer-client 0.0.1-commit.6c91f13 → 0.0.1-commit.96bb3f7

package/src/sequencer/checkpoint_proposal_job.ts

@@ -2,6 +2,7 @@ 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 { 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';
@@ -15,6 +16,7 @@ import {
   CommitteeAttestation,
   CommitteeAttestationsAndSigners,
   L2BlockNew,
+  type L2BlockSink,
   MaliciousCommitteeAttestationsAndSigners,
 } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
@@ -25,18 +27,17 @@ import type {
   ResolvedSequencerConfig,
   WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import type { BlockProposal, BlockProposalOptions } from '@aztec/stdlib/p2p';
+import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import type { BlockProposalOptions, CheckpointProposal, CheckpointProposalOptions } from '@aztec/stdlib/p2p';
 import { orderAttestations } from '@aztec/stdlib/p2p';
-import { CheckpointHeader } from '@aztec/stdlib/rollup';
 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 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,7 +55,7 @@ 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 {
   constructor(
     private readonly slot: SlotNumber,
     private readonly checkpointNumber: CheckpointNumber,
@@ -63,13 +64,14 @@ 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 checkpointsBuilder: FullNodeCheckpointsBuilder,
+    private readonly blockSink: L2BlockSink,
     private readonly l1Constants: SequencerRollupConstants,
     protected config: ResolvedSequencerConfig,
     protected timetable: SequencerTimetable,
@@ -80,12 +82,14 @@ export class CheckpointProposalJob {
     private readonly eventEmitter: TypedEventEmitter<SequencerEvents>,
     private readonly setStateFn: (state: SequencerState, slot?: SlotNumber) => void,
     protected readonly log: Logger,
+    public readonly tracer: Tracer,
   ) {}
 
   /**
    * 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
@@ -132,6 +136,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
@@ -142,9 +153,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
@@ -154,8 +165,9 @@ 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);
 
       // Create a long-lived forked world state for the checkpoint builder
       using fork = await this.worldState.fork(this.syncedToBlockNumber, { closeDelayMs: 12_000 });
@@ -174,10 +186,16 @@ export class CheckpointProposalJob {
         broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal,
       };
 
+      const checkpointProposalOptions: CheckpointProposalOptions = {
+        publishFullTxs: !!this.config.publishTxsWithProposals,
+        broadcastInvalidCheckpointProposal: this.config.broadcastInvalidBlockProposal,
+      };
+
       // Main loop: build blocks for the checkpoint
-      const { blocksInCheckpoint, pendingBroadcast } = await this.buildBlocksForCheckpoint(
+      const { blocksInCheckpoint, blockPendingBroadcast } = await this.buildBlocksForCheckpoint(
         checkpointBuilder,
         checkpointGlobalVariables.timestamp,
+        inHash,
         blockProposalOptions,
       );
 
@@ -207,22 +225,30 @@ 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 ?? [],
+        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();
@@ -235,7 +261,7 @@ export class CheckpointProposalJob {
       const txTimeoutAt = new Date((slotStartBuildTimestamp + aztecSlotDuration) * 1000);
       await this.publisher.enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, {
         txTimeoutAt,
-        forcePendingBlockNumber: this.invalidateBlock?.forcePendingBlockNumber,
+        forcePendingCheckpointNumber: this.invalidateCheckpoint?.forcePendingCheckpointNumber,
       });
 
       return checkpoint;
@@ -248,20 +274,22 @@ 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;
+    blockPendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined;
   }> {
     const blocksInCheckpoint: L2BlockNew[] = [];
     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 pendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined = undefined;
+    let blockPendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined = undefined;
 
     while (true) {
       const blocksBuilt = blocksInCheckpoint.length;
@@ -331,17 +359,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,
@@ -359,13 +387,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 });
@@ -373,6 +399,7 @@ export class CheckpointProposalJob {
   }
 
   /** Builds a single block. Called from the main block building loop. */
+  @trackSpan('CheckpointProposalJob.buildSingleBlock')
   private async buildSingleBlock(
     checkpointBuilder: CheckpointBuilder,
     opts: {
@@ -484,6 +511,7 @@ export class CheckpointProposalJob {
   }
 
   /** Waits until minTxs are available on the pool for building a block. */
+  @trackSpan('CheckpointProposalJob.waitForMinTxs')
   private async waitForMinTxs(opts: {
     forceCreate?: boolean;
     blockNumber: BlockNumber;
@@ -524,7 +552,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();
@@ -573,8 +602,7 @@ export class CheckpointProposalJob {
 
       // 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);
@@ -590,7 +618,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[],
@@ -598,7 +626,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)),
     );
@@ -647,16 +674,24 @@ export class CheckpointProposalJob {
   }
 
   /**
-   * 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}`, {
+    // TODO(palla/mbps): Change default to false once block sync is stable.
+    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 */
@@ -685,6 +720,7 @@ export class CheckpointProposalJob {
   }
 
   /** 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;

package/src/sequencer/index.ts

@@ -1,5 +1,4 @@
 export * from './block_builder.js';
-export * from './checkpoint_builder.js';
 export * from './checkpoint_proposal_job.js';
 export * from './checkpoint_voter.js';
 export * from './config.js';

package/src/sequencer/metrics.ts

@@ -11,7 +11,6 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
-  ValueType,
 } from '@aztec/telemetry-client';
 
 import { type Hex, formatUnits } from 'viem';
@@ -44,7 +43,7 @@ export class SequencerMetrics {
   private blockProposalPrecheckFailed: UpDownCounter;
   private checkpointSuccess: UpDownCounter;
   private slashingAttempts: UpDownCounter;
-  private blockAttestationDelay: Histogram;
+  private checkpointAttestationDelay: Histogram;
 
   // Fisherman fee analysis metrics
   private fishermanWouldBeIncluded: UpDownCounter;
@@ -70,33 +69,13 @@ export class SequencerMetrics {
 
     this.blockCounter = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
 
-    this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
-      unit: 'ms',
-      description: 'Duration to build a block',
-      valueType: ValueType.INT,
-    });
+    this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION);
 
-    this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND, {
-      unit: 'mana/s',
-      description: 'Mana per second when building a block',
-      valueType: ValueType.INT,
-    });
+    this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND);
 
-    this.stateTransitionBufferDuration = this.meter.createHistogram(
-      Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION,
-      {
-        unit: 'ms',
-        description:
-          'The time difference between when the sequencer needed to transition to a new state and when it actually did.',
-        valueType: ValueType.INT,
-      },
-    );
+    this.stateTransitionBufferDuration = this.meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION);
 
-    this.blockAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_ATTESTATION_DELAY, {
-      unit: 'ms',
-      description: 'The time difference between block proposal and minimal attestation count reached,',
-      valueType: ValueType.INT,
-    });
+    this.checkpointAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY);
 
     // Init gauges and counters
     this.blockCounter.add(0, {
@@ -106,152 +85,65 @@ export class SequencerMetrics {
       [Attributes.STATUS]: 'built',
     });
 
-    this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS, {
-      valueType: ValueType.DOUBLE,
-      description: 'The rewards earned',
-    });
+    this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS);
 
-    this.slots = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLOT_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of slots this sequencer was selected for',
-    });
+    this.slots = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLOT_COUNT);
 
     /**
      * NOTE: we do not track missed slots as a separate metric. That would be difficult to determine
      * Instead, use a computed metric, `slots - filledSlots` to get the number of slots a sequencer has missed.
      */
-    this.filledSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_FILLED_SLOT_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of slots this sequencer has filled',
-    });
+    this.filledSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_FILLED_SLOT_COUNT);
 
-    this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION, {
-      description: 'The time spent collecting attestations from committee members',
-      unit: 'ms',
-      valueType: ValueType.INT,
-    });
+    this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION);
 
-    this.allowanceToCollectAttestations = this.meter.createGauge(
-      Metrics.SEQUENCER_COLLECT_ATTESTATIONS_TIME_ALLOWANCE,
-      {
-        description: 'Maximum amount of time to collect attestations',
-        unit: 'ms',
-        valueType: ValueType.INT,
-      },
-    );
+    this.allowanceToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_TIME_ALLOWANCE);
 
-    this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The minimum number of attestations required to publish a block',
-    });
+    this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT);
 
-    this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The minimum number of attestations required to publish a block',
-    });
+    this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT);
 
-    this.blockProposalFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of times block proposal failed (including validation builds)',
-    });
+    this.blockProposalFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT);
 
-    this.blockProposalSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of times block proposal succeeded (including validation builds)',
-    });
+    this.blockProposalSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT);
 
-    this.checkpointSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of times checkpoint publishing succeeded',
-    });
+    this.checkpointSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
 
     this.blockProposalPrecheckFailed = this.meter.createUpDownCounter(
       Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT,
-      {
-        valueType: ValueType.INT,
-        description: 'The number of times block proposal pre-build checks failed',
-      },
     );
 
-    this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of slashing action attempts',
-    });
+    this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
 
     // Fisherman fee analysis metrics
-    this.fishermanWouldBeIncluded = this.meter.createUpDownCounter(Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED, {
-      valueType: ValueType.INT,
-      description: 'Whether the transaction would have been included in the block',
-    });
+    this.fishermanWouldBeIncluded = this.meter.createUpDownCounter(Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED);
 
-    this.fishermanTimeBeforeBlock = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_TIME_BEFORE_BLOCK, {
-      unit: 'ms',
-      description: 'Time in ms between fee analysis and block being mined',
-      valueType: ValueType.INT,
-    });
+    this.fishermanTimeBeforeBlock = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_TIME_BEFORE_BLOCK);
 
-    this.fishermanPendingBlobTxCount = this.meter.createHistogram(
-      Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_TX_COUNT,
-      {
-        description: 'Number of blob transactions seen in the pending block',
-        valueType: ValueType.INT,
-      },
-    );
+    this.fishermanPendingBlobTxCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_TX_COUNT);
 
     this.fishermanIncludedBlobTxCount = this.meter.createHistogram(
       Metrics.FISHERMAN_FEE_ANALYSIS_INCLUDED_BLOB_TX_COUNT,
-      {
-        description: 'Number of blob transactions that got included in the mined block',
-        valueType: ValueType.INT,
-      },
     );
 
     this.fishermanCalculatedPriorityFee = this.meter.createHistogram(
       Metrics.FISHERMAN_FEE_ANALYSIS_CALCULATED_PRIORITY_FEE,
-      {
-        unit: 'gwei',
-        description: 'Priority fee calculated by each strategy',
-        valueType: ValueType.DOUBLE,
-      },
     );
 
-    this.fishermanPriorityFeeDelta = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PRIORITY_FEE_DELTA, {
-      unit: 'gwei',
-      description: 'Difference between our priority fee and minimum included priority fee',
-      valueType: ValueType.DOUBLE,
-    });
+    this.fishermanPriorityFeeDelta = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PRIORITY_FEE_DELTA);
 
-    this.fishermanEstimatedCost = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_COST, {
-      unit: 'eth',
-      description: 'Estimated total cost in ETH for the transaction with this strategy',
-      valueType: ValueType.DOUBLE,
-    });
+    this.fishermanEstimatedCost = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_COST);
 
     this.fishermanEstimatedOverpayment = this.meter.createHistogram(
       Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_OVERPAYMENT,
-      {
-        unit: 'eth',
-        description: 'Estimated overpayment in ETH vs minimum required for inclusion',
-        valueType: ValueType.DOUBLE,
-      },
     );
 
     this.fishermanMinedBlobTxPriorityFee = this.meter.createHistogram(
       Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_PRIORITY_FEE,
-      {
-        unit: 'gwei',
-        description: 'Priority fee per gas for blob transactions in mined blocks',
-        valueType: ValueType.DOUBLE,
-      },
     );
 
     this.fishermanMinedBlobTxTotalCost = this.meter.createHistogram(
       Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_TOTAL_COST,
-      {
-        unit: 'eth',
-        description: 'Total cost in ETH for blob transactions in mined blocks',
-        valueType: ValueType.DOUBLE,
-      },
     );
   }
 
@@ -264,8 +156,8 @@ export class SequencerMetrics {
     this.timeToCollectAttestations.record(0);
   }
 
-  public recordBlockAttestationDelay(duration: number) {
-    this.blockAttestationDelay.record(duration);
+  public recordCheckpointAttestationDelay(duration: number) {
+    this.checkpointAttestationDelay.record(duration);
   }
 
   public recordCollectedAttestations(count: number, durationMs: number) {