@lodestar/beacon-node 1.45.0-dev.e10fb5e991 → 1.45.0-dev.ea1ba2d8ba

package/src/api/impl/validator/index.ts

@@ -65,6 +65,8 @@ import {
   AttestationError,
   AttestationErrorCode,
   GossipAction,
+  ProposerPreferencesError,
+  ProposerPreferencesErrorCode,
   SyncCommitteeError,
   SyncCommitteeErrorCode,
 } from "../../../chain/errors/index.js";
@@ -74,6 +76,7 @@ import {BlockType, ProduceFullDeneb, ProduceFullGloas} from "../../../chain/prod
 import {RegenCaller} from "../../../chain/regen/index.js";
 import {CheckpointHex} from "../../../chain/stateCache/types.js";
 import {validateApiAggregateAndProof} from "../../../chain/validation/index.js";
+import {validateGossipProposerPreferences} from "../../../chain/validation/proposerPreferences.js";
 import {validateSyncCommitteeGossipContributionAndProof} from "../../../chain/validation/syncCommitteeContributionAndProof.js";
 import {ZERO_HASH} from "../../../constants/index.js";
 import {BuilderStatus, NoBidReceived} from "../../../execution/builder/http.js";
@@ -1118,8 +1121,8 @@ export function getValidatorApi(
 
       const block = chain.forkChoice.getCanonicalBlockAtSlot(slot);
       if (!block) {
-        // No block is seen at slot. Return 404 so vc can skip casting payload attestation.
-        throw new ApiError(404, `No canonical block found at slot=${slot}`);
+        // No canonical block is seen at slot. Return 204 so vc can skip casting payload attestation.
+        return {data: undefined, meta: {version: fork}, status: 204};
       }
 
       const payloadInput = chain.seenPayloadEnvelopeInputCache.get(block.blockRoot);
@@ -1771,6 +1774,46 @@ export function getValidatorApi(
       });
     },
 
+    async submitProposerPreferences({signedProposerPreferences}) {
+      const failures: FailureList = [];
+
+      await Promise.all(
+        signedProposerPreferences.map(async (signed, i) => {
+          try {
+            await validateGossipProposerPreferences(chain, signed);
+
+            chain.proposerPreferencesPool.add(signed);
+            await network.publishProposerPreferences(signed);
+            chain.emitter.emit(routes.events.EventType.proposerPreferences, {
+              version: config.getForkName(signed.message.proposalSlot),
+              data: signed,
+            });
+          } catch (e) {
+            const logCtx = {
+              slot: signed.message.proposalSlot,
+              validatorIndex: signed.message.validatorIndex,
+              dependentRoot: toRootHex(signed.message.dependentRoot),
+            };
+
+            if (e instanceof ProposerPreferencesError && e.type.code === ProposerPreferencesErrorCode.ALREADY_KNOWN) {
+              logger.debug("Ignoring known signed proposer preferences", logCtx);
+              return;
+            }
+
+            failures.push({index: i, message: (e as Error).message});
+            logger.verbose(`Error on submitProposerPreferences [${i}]`, logCtx, e as Error);
+            if (e instanceof ProposerPreferencesError && e.action === GossipAction.REJECT) {
+              chain.persistInvalidSszValue(ssz.gloas.SignedProposerPreferences, signed, "api_reject");
+            }
+          }
+        })
+      );
+
+      if (failures.length > 0) {
+        throw new IndexedError("Error processing signed proposer preferences", failures);
+      }
+    },
+
     async getExecutionPayloadEnvelope({slot, beaconBlockRoot}) {
       const fork = config.getForkName(slot);
 

package/src/chain/blocks/importBlock.ts

@@ -124,18 +124,13 @@ export async function importBlock(
     executionStatus = parentBlock.executionStatus;
   }
 
-  // getBeaconProposerOrNull will return null if head state is more than one epoch away
-  // from block slot. We skip proposer boost canonical check as we cannot determine the canonical proposer
-  const expectedProposerIndex: number | null = this.getHeadState().getBeaconProposerOrNull(blockSlot);
-
   const blockSummary = this.forkChoice.onBlock(
     block.message,
     postState,
     blockDelaySec,
     currentSlot,
     executionStatus,
-    dataAvailabilityStatus,
-    expectedProposerIndex
+    dataAvailabilityStatus
   );
 
   // This adds the state necessary to process the next block

package/src/chain/produceBlock/produceBlockBody.ts

@@ -43,6 +43,7 @@ import {
   ValidatorIndex,
   Wei,
   altair,
+  bellatrix,
   capella,
   deneb,
   electra,
@@ -830,28 +831,19 @@ export function getPayloadAttributesForSSE(
     feeRecipient,
   });
 
-  let parentBlockNumber: number;
-  if (isForkPostGloas(fork)) {
-    const parentBlock = chain.forkChoice.getBlockHexAndBlockHash(
-      toRootHex(parentBlockRoot),
-      toRootHex(parentBlockHash)
-    );
-    if (parentBlock?.executionPayloadBlockHash == null) {
-      throw Error(`Parent block not found in fork choice root=${toRootHex(parentBlockRoot)}`);
-    }
-    parentBlockNumber = parentBlock.executionPayloadNumber;
-  } else {
-    parentBlockNumber = prepareState.payloadBlockNumber;
-  }
-
-  const ssePayloadAttributes: SSEPayloadAttributes = {
+  const ssePayloadAttributes = {
     proposerIndex: prepareState.getBeaconProposer(prepareSlot),
     proposalSlot: prepareSlot,
-    parentBlockNumber,
     parentBlockRoot,
     parentBlockHash,
     payloadAttributes,
-  };
+  } as SSEPayloadAttributes;
+
+  if (!isForkPostGloas(fork)) {
+    // Removed in Gloas, builders can get the block number from the EL via the block hash if required
+    (ssePayloadAttributes as bellatrix.SSEPayloadAttributes).parentBlockNumber = prepareState.payloadBlockNumber;
+  }
+
   return ssePayloadAttributes;
 }
 

package/src/chain/validation/executionPayloadBid.ts

@@ -37,9 +37,11 @@ async function validateExecutionPayloadBid(
   const parentBlockRootHex = toRootHex(bid.parentBlockRoot);
   const parentBlockHashHex = toRootHex(bid.parentBlockHash);
 
-  // [IGNORE] `bid.slot` is the current slot or the next slot.
-  const currentSlot = chain.clock.currentSlot;
-  if (bid.slot !== currentSlot && bid.slot !== currentSlot + 1) {
+  // [IGNORE] `bid.slot` is the current slot, or the next slot (`bid.slot - 1` is current), allowing for `MAXIMUM_GOSSIP_CLOCK_DISPARITY`.
+  if (
+    !chain.clock.isCurrentSlotGivenGossipDisparity(bid.slot) &&
+    !chain.clock.isCurrentSlotGivenGossipDisparity(bid.slot - 1)
+  ) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.INVALID_SLOT,
       builderIndex: bid.builderIndex,
@@ -122,17 +124,20 @@ async function validateExecutionPayloadBid(
     throw new Error(`Expected gloas+ state for execution payload bid validation, got fork=${state.forkName}`);
   }
 
-  // [REJECT] `bid.builder_index` is a valid/active builder index -- i.e.
-  // `is_active_builder(state, bid.builder_index)` returns `True`.
-  let builder: gloas.Builder;
-  try {
-    builder = state.getBuilder(bid.builderIndex);
-  } catch {
+  // [REJECT] `bid.builder_index` is within bounds -- i.e. `bid.builder_index < len(state.builders)`.
+  // `state.getBuilder` returns a lazy SSZ `getReadonly` view that is not bounds-checked eagerly; an
+  // out-of-range index only throws (`LeafNode has no right node`) on deferred field access (e.g. inside
+  // `isActiveBuilder`), escaping a try/catch around `getBuilder`. Check the length explicitly instead.
+  if (bid.builderIndex >= state.getBuildersLength()) {
     throw new ExecutionPayloadBidError(GossipAction.REJECT, {
       code: ExecutionPayloadBidErrorCode.BUILDER_NOT_ELIGIBLE,
       builderIndex: bid.builderIndex,
     });
   }
+
+  // [REJECT] `bid.builder_index` is a valid/active builder index -- i.e.
+  // `is_active_builder(state, bid.builder_index)` returns `True`.
+  const builder = state.getBuilder(bid.builderIndex);
   if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
     throw new ExecutionPayloadBidError(GossipAction.REJECT, {
       code: ExecutionPayloadBidErrorCode.BUILDER_NOT_ELIGIBLE,

package/src/chain/validation/proposerPreferences.ts

@@ -32,8 +32,9 @@ export async function validateGossipProposerPreferences(
     });
   }
 
-  // [IGNORE] `preferences.proposal_slot` has not already passed.
-  const currentSlot = chain.clock.currentSlot;
+  // [IGNORE] `preferences.proposal_slot` has not already passed, i.e. `proposal_slot > current_slot`,
+  // allowing for `MAXIMUM_GOSSIP_CLOCK_DISPARITY`.
+  const currentSlot = chain.clock.currentSlotWithGossipDisparity;
   if (proposalSlot <= currentSlot) {
     throw new ProposerPreferencesError(GossipAction.IGNORE, {
       code: ProposerPreferencesErrorCode.PROPOSAL_SLOT_PASSED,

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

@@ -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")}`;

package/src/network/gossip/gossipsub.ts

@@ -35,7 +35,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 +140,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,

package/src/network/gossip/topic.ts

@@ -246,7 +246,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 +266,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 +309,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/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

@@ -1241,6 +1241,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,
@@ -1274,7 +1279,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       await validateGossipProposerPreferences(chain, signedProposerPreferences);
 
       chain.emitter.emit(routes.events.EventType.proposerPreferences, {
-        version: ForkName.gloas,
+        version: config.getForkName(signedProposerPreferences.message.proposalSlot),
         data: signedProposerPreferences,
       });
     },