@lodestar/beacon-node 1.35.0-dev.91dadf81de → 1.35.0-dev.955e9f89ed

package/src/network/peers/peersData.ts

@@ -1,65 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

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

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

@@ -1,74 +0,0 @@
-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

@@ -1,200 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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