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

package/src/network/subnets/attnetsService.ts

@@ -0,0 +1,382 @@
+import {BeaconConfig, ForkBoundary} from "@lodestar/config";
+import {ATTESTATION_SUBNET_COUNT, EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {computeEpochAtSlot} from "@lodestar/state-transition";
+import {Epoch, Slot, SubnetID, ssz} from "@lodestar/types";
+import {Logger, MapDef} from "@lodestar/utils";
+import {ClockEvent, IClock} from "../../util/clock.js";
+import {NetworkCoreMetrics} from "../core/metrics.js";
+import {getActiveForkBoundaries} from "../forks.js";
+import {GossipType} from "../gossip/index.js";
+import {GOSSIP_D_LOW} from "../gossip/scoringParameters.js";
+import {stringifyGossipTopic} from "../gossip/topic.js";
+import {MetadataController} from "../metadata.js";
+import {RequestedSubnet, SubnetMap} from "../peers/utils/index.js";
+import {CommitteeSubscription, GossipSubscriber, IAttnetsService, NodeId, SubnetsServiceOpts} from "./interface.js";
+import {computeSubscribedSubnet} from "./util.js";
+
+const gossipType = GossipType.beacon_attestation;
+
+export enum SubnetSource {
+  committee = "committee",
+  longLived = "long_lived",
+}
+
+// map of subnet to time to form stable mesh as seconds, null if not yet formed
+type AggregatorDutyInfo = Map<SubnetID, number | null>;
+
+/**
+ * This value means node is not able to form stable mesh.
+ */
+const NOT_ABLE_TO_FORM_STABLE_MESH_SEC = -1;
+
+/**
+ * Manage deleterministic long lived (DLL) subnets and short lived subnets.
+ * - PeerManager uses attnetsService to know which peers are required for duties and long lived subscriptions
+ * - Network call addCommitteeSubscriptions() from API calls
+ * - Gossip handler checks shouldProcess to know if validator is aggregator
+ */
+export class AttnetsService implements IAttnetsService {
+  /** Committee subnets - PeerManager must find peers for those */
+  private committeeSubnets = new SubnetMap();
+  /**
+   * All currently subscribed short-lived subnets, for attestation aggregation
+   * This class will tell gossip to subscribe and un-subscribe
+   * If a value exists for `SubscriptionId` it means that gossip subscription is active in network.gossip
+   */
+  private shortLivedSubscriptions = new SubnetMap();
+  /** ${SUBNETS_PER_NODE} long lived subscriptions, may overlap with `shortLivedSubscriptions` */
+  private longLivedSubscriptions = new Set<number>();
+  /**
+   * Map of an aggregator at a slot and AggregatorDutyInfo
+   * Used to determine if we should process an attestation.
+   */
+  private aggregatorSlotSubnet = new MapDef<Slot, AggregatorDutyInfo>(() => new Map());
+
+  constructor(
+    private readonly config: BeaconConfig,
+    private readonly clock: IClock,
+    private readonly gossip: GossipSubscriber,
+    private readonly metadata: MetadataController,
+    private readonly logger: Logger,
+    private readonly metrics: NetworkCoreMetrics | null,
+    private readonly nodeId: NodeId | null,
+    private readonly opts: SubnetsServiceOpts
+  ) {
+    // if subscribeAllSubnets, we act like we have >= ATTESTATION_SUBNET_COUNT validators connecting to this node
+    // so that we have enough subnet topic peers, see https://github.com/ChainSafe/lodestar/issues/4921
+    if (this.opts.subscribeAllSubnets) {
+      for (let subnet = 0; subnet < ATTESTATION_SUBNET_COUNT; subnet++) {
+        this.committeeSubnets.request({subnet, toSlot: Infinity});
+      }
+    }
+
+    if (metrics) {
+      metrics.attnetsService.longLivedSubscriptions.addCollect(() => this.onScrapeLodestarMetrics(metrics));
+    }
+    this.recomputeLongLivedSubnets();
+    this.clock.on(ClockEvent.slot, this.onSlot);
+    this.clock.on(ClockEvent.epoch, this.onEpoch);
+  }
+
+  close(): void {
+    this.clock.off(ClockEvent.slot, this.onSlot);
+    this.clock.off(ClockEvent.epoch, this.onEpoch);
+  }
+
+  /**
+   * Get all active subnets for the hearbeat:
+   *   - committeeSubnets so that submitted attestations can be spread to the network
+   *  - longLivedSubscriptions because other peers based on this node's ENR for their submitted attestations
+   */
+  getActiveSubnets(): RequestedSubnet[] {
+    const shortLivedSubnets = this.committeeSubnets.getActiveTtl(this.clock.currentSlot);
+
+    const longLivedSubscriptionsToSlot =
+      (Math.floor(this.clock.currentEpoch / EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION) + 1) *
+      EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION *
+      SLOTS_PER_EPOCH;
+    const longLivedSubnets = Array.from(this.longLivedSubscriptions).map((subnet) => ({
+      subnet,
+      toSlot: longLivedSubscriptionsToSlot,
+    }));
+
+    // could be overlap, PeerDiscovery will handle it
+    return [...shortLivedSubnets, ...longLivedSubnets];
+  }
+
+  /**
+   * Called from the API when validator is a part of a committee.
+   */
+  addCommitteeSubscriptions(subscriptions: CommitteeSubscription[]): void {
+    for (const {subnet, slot, isAggregator} of subscriptions) {
+      // the peer-manager heartbeat will help find the subnet
+      this.committeeSubnets.request({subnet, toSlot: slot + 1});
+      if (isAggregator) {
+        // need exact slot here
+        this.aggregatorSlotSubnet.getOrDefault(slot).set(subnet, null);
+      }
+    }
+  }
+
+  /**
+   * Check if a subscription is still active before handling a gossip object
+   */
+  shouldProcess(subnet: SubnetID, slot: Slot): boolean {
+    if (!this.aggregatorSlotSubnet.has(slot)) {
+      return false;
+    }
+    return this.aggregatorSlotSubnet.getOrDefault(slot).has(subnet);
+  }
+
+  /**
+   * TODO-dll: clarify how many epochs before the fork we should subscribe to the new fork
+   * Call ONLY ONCE: Two epoch before the fork, re-subscribe all existing random subscriptions to the new fork
+   **/
+  subscribeSubnetsNextBoundary(boundary: ForkBoundary): void {
+    this.logger.info("Subscribing to long lived attnets for next fork boundary", {
+      ...boundary,
+      subnets: Array.from(this.longLivedSubscriptions).join(","),
+    });
+    for (const subnet of this.longLivedSubscriptions) {
+      this.gossip.subscribeTopic({type: gossipType, subnet, boundary});
+    }
+  }
+
+  /**
+   * TODO-dll: clarify how many epochs after the fork we should unsubscribe to the new fork
+   * Call  ONLY ONCE: Two epochs after the fork, un-subscribe all subnets from the old fork
+   **/
+  unsubscribeSubnetsPrevBoundary(boundary: ForkBoundary): void {
+    this.logger.info("Unsubscribing from long lived attnets of previous fork boundary", boundary);
+    for (let subnet = 0; subnet < ATTESTATION_SUBNET_COUNT; subnet++) {
+      if (!this.opts.subscribeAllSubnets) {
+        this.gossip.unsubscribeTopic({type: gossipType, subnet, boundary});
+      }
+    }
+  }
+
+  /**
+   * Run per slot.
+   * - Subscribe to gossip subnets 2 slots in advance
+   * - Unsubscribe from expired subnets
+   * - Track time to stable mesh if not yet formed
+   */
+  private onSlot = (clockSlot: Slot): void => {
+    try {
+      setTimeout(() => {
+        this.onHalfSlot(clockSlot);
+      }, this.config.SLOT_DURATION_MS * 0.5);
+
+      for (const [dutiedSlot, dutiedInfo] of this.aggregatorSlotSubnet.entries()) {
+        if (dutiedSlot === clockSlot + this.opts.slotsToSubscribeBeforeAggregatorDuty) {
+          // Trigger gossip subscription first, in batch
+          if (dutiedInfo.size > 0) {
+            this.subscribeToSubnets(Array.from(dutiedInfo.keys()), SubnetSource.committee);
+          }
+          // Then, register the subscriptions
+          for (const subnet of dutiedInfo.keys()) {
+            this.shortLivedSubscriptions.request({subnet, toSlot: dutiedSlot});
+          }
+        }
+        this.trackTimeToStableMesh(clockSlot, dutiedSlot, dutiedInfo);
+      }
+
+      this.unsubscribeExpiredCommitteeSubnets(clockSlot);
+      this.pruneExpiredAggregator(clockSlot);
+    } catch (e) {
+      this.logger.error("Error on AttnetsService.onSlot", {slot: clockSlot}, e as Error);
+    }
+  };
+
+  private onHalfSlot = (clockSlot: Slot): void => {
+    for (const [dutiedSlot, dutiedInfo] of this.aggregatorSlotSubnet.entries()) {
+      this.trackTimeToStableMesh(clockSlot, dutiedSlot, dutiedInfo);
+    }
+  };
+
+  /**
+   * Track time to form stable mesh if not yet formed
+   */
+  private trackTimeToStableMesh(clockSlot: Slot, dutiedSlot: Slot, dutiedInfo: AggregatorDutyInfo): void {
+    if (dutiedSlot < clockSlot) {
+      // aggregator duty is expired, set timeToStableMesh to some big value so we know this value is not good
+      for (const [subnet, timeToFormMesh] of dutiedInfo.entries()) {
+        if (timeToFormMesh === null) {
+          dutiedInfo.set(subnet, NOT_ABLE_TO_FORM_STABLE_MESH_SEC);
+          this.metrics?.attnetsService.subscriptionsCommitteeTimeToStableMesh.observe(
+            {subnet},
+            NOT_ABLE_TO_FORM_STABLE_MESH_SEC
+          );
+        }
+      }
+    } else if (dutiedSlot <= clockSlot + this.opts.slotsToSubscribeBeforeAggregatorDuty) {
+      // aggregator duty is not expired, track time to stable mesh if this is the 1st time we see mesh peers>=Dlo (6)
+      for (const [subnet, timeToFormMesh] of dutiedInfo.entries()) {
+        if (timeToFormMesh === null) {
+          const topicStr = stringifyGossipTopic(this.config, {
+            type: gossipType,
+            boundary: this.config.getForkBoundaryAtEpoch(computeEpochAtSlot(dutiedSlot)),
+            subnet,
+          });
+          const numMeshPeers = this.gossip.mesh.get(topicStr)?.size ?? 0;
+          if (numMeshPeers >= GOSSIP_D_LOW) {
+            const timeToStableMeshSec = this.clock.secFromSlot(
+              dutiedSlot - this.opts.slotsToSubscribeBeforeAggregatorDuty
+            );
+            // set to dutiedInfo so we'll not set to metrics again
+            dutiedInfo.set(subnet, timeToStableMeshSec);
+            this.metrics?.attnetsService.subscriptionsCommitteeTimeToStableMesh.observe({subnet}, timeToStableMeshSec);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Run per epoch, clean-up operations that are not urgent
+   * Subscribe to new random subnets every EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION epochs
+   */
+  private onEpoch = (epoch: Epoch): void => {
+    try {
+      if (epoch % EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION === 0) {
+        this.recomputeLongLivedSubnets();
+      }
+    } catch (e) {
+      this.logger.error("Error on AttnetsService.onEpoch", {epoch}, e as Error);
+    }
+  };
+
+  private recomputeLongLivedSubnets(): void {
+    if (this.nodeId === null) {
+      this.logger.verbose("Cannot recompute long-lived subscriptions, no nodeId");
+      return;
+    }
+
+    const oldSubnets = this.longLivedSubscriptions;
+    const newSubnets = computeSubscribedSubnet(this.nodeId, this.clock.currentEpoch);
+    this.logger.verbose("Recomputing long-lived subscriptions", {
+      epoch: this.clock.currentEpoch,
+      oldSubnets: Array.from(oldSubnets).join(","),
+      newSubnets: newSubnets.join(","),
+    });
+
+    const toRemoveSubnets = [];
+    for (const subnet of oldSubnets) {
+      if (!newSubnets.includes(subnet)) {
+        toRemoveSubnets.push(subnet);
+      }
+    }
+
+    // First, tell gossip to subscribe to the subnets if not connected already
+    this.subscribeToSubnets(newSubnets, SubnetSource.longLived);
+
+    // then update longLivedSubscriptions
+    for (const subnet of toRemoveSubnets) {
+      this.longLivedSubscriptions.delete(subnet);
+    }
+
+    for (const subnet of newSubnets) {
+      //  this.longLivedSubscriptions is a set so it'll handle duplicates
+      this.longLivedSubscriptions.add(subnet);
+    }
+
+    // Only tell gossip to unsubsribe last, longLivedSubscriptions has the latest state
+    this.unsubscribeSubnets(toRemoveSubnets, this.clock.currentSlot, SubnetSource.longLived);
+    this.updateMetadata();
+  }
+
+  /**
+   * Unsubscribe to a committee subnet from subscribedCommitteeSubnets.
+   * If a random subnet is present, we do not unsubscribe from it.
+   */
+  private unsubscribeExpiredCommitteeSubnets(slot: Slot): void {
+    const expired = this.shortLivedSubscriptions.getExpired(slot);
+    if (expired.length > 0) {
+      this.unsubscribeSubnets(expired, slot, SubnetSource.committee);
+    }
+  }
+
+  /**
+   * No need to track aggregator for past slots.
+   * @param currentSlot
+   */
+  private pruneExpiredAggregator(currentSlot: Slot): void {
+    for (const dutiedSlot of this.aggregatorSlotSubnet.keys()) {
+      if (currentSlot > dutiedSlot) {
+        this.aggregatorSlotSubnet.delete(dutiedSlot);
+      }
+    }
+  }
+
+  /** Update ENR */
+  private updateMetadata(): void {
+    const subnets = ssz.phase0.AttestationSubnets.defaultValue();
+    for (const subnet of this.longLivedSubscriptions) {
+      subnets.set(subnet, true);
+    }
+
+    // Only update metadata if necessary, setting `metadata.[key]` triggers a write to disk
+    if (!ssz.phase0.AttestationSubnets.equals(subnets, this.metadata.attnets)) {
+      this.metadata.attnets = subnets;
+    }
+  }
+
+  /**
+   * Trigger a gossip subcription only if not already subscribed
+   * shortLivedSubscriptions or longLivedSubscriptions should be updated right AFTER this called
+   **/
+  private subscribeToSubnets(subnets: number[], src: SubnetSource): void {
+    const boundaries = getActiveForkBoundaries(this.config, this.clock.currentEpoch);
+
+    for (const subnet of subnets) {
+      if (!this.shortLivedSubscriptions.has(subnet) && !this.longLivedSubscriptions.has(subnet)) {
+        for (const boundary of boundaries) {
+          this.gossip.subscribeTopic({type: gossipType, subnet, boundary});
+        }
+        this.metrics?.attnetsService.subscribeSubnets.inc({subnet, src});
+      }
+    }
+  }
+
+  /**
+   * Trigger a gossip un-subscription only if no-one is still subscribed
+   * If unsubscribe long lived subnets, longLivedSubscriptions should be updated right BEFORE this called
+   **/
+  private unsubscribeSubnets(subnets: number[], slot: Slot, src: SubnetSource): void {
+    // No need to unsubscribeTopic(). Return early to prevent repetitive extra work
+    if (this.opts.subscribeAllSubnets) return;
+
+    const boundaries = getActiveForkBoundaries(this.config, this.clock.currentEpoch);
+
+    for (const subnet of subnets) {
+      if (!this.shortLivedSubscriptions.isActiveAtSlot(subnet, slot) && !this.longLivedSubscriptions.has(subnet)) {
+        for (const boundary of boundaries) {
+          this.gossip.unsubscribeTopic({type: gossipType, subnet, boundary});
+        }
+        this.metrics?.attnetsService.unsubscribeSubnets.inc({subnet, src});
+      }
+    }
+  }
+
+  private onScrapeLodestarMetrics(metrics: NetworkCoreMetrics): void {
+    metrics.attnetsService.committeeSubnets.set(this.committeeSubnets.size);
+    metrics.attnetsService.subscriptionsCommittee.set(this.shortLivedSubscriptions.size);
+    // track short lived subnet status, >= 6 (Dlo) means healthy, otherwise unhealthy
+    const currentSlot = this.clock.currentSlot;
+    for (const {subnet} of this.shortLivedSubscriptions.getActiveTtl(currentSlot)) {
+      const topicStr = stringifyGossipTopic(this.config, {
+        type: gossipType,
+        boundary: this.config.getForkBoundaryAtEpoch(this.clock.currentEpoch),
+        subnet,
+      });
+      const numMeshPeers = this.gossip.mesh.get(topicStr)?.size ?? 0;
+      metrics.attnetsService.subscriptionsCommitteeMeshPeers.observe({subnet}, numMeshPeers);
+    }
+    metrics.attnetsService.longLivedSubscriptions.set(this.longLivedSubscriptions.size);
+    let aggregatorCount = 0;
+    for (const subnets of this.aggregatorSlotSubnet.values()) {
+      aggregatorCount += subnets.size;
+    }
+    metrics.attnetsService.aggregatorSlotSubnetCount.set(aggregatorCount);
+  }
+}

package/src/network/subnets/index.ts

@@ -0,0 +1,2 @@
+export * from "./interface.js";
+export * from "./syncnetsService.js";

package/src/network/subnets/interface.ts

@@ -0,0 +1,66 @@
+import type {PeerId, PrivateKey} from "@libp2p/interface";
+import {peerIdFromPrivateKey} from "@libp2p/peer-id";
+import {getV4Crypto} from "@chainsafe/enr";
+import {ForkBoundary} from "@lodestar/config";
+import {Bytes32, Slot, SubnetID, ValidatorIndex} from "@lodestar/types";
+import {fromHex} from "@lodestar/utils";
+import {GossipTopic} from "../gossip/interface.js";
+import {RequestedSubnet} from "../peers/utils/index.js";
+
+/** Generic CommitteeSubscription for both beacon attnets subs and syncnets subs */
+export type CommitteeSubscription = {
+  validatorIndex: ValidatorIndex;
+  subnet: SubnetID;
+  slot: Slot;
+  isAggregator: boolean;
+};
+
+export type SubnetsService = {
+  close(): void;
+  addCommitteeSubscriptions(subscriptions: CommitteeSubscription[]): void;
+  getActiveSubnets(): RequestedSubnet[];
+  subscribeSubnetsNextBoundary(boundary: ForkBoundary): void;
+  unsubscribeSubnetsPrevBoundary(boundary: ForkBoundary): void;
+};
+
+export interface IAttnetsService extends SubnetsService {
+  shouldProcess(subnet: SubnetID, slot: Slot): boolean;
+}
+
+export type RandBetweenFn = (min: number, max: number) => number;
+export type ShuffleFn = <T>(arr: T[]) => T[];
+
+export type SubnetsServiceOpts = {
+  subscribeAllSubnets?: boolean;
+  slotsToSubscribeBeforeAggregatorDuty: number;
+};
+
+export type SubnetsServiceTestOpts = {
+  // For deterministic randomness in unit test after ESM prevents simple import mocking
+  randBetweenFn?: RandBetweenFn;
+  shuffleFn?: ShuffleFn;
+};
+
+type TopicStr = string;
+type PeerIdStr = string;
+
+export type GossipSubscriber = {
+  subscribeTopic(topic: GossipTopic): void;
+  unsubscribeTopic(topic: GossipTopic): void;
+  mesh: Map<TopicStr, Set<PeerIdStr>>;
+};
+
+// uint256 in the spec
+export type NodeId = Bytes32;
+export function computeNodeIdFromPrivateKey(privateKey: PrivateKey): NodeId {
+  const peerId = peerIdFromPrivateKey(privateKey);
+  return computeNodeId(peerId);
+}
+
+export function computeNodeId(peerId: PeerId): Uint8Array {
+  if (peerId.publicKey === undefined) {
+    throw Error(`Undefined publicKey peerId=${peerId.toString()}`);
+  }
+  const nodeIdHex = getV4Crypto().nodeId(peerId.publicKey.raw);
+  return fromHex(nodeIdHex);
+}

package/src/network/subnets/syncnetsService.ts

@@ -0,0 +1,147 @@
+import {BeaconConfig, ForkBoundary} from "@lodestar/config";
+import {SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
+import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
+import {Epoch, ssz} from "@lodestar/types";
+import {Logger} from "@lodestar/utils";
+import {ClockEvent, IClock} from "../../util/clock.js";
+import {NetworkCoreMetrics} from "../core/metrics.js";
+import {getActiveForkBoundaries} from "../forks.js";
+import {GossipType} from "../gossip/index.js";
+import {MetadataController} from "../metadata.js";
+import {RequestedSubnet, SubnetMap} from "../peers/utils/index.js";
+import {CommitteeSubscription, GossipSubscriber, SubnetsService, SubnetsServiceOpts} from "./interface.js";
+
+/**
+ * Manage sync committee subnets. Sync committees are long (~27h) so there aren't random long-lived subscriptions
+ */
+export class SyncnetsService implements SubnetsService {
+  /**
+   * All currently subscribed subnets. Syncnets do not have additional long-lived
+   * random subscriptions since the committees are already active for long periods of time.
+   * Also, the node will aggregate through the entire period to simplify the validator logic.
+   * So `subscriptionsCommittee` represents subnets to find peers and aggregate data.
+   * This class will tell gossip to subscribe and un-subscribe.
+   * If a value exists for `SubscriptionId` it means that gossip subscription is active in network.gossip
+   */
+  private subscriptionsCommittee = new SubnetMap();
+
+  constructor(
+    private readonly config: BeaconConfig,
+    private readonly clock: IClock,
+    private readonly gossip: GossipSubscriber,
+    private readonly metadata: MetadataController,
+    private readonly logger: Logger,
+    private readonly metrics: NetworkCoreMetrics | null,
+    private readonly opts?: SubnetsServiceOpts
+  ) {
+    if (metrics) {
+      metrics.syncnetsService.subscriptionsCommittee.addCollect(() => this.onScrapeLodestarMetrics(metrics));
+    }
+
+    this.clock.on(ClockEvent.epoch, this.onEpoch);
+  }
+
+  close(): void {
+    this.clock.off(ClockEvent.epoch, this.onEpoch);
+  }
+
+  /**
+   * Get all active subnets for the hearbeat.
+   */
+  getActiveSubnets(): RequestedSubnet[] {
+    return this.subscriptionsCommittee.getActiveTtl(this.clock.currentSlot);
+  }
+
+  /**
+   * Called from the API when validator is a part of a committee.
+   */
+  addCommitteeSubscriptions(subscriptions: CommitteeSubscription[]): void {
+    // Trigger gossip subscription first, in batch
+    if (subscriptions.length > 0) {
+      this.subscribeToSubnets(subscriptions.map((sub) => sub.subnet));
+    }
+
+    // Then, register the subscriptions
+    for (const {subnet, slot} of subscriptions) {
+      this.subscriptionsCommittee.request({subnet, toSlot: slot});
+    }
+
+    // For syncnets regular subscriptions are persisted in the ENR
+    this.updateMetadata();
+  }
+
+  /** Call ONLY ONCE: Two epoch before the fork, re-subscribe all existing random subscriptions to the new fork  */
+  subscribeSubnetsNextBoundary(boundary: ForkBoundary): void {
+    this.logger.info("Subscribing to random attnets for next fork boundary", boundary);
+    for (const subnet of this.subscriptionsCommittee.getAll()) {
+      this.gossip.subscribeTopic({type: GossipType.sync_committee, boundary, subnet});
+    }
+  }
+
+  /** Call  ONLY ONCE: Two epochs after the fork, un-subscribe all subnets from the old fork */
+  unsubscribeSubnetsPrevBoundary(boundary: ForkBoundary): void {
+    this.logger.info("Unsubscribing from random attnets of previous fork boundary", boundary);
+    for (let subnet = 0; subnet < SYNC_COMMITTEE_SUBNET_COUNT; subnet++) {
+      if (!this.opts?.subscribeAllSubnets) {
+        this.gossip.unsubscribeTopic({type: GossipType.sync_committee, boundary, subnet});
+      }
+    }
+  }
+
+  /**
+   * Run per epoch, clean-up operations that are not urgent
+   */
+  private onEpoch = (epoch: Epoch): void => {
+    try {
+      const slot = computeStartSlotAtEpoch(epoch);
+      // Unsubscribe to a committee subnet from subscriptionsCommittee.
+      this.unsubscribeSubnets(this.subscriptionsCommittee.getExpired(slot));
+    } catch (e) {
+      this.logger.error("Error on SyncnetsService.onEpoch", {epoch}, e as Error);
+    }
+  };
+
+  /** Update ENR */
+  private updateMetadata(): void {
+    const subnets = ssz.altair.SyncSubnets.defaultValue();
+    for (const subnet of this.subscriptionsCommittee.getAll()) {
+      subnets.set(subnet, true);
+    }
+
+    // Only update metadata if necessary, setting `metadata.[key]` triggers a write to disk
+    if (!ssz.altair.SyncSubnets.equals(subnets, this.metadata.syncnets)) {
+      this.metadata.syncnets = subnets;
+    }
+  }
+
+  /** Tigger a gossip subcription only if not already subscribed */
+  private subscribeToSubnets(subnets: number[]): void {
+    const boundaries = getActiveForkBoundaries(this.config, this.clock.currentEpoch);
+    for (const subnet of subnets) {
+      if (!this.subscriptionsCommittee.has(subnet)) {
+        for (const boundary of boundaries) {
+          this.gossip.subscribeTopic({type: GossipType.sync_committee, boundary, subnet});
+        }
+        this.metrics?.syncnetsService.subscribeSubnets.inc({subnet});
+      }
+    }
+  }
+
+  /** Trigger a gossip un-subscrition only if no-one is still subscribed */
+  private unsubscribeSubnets(subnets: number[]): void {
+    const boundaries = getActiveForkBoundaries(this.config, this.clock.currentEpoch);
+    for (const subnet of subnets) {
+      // No need to check if active in subscriptionsCommittee since we only have a single SubnetMap
+      if (!this.opts?.subscribeAllSubnets) {
+        for (const boundary of boundaries) {
+          this.gossip.unsubscribeTopic({type: GossipType.sync_committee, boundary, subnet});
+        }
+        this.metrics?.syncnetsService.unsubscribeSubnets.inc({subnet});
+      }
+    }
+  }
+
+  private onScrapeLodestarMetrics(metrics: NetworkCoreMetrics): void {
+    metrics.syncnetsService.subscriptionsCommittee.set(this.subscriptionsCommittee.size);
+  }
+}

package/src/network/subnets/util.ts

@@ -0,0 +1,63 @@
+import {digest} from "@chainsafe/as-sha256";
+import {
+  ATTESTATION_SUBNET_COUNT,
+  ATTESTATION_SUBNET_PREFIX_BITS,
+  EPOCHS_PER_SUBNET_SUBSCRIPTION,
+  NODE_ID_BITS,
+  SUBNETS_PER_NODE,
+} from "@lodestar/params";
+import {computeShuffledIndex} from "@lodestar/state-transition";
+import {Epoch, ssz} from "@lodestar/types";
+import {NodeId} from "./interface.js";
+
+/**
+ * Spec https://github.com/ethereum/consensus-specs/blob/v1.4.0-alpha.3/specs/phase0/p2p-interface.md
+ */
+export function computeSubscribedSubnet(nodeId: NodeId, epoch: Epoch): number[] {
+  const subnets: number[] = [];
+  for (let index = 0; index < SUBNETS_PER_NODE; index++) {
+    subnets.push(computeSubscribedSubnetByIndex(nodeId, epoch, index));
+  }
+  return subnets;
+}
+
+/**
+ * Spec https://github.com/ethereum/consensus-specs/blob/v1.4.0-alpha.3/specs/phase0/p2p-interface.md
+ */
+export function computeSubscribedSubnetByIndex(nodeId: NodeId, epoch: Epoch, index: number): number {
+  const nodeIdPrefix = getNodeIdPrefix(nodeId);
+  const nodeOffset = getNodeOffset(nodeId);
+  const permutationSeed = digest(
+    ssz.UintNum64.serialize(Math.floor((epoch + nodeOffset) / EPOCHS_PER_SUBNET_SUBSCRIPTION))
+  );
+  const permutatedPrefix = computeShuffledIndex(nodeIdPrefix, 1 << ATTESTATION_SUBNET_PREFIX_BITS, permutationSeed);
+  return (permutatedPrefix + index) % ATTESTATION_SUBNET_COUNT;
+}
+
+/**
+ * Should return node_id >> (NODE_ID_BITS - int(ATTESTATION_SUBNET_PREFIX_BITS))
+ * Ideally we should use bigint here but since these constants are not likely to change we can use number
+ */
+export function getNodeIdPrefix(nodeId: NodeId): number {
+  const totalShiftedBits = NODE_ID_BITS - ATTESTATION_SUBNET_PREFIX_BITS;
+  const shiftedBytes = Math.floor(totalShiftedBits / 8);
+  const shiftedBits = totalShiftedBits % 8;
+  const prefixBytes = nodeId.slice(0, nodeId.length - shiftedBytes);
+  const dataView = new DataView(prefixBytes.buffer, prefixBytes.byteOffset, prefixBytes.byteLength);
+  // only 6 bits are used for prefix so getUint8() is safe
+  const prefix = dataView.getUint8(0) >> shiftedBits;
+  return prefix;
+}
+
+/**
+ * Should return node_offset = node_id % EPOCHS_PER_SUBNET_SUBSCRIPTION
+ * This function is safe to return number because EPOCHS_PER_SUBNET_SUBSCRIPTION is 256
+ */
+export function getNodeOffset(nodeId: NodeId): number {
+  // Big endian means that the least significant byte comes last
+  // The n % 256 is equivalent to the last byte of the node_id
+  const lastByte = nodeId.at(-1);
+  if (lastByte === undefined) throw new Error("Can not get node offset");
+
+  return lastByte;
+}

package/src/network/util.ts

@@ -0,0 +1,29 @@
+import type {Connection, PeerId} from "@libp2p/interface";
+import type {PeerIdStr} from "../util/peerId.js";
+import type {Libp2p} from "./interface.js";
+
+export function prettyPrintPeerId(peerId: PeerId): string {
+  return prettyPrintPeerIdStr(peerId.toString());
+}
+
+export function prettyPrintPeerIdStr(id: PeerIdStr): string {
+  return `${id.slice(0, 2)}...${id.slice(id.length - 6, id.length)}`;
+}
+
+/**
+ * Get the connections map from a connection manager
+ */
+// Compat function for efficiency reasons
+export function getConnectionsMap(libp2p: Libp2p): Map<string, {key: PeerId; value: Connection[]}> {
+  // biome-ignore lint/complexity/useLiteralKeys: access of private property
+  return libp2p.services.components.connectionManager.getConnectionsMap()["map"];
+}
+
+export function getConnection(libp2p: Libp2p, peerIdStr: string): Connection | undefined {
+  return getConnectionsMap(libp2p).get(peerIdStr)?.value[0] ?? undefined;
+}
+
+// https://github.com/ChainSafe/js-libp2p-gossipsub/blob/3475242ed254f7647798ab7f36b21909f6cb61da/src/index.ts#L2009
+export function isPublishToZeroPeersError(e: Error): boolean {
+  return e.message.includes("PublishError.InsufficientPeers");
+}