@aztec/p2p 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/services/discv5/persisted_enr_store.ts

@@ -0,0 +1,158 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+
+import { ENR } from '@nethermindeth/enr';
+
+/** Map name under which discovered peer ENRs are persisted so discovery can be re-seeded after a restart. */
+const PERSISTED_ENRS_MAP_NAME = 'discovered_peer_enrs';
+
+/**
+ * A persisted peer entry: the ENR text plus a monotonic sequence number recording when the peer was
+ * last seen. The sequence orders the store as a FIFO so eviction drops the oldest-seen peers first.
+ */
+interface PersistedEnr {
+  enr: string;
+  seq: number;
+}
+
+function parsePersistedEnr(value: string): PersistedEnr | undefined {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed?.enr === 'string' && typeof parsed?.seq === 'number') {
+      return parsed;
+    }
+  } catch {
+    // Unparseable entry; caller treats it as stale.
+  }
+  return undefined;
+}
+
+/**
+ * A bounded, transactional store of discovered peer ENRs used to re-seed discovery after a restart.
+ *
+ * Entries are keyed by nodeId (so re-seeing a peer dedups in place) and carry a monotonic sequence so
+ * the store behaves as a FIFO: when it exceeds its cap, the oldest-seen peers are evicted first. All
+ * writes run in a transaction so concurrent discovery events can't race the size check.
+ */
+export class PersistedEnrStore {
+  private readonly enrs: AztecAsyncMap<string, string>;
+  /** Monotonic sequence stamped on each entry; seeded from the store's max in {@link load}. */
+  private seq = 0;
+
+  constructor(
+    private readonly store: AztecAsyncKVStore,
+    private readonly maxEntries: number,
+    private readonly logger: Logger = createLogger('p2p:discv5:enr-store'),
+  ) {
+    this.enrs = store.openMap(PERSISTED_ENRS_MAP_NAME);
+  }
+
+  /** Adds or replaces a peer's ENR, stamping it as most-recently-seen and evicting the oldest if over cap. */
+  public async persist(enr: ENR): Promise<void> {
+    const nodeId = enr.nodeId;
+    const enrTxt = enr.encodeTxt();
+    try {
+      await this.store.transactionAsync(async () => {
+        const seq = ++this.seq;
+        const others: { nodeId: string; seq: number }[] = [];
+        for await (const [id, value] of this.enrs.entriesAsync()) {
+          if (id !== nodeId) {
+            others.push({ nodeId: id, seq: parsePersistedEnr(value)?.seq ?? 0 });
+          }
+        }
+        const overflow = others.length + 1 - this.maxEntries;
+        if (overflow > 0) {
+          others.sort((a, b) => a.seq - b.seq); // oldest-seen (lowest sequence) first
+          for (let i = 0; i < overflow; i++) {
+            await this.enrs.delete(others[i].nodeId);
+          }
+        }
+        await this.enrs.set(nodeId, JSON.stringify({ enr: enrTxt, seq }));
+      });
+    } catch (err) {
+      this.logger.warn(`Failed to persist discovered ENR ${nodeId}`, err);
+    }
+  }
+
+  /**
+   * Refreshes an already-persisted peer's stored ENR when a newer one (higher ENR sequence) is seen.
+   * A no-op for peers we don't already track — we never add new peers via this path, only update.
+   *
+   * This exists because discv5 updates an existing routing-table entry on an ENR sequence bump without
+   * emitting an `enrAdded` event, so a peer that changes address would otherwise keep its stale ENR
+   * persisted until evicted.
+   */
+  public async refresh(enr: ENR): Promise<void> {
+    const nodeId = enr.nodeId;
+    try {
+      await this.store.transactionAsync(async () => {
+        const existing = await this.enrs.getAsync(nodeId);
+        if (!existing) {
+          return;
+        }
+        // Two unrelated sequence numbers are in play:
+        //  - the ENR sequence (`enr.seq` / `storedEnrSeq`) is set by the *peer* and bumped whenever it
+        //    revises its record (e.g. changes address); we compare these to decide whether the incoming
+        //    ENR is genuinely newer and worth keeping.
+        //  - our storage sequence (`this.seq`) is an internal counter used only for FIFO eviction; we
+        //    stamp a fresh one so this entry counts as most-recently-seen.
+        const storedEnrSeq = this.decodeStoredEnr(existing)?.seq;
+        if (storedEnrSeq !== undefined && enr.seq <= storedEnrSeq) {
+          return;
+        }
+        await this.enrs.set(nodeId, JSON.stringify({ enr: enr.encodeTxt(), seq: ++this.seq }));
+      });
+    } catch (err) {
+      this.logger.warn(`Failed to refresh persisted ENR ${nodeId}`, err);
+    }
+  }
+
+  /**
+   * Loads all persisted ENRs, decoding each and keeping those the `accept` predicate allows. Entries
+   * that fail to decode or are rejected are removed from the store. The FIFO sequence resumes from the
+   * highest persisted value so eviction order survives restarts.
+   */
+  public async load(accept: (enr: ENR) => boolean): Promise<ENR[]> {
+    const valid: ENR[] = [];
+    const stale: string[] = [];
+    let maxSeq = 0;
+    for await (const [nodeId, value] of this.enrs.entriesAsync()) {
+      const parsed = parsePersistedEnr(value);
+      let enr: ENR | undefined;
+      if (parsed) {
+        try {
+          enr = ENR.decodeTxt(parsed.enr);
+        } catch (err) {
+          this.logger.debug(`Dropping undecodable persisted ENR ${nodeId}`, err);
+        }
+      }
+      if (!parsed || !enr || !accept(enr)) {
+        stale.push(nodeId);
+        continue;
+      }
+      maxSeq = Math.max(maxSeq, parsed.seq);
+      valid.push(enr);
+    }
+    this.seq = maxSeq;
+    if (stale.length > 0) {
+      await this.store.transactionAsync(async () => {
+        for (const nodeId of stale) {
+          await this.enrs.delete(nodeId);
+        }
+      });
+    }
+    return valid;
+  }
+
+  private decodeStoredEnr(value: string): ENR | undefined {
+    const parsed = parsePersistedEnr(value);
+    if (!parsed) {
+      return undefined;
+    }
+    try {
+      return ENR.decodeTxt(parsed.enr);
+    } catch {
+      return undefined;
+    }
+  }
+}

package/src/services/dummy_service.ts

@@ -18,16 +18,17 @@ import type {
   ReqRespSubProtocol,
   ReqRespSubProtocolHandler,
   ReqRespSubProtocolHandlers,
-  ReqRespSubProtocolValidators,
   SubProtocolMap,
 } from './reqresp/interface.js';
 import type { GoodByeReason } from './reqresp/protocols/goodbye.js';
 import { ReqRespStatus } from './reqresp/status.js';
 import {
   type P2PBlockReceivedCallback,
+  type P2PCheckpointAttestationCallback,
   type P2PCheckpointReceivedCallback,
   type P2PDuplicateAttestationCallback,
   type P2PDuplicateProposalCallback,
+  type P2POversizedProposalCallback,
   type P2PService,
   type PeerDiscoveryService,
   PeerDiscoveryState,
@@ -37,6 +38,8 @@ import {
  * A dummy implementation of the P2P Service.
  */
 export class DummyP2PService implements P2PService {
+  private allNodesCheckpointReceivedCallback?: P2PCheckpointReceivedCallback;
+
   updateConfig(_config: Partial<P2PReqRespConfig>): void {}
 
   /** Returns an empty array for peers. */
@@ -86,18 +89,28 @@ export class DummyP2PService implements P2PService {
   /**
    * Register a callback into the validator client for when a checkpoint proposal is received
    */
-  public registerCheckpointReceivedCallback(_callback: P2PCheckpointReceivedCallback) {}
+  public registerValidatorCheckpointReceivedCallback(_callback: P2PCheckpointReceivedCallback) {}
+  public registerAllNodesCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback) {
+    this.allNodesCheckpointReceivedCallback = callback;
+  }
 
   /**
    * Register a callback for when a duplicate proposal is detected
    */
   public registerDuplicateProposalCallback(_callback: P2PDuplicateProposalCallback): void {}
 
+  /**
+   * Register a callback for when an oversized proposal is stored
+   */
+  public registerOversizedProposalCallback(_callback: P2POversizedProposalCallback): void {}
+
   /**
    * Register a callback for when a duplicate attestation is detected
    */
   public registerDuplicateAttestationCallback(_callback: P2PDuplicateAttestationCallback): void {}
 
+  public registerCheckpointAttestationCallback(_callback: P2PCheckpointAttestationCallback): void {}
+
   /**
    * Sends a request to a peer.
    * @param _protocol - The protocol to send the request on.
@@ -111,19 +124,6 @@ export class DummyP2PService implements P2PService {
     return Promise.resolve(undefined);
   }
 
-  /**
-   * Sends a batch request to a peer.
-   * @param _protocol - The protocol to send the request on.
-   * @param _requests - The requests to send.
-   * @returns The responses from the peer, otherwise undefined.
-   */
-  public sendBatchRequest<Protocol extends ReqRespSubProtocol>(
-    _protocol: Protocol,
-    _requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]> {
-    return Promise.resolve([]);
-  }
-
   public sendRequestToPeer(
     _peerId: PeerId,
     _subProtocol: ReqRespSubProtocol,
@@ -145,11 +145,7 @@ export class DummyP2PService implements P2PService {
     return Promise.resolve();
   }
 
-  addReqRespSubProtocol(
-    _subProtocol: ReqRespSubProtocol,
-    _handler: ReqRespSubProtocolHandler,
-    _validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
-  ): Promise<void> {
+  addReqRespSubProtocol(_subProtocol: ReqRespSubProtocol, _handler: ReqRespSubProtocolHandler): Promise<void> {
     return Promise.resolve();
   }
 
@@ -178,6 +174,7 @@ export class DummyP2PService implements P2PService {
       peerScoring: {
         penalizePeer: (_peerId, _penalty) => {},
       },
+      validateRequestedBlockTxsConsistency: () => Promise.resolve(true),
     };
   }
 }
@@ -282,10 +279,8 @@ export class DummyPeerManager implements PeerManagerInterface {
 
 export class DummyReqResp implements ReqRespInterface {
   updateConfig(_config: Partial<P2PReqRespConfig>): void {}
-  start(
-    _subProtocolHandlers: ReqRespSubProtocolHandlers,
-    _subProtocolValidators: ReqRespSubProtocolValidators,
-  ): Promise<void> {
+  setShouldRejectPeer(): void {}
+  start(_subProtocolHandlers: ReqRespSubProtocolHandlers): Promise<void> {
     return Promise.resolve();
   }
   stop(): Promise<void> {
@@ -297,16 +292,6 @@ export class DummyReqResp implements ReqRespInterface {
   ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined> {
     return Promise.resolve(undefined);
   }
-  sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(
-    _subProtocol: SubProtocol,
-    _requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
-    _pinnedPeer: PeerId | undefined,
-    _timeoutMs?: number,
-    _maxPeers?: number,
-    _maxRetryAttempts?: number,
-  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]> {
-    return Promise.resolve([]);
-  }
   public sendRequestToPeer(
     _peerId: PeerId,
     _subProtocol: ReqRespSubProtocol,
@@ -325,11 +310,7 @@ export class DummyReqResp implements ReqRespInterface {
     };
   }
 
-  addSubProtocol(
-    _subProtocol: ReqRespSubProtocol,
-    _handler: ReqRespSubProtocolHandler,
-    _validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
-  ): Promise<void> {
+  addSubProtocol(_subProtocol: ReqRespSubProtocol, _handler: ReqRespSubProtocolHandler): Promise<void> {
     return Promise.resolve();
   }
 }

package/src/services/encoding.ts

@@ -2,12 +2,10 @@
 import { createLogger } from '@aztec/foundation/log';
 import { MAX_TX_SIZE_KB, TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
 
-import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
 import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
 import type { Message } from '@libp2p/interface';
 import { webcrypto } from 'node:crypto';
 import { compressSync, uncompressSync } from 'snappy';
-import xxhashFactory from 'xxhash-wasm';
 
 /** Thrown when a Snappy-compressed response exceeds the allowed decompressed size. */
 export class OversizedSnappyResponseError extends Error {
@@ -17,26 +15,9 @@ export class OversizedSnappyResponseError extends Error {
   }
 }
 
-// Load WASM
-const xxhash = await xxhashFactory();
-
-// Use salt to prevent msgId from being mined for collisions
-const h64Seed = BigInt(Math.floor(Math.random() * 1e9));
-
 // Shared buffer to convert msgId to string
 const sharedMsgIdBuf = Buffer.alloc(20);
 
-/**
- * The function used to generate a gossipsub message id
- * We use the first 8 bytes of SHA256(data) for content addressing
- */
-export function fastMsgIdFn(rpcMsg: RPC.Message): string {
-  if (rpcMsg.data) {
-    return xxhash.h64Raw(rpcMsg.data, h64Seed).toString(16);
-  }
-  return '0000000000000000';
-}
-
 export function msgIdToStrFn(msgId: Uint8Array): string {
   // This happens serially, no need to reallocate the buffer
   sharedMsgIdBuf.set(msgId);
@@ -49,11 +30,20 @@ export function msgIdToStrFn(msgId: Uint8Array): string {
  * Follows similarly to:
  * https://github.com/ethereum/consensus-specs/blob/v1.1.0-alpha.7/specs/altair/p2p-interface.md#topics-and-messages
  *
+ * The topic length is framed into the hash input (`uint32be(topicLen) || topic || data`) so the
+ * `(topic, data)` boundary is unambiguous. A raw `topic || data` concatenation is not injective —
+ * shifting bytes across the boundary (e.g. `(topic + data[0], data[1:])`) yields the same bytes and
+ * thus the same id, letting an unsubscribed-topic message pre-occupy a real message's seenCache slot
+ * and suppress it as a duplicate.
+ *
  * @param message - The libp2p message
  * @returns The message identifier
  */
-export async function getMsgIdFn({ topic, data }: Message): Promise<Uint8Array> {
-  const buffer = Buffer.concat([Buffer.from(topic), data]);
+export async function getMsgIdFn({ topic, data }: Pick<Message, 'topic' | 'data'>): Promise<Uint8Array> {
+  const topicBytes = Buffer.from(topic);
+  const framedTopicLength = Buffer.allocUnsafe(4);
+  framedTopicLength.writeUInt32BE(topicBytes.length);
+  const buffer = Buffer.concat([framedTopicLength, topicBytes, data]);
   const hash = await webcrypto.subtle.digest('SHA-256', buffer);
   return Buffer.from(hash.slice(0, 20));
 }

package/src/services/gossipsub/README.md

@@ -205,7 +205,7 @@ This ensures P3 max penalty (-34) exceeds P1 + P2 max (+33), causing mesh prunin
 | Topic | Expected/Slot | Decay Window | Notes |
 |-------|--------------|--------------|-------|
 | `tx` | Unpredictable | N/A | P3/P3b disabled |
-| `block_proposal` | N-1 | 3 slots | N = blocks per slot (MBPS mode) |
+| `block_proposal` | N-1 | 3 slots | N = blocks per slot |
 | `checkpoint_proposal` | 1 | 5 slots | One per slot |
 | `checkpoint_attestation` | C (~48) | 2 slots | C = committee size |
 
@@ -223,15 +223,15 @@ Block proposal scoring is controlled by the `expectedBlockProposalsPerSlot` conf
 |-------------|----------|
 | `0` (current default) | Block proposal P3 scoring is **disabled** |
 | Positive number | Uses the provided value as expected proposals per slot |
-| `undefined` | Falls back to `blocksPerSlot - 1` (MBPS mode: N-1, single block: 0) |
+| `undefined` | Falls back to `blocksPerSlot - 1` (N-1 when the slot fits multiple blocks, 0 when it fits one) |
 
 **Current behavior note:** In the current implementation, if `SEQ_EXPECTED_BLOCK_PROPOSALS_PER_SLOT` is not set, config mapping applies `0` by default (scoring disabled). The `undefined` fallback above is currently reachable only if the value is explicitly provided as `undefined` in code.
 
 **Future intent:** Once throughput is stable, we may change env parsing/defaults so an unset env var resolves to `undefined` again (re-enabling automatic fallback to `blocksPerSlot - 1`).
 
-**Why disabled by default?** In MBPS mode, gossipsub expects N-1 block proposals per slot. When transaction throughput is low (as expected at launch), fewer blocks are actually built, causing peers to be incorrectly penalized for under-delivering block proposals. The default of 0 disables this scoring. Set to a positive value when throughput increases and block production is consistent.
+**Why disabled by default?** Gossipsub expects N-1 block proposals per slot. When transaction throughput is low (as expected at launch), fewer blocks are actually built, causing peers to be incorrectly penalized for under-delivering block proposals. The default of 0 disables this scoring. Set to a positive value when throughput increases and block production is consistent.
 
-In MBPS mode (when enabled), N-1 block proposals are gossiped per slot (the last block is bundled with the checkpoint). In single-block mode, this is 0.
+When a slot fits multiple blocks, N-1 block proposals are gossiped per slot (the last block is bundled with the checkpoint). When the slot fits exactly one block, this is 0.
 
 ### Checkpoint Proposals (checkpoint_proposal)
 
@@ -254,7 +254,7 @@ The scoring parameters depend on:
 | `slotDuration` | L1RollupConstants | 72s |
 | `targetCommitteeSize` | L1RollupConstants | 48 |
 | `heartbeatInterval` | P2PConfig.gossipsubInterval | 700ms |
-| `blockDurationMs` | P2PConfig.blockDurationMs | undefined (single block) |
+| `blockDurationMs` | P2PConfig.blockDurationMs | 3000ms |
 | `expectedBlockProposalsPerSlot` | P2PConfig.expectedBlockProposalsPerSlot | 0 (disabled; current unset-env behavior) |
 
 ## Invalid Message Handling (P4)
@@ -470,7 +470,22 @@ Application scores decay by 10% per minute (`decayFactor = 0.9`):
 - Score -100 → -35 after 10 minutes
 - Score -100 → -12 after 20 minutes
 
-This allows honest peers to recover from temporary issues.
+This allows honest peers to recover from temporary issues — but only up to the ban threshold. Once a peer
+crosses into the **Banned** state, decay no longer applies until the ban expires (see Ban Duration below).
+
+### Ban Duration
+
+Once a peer's score drops below the ban threshold (`MIN_SCORE_BEFORE_BAN = -100`) the ban is held for a configurable
+duration:
+
+- The score the peer held when banned is recorded in memory alongside an expiry timestamp.
+- While the ban is active, `getScore` returns the **ban score** regardless of decay, so the peer stays in the
+  `Banned` state for the full window and cannot decay its way out early.
+- When the ban expires it is removed and the live (decayed) score takes over again, letting the peer recover.
+
+The ban duration is controlled by `P2P_PEER_BAN_DURATION_SECONDS` (config field `peerBanDurationSeconds`), defaulting
+to 24 hours. Bans are held in memory only (cleared on restart). This is independent of the gossipsub topic-score
+decay (P4, P3b), which continues to decay as described above; only the application-level ban score is pinned.
 
 ## Score Calculation Examples
 
@@ -544,15 +559,22 @@ Initial state: Total score -3003
 
 After 4 slots (~5 min):
   P4 decays to 1%: -2000 → -20
-  App score unchanged: -1000
+  App score pinned at ban floor: -1000
   Total: -1023 → Still banned, but no longer graylisted
 
-After 10 min:
-  App score decays: -100 → -35 → -350 contribution
-  P4 further decayed: ~-5
-  Total: -358 → Above gossipThreshold, starting to recover
+For the rest of the ban window (default 24h):
+  Topic scores (P4, P3b) keep decaying toward 0
+  App score stays pinned at the ban floor: -1000 contribution
+  Total: ~-1000 → Remains banned (cannot publish)
+
+After the ban expires:
+  The ban is lifted; the live app score (now decayed toward 0) takes over
+  Total: recovers, peer can participate again
 ```
 
+Unlike topic scores, the application ban score does **not** decay-recover during the ban window — that is the
+point of the ban duration (see above). A banned peer is held for the full `P2P_PEER_BAN_DURATION_SECONDS`.
+
 ## Network Outage Analysis
 
 What happens when a peer experiences a network outage and stops delivering messages?

package/src/services/gossipsub/topic_score_params.ts

@@ -1,5 +1,4 @@
 import { TopicType, createTopicString } from '@aztec/stdlib/p2p';
-import { calculateMaxBlocksPerSlot } from '@aztec/stdlib/timetable';
 
 import { createTopicScoreParams } from '@chainsafe/libp2p-gossipsub/score';
 
@@ -13,24 +12,15 @@ export type TopicScoringNetworkParams = {
   heartbeatIntervalMs: number;
   /** Target committee size (number of validators expected to attest per slot) */
   targetCommitteeSize: number;
-  /** Duration per block in milliseconds when building multiple blocks per slot. If undefined, single block mode. */
-  blockDurationMs?: number;
+  /**
+   * Max blocks per checkpoint, the network-wide config value. Used to derive expected per-slot message rates
+   * for scoring; it is a peer-rate threshold input, not a consensus deadline.
+   */
+  maxBlocksPerCheckpoint: number;
   /** Expected number of block proposals per slot for scoring override. 0 disables scoring, undefined falls back to blocksPerSlot - 1. */
   expectedBlockProposalsPerSlot?: number;
 };
 
-/**
- * Calculates the number of blocks per slot based on timing parameters.
- * Uses the shared calculation from @aztec/stdlib/timetable.
- *
- * @param slotDurationMs - L2 slot duration in milliseconds
- * @param blockDurationMs - Duration per block in milliseconds (undefined = single block mode)
- * @returns Number of blocks per slot
- */
-export function calculateBlocksPerSlot(slotDurationMs: number, blockDurationMs: number | undefined): number {
-  return calculateMaxBlocksPerSlot(slotDurationMs / 1000, blockDurationMs ? blockDurationMs / 1000 : undefined);
-}
-
 /**
  * Determines the decay window in slots based on expected message frequency.
  * Low-frequency topics need longer decay windows to accumulate meaningful counter values.
@@ -276,10 +266,11 @@ export class TopicScoreParamsFactory {
   };
 
   constructor(private readonly params: TopicScoringNetworkParams) {
-    const { slotDurationMs, heartbeatIntervalMs, blockDurationMs } = params;
+    const { slotDurationMs, heartbeatIntervalMs } = params;
 
-    // Compute values that are the same for all topics
-    this.blocksPerSlot = calculateBlocksPerSlot(slotDurationMs, blockDurationMs);
+    // Compute values that are the same for all topics. The block count comes straight from the network-wide
+    // max-blocks-per-checkpoint config value.
+    this.blocksPerSlot = params.maxBlocksPerCheckpoint;
     this.heartbeatsPerSlot = slotDurationMs / heartbeatIntervalMs;
     this.invalidDecay = computeDecay(heartbeatIntervalMs, slotDurationMs, INVALID_DECAY_WINDOW_SLOTS);
 

package/src/services/libp2p/instrumentation.ts

@@ -18,6 +18,7 @@ export class P2PInstrumentation {
   private messagePrevalidationCount: UpDownCounter;
   private messageLatency: Histogram;
   private txReceivedCount: UpDownCounter;
+  private slowValidationCount: UpDownCounter;
 
   private aggLatencyHisto = new Map<TopicType, RecordableHistogram>();
   private aggValidationHisto = new Map<TopicType, RecordableHistogram>();
@@ -48,6 +49,15 @@ export class P2PInstrumentation {
 
     this.txReceivedCount = createUpDownCounterWithDefault(meter, Metrics.P2P_GOSSIP_TX_RECEIVED_COUNT);
 
+    this.slowValidationCount = createUpDownCounterWithDefault(meter, Metrics.P2P_GOSSIP_SLOW_VALIDATION_COUNT, {
+      [Attributes.TOPIC_NAME]: [
+        TopicType.tx,
+        TopicType.block_proposal,
+        TopicType.checkpoint_proposal,
+        TopicType.checkpoint_attestation,
+      ],
+    });
+
     this.aggLatencyMetrics = {
       avg: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_AVG),
       max: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_MAX),
@@ -87,6 +97,10 @@ export class P2PInstrumentation {
     this.txReceivedCount.add(count);
   }
 
+  public incSlowValidation(topicName: TopicType) {
+    this.slowValidationCount.add(1, { [Attributes.TOPIC_NAME]: topicName });
+  }
+
   public incMessagePrevalidationStatus(passed: boolean, topicName: TopicType | undefined) {
     this.messagePrevalidationCount.add(1, { [Attributes.TOPIC_NAME]: topicName, [Attributes.OK]: passed });
   }