@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/network/peers/peersData.ts

@@ -0,0 +1,65 @@
+import {PeerId} from "@libp2p/interface";
+import {Encoding} from "@lodestar/reqresp";
+import {CustodyIndex, Slot, Status, fulu} from "@lodestar/types";
+import {NodeId} from "../subnets/interface.js";
+import {ClientKind} from "./client.js";
+
+type PeerIdStr = string;
+type Metadata = fulu.Metadata & {custodyGroups: CustodyIndex[]; samplingGroups: CustodyIndex[]};
+export type PeerSyncMeta = {
+  peerId: PeerIdStr;
+  client: string;
+  custodyColumns: CustodyIndex[];
+  earliestAvailableSlot?: Slot;
+};
+
+export enum RelevantPeerStatus {
+  Unknown = "unknown",
+  relevant = "relevant",
+  irrelevant = "irrelevant",
+}
+
+export type PeerData = {
+  lastReceivedMsgUnixTsMs: number;
+  lastStatusUnixTsMs: number;
+  connectedUnixTsMs: number;
+  relevantStatus: RelevantPeerStatus;
+  direction: "inbound" | "outbound";
+  peerId: PeerId;
+  nodeId: NodeId | null;
+  metadata: Metadata | null;
+  status: Status | null;
+  agentVersion: string | null;
+  agentClient: ClientKind | null;
+  encodingPreference: Encoding | null;
+};
+
+/**
+ * Make data available to multiple components in the network stack.
+ * Due to class dependencies some modules have circular dependencies, like PeerManager - ReqResp.
+ * This third party class allows data to be available to both.
+ *
+ * The pruning and bounding of this class is handled by the PeerManager
+ */
+export class PeersData {
+  readonly connectedPeers = new Map<PeerIdStr, PeerData>();
+
+  getAgentVersion(peerIdStr: string): string {
+    return this.connectedPeers.get(peerIdStr)?.agentVersion ?? "NA";
+  }
+
+  getPeerKind(peerIdStr: string): ClientKind | null {
+    return this.connectedPeers.get(peerIdStr)?.agentClient ?? null;
+  }
+
+  getEncodingPreference(peerIdStr: string): Encoding | null {
+    return this.connectedPeers.get(peerIdStr)?.encodingPreference ?? null;
+  }
+
+  setEncodingPreference(peerIdStr: string, encoding: Encoding): void {
+    const peerData = this.connectedPeers.get(peerIdStr);
+    if (peerData) {
+      peerData.encodingPreference = encoding;
+    }
+  }
+}

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

@@ -0,0 +1,34 @@
+import {gossipScoreThresholds} from "../../gossip/scoringParameters.js";
+
+/** The default score for new peers */
+export const DEFAULT_SCORE = 0;
+/** The minimum reputation before a peer is disconnected */
+export const MIN_SCORE_BEFORE_DISCONNECT = -20;
+/** The minimum reputation before a peer is banned */
+export const MIN_SCORE_BEFORE_BAN = -50;
+// If a peer has a lodestar score below this constant all other score parts will get ignored and
+// the peer will get banned regardless of the other parts.
+export const MIN_LODESTAR_SCORE_BEFORE_BAN = -60.0;
+/** The maximum score a peer can obtain. Update metrics.peerScore if this changes */
+export const MAX_SCORE = 100;
+/** The minimum score a peer can obtain. Update metrics.peerScore if this changes */
+export const MIN_SCORE = -100;
+/** Drop score if absolute value is below this threshold */
+export const SCORE_THRESHOLD = 1;
+/** The halflife of a peer's score. I.e the number of milliseconds it takes for the score to decay to half its value */
+export const SCORE_HALFLIFE_MS = 10 * 60 * 1000;
+export const HALFLIFE_DECAY_MS = -Math.log(2) / SCORE_HALFLIFE_MS;
+/** The number of milliseconds we ban a peer for before their score begins to decay */
+export const COOL_DOWN_BEFORE_DECAY_MS = 30 * 60 * 1000;
+/** Limit of entries in the scores map */
+export const MAX_ENTRIES = 1000;
+/** Const that gets returned when no cool-down is applied */
+export const NO_COOL_DOWN_APPLIED = -1;
+
+/**
+ * We weight negative gossipsub scores in such a way that they never result in a disconnect by
+ * themselves. This "solves" the problem of non-decaying gossipsub scores for disconnected peers.
+ */
+export const GOSSIPSUB_NEGATIVE_SCORE_WEIGHT =
+  (MIN_SCORE_BEFORE_DISCONNECT + 1) / gossipScoreThresholds.graylistThreshold;
+export const GOSSIPSUB_POSITIVE_SCORE_WEIGHT = GOSSIPSUB_NEGATIVE_SCORE_WEIGHT;

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

@@ -0,0 +1,4 @@
+export * from "./interface.js";
+export * from "./score.js";
+export * from "./store.js";
+export * from "./utils.js";

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

@@ -0,0 +1,74 @@
+import {PeerId} from "@libp2p/interface";
+import {GoodByeReasonCode} from "../../../constants/network.js";
+import {PeerIdStr} from "../../../util/peerId.js";
+import {NetworkCoreMetrics} from "../../core/metrics.js";
+
+export type PeerRpcScoreOpts = {
+  disablePeerScoring?: boolean;
+};
+
+export interface IPeerRpcScoreStore {
+  getScore(peer: PeerId): number;
+  getGossipScore(peer: PeerId): number;
+  getScoreState(peer: PeerId): ScoreState;
+  isCoolingDown(peer: PeerIdStr): boolean;
+  dumpPeerScoreStats(): PeerScoreStats;
+  applyAction(peer: PeerId, action: PeerAction, actionName: string): void;
+  applyReconnectionCoolDown(peer: PeerIdStr, reason: GoodByeReasonCode): number;
+  update(): void;
+  updateGossipsubScore(peerId: PeerIdStr, newScore: number, ignore: boolean): void;
+}
+
+export interface IPeerScore {
+  getScore(): number;
+  getGossipScore(): number;
+  isCoolingDown(): boolean;
+  add(scoreDelta: number): number;
+  update(): number;
+  updateGossipsubScore(newScore: number, ignore: boolean): void;
+  getStat(): PeerScoreStat;
+  applyReconnectionCoolDown(reason: GoodByeReasonCode): number;
+}
+
+export enum ScoreState {
+  /** We are content with the peers performance. We permit connections and messages. */
+  Healthy = "Healthy",
+  /** The peer should be disconnected. We allow re-connections if the peer is persistent */
+  Disconnected = "Disconnected",
+  /** The peer is banned. We disallow new connections until it's score has decayed into a tolerable threshold */
+  Banned = "Banned",
+}
+
+export type PeerRpcScoreStoreModules = {
+  metrics: NetworkCoreMetrics | null;
+};
+
+export type PeerScoreStats = ({peerId: PeerIdStr} & PeerScoreStat)[];
+
+export type PeerScoreStat = {
+  lodestarScore: number;
+  gossipScore: number;
+  ignoreNegativeGossipScore: boolean;
+  score: number;
+  lastUpdate: number;
+};
+
+export enum PeerAction {
+  /** Immediately ban peer */
+  Fatal = "Fatal",
+  /**
+   * Not malicious action, but it must not be tolerated
+   * ~5 occurrences will get the peer banned
+   */
+  LowToleranceError = "LowToleranceError",
+  /**
+   * Negative action that can be tolerated only sometimes
+   * ~10 occurrences will get the peer banned
+   */
+  MidToleranceError = "MidToleranceError",
+  /**
+   * Some error that can be tolerated multiple times
+   * ~50 occurrences will get the peer banned
+   */
+  HighToleranceError = "HighToleranceError",
+}

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

@@ -0,0 +1,200 @@
+import {GoodByeReasonCode} from "../../../constants/network.js";
+import {
+  COOL_DOWN_BEFORE_DECAY_MS,
+  DEFAULT_SCORE,
+  GOSSIPSUB_NEGATIVE_SCORE_WEIGHT,
+  GOSSIPSUB_POSITIVE_SCORE_WEIGHT,
+  HALFLIFE_DECAY_MS,
+  MAX_SCORE,
+  MIN_LODESTAR_SCORE_BEFORE_BAN,
+  MIN_SCORE,
+  NO_COOL_DOWN_APPLIED,
+} from "./constants.js";
+import {IPeerScore, PeerScoreStat, ScoreState} from "./interface.js";
+import {scoreToState} from "./utils.js";
+
+/**
+ * Manage score of a peer.
+ */
+export class RealScore implements IPeerScore {
+  private lodestarScore: number;
+  private gossipScore: number;
+  private ignoreNegativeGossipScore: boolean;
+  /** The final score, computed from the above */
+  private score: number;
+  private lastUpdate: number;
+
+  constructor() {
+    this.lodestarScore = DEFAULT_SCORE;
+    this.gossipScore = DEFAULT_SCORE;
+    this.score = DEFAULT_SCORE;
+    this.ignoreNegativeGossipScore = false;
+    this.lastUpdate = Date.now();
+  }
+
+  isCoolingDown(): boolean {
+    return Date.now() < this.lastUpdate;
+  }
+
+  getScore(): number {
+    return this.score;
+  }
+
+  getGossipScore(): number {
+    return this.gossipScore;
+  }
+
+  add(scoreDelta: number): number {
+    let newScore = this.lodestarScore + scoreDelta;
+    if (newScore > MAX_SCORE) newScore = MAX_SCORE;
+    if (newScore < MIN_SCORE) newScore = MIN_SCORE;
+
+    this.setLodestarScore(newScore);
+    return newScore;
+  }
+
+  applyReconnectionCoolDown(reason: GoodByeReasonCode): number {
+    let coolDownMin = NO_COOL_DOWN_APPLIED;
+    switch (reason) {
+      // let scoring system handle score decay by itself
+      case GoodByeReasonCode.BANNED:
+      case GoodByeReasonCode.SCORE_TOO_LOW:
+        return coolDownMin;
+      case GoodByeReasonCode.INBOUND_DISCONNECT:
+      case GoodByeReasonCode.TOO_MANY_PEERS:
+        coolDownMin = 5;
+        break;
+      case GoodByeReasonCode.ERROR:
+      case GoodByeReasonCode.CLIENT_SHUTDOWN:
+        coolDownMin = 60;
+        break;
+      case GoodByeReasonCode.IRRELEVANT_NETWORK:
+        coolDownMin = 240;
+        break;
+    }
+    // set banning period to time in ms in the future from now
+    this.lastUpdate = Date.now() + coolDownMin * 60 * 1000;
+    return coolDownMin;
+  }
+
+  /**
+   * Applies time-based logic such as decay rates to the score.
+   * This function should be called periodically.
+   *
+   * Return the new score.
+   */
+  update(): number {
+    const nowMs = Date.now();
+
+    // Decay the current score
+    // Using exponential decay based on a constant half life.
+    const sinceLastUpdateMs = nowMs - this.lastUpdate;
+    // If peer was banned, lastUpdate will be in the future
+    if (sinceLastUpdateMs > 0) {
+      this.lastUpdate = nowMs;
+      // e^(-ln(2)/HL*t)
+      const decayFactor = Math.exp(HALFLIFE_DECAY_MS * sinceLastUpdateMs);
+      this.setLodestarScore(this.lodestarScore * decayFactor);
+    }
+
+    return this.lodestarScore;
+  }
+
+  updateGossipsubScore(newScore: number, ignore: boolean): void {
+    // we only update gossipsub if last_updated is in the past which means either the peer is
+    // not banned or the BANNED_BEFORE_DECAY time is over.
+    if (this.lastUpdate <= Date.now()) {
+      this.gossipScore = newScore;
+      this.ignoreNegativeGossipScore = ignore;
+    }
+  }
+
+  getStat(): PeerScoreStat {
+    return {
+      lodestarScore: this.lodestarScore,
+      gossipScore: this.gossipScore,
+      ignoreNegativeGossipScore: this.ignoreNegativeGossipScore,
+      score: this.score,
+      lastUpdate: this.lastUpdate,
+    };
+  }
+
+  /**
+   * Updating lodestarScore should always go through this method,
+   * so that we update this.score accordingly.
+   */
+  private setLodestarScore(newScore: number): void {
+    this.lodestarScore = newScore;
+    this.updateState();
+  }
+
+  /**
+   * Compute the final score, ban peer if needed
+   */
+  private updateState(): void {
+    const prevState = scoreToState(this.score);
+    this.recomputeScore();
+    const newState = scoreToState(this.score);
+
+    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;
+    }
+  }
+
+  /**
+   * Compute the final score
+   */
+  private recomputeScore(): void {
+    this.score = this.lodestarScore;
+    if (this.score <= MIN_LODESTAR_SCORE_BEFORE_BAN) {
+      // ignore all other scores, i.e. do nothing here
+      return;
+    }
+
+    if (this.gossipScore >= 0) {
+      this.score += this.gossipScore * GOSSIPSUB_POSITIVE_SCORE_WEIGHT;
+    } else if (!this.ignoreNegativeGossipScore) {
+      this.score += this.gossipScore * GOSSIPSUB_NEGATIVE_SCORE_WEIGHT;
+    }
+  }
+}
+
+/** An implementation of IPeerScore for testing */
+export class MaxScore implements IPeerScore {
+  getScore(): number {
+    return MAX_SCORE;
+  }
+
+  getGossipScore(): number {
+    return DEFAULT_SCORE;
+  }
+
+  isCoolingDown(): boolean {
+    return false;
+  }
+
+  add(): number {
+    return DEFAULT_SCORE;
+  }
+
+  update(): number {
+    return MAX_SCORE;
+  }
+
+  applyReconnectionCoolDown(_reason: GoodByeReasonCode): number {
+    return NO_COOL_DOWN_APPLIED;
+  }
+
+  updateGossipsubScore(): void {}
+
+  getStat(): PeerScoreStat {
+    return {
+      lodestarScore: MAX_SCORE,
+      gossipScore: DEFAULT_SCORE,
+      ignoreNegativeGossipScore: false,
+      score: MAX_SCORE,
+      lastUpdate: Date.now(),
+    };
+  }
+}

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

@@ -0,0 +1,95 @@
+import {PeerId} from "@libp2p/interface";
+import {Logger, MapDef, pruneSetToMax} from "@lodestar/utils";
+import {GoodByeReasonCode} from "../../../constants/network.js";
+import {PeerIdStr} from "../../../util/peerId.js";
+import {NetworkCoreMetrics} from "../../core/metrics.js";
+import {prettyPrintPeerId} from "../../util.js";
+import {DEFAULT_SCORE, MAX_ENTRIES, MAX_SCORE, MIN_SCORE, SCORE_THRESHOLD} from "./constants.js";
+import {IPeerRpcScoreStore, IPeerScore, PeerAction, PeerRpcScoreOpts, PeerScoreStats, ScoreState} from "./interface.js";
+import {MaxScore, RealScore} from "./score.js";
+import {scoreToState} from "./utils.js";
+
+const peerActionScore: Record<PeerAction, number> = {
+  [PeerAction.Fatal]: -(MAX_SCORE - MIN_SCORE),
+  [PeerAction.LowToleranceError]: -10,
+  [PeerAction.MidToleranceError]: -5,
+  [PeerAction.HighToleranceError]: -1,
+};
+
+/**
+ * A peer's score (perceived potential usefulness).
+ * This simplistic version consists of a global score per peer which decays to 0 over time.
+ * The decay rate applies equally to positive and negative scores.
+ * Peer cool-down period will be checked before dialing and will only be dialed if score is not waiting to decay
+ */
+export class PeerRpcScoreStore implements IPeerRpcScoreStore {
+  private readonly scores: MapDef<PeerIdStr, IPeerScore>;
+  private readonly metrics: NetworkCoreMetrics | null;
+  private readonly logger: Logger | null;
+
+  // TODO: Persist scores, at least BANNED status to disk
+
+  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());
+  }
+
+  getScore(peer: PeerId): number {
+    return this.scores.get(peer.toString())?.getScore() ?? DEFAULT_SCORE;
+  }
+
+  getGossipScore(peer: PeerId): number {
+    return this.scores.get(peer.toString())?.getGossipScore() ?? DEFAULT_SCORE;
+  }
+
+  getScoreState(peer: PeerId): ScoreState {
+    return scoreToState(this.getScore(peer));
+  }
+
+  isCoolingDown(peerIdStr: PeerIdStr): boolean {
+    return this.scores.get(peerIdStr)?.isCoolingDown() ?? false;
+  }
+
+  dumpPeerScoreStats(): PeerScoreStats {
+    return Array.from(this.scores.entries()).map(([peerId, peerScore]) => ({peerId, ...peerScore.getStat()}));
+  }
+
+  applyAction(peer: PeerId, action: PeerAction, actionName: string): void {
+    const peerScore = this.scores.getOrDefault(peer.toString());
+    const scoreChange = peerActionScore[action];
+    const newScore = peerScore.add(scoreChange);
+
+    this.logger?.debug("peer score adjusted", {scoreChange, newScore, peerId: prettyPrintPeerId(peer), actionName});
+    this.metrics?.peersReportPeerCount.inc({reason: actionName});
+  }
+
+  /**
+   * Apply a reconnection cool-down period to prevent automatic reconnection. Sets peer
+   * banning period and updates gossip score to -1 so next update removes the negative
+   * score
+   */
+  applyReconnectionCoolDown(peer: PeerIdStr, reason: GoodByeReasonCode): number {
+    const peerScore = this.scores.getOrDefault(peer);
+    return peerScore.applyReconnectionCoolDown(reason);
+  }
+
+  update(): void {
+    // Bound size of data structures
+    pruneSetToMax(this.scores, MAX_ENTRIES);
+
+    for (const [peerIdStr, peerScore] of this.scores) {
+      const newScore = peerScore.update();
+
+      // Prune scores below threshold
+      if (Math.abs(newScore) < SCORE_THRESHOLD) {
+        this.scores.delete(peerIdStr);
+      }
+    }
+  }
+
+  updateGossipsubScore(peerId: PeerIdStr, newScore: number, ignore: boolean): void {
+    const peerScore = this.scores.getOrDefault(peerId);
+    peerScore.updateGossipsubScore(newScore, ignore);
+  }
+}

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

@@ -0,0 +1,37 @@
+import {negativeGossipScoreIgnoreThreshold} from "../../gossip/scoringParameters.js";
+import {MIN_SCORE_BEFORE_BAN, MIN_SCORE_BEFORE_DISCONNECT} from "./constants.js";
+import {IPeerRpcScoreStore, ScoreState} from "./interface.js";
+
+export function scoreToState(score: number): ScoreState {
+  if (score <= MIN_SCORE_BEFORE_BAN) return ScoreState.Banned;
+  if (score <= MIN_SCORE_BEFORE_DISCONNECT) return ScoreState.Disconnected;
+  return ScoreState.Healthy;
+}
+
+/**
+ * Utility to update gossipsub score of connected peers
+ */
+export function updateGossipsubScores(
+  peerRpcScores: IPeerRpcScoreStore,
+  gossipsubScores: Map<string, number>,
+  toIgnoreNegativePeers: number
+): void {
+  // sort by gossipsub score desc
+  const sortedPeerIds = Array.from(gossipsubScores.keys()).sort(
+    (a, b) => (gossipsubScores.get(b) ?? 0) - (gossipsubScores.get(a) ?? 0)
+  );
+  for (const peerId of sortedPeerIds) {
+    const gossipsubScore = gossipsubScores.get(peerId);
+    if (gossipsubScore !== undefined) {
+      let ignore = false;
+      if (gossipsubScore < 0 && gossipsubScore > negativeGossipScoreIgnoreThreshold && toIgnoreNegativePeers > 0) {
+        // We ignore the negative score for the best negative peers so that their
+        // gossipsub score can recover without getting disconnected.
+        ignore = true;
+        toIgnoreNegativePeers -= 1;
+      }
+
+      peerRpcScores.updateGossipsubScore(peerId, gossipsubScore, ignore);
+    }
+  }
+}

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

@@ -0,0 +1,99 @@
+import {ForkName, isForkPostFulu} from "@lodestar/params";
+import {ForkDigest, Root, Slot, Status, fulu, ssz} from "@lodestar/types";
+import {toHex, toRootHex} from "@lodestar/utils";
+
+// TODO: Why this value? (From Lighthouse)
+const FUTURE_SLOT_TOLERANCE = 1;
+
+export enum IrrelevantPeerCode {
+  INCOMPATIBLE_FORKS = "IRRELEVANT_PEER_INCOMPATIBLE_FORKS",
+  DIFFERENT_CLOCKS = "IRRELEVANT_PEER_DIFFERENT_CLOCKS",
+  DIFFERENT_FINALIZED = "IRRELEVANT_PEER_DIFFERENT_FINALIZED",
+  NO_EARLIEST_AVAILABLE_SLOT = "NO_EARLIEST_AVAILABLE_SLOT",
+}
+
+type IrrelevantPeerType =
+  | {code: IrrelevantPeerCode.INCOMPATIBLE_FORKS; ours: ForkDigest; theirs: ForkDigest}
+  | {code: IrrelevantPeerCode.DIFFERENT_CLOCKS; slotDiff: number}
+  | {code: IrrelevantPeerCode.NO_EARLIEST_AVAILABLE_SLOT}
+  | {code: IrrelevantPeerCode.DIFFERENT_FINALIZED; expectedRoot: Root; remoteRoot: Root};
+
+/**
+ * Process a `Status` message to determine if a peer is relevant to us. If the peer is
+ * irrelevant the reason is returned.
+ */
+export function assertPeerRelevance(
+  forkName: ForkName,
+  remote: Status,
+  local: Status,
+  currentSlot: Slot
+): IrrelevantPeerType | null {
+  // The node is on a different network/fork
+  if (!ssz.ForkDigest.equals(local.forkDigest, remote.forkDigest)) {
+    return {
+      code: IrrelevantPeerCode.INCOMPATIBLE_FORKS,
+      ours: local.forkDigest,
+      theirs: remote.forkDigest,
+    };
+  }
+
+  // The remote's head is on a slot that is significantly ahead of what we consider the
+  // current slot. This could be because they are using a different genesis time, or that
+  // their or our system's clock is incorrect.
+  const slotDiff = remote.headSlot - Math.max(currentSlot, 0);
+  if (slotDiff > FUTURE_SLOT_TOLERANCE) {
+    return {code: IrrelevantPeerCode.DIFFERENT_CLOCKS, slotDiff};
+  }
+
+  // The remote's finalized epoch is less than or equal to ours, but the block root is
+  // different to the one in our chain. Therefore, the node is on a different chain and we
+  // should not communicate with them.
+
+  if (
+    remote.finalizedEpoch <= local.finalizedEpoch &&
+    !isZeroRoot(remote.finalizedRoot) &&
+    !isZeroRoot(local.finalizedRoot)
+  ) {
+    // NOTE: due to preferring to not access chain state here, we can't check the finalized root against our history.
+    // The impact of not doing check is low: peers that are behind us we can't confirm they are in the same chain as us.
+    // In the worst case they will attempt to sync from us, fail and disconnect. The ENR fork check should be sufficient
+    // to differentiate most peers in normal network conditions.
+    const remoteRoot = remote.finalizedRoot;
+    const expectedRoot = remote.finalizedEpoch === local.finalizedEpoch ? local.finalizedRoot : null;
+
+    if (expectedRoot !== null && !ssz.Root.equals(remoteRoot, expectedRoot)) {
+      return {
+        code: IrrelevantPeerCode.DIFFERENT_FINALIZED,
+        expectedRoot: expectedRoot, // forkChoice returns Tree BranchNode which the logger prints as {}
+        remoteRoot: remoteRoot,
+      };
+    }
+  }
+
+  if (isForkPostFulu(forkName) && (remote as fulu.Status).earliestAvailableSlot === undefined) {
+    return {
+      code: IrrelevantPeerCode.NO_EARLIEST_AVAILABLE_SLOT,
+    };
+  }
+
+  // Note: Accept request status finalized checkpoint in the future, we do not know if it is a true finalized root
+  return null;
+}
+
+export function isZeroRoot(root: Root): boolean {
+  const ZERO_ROOT = ssz.Root.defaultValue();
+  return ssz.Root.equals(root, ZERO_ROOT);
+}
+
+export function renderIrrelevantPeerType(type: IrrelevantPeerType): string {
+  switch (type.code) {
+    case IrrelevantPeerCode.INCOMPATIBLE_FORKS:
+      return `INCOMPATIBLE_FORKS ours: ${toHex(type.ours)} theirs: ${toHex(type.theirs)}`;
+    case IrrelevantPeerCode.DIFFERENT_CLOCKS:
+      return `DIFFERENT_CLOCKS slotDiff: ${type.slotDiff}`;
+    case IrrelevantPeerCode.DIFFERENT_FINALIZED:
+      return `DIFFERENT_FINALIZED root: ${toRootHex(type.remoteRoot)} expected: ${toRootHex(type.expectedRoot)}`;
+    case IrrelevantPeerCode.NO_EARLIEST_AVAILABLE_SLOT:
+      return "No earliestAvailableSlot announced via peer Status";
+  }
+}

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

@@ -0,0 +1,27 @@
+import {getUint8ByteToBitBooleanArray} from "@chainsafe/ssz";
+import {ATTESTATION_SUBNET_COUNT, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
+import {newFilledArray} from "@lodestar/state-transition";
+
+export const zeroAttnets = newFilledArray(ATTESTATION_SUBNET_COUNT, false);
+export const zeroSyncnets = newFilledArray(SYNC_COMMITTEE_SUBNET_COUNT, false);
+
+/**
+ * Fast deserialize a BitVector, with pre-cached bool array in `getUint8ByteToBitBooleanArray()`
+ *
+ * Never throw a deserialization error:
+ * - if bytes is too short, it will pad with zeroes
+ * - if bytes is too long, it will ignore the extra values
+ */
+export function deserializeEnrSubnets(bytes: Uint8Array, subnetCount: number): boolean[] {
+  if (subnetCount <= 8) {
+    return getUint8ByteToBitBooleanArray(bytes[0] ?? 0);
+  }
+
+  let boolsArr: boolean[] = [];
+  const byteCount = Math.ceil(subnetCount / 8);
+  for (let i = 0; i < byteCount; i++) {
+    boolsArr = boolsArr.concat(getUint8ByteToBitBooleanArray(bytes[i] ?? 0));
+  }
+
+  return boolsArr;
+}

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

@@ -0,0 +1,33 @@
+import {Connection, PeerId} from "@libp2p/interface";
+import {Libp2p} from "../../interface.js";
+import {getConnectionsMap} from "../../util.js";
+
+/**
+ * Return peers with at least one connection in status "open"
+ */
+export function getConnectedPeerIds(libp2p: Libp2p): PeerId[] {
+  const peerIds: PeerId[] = [];
+  for (const connections of getConnectionsMap(libp2p).values()) {
+    const openConnection = connections.value.find(isConnectionOpen);
+    if (openConnection) {
+      peerIds.push(openConnection.remotePeer);
+    }
+  }
+  return peerIds;
+}
+
+/**
+ * Efficiently check if there is at least one peer connected
+ */
+export function hasSomeConnectedPeer(libp2p: Libp2p): boolean {
+  for (const connections of getConnectionsMap(libp2p).values()) {
+    if (connections.value.some(isConnectionOpen)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function isConnectionOpen(connection: Connection): boolean {
+  return connection.status === "open";
+}

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

@@ -0,0 +1,4 @@
+export * from "./assertPeerRelevance.js";
+export * from "./getConnectedPeerIds.js";
+export * from "./prioritizePeers.js";
+export * from "./subnetMap.js";