@lodestar/beacon-node 1.45.0-dev.fadf0fbb1f → 1.46.0-dev.8fc4e297d2

package/src/network/core/metrics.ts

@@ -127,6 +127,100 @@ export function createNetworkCoreMetrics(register: RegistryMetricCreator) {
         name: "lodestar_peer_manager_starved_bool",
         help: "Whether lodestar is starved of data while syncing",
       }),
+      /**
+       * Core selection/pruning phase of the heartbeat, split out of heartbeatDuration so it
+       * can be attributed on its own. Divide by peersEvaluated for time-per-peer.
+       */
+      prioritizePeersDuration: register.histogram({
+        name: "lodestar_peer_manager_prioritize_peers_seconds",
+        help: "prioritizePeers function duration in seconds, the core peer selection/pruning algorithm",
+        buckets: [0.0005, 0.001, 0.005, 0.01, 0.05, 0.1],
+      }),
+      /**
+       * Score decay + map prune over every tracked peer, split out of heartbeatDuration.
+       * This loop iterates the whole score store, so divide by scoreMapSize (not
+       * peersEvaluated) for time-per-peer.
+       */
+      scoreUpdateDuration: register.histogram({
+        name: "lodestar_peer_score_update_seconds",
+        help: "Peer score store update (decay + prune over all peers) duration in seconds",
+        buckets: [0.0005, 0.001, 0.005, 0.01, 0.05, 0.1],
+      }),
+      /**
+       * Denominator for prioritizePeersDuration: it scales with the number of connected
+       * healthy peers, so time-per-peer (prioritizePeersDuration / this) is the comparable
+       * figure. For scoreUpdateDuration use scoreMapSize instead.
+       */
+      peersEvaluated: register.histogram({
+        name: "lodestar_peer_manager_peers_evaluated_count",
+        help: "Number of connected healthy peers evaluated by prioritizePeers per heartbeat, denominator for prioritize_peers_seconds",
+        buckets: [0, 25, 50, 75, 100, 150, 200],
+      }),
+      /**
+       * Every peer the manager intends to disconnect. Covers both the top-of-heartbeat
+       * bad-score disconnects ("banned"/"score_too_low") and the prioritization reasons;
+       * the older peersRequestedToDisconnect gauge only recorded the latter. Counts intent,
+       * not completion (goodbye is fire-and-forget).
+       */
+      peersPruned: register.counter<{reason: string}>({
+        name: "lodestar_peer_manager_peers_pruned_total",
+        help: "Total peers the peer manager intends to disconnect, labeled by reason (incl. bad-score and prioritization reasons)",
+        labelNames: ["reason"],
+      }),
+      /**
+       * Actual peer count per active subnet, to check the min-peers-per-subnet invariant.
+       * Buckets straddle the target (TARGET_SUBNET_PEERS = 6).
+       */
+      peersPerActiveSubnet: register.histogram<{type: SubnetType}>({
+        name: "lodestar_peer_manager_peers_per_active_subnet",
+        help: "Histogram of connected peer count per active subnet, labeled by subnet type",
+        labelNames: ["type"],
+        buckets: [0, 2, 4, 6, 8, 12],
+      }),
+      /**
+       * Live outbound ratio, to check the OUTBOUND_PEERS_RATIO (10%) invariant (issue #2215).
+       * Denominator is connected healthy peers (banned/disconnected already removed).
+       */
+      outboundPeersRatio: register.gauge({
+        name: "lodestar_peer_manager_outbound_peers_ratio",
+        help: "Ratio of outbound peers to total connected healthy peers, verifies the outbound peers invariant",
+      }),
+      /**
+       * Score state crossings (Healthy/Disconnected/Banned). Sensitive to the decay formula,
+       * thresholds, and gossip-score weighting.
+       */
+      scoreStateTransitions: register.counter<{from: string; to: string}>({
+        name: "lodestar_peer_score_state_transitions_total",
+        help: "Total peer score state transitions, labeled by from and to state (Healthy/Disconnected/Banned)",
+        labelNames: ["from", "to"],
+      }),
+      /**
+       * Entry count of the score store (not bytes). Reflects the prune-to-MAX_ENTRIES /
+       * SCORE_THRESHOLD retention logic. Also the denominator for scoreUpdateDuration
+       * time-per-peer (that loop iterates the whole store, not just connected peers).
+       */
+      scoreMapSize: register.gauge({
+        name: "lodestar_peer_manager_score_map_size",
+        help: "Current number of entries in the peer score store",
+      }),
+      /**
+       * Entry count of the connectedPeers map (not bytes). Should track libp2p_peers; a
+       * persistent gap indicates the connection leak guarded by leakedConnectionsCount.
+       */
+      connectedPeersMapSize: register.gauge({
+        name: "lodestar_peer_manager_connected_peers_map_size",
+        help: "Current number of entries in the peer manager connectedPeers map",
+      }),
+      /**
+       * assertPeerRelevance outcome per Status exchange: "relevant", an irrelevant reason
+       * code, or "error". Fires on every status evaluation (inbound requests and our own
+       * requestStatus responses both route through onStatus).
+       */
+      relevanceCheck: register.counter<{result: string}>({
+        name: "lodestar_peer_relevance_check_total",
+        help: "Total peer relevance checks on Status, labeled by result (relevant or irrelevant reason code)",
+        labelNames: ["result"],
+      }),
     },
     leakedConnectionsCount: register.gauge({
       name: "lodestar_peer_manager_leaked_connections_count",

package/src/network/discv5/utils.ts

@@ -13,9 +13,17 @@ export enum ENRRelevance {
 }
 
 export function enrRelevance(enr: ENR, config: BeaconConfig, clock: IClock): ENRRelevance {
-  // We are not interested in peers that don't advertise at least one transport (tcp or quic)
-  const multiaddrTCP = enr.getLocationMultiaddr(ENRKey.tcp);
-  const multiaddrQUIC = enr.getLocationMultiaddr(ENRKey.quic);
+  // We are not interested in peers that don't advertise at least one transport (tcp or quic).
+  let multiaddrTCP: ReturnType<ENR["getLocationMultiaddr"]>;
+  let multiaddrQUIC: ReturnType<ENR["getLocationMultiaddr"]>;
+  // Malformed ENR endpoint fields can make multiaddr conversion throw.
+  // Treat endpoints that cannot be converted as unusable.
+  try {
+    multiaddrTCP = enr.getLocationMultiaddr(ENRKey.tcp);
+    multiaddrQUIC = enr.getLocationMultiaddr(ENRKey.quic);
+  } catch {
+    return ENRRelevance.no_transport;
+  }
   if (!multiaddrTCP && !multiaddrQUIC) {
     return ENRRelevance.no_transport;
   }

package/src/network/gossip/encoding.ts

@@ -9,7 +9,7 @@ import {ForkName} from "@lodestar/params";
 import {intToBytes} from "@lodestar/utils";
 import {MESSAGE_DOMAIN_VALID_SNAPPY} from "./constants.js";
 import {Eth2GossipsubMetrics} from "./metrics.js";
-import {GossipTopicCache, getGossipSSZType} from "./topic.js";
+import {GossipTopicCache, getGossipSSZMaxSize, getGossipSSZType} from "./topic.js";
 
 // Load WASM
 const xxhash = await xxhashFactory();
@@ -52,6 +52,13 @@ export function fastMsgIdFn(rpcMsg: RPC.Message): string {
 }
 
 export function msgIdToStrFn(msgId: Uint8Array): string {
+  // Spec mandates a 20-byte gossipsub message-id, but control-message IDs from peers
+  // can be any length. Reject non-20-byte IDs to avoid a Buffer.set() RangeError on
+  // longer IDs and stale shared-buffer bytes on shorter ones.
+  // Ref: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.10/specs/phase0/p2p-interface.md?plain=1#L486
+  if (msgId.length !== 20) {
+    throw Error(`Expect msgId to be 20 bytes, got ${msgId.length}`);
+  }
   // this is the same logic to `toHex(msgId)` with better performance
   sharedMsgIdBuf.set(msgId);
   return `0x${sharedMsgIdBuf.toString("hex")}`;
@@ -91,7 +98,7 @@ export function msgIdFn(gossipTopicCache: GossipTopicCache, msg: Message): Uint8
 export class DataTransformSnappy implements DataTransform {
   constructor(
     private readonly gossipTopicCache: GossipTopicCache,
-    private readonly maxSizePerMessage: number,
+    private readonly maxPayloadSize: number,
     private readonly metrics: Eth2GossipsubMetrics | null
   ) {}
 
@@ -104,17 +111,18 @@ export class DataTransformSnappy implements DataTransform {
   inboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
     // check uncompressed data length before we actually decompress
     const uncompressedDataLength = snappyWasm.decompress_len(data);
-    if (uncompressedDataLength > this.maxSizePerMessage) {
-      throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${this.maxSizePerMessage}`);
-    }
 
     const topic = this.gossipTopicCache.getTopic(topicStr);
     const sszType = getGossipSSZType(topic);
+    const maxSize = getGossipSSZMaxSize(topic, this.maxPayloadSize, sszType);
     this.metrics?.dataTransform.inbound.inc({type: topic.type});
 
     if (uncompressedDataLength < sszType.minSize) {
       throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} < ${sszType.minSize}`);
     }
+    if (uncompressedDataLength > maxSize) {
+      throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${maxSize}`);
+    }
     if (uncompressedDataLength > sszType.maxSize) {
       throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${sszType.maxSize}`);
     }
@@ -132,9 +140,14 @@ export class DataTransformSnappy implements DataTransform {
    */
   outboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
     const topic = this.gossipTopicCache.getTopic(topicStr);
+    const sszType = getGossipSSZType(topic);
+    const maxSize = getGossipSSZMaxSize(topic, this.maxPayloadSize, sszType);
     this.metrics?.dataTransform.outbound.inc({type: topic.type});
-    if (data.length > this.maxSizePerMessage) {
-      throw Error(`ssz_snappy encoded data length ${data.length} > ${this.maxSizePerMessage}`);
+    if (data.length > maxSize) {
+      throw Error(`ssz_snappy encoded data length ${data.length} > ${maxSize}`);
+    }
+    if (data.length > sszType.maxSize) {
+      throw Error(`ssz_snappy encoded data length ${data.length} > ${sszType.maxSize}`);
     }
 
     // Using Buffer.alloc() instead of Buffer.allocUnsafe() to mitigate high GC pressure observed in some environments

package/src/network/gossip/gossipsub.ts

@@ -15,7 +15,12 @@ import {type Multiaddr, multiaddr} from "@multiformats/multiaddr";
 import {ENR} from "@chainsafe/enr";
 import {routes} from "@lodestar/api";
 import {BeaconConfig, ForkBoundary} from "@lodestar/config";
-import {ATTESTATION_SUBNET_COUNT, SLOTS_PER_EPOCH, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
+import {
+  ATTESTATION_SUBNET_COUNT,
+  MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE,
+  SLOTS_PER_EPOCH,
+  SYNC_COMMITTEE_SUBNET_COUNT,
+} from "@lodestar/params";
 import {SubnetID} from "@lodestar/types";
 import {Logger, Map2d, Map2dArr} from "@lodestar/utils";
 import {RegistryMetricCreator} from "../../metrics/index.js";
@@ -35,7 +40,7 @@ import {
   computeGossipPeerScoreParams,
   gossipScoreThresholds,
 } from "./scoringParameters.js";
-import {GossipTopicCache, getCoreTopicsAtFork, stringifyGossipTopic} from "./topic.js";
+import {GossipTopicCache, getAllowedTopics, getCoreTopicsAtFork, stringifyGossipTopic} from "./topic.js";
 
 /** As specified in https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md */
 const GOSSIPSUB_HEARTBEAT_INTERVAL = 0.7 * 1000;
@@ -140,6 +145,7 @@ export class Eth2Gossipsub {
     const gossipsubInstance = gossipsub({
       globalSignaturePolicy: StrictNoSign,
       allowPublishToZeroTopicPeers: allowPublishToZeroPeers,
+      allowedTopics: getAllowedTopics(networkConfig),
       D: gossipsubD ?? GOSSIP_D,
       Dlo: gossipsubDLow ?? GOSSIP_D_LOW,
       Dhi: gossipsubDHigh ?? GOSSIP_D_HIGH,
@@ -178,7 +184,7 @@ export class Eth2Gossipsub {
       // Only send IDONTWANT messages if the message size is larger than this
       // This should be large enough to not send IDONTWANT for "small" messages
       // See https://github.com/ChainSafe/lodestar/pull/7077#issuecomment-2383679472
-      idontwantMinDataSize: 16829,
+      idontwantMinDataSize: MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE,
     })(modules.libp2p.services.components) as GossipSubInternal;
 
     if (metrics) {

package/src/network/gossip/topic.ts

@@ -1,12 +1,18 @@
+import {type CompositeTypeAny} from "@chainsafe/ssz";
 import {ForkDigestContext} from "@lodestar/config";
 import {
   ATTESTATION_SUBNET_COUNT,
   ForkName,
   ForkSeq,
+  MAX_ATTESTER_SLASHING_SIZE,
+  MAX_DATA_COLUMN_SIDECAR_SIZE,
+  MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE,
+  MAX_SIGNED_EXECUTION_PAYLOAD_BID_SIZE,
   SYNC_COMMITTEE_SUBNET_COUNT,
   isForkPostAltair,
   isForkPostElectra,
   isForkPostFulu,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {Attestation, SingleAttestation, ssz, sszTypesFor} from "@lodestar/types";
 import {GossipAction, GossipActionError, GossipErrorCode} from "../../chain/errors/gossipValidation.js";
@@ -130,6 +136,30 @@ export function getGossipSSZType(topic: GossipTopic) {
   }
 }
 
+/**
+ * Return the maximum uncompressed SSZ byte length accepted for a gossip object.
+ */
+export function getGossipSSZMaxSize(topic: GossipTopic, maxPayloadSize: number, sszType?: CompositeTypeAny): number {
+  const {fork} = topic.boundary;
+  // Gloas progressive containers have broad theoretical SSZ max sizes; use the preset p2p bounds instead.
+  switch (topic.type) {
+    case GossipType.beacon_block:
+      return maxPayloadSize;
+    case GossipType.beacon_aggregate_and_proof:
+      return isForkPostGloas(fork) ? MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE : (sszType ?? getGossipSSZType(topic)).maxSize;
+    case GossipType.attester_slashing:
+      return isForkPostGloas(fork) ? MAX_ATTESTER_SLASHING_SIZE : (sszType ?? getGossipSSZType(topic)).maxSize;
+    case GossipType.data_column_sidecar:
+      return isForkPostGloas(fork) ? MAX_DATA_COLUMN_SIDECAR_SIZE : (sszType ?? getGossipSSZType(topic)).maxSize;
+    case GossipType.execution_payload:
+      return maxPayloadSize;
+    case GossipType.execution_payload_bid:
+      return MAX_SIGNED_EXECUTION_PAYLOAD_BID_SIZE;
+    default:
+      return (sszType ?? getGossipSSZType(topic)).maxSize;
+  }
+}
+
 /**
  * Deserialize a gossip serialized data into an ssz object.
  */
@@ -246,7 +276,7 @@ export function parseGossipTopic(forkDigestContext: ForkDigestContext, topicStr:
 export function getCoreTopicsAtFork(
   networkConfig: NetworkConfig,
   fork: ForkName,
-  opts: {subscribeAllSubnets?: boolean; disableLightClientServer?: boolean}
+  opts: {subscribeAllSubnets?: boolean; subscribeAllColumnSubnets?: boolean; disableLightClientServer?: boolean}
 ): GossipTopicTypeMap[keyof GossipTopicTypeMap][] {
   // Common topics for all forks
   const topics: GossipTopicTypeMap[keyof GossipTopicTypeMap][] = [
@@ -266,7 +296,7 @@ export function getCoreTopicsAtFork(
 
   // After fulu also track data_column_sidecar_{index}
   if (ForkSeq[fork] >= ForkSeq.fulu) {
-    topics.push(...getDataColumnSidecarTopics(networkConfig));
+    topics.push(...getDataColumnSidecarTopics(networkConfig, opts.subscribeAllColumnSubnets));
   }
 
   // After Deneb and before Fulu also track blob_sidecar_{subnet_id}
@@ -309,15 +339,39 @@ export function getCoreTopicsAtFork(
   return topics;
 }
 
+/**
+ * Build the complete set of valid gossip topic strings across every fork boundary.
+ */
+export function getAllowedTopics(networkConfig: NetworkConfig): Set<string> {
+  const {config} = networkConfig;
+  const allowedTopics = new Set<string>();
+
+  for (const boundary of config.forkBoundariesAscendingEpochOrder) {
+    const topics = getCoreTopicsAtFork(networkConfig, boundary.fork, {
+      subscribeAllSubnets: true,
+      subscribeAllColumnSubnets: true,
+      disableLightClientServer: false,
+    });
+    for (const topic of topics) {
+      allowedTopics.add(stringifyGossipTopic(config, {...topic, boundary}));
+    }
+  }
+
+  return allowedTopics;
+}
+
 /**
  * Pick data column subnets to subscribe to post-fulu.
  */
 export function getDataColumnSidecarTopics(
-  networkConfig: NetworkConfig
+  networkConfig: NetworkConfig,
+  subscribeAllColumnSubnets = false
 ): GossipTopicTypeMap[keyof GossipTopicTypeMap][] {
   const topics: GossipTopicTypeMap[keyof GossipTopicTypeMap][] = [];
 
-  const subnets = networkConfig.custodyConfig.sampledSubnets;
+  const subnets = subscribeAllColumnSubnets
+    ? Array.from({length: networkConfig.config.DATA_COLUMN_SIDECAR_SUBNET_COUNT}, (_, i) => i)
+    : networkConfig.custodyConfig.sampledSubnets;
   for (const subnet of subnets) {
     topics.push({type: GossipType.data_column_sidecar, subnet});
   }

package/src/network/interface.ts

@@ -103,7 +103,9 @@ export interface INetwork extends INetworkCorePublic {
   publishBlobSidecar(blobSidecar: deneb.BlobSidecar): Promise<number>;
   publishBeaconAggregateAndProof(aggregateAndProof: SignedAggregateAndProof): Promise<number>;
   publishBeaconAttestation(attestation: SingleAttestation, subnet: SubnetID): Promise<number>;
-  publishDataColumnSidecar(dataColumnSideCar: DataColumnSidecar): Promise<number>;
+  publishDataColumnSidecar(
+    dataColumnSideCar: DataColumnSidecar
+  ): Promise<{sentPeers: number; alreadyPublished: boolean}>;
   publishVoluntaryExit(voluntaryExit: phase0.SignedVoluntaryExit): Promise<number>;
   publishBlsToExecutionChange(blsToExecutionChange: capella.SignedBLSToExecutionChange): Promise<number>;
   publishProposerSlashing(proposerSlashing: phase0.ProposerSlashing): Promise<number>;

package/src/network/network.ts

@@ -65,7 +65,7 @@ import {
 } from "./reqresp/utils/collect.js";
 import {collectSequentialBlocksInRange} from "./reqresp/utils/collectSequentialBlocksInRange.js";
 import {CommitteeSubscription} from "./subnets/index.js";
-import {isPublishToZeroPeersError, prettyPrintPeerIdStr} from "./util.js";
+import {isPublishDuplicateError, isPublishToZeroPeersError, prettyPrintPeerIdStr} from "./util.js";
 
 type NetworkModules = {
   opts: NetworkOptions;
@@ -366,7 +366,9 @@ export class Network implements INetwork {
     });
   }
 
-  async publishDataColumnSidecar(dataColumnSidecar: DataColumnSidecar): Promise<number> {
+  async publishDataColumnSidecar(
+    dataColumnSidecar: DataColumnSidecar
+  ): Promise<{sentPeers: number; alreadyPublished: boolean}> {
     const slot = isGloasDataColumnSidecar(dataColumnSidecar)
       ? dataColumnSidecar.slot
       : dataColumnSidecar.signedBlockHeader.message.slot;
@@ -374,18 +376,25 @@ export class Network implements INetwork {
     const boundary = this.config.getForkBoundaryAtEpoch(epoch);
 
     const subnet = computeSubnetForDataColumnSidecar(this.config, dataColumnSidecar);
-    return this.publishGossip<GossipType.data_column_sidecar>(
-      {type: GossipType.data_column_sidecar, boundary, subnet},
-      dataColumnSidecar,
-      {
-        ignoreDuplicatePublishError: true,
-        // we ensure having all topic peers via prioritizePeers() function
-        // in the worse case, if there is 0 peer on the topic, the overall publish operation could be still a success
-        // because supernode will rebuild and publish missing data column sidecars for us
-        // hence we want to track sent peers as 0 instead of an error
-        allowPublishToZeroTopicPeers: true,
+    try {
+      const sentPeers = await this.publishGossip<GossipType.data_column_sidecar>(
+        {type: GossipType.data_column_sidecar, boundary, subnet},
+        dataColumnSidecar,
+        {
+          // we ensure having all topic peers via prioritizePeers() function
+          // in the worse case, if there is 0 peer on the topic, the overall publish operation could be still a success
+          // because supernode will rebuild and publish missing data column sidecars for us
+          // hence we want to track sent peers as 0 instead of an error
+          allowPublishToZeroTopicPeers: true,
+        }
+      );
+      return {sentPeers, alreadyPublished: false};
+    } catch (e) {
+      if (isPublishDuplicateError(e as Error)) {
+        return {sentPeers: 0, alreadyPublished: true};
       }
-    );
+      throw e;
+    }
   }
 
   async publishBeaconAggregateAndProof(aggregateAndProof: SignedAggregateAndProof): Promise<number> {
@@ -860,8 +869,8 @@ export class Network implements INetwork {
     this.core.setTargetGroupCount(count);
   };
 
-  private onPublishDataColumns = (sidecars: DataColumnSidecar[]): Promise<number[]> => {
-    return promiseAllMaybeAsync(sidecars.map((sidecar) => () => this.publishDataColumnSidecar(sidecar)));
+  private onPublishDataColumns = async (sidecars: DataColumnSidecar[]): Promise<void> => {
+    await promiseAllMaybeAsync(sidecars.map((sidecar) => () => this.publishDataColumnSidecar(sidecar)));
   };
 
   private onPublishBlobSidecars = (sidecars: deneb.BlobSidecar[]): Promise<number[]> => {

package/src/network/peers/peerManager.ts

@@ -415,8 +415,10 @@ export class PeerManager {
       );
       if (irrelevantReasonType === null) {
         isIrrelevant = false;
+        this.metrics?.peerManager.relevanceCheck.inc({result: "relevant"});
       } else {
         isIrrelevant = true;
+        this.metrics?.peerManager.relevanceCheck.inc({result: irrelevantReasonType.code});
         this.logger.debug("Irrelevant peer", {
           peer: prettyPrintPeerId(peer),
           reason: renderIrrelevantPeerType(irrelevantReasonType),
@@ -424,6 +426,7 @@ export class PeerManager {
       }
     } catch (e) {
       this.logger.error("Irrelevant peer - unexpected error", {peer: prettyPrintPeerId(peer)}, e as Error);
+      this.metrics?.peerManager.relevanceCheck.inc({result: "error"});
       isIrrelevant = true;
     }
 
@@ -552,15 +555,18 @@ export class PeerManager {
     for (const peer of connectedPeers) {
       switch (this.peerRpcScores.getScoreState(peer)) {
         case ScoreState.Banned:
+          this.metrics?.peerManager.peersPruned.inc({reason: "banned"});
           void this.goodbyeAndDisconnect(peer, GoodByeReasonCode.BANNED);
           break;
         case ScoreState.Disconnected:
+          this.metrics?.peerManager.peersPruned.inc({reason: "score_too_low"});
           void this.goodbyeAndDisconnect(peer, GoodByeReasonCode.SCORE_TOO_LOW);
           break;
         case ScoreState.Healthy:
           connectedHealthyPeers.push(peer);
       }
     }
+    this.metrics?.peerManager.peersEvaluated.observe(connectedHealthyPeers.length);
 
     const status = this.statusCache.get();
     const starved =
@@ -572,6 +578,7 @@ export class PeerManager {
     this.metrics?.peerManager.starved.set(starved ? 1 : 0);
     const forkSeq = this.config.getForkSeq(this.clock.currentSlot);
 
+    const prioritizeTimer = this.metrics?.peerManager.prioritizePeersDuration.startTimer();
     const {peersToDisconnect, peersToConnect, attnetQueries, syncnetQueries, custodyGroupQueries} = prioritizePeers(
       connectedHealthyPeers.map((peer) => {
         const peerData = this.connectedPeers.get(peer.toString());
@@ -601,6 +608,7 @@ export class PeerManager {
       this.config,
       this.metrics
     );
+    prioritizeTimer?.();
 
     const queriesMerged: SubnetDiscvQueryMs[] = [];
     for (const {type, queries} of [
@@ -632,6 +640,7 @@ export class PeerManager {
     // disconnect first to have more slots before we dial new peers
     for (const [reason, peers] of peersToDisconnect) {
       this.metrics?.peersRequestedToDisconnect.inc({reason}, peers.length);
+      this.metrics?.peerManager.peersPruned.inc({reason}, peers.length);
       for (const peer of peers) {
         void this.goodbyeAndDisconnect(peer, GoodByeReasonCode.TOO_MANY_PEERS);
       }
@@ -659,6 +668,8 @@ export class PeerManager {
       }
     }
 
+    this.metrics?.peerManager.connectedPeersMapSize.set(this.connectedPeers.size);
+
     timer?.();
 
     this.logger.debug("peerManager heartbeat result", {

package/src/network/peers/score/score.ts

@@ -1,4 +1,5 @@
 import {GoodByeReasonCode} from "../../../constants/network.js";
+import {NetworkCoreMetrics} from "../../core/metrics.js";
 import {
   COOL_DOWN_BEFORE_DECAY_MS,
   DEFAULT_SCORE,
@@ -23,13 +24,15 @@ export class RealScore implements IPeerScore {
   /** The final score, computed from the above */
   private score: number;
   private lastUpdate: number;
+  private readonly metrics: NetworkCoreMetrics | null;
 
-  constructor() {
+  constructor(metrics: NetworkCoreMetrics | null = null) {
     this.lodestarScore = DEFAULT_SCORE;
     this.gossipScore = DEFAULT_SCORE;
     this.score = DEFAULT_SCORE;
     this.ignoreNegativeGossipScore = false;
     this.lastUpdate = Date.now();
+    this.metrics = metrics;
   }
 
   isCoolingDown(): boolean {
@@ -136,6 +139,10 @@ export class RealScore implements IPeerScore {
     this.recomputeScore();
     const newState = scoreToState(this.score);
 
+    if (prevState !== newState) {
+      this.metrics?.peerManager.scoreStateTransitions.inc({from: prevState, to: newState});
+    }
+
     if (prevState !== ScoreState.Banned && newState === ScoreState.Banned) {
       // ban this peer for at least BANNED_BEFORE_DECAY_MS seconds
       this.lastUpdate = Date.now() + COOL_DOWN_BEFORE_DECAY_MS;

package/src/network/peers/score/store.ts

@@ -32,7 +32,9 @@ export class PeerRpcScoreStore implements IPeerRpcScoreStore {
   constructor(opts: PeerRpcScoreOpts = {}, metrics: NetworkCoreMetrics | null = null, logger: Logger | null = null) {
     this.metrics = metrics;
     this.logger = logger;
-    this.scores = opts.disablePeerScoring ? new MapDef(() => new MaxScore()) : new MapDef(() => new RealScore());
+    this.scores = opts.disablePeerScoring
+      ? new MapDef(() => new MaxScore())
+      : new MapDef(() => new RealScore(this.metrics));
   }
 
   getScore(peer: PeerId): number {
@@ -75,6 +77,8 @@ export class PeerRpcScoreStore implements IPeerRpcScoreStore {
   }
 
   update(): void {
+    const timer = this.metrics?.peerManager.scoreUpdateDuration.startTimer();
+
     // Bound size of data structures
     pruneSetToMax(this.scores, MAX_ENTRIES);
 
@@ -86,6 +90,9 @@ export class PeerRpcScoreStore implements IPeerRpcScoreStore {
         this.scores.delete(peerIdStr);
       }
     }
+
+    this.metrics?.peerManager.scoreMapSize.set(this.scores.size);
+    timer?.();
   }
 
   updateGossipsubScore(peerId: PeerIdStr, newScore: number, ignore: boolean): void {

package/src/network/peers/utils/prioritizePeers.ts

@@ -7,6 +7,7 @@ import {MapDef} from "@lodestar/utils";
 import {shuffle} from "../../../util/shuffle.js";
 import {sortBy} from "../../../util/sortBy.js";
 import {NetworkCoreMetrics} from "../../core/metrics.js";
+import {SubnetType} from "../../metadata.js";
 import {RequestedSubnet} from "./subnetMap.js";
 
 /** Target number of peers we'd like to have connected to a given long-lived subnet */
@@ -189,6 +190,18 @@ export function prioritizePeers(
 
   const connectedPeerCount = connectedPeers.length;
 
+  // Track the outbound peers invariant (we keep at least OUTBOUND_PEERS_RATIO outbound peers).
+  // Report 0 when there are no peers so the gauge doesn't go stale at its last value.
+  if (metrics) {
+    let outboundPeerCount = 0;
+    for (const peer of connectedPeers) {
+      if (peer.direction === "outbound") {
+        outboundPeerCount++;
+      }
+    }
+    metrics.peerManager.outboundPeersRatio.set(connectedPeerCount > 0 ? outboundPeerCount / connectedPeerCount : 0);
+  }
+
   if (connectedPeerCount < targetPeers) {
     // Need more peers.
     // Instead of attempting to connect the exact amount necessary this will overshoot a little since the success
@@ -256,6 +269,7 @@ function requestSubnetPeers(
 
     for (const {subnet, toSlot} of activeAttnets) {
       const peersInSubnet = peersPerSubnet.get(subnet) ?? 0;
+      metrics?.peerManager.peersPerActiveSubnet.observe({type: SubnetType.attnets}, peersInSubnet);
       if (peersInSubnet < targetSubnetPeers) {
         // We need more peers
         attnetQueries.push({subnet, toSlot, maxPeersToDiscover: targetSubnetPeers - peersInSubnet});
@@ -282,6 +296,7 @@ function requestSubnetPeers(
 
     for (const {subnet, toSlot} of activeSyncnets) {
       const peersInSubnet = peersPerSubnet.get(subnet) ?? 0;
+      metrics?.peerManager.peersPerActiveSubnet.observe({type: SubnetType.syncnets}, peersInSubnet);
       if (peersInSubnet < targetSubnetPeers) {
         // We need more peers
         syncnetQueries.push({subnet, toSlot, maxPeersToDiscover: targetSubnetPeers - peersInSubnet});

package/src/network/processor/gossipHandlers.ts

@@ -176,7 +176,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
 
     // optimistically add gossip block to the seen cache
     // if validation fails, we will NOT forward this gossip block to peers
-    //   - if PARENT_UNKNOWN error, blockInput will then be queued inside BlockInputSync. If the gossip block is really invalid, it will be pruned there
+    //   - if PARENT_BLOCK_UNKNOWN error, blockInput will then be queued inside BlockInputSync. If the gossip block is really invalid, it will be pruned there
     //   - if other validator errors, blockInput will stay in the seen cache and will be pruned on finalization
     const blockInput = chain.seenBlockInputCache.getByBlock({
       block: signedBlock,
@@ -187,7 +187,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     });
 
     // Optimistically seed the payload-envelope cache too, mirroring seenBlockInputCache above.
-    // This ensures we have PayloadEnvelopeInput, even through "PARENT_UNKNOWN" error
+    // This ensures we have PayloadEnvelopeInput, even through "PARENT_BLOCK_UNKNOWN" error
     // see https://github.com/ChainSafe/lodestar/issues/9475
     if (isForkPostGloas(fork)) {
       chain.seenPayloadEnvelopeInputCache.add({
@@ -227,7 +227,8 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       if (e instanceof BlockGossipError) {
         logger.debug("Gossip block has error", {slot, root: blockShortHex, code: e.type.code});
         if (
-          (e.type.code === BlockErrorCode.PARENT_UNKNOWN || e.type.code === BlockErrorCode.PARENT_PAYLOAD_UNKNOWN) &&
+          (e.type.code === BlockErrorCode.PARENT_BLOCK_UNKNOWN ||
+            e.type.code === BlockErrorCode.PARENT_PAYLOAD_UNKNOWN) &&
           blockInput
         ) {
           chain.emitter.emit(ChainEvent.blockUnknownParent, {
@@ -661,14 +662,19 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
               break;
             }
             // ALREADY_KNOWN should not happen with ignoreIfKnown=true above
-            // PARENT_UNKNOWN should not happen, we handled this in validateBeaconBlock() function above
+            // PARENT_BLOCK_UNKNOWN should not happen, we handled this in validateBeaconBlock() function above
             case BlockErrorCode.ALREADY_KNOWN:
-            case BlockErrorCode.PARENT_UNKNOWN:
+            case BlockErrorCode.PARENT_BLOCK_UNKNOWN:
             case BlockErrorCode.PRESTATE_MISSING:
             case BlockErrorCode.EXECUTION_ENGINE_ERROR:
-              // Errors might indicate an issue with our node or the connected EL client
+              // Errors might indicate an issue with our node or the connected EL client.
               logLevel = LogLevel.error;
               break;
+            case BlockErrorCode.EXECUTION_ENGINE_INVALID:
+              // the peer served a bad block
+              core.reportPeer(peerIdStr, PeerAction.LowToleranceError, "ExecutionEngineInvalid");
+              logLevel = LogLevel.warn;
+              break;
             default:
               // TODO: Should it use PeerId or string?
               core.reportPeer(peerIdStr, PeerAction.LowToleranceError, "BadGossipBlock");
@@ -1241,6 +1247,11 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         payloadAttestationMessage.data.payloadPresent,
         payloadAttestationMessage.data.blobDataAvailable
       );
+
+      chain.emitter.emit(routes.events.EventType.payloadAttestationMessage, {
+        version: config.getForkName(payloadAttestationMessage.data.slot),
+        data: payloadAttestationMessage,
+      });
     },
     [GossipType.execution_payload_bid]: async ({
       gossipData,