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

package/src/network/gossip/scoringParameters.ts

@@ -0,0 +1,333 @@
+import {
+  PeerScoreParams,
+  PeerScoreThresholds,
+  TopicScoreParams,
+  defaultTopicScoreParams,
+} from "@chainsafe/libp2p-gossipsub/score";
+import {BeaconConfig} from "@lodestar/config";
+import {ATTESTATION_SUBNET_COUNT, SLOTS_PER_EPOCH, TARGET_AGGREGATORS_PER_COMMITTEE} from "@lodestar/params";
+import {computeCommitteeCount} from "@lodestar/state-transition";
+import {getActiveForkBoundaries} from "../forks.js";
+import {Eth2Context} from "./gossipsub.js";
+import {GossipType} from "./interface.js";
+import {stringifyGossipTopic} from "./topic.js";
+
+export const GOSSIP_D = 8;
+export const GOSSIP_D_LOW = 6;
+export const GOSSIP_D_HIGH = 12;
+
+const MAX_IN_MESH_SCORE = 10.0;
+const MAX_FIRST_MESSAGE_DELIVERIES_SCORE = 40.0;
+const BEACON_BLOCK_WEIGHT = 0.5;
+const BEACON_AGGREGATE_PROOF_WEIGHT = 0.5;
+const VOLUNTARY_EXIT_WEIGHT = 0.05;
+const PROPOSER_SLASHING_WEIGHT = 0.05;
+const ATTESTER_SLASHING_WEIGHT = 0.05;
+const BLS_TO_EXECUTION_CHANGE_WEIGHT = 0.05;
+
+const beaconAttestationSubnetWeight = 1 / ATTESTATION_SUBNET_COUNT;
+const maxPositiveScore =
+  (MAX_IN_MESH_SCORE + MAX_FIRST_MESSAGE_DELIVERIES_SCORE) *
+  (BEACON_BLOCK_WEIGHT +
+    +BEACON_AGGREGATE_PROOF_WEIGHT +
+    beaconAttestationSubnetWeight * ATTESTATION_SUBNET_COUNT +
+    VOLUNTARY_EXIT_WEIGHT +
+    PROPOSER_SLASHING_WEIGHT +
+    ATTESTER_SLASHING_WEIGHT +
+    BLS_TO_EXECUTION_CHANGE_WEIGHT);
+
+/**
+ * The following params is implemented by Lighthouse at
+ * https://github.com/sigp/lighthouse/blob/b0ac3464ca5fb1e9d75060b56c83bfaf990a3d25/beacon_node/eth2_libp2p/src/behaviour/gossipsub_scoring_parameters.rs#L83
+ */
+export const gossipScoreThresholds: PeerScoreThresholds = {
+  gossipThreshold: -4000,
+  publishThreshold: -8000,
+  graylistThreshold: -16000,
+  acceptPXThreshold: 100,
+  opportunisticGraftThreshold: 5,
+};
+
+/**
+ * Peer may sometimes has negative gossipsub score and we give it time to recover, however gossipsub score comes below this we need to take into account.
+ * Given gossipsubThresold = -4000, it's comfortable to only ignore negative score gossip peer score > -1000
+ */
+export const negativeGossipScoreIgnoreThreshold = -1000;
+
+type MeshMessageInfo = {
+  decaySlots: number;
+  capFactor: number;
+  activationWindow: number;
+  currentSlot: number;
+};
+
+type PreComputedParams = {
+  scoreParameterDecayFn: (decayTimeMs: number) => number;
+  epochDurationMs: number;
+  slotDurationMs: number;
+};
+
+type TopicScoreInput = {
+  topicWeight: number;
+  expectedMessageRate: number;
+  firstMessageDecayTime: number;
+  meshMessageInfo?: MeshMessageInfo;
+};
+
+/**
+ * Explanation of each param https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.1.md#peer-scoring
+ */
+export function computeGossipPeerScoreParams({
+  config,
+  eth2Context,
+}: {
+  config: BeaconConfig;
+  eth2Context: Eth2Context;
+}): Partial<PeerScoreParams> {
+  const decayIntervalMs = config.SLOT_DURATION_MS;
+  const decayToZero = 0.01;
+  const epochDurationMs = config.SLOT_DURATION_MS * SLOTS_PER_EPOCH;
+  const slotDurationMs = config.SLOT_DURATION_MS;
+  const scoreParameterDecayFn = (decayTimeMs: number): number => {
+    return scoreParameterDecayWithBase(decayTimeMs, decayIntervalMs, decayToZero);
+  };
+  const behaviourPenaltyDecay = scoreParameterDecayFn(epochDurationMs * 10);
+  const behaviourPenaltyThreshold = 6;
+  const targetValue = decayConvergence(behaviourPenaltyDecay, 10 / SLOTS_PER_EPOCH) - behaviourPenaltyThreshold;
+  const topicScoreCap = maxPositiveScore * 0.5;
+
+  const params = {
+    topics: getAllTopicsScoreParams(config, eth2Context, {
+      epochDurationMs,
+      slotDurationMs,
+      scoreParameterDecayFn,
+    }),
+    decayInterval: decayIntervalMs,
+    decayToZero,
+    // time to remember counters for a disconnected peer, should be in ms
+    retainScore: epochDurationMs * 100,
+    appSpecificWeight: 1,
+    IPColocationFactorThreshold: 3,
+    // js-gossipsub doesn't have behaviourPenaltiesThreshold
+    behaviourPenaltyDecay,
+    behaviourPenaltyWeight: gossipScoreThresholds.gossipThreshold / (targetValue * targetValue),
+    behaviourPenaltyThreshold,
+    topicScoreCap,
+    IPColocationFactorWeight: -1 * topicScoreCap,
+  };
+  return params;
+}
+
+function getAllTopicsScoreParams(
+  config: BeaconConfig,
+  eth2Context: Eth2Context,
+  precomputedParams: PreComputedParams
+): Record<string, TopicScoreParams> {
+  const {epochDurationMs, slotDurationMs} = precomputedParams;
+  const epoch = eth2Context.currentEpoch;
+  const topicsParams: Record<string, TopicScoreParams> = {};
+  const boundaries = getActiveForkBoundaries(config, epoch);
+  const beaconAttestationSubnetWeight = 1 / ATTESTATION_SUBNET_COUNT;
+  for (const boundary of boundaries) {
+    //first all fixed topics
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.voluntary_exit,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: VOLUNTARY_EXIT_WEIGHT,
+      expectedMessageRate: 4 / SLOTS_PER_EPOCH,
+      firstMessageDecayTime: epochDurationMs * 100,
+    });
+
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.bls_to_execution_change,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: BLS_TO_EXECUTION_CHANGE_WEIGHT,
+      expectedMessageRate: 4 / SLOTS_PER_EPOCH,
+      firstMessageDecayTime: epochDurationMs * 100,
+    });
+
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.attester_slashing,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: ATTESTER_SLASHING_WEIGHT,
+      expectedMessageRate: 1 / 5 / SLOTS_PER_EPOCH,
+      firstMessageDecayTime: epochDurationMs * 100,
+    });
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.proposer_slashing,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: PROPOSER_SLASHING_WEIGHT,
+      expectedMessageRate: 1 / 5 / SLOTS_PER_EPOCH,
+      firstMessageDecayTime: epochDurationMs * 100,
+    });
+
+    // other topics
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.beacon_block,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: BEACON_BLOCK_WEIGHT,
+      expectedMessageRate: 1,
+      firstMessageDecayTime: epochDurationMs * 20,
+      meshMessageInfo: {
+        decaySlots: SLOTS_PER_EPOCH * 5,
+        capFactor: 3,
+        activationWindow: epochDurationMs,
+        currentSlot: eth2Context.currentSlot,
+      },
+    });
+
+    const activeValidatorCount = eth2Context.activeValidatorCount;
+    const {aggregatorsPerslot, committeesPerSlot} = expectedAggregatorCountPerSlot(activeValidatorCount);
+
+    // Checks to prevent unwanted errors in gossipsub
+    // Error: invalid score parameters for topic /eth2/4a26c58b/beacon_attestation_0/ssz_snappy: invalid FirstMessageDeliveriesCap; must be positive
+    //   at Object.validatePeerScoreParams (/usr/app/node_modules/libp2p-gossipsub/src/score/peer-score-params.js:62:27)
+    if (activeValidatorCount === 0) throw Error("activeValidatorCount === 0");
+    if (aggregatorsPerslot === 0) throw Error("aggregatorsPerslot === 0");
+
+    const multipleBurstsPerSubnetPerEpoch = committeesPerSlot >= (2 * ATTESTATION_SUBNET_COUNT) / SLOTS_PER_EPOCH;
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.beacon_aggregate_and_proof,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: BEACON_AGGREGATE_PROOF_WEIGHT,
+      expectedMessageRate: aggregatorsPerslot,
+      firstMessageDecayTime: epochDurationMs,
+      meshMessageInfo: {
+        decaySlots: SLOTS_PER_EPOCH * 2,
+        capFactor: 4,
+        activationWindow: epochDurationMs,
+        currentSlot: eth2Context.currentSlot,
+      },
+    });
+
+    const beaconAttestationParams = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: beaconAttestationSubnetWeight,
+      expectedMessageRate: activeValidatorCount / ATTESTATION_SUBNET_COUNT / SLOTS_PER_EPOCH,
+      firstMessageDecayTime: multipleBurstsPerSubnetPerEpoch ? epochDurationMs : epochDurationMs * 4,
+      meshMessageInfo: {
+        decaySlots: multipleBurstsPerSubnetPerEpoch ? SLOTS_PER_EPOCH * 4 : SLOTS_PER_EPOCH * 16,
+        capFactor: 16,
+        activationWindow: multipleBurstsPerSubnetPerEpoch
+          ? slotDurationMs * (SLOTS_PER_EPOCH / 2 + 1)
+          : epochDurationMs,
+        currentSlot: eth2Context.currentSlot,
+      },
+    });
+    for (let subnet = 0; subnet < ATTESTATION_SUBNET_COUNT; subnet++) {
+      const topicStr = stringifyGossipTopic(config, {
+        type: GossipType.beacon_attestation,
+        subnet,
+        boundary,
+      });
+      topicsParams[topicStr] = beaconAttestationParams;
+    }
+  }
+  return topicsParams;
+}
+
+function getTopicScoreParams(
+  config: BeaconConfig,
+  {epochDurationMs, slotDurationMs, scoreParameterDecayFn}: PreComputedParams,
+  {topicWeight, expectedMessageRate, firstMessageDecayTime, meshMessageInfo}: TopicScoreInput
+): TopicScoreParams {
+  const params = {...defaultTopicScoreParams};
+
+  params.topicWeight = topicWeight;
+
+  params.timeInMeshQuantum = slotDurationMs;
+  params.timeInMeshCap = 3600 / (params.timeInMeshQuantum / 1000);
+  params.timeInMeshWeight = 10 / params.timeInMeshCap;
+
+  params.firstMessageDeliveriesDecay = scoreParameterDecayFn(firstMessageDecayTime);
+  params.firstMessageDeliveriesCap = decayConvergence(
+    params.firstMessageDeliveriesDecay,
+    (2 * expectedMessageRate) / GOSSIP_D
+  );
+  params.firstMessageDeliveriesWeight = 40 / params.firstMessageDeliveriesCap;
+
+  if (meshMessageInfo) {
+    const {decaySlots, capFactor, activationWindow, currentSlot} = meshMessageInfo;
+    const decayTimeMs = config.SLOT_DURATION_MS * decaySlots;
+    params.meshMessageDeliveriesDecay = scoreParameterDecayFn(decayTimeMs);
+    params.meshMessageDeliveriesThreshold = threshold(params.meshMessageDeliveriesDecay, expectedMessageRate / 50);
+    params.meshMessageDeliveriesCap = Math.max(capFactor * params.meshMessageDeliveriesThreshold, 2);
+    params.meshMessageDeliveriesActivation = activationWindow;
+    // the default in gossipsub is 2s is not enough since lodestar suffers from I/O lag
+    params.meshMessageDeliveriesWindow = 12 * 1000; // 12s
+    params.meshFailurePenaltyDecay = params.meshMessageDeliveriesDecay;
+    params.meshMessageDeliveriesWeight =
+      (-1 * maxPositiveScore) / (params.topicWeight * Math.pow(params.meshMessageDeliveriesThreshold, 2));
+    params.meshFailurePenaltyWeight = params.meshMessageDeliveriesWeight;
+    if (decaySlots >= currentSlot) {
+      params.meshMessageDeliveriesThreshold = 0;
+      params.meshMessageDeliveriesWeight = 0;
+    }
+  } else {
+    params.meshMessageDeliveriesWeight = 0;
+    params.meshMessageDeliveriesThreshold = 0;
+    params.meshMessageDeliveriesDecay = 0;
+    params.meshMessageDeliveriesCap = 0;
+    params.meshMessageDeliveriesWindow = 0;
+    params.meshMessageDeliveriesActivation = 0;
+    params.meshFailurePenaltyDecay = 0;
+    params.meshFailurePenaltyWeight = 0;
+  }
+  params.invalidMessageDeliveriesWeight = (-1 * maxPositiveScore) / params.topicWeight;
+  params.invalidMessageDeliveriesDecay = scoreParameterDecayFn(epochDurationMs * 50);
+  return params;
+}
+
+function scoreParameterDecayWithBase(decayTimeMs: number, decayIntervalMs: number, decayToZero: number): number {
+  const ticks = decayTimeMs / decayIntervalMs;
+  return Math.pow(decayToZero, 1 / ticks);
+}
+
+function expectedAggregatorCountPerSlot(activeValidatorCount: number): {
+  aggregatorsPerslot: number;
+  committeesPerSlot: number;
+} {
+  const committeesPerSlot = computeCommitteeCount(activeValidatorCount);
+  const committeesPerEpoch = committeesPerSlot * SLOTS_PER_EPOCH;
+  const smallerCommitteeSize = Math.floor(activeValidatorCount / committeesPerEpoch);
+  const largerCommiteeeSize = smallerCommitteeSize + 1;
+  const largeCommitteesPerEpoch = activeValidatorCount - smallerCommitteeSize * committeesPerEpoch;
+  const smallCommiteesPerEpoch = committeesPerEpoch - largeCommitteesPerEpoch;
+  const moduloSmaller = Math.max(1, Math.floor(smallerCommitteeSize / TARGET_AGGREGATORS_PER_COMMITTEE));
+  const moduloLarger = Math.max(1, Math.floor((smallerCommitteeSize + 1) / TARGET_AGGREGATORS_PER_COMMITTEE));
+  const smallCommitteeAggregatorPerEpoch = Math.floor((smallerCommitteeSize / moduloSmaller) * smallCommiteesPerEpoch);
+  const largeCommitteeAggregatorPerEpoch = Math.floor((largerCommiteeeSize / moduloLarger) * largeCommitteesPerEpoch);
+
+  return {
+    aggregatorsPerslot: Math.max(
+      1,
+      Math.floor((smallCommitteeAggregatorPerEpoch + largeCommitteeAggregatorPerEpoch) / SLOTS_PER_EPOCH)
+    ),
+    committeesPerSlot,
+  };
+}
+
+function threshold(decay: number, rate: number): number {
+  return decayConvergence(decay, rate) * decay;
+}
+
+function decayConvergence(decay: number, rate: number): number {
+  return rate / (1 - decay);
+}

package/src/network/gossip/topic.ts

@@ -0,0 +1,332 @@
+import {ForkDigestContext} from "@lodestar/config";
+import {
+  ATTESTATION_SUBNET_COUNT,
+  ForkName,
+  ForkSeq,
+  SYNC_COMMITTEE_SUBNET_COUNT,
+  isForkPostAltair,
+  isForkPostElectra,
+} from "@lodestar/params";
+import {Attestation, SingleAttestation, ssz, sszTypesFor} from "@lodestar/types";
+import {GossipAction, GossipActionError, GossipErrorCode} from "../../chain/errors/gossipValidation.js";
+import {NetworkConfig} from "../networkConfig.js";
+import {DEFAULT_ENCODING} from "./constants.js";
+import {GossipEncoding, GossipTopic, GossipTopicTypeMap, GossipType, SSZTypeOfGossipTopic} from "./interface.js";
+
+export interface IGossipTopicCache {
+  getTopic(topicStr: string): GossipTopic;
+}
+
+export class GossipTopicCache implements IGossipTopicCache {
+  private topicsByTopicStr = new Map<string, Required<GossipTopic>>();
+
+  constructor(private readonly forkDigestContext: ForkDigestContext) {}
+
+  /** Returns cached GossipTopic, otherwise attempts to parse it from the str */
+  getTopic(topicStr: string): GossipTopic {
+    let topic = this.topicsByTopicStr.get(topicStr);
+    if (topic === undefined) {
+      topic = parseGossipTopic(this.forkDigestContext, topicStr);
+      // TODO: Consider just throwing here. We should only receive messages from known subscribed topics
+      this.topicsByTopicStr.set(topicStr, topic);
+    }
+    return topic;
+  }
+
+  /** Returns cached GossipTopic, otherwise returns undefined */
+  getKnownTopic(topicStr: string): GossipTopic | undefined {
+    return this.topicsByTopicStr.get(topicStr);
+  }
+
+  setTopic(topicStr: string, topic: GossipTopic): void {
+    if (!this.topicsByTopicStr.has(topicStr)) {
+      this.topicsByTopicStr.set(topicStr, {encoding: DEFAULT_ENCODING, ...topic});
+    }
+  }
+}
+
+/**
+ * Stringify a GossipTopic into a spec-ed formated topic string
+ */
+export function stringifyGossipTopic(forkDigestContext: ForkDigestContext, topic: GossipTopic): string {
+  const forkDigestHexNoPrefix = forkDigestContext.forkBoundary2ForkDigestHex(topic.boundary);
+  const topicType = stringifyGossipTopicType(topic);
+  const encoding = topic.encoding ?? DEFAULT_ENCODING;
+  return `/eth2/${forkDigestHexNoPrefix}/${topicType}/${encoding}`;
+}
+
+/**
+ * Stringify a GossipTopic into a spec-ed formated partial topic string
+ */
+function stringifyGossipTopicType(topic: GossipTopic): string {
+  switch (topic.type) {
+    case GossipType.beacon_block:
+    case GossipType.beacon_aggregate_and_proof:
+    case GossipType.voluntary_exit:
+    case GossipType.proposer_slashing:
+    case GossipType.attester_slashing:
+    case GossipType.sync_committee_contribution_and_proof:
+    case GossipType.light_client_finality_update:
+    case GossipType.light_client_optimistic_update:
+    case GossipType.bls_to_execution_change:
+      return topic.type;
+    case GossipType.beacon_attestation:
+    case GossipType.sync_committee:
+      return `${topic.type}_${topic.subnet}`;
+    case GossipType.blob_sidecar:
+      return `${topic.type}_${topic.subnet}`;
+    case GossipType.data_column_sidecar:
+      return `${topic.type}_${topic.subnet}`;
+  }
+}
+
+export function getGossipSSZType(topic: GossipTopic) {
+  const {fork} = topic.boundary;
+  switch (topic.type) {
+    case GossipType.beacon_block:
+      // beacon_block is updated in altair to support the updated SignedBeaconBlock type
+      return ssz[fork].SignedBeaconBlock;
+    case GossipType.blob_sidecar:
+      return ssz.deneb.BlobSidecar;
+    case GossipType.data_column_sidecar:
+      return ssz.fulu.DataColumnSidecar;
+    case GossipType.beacon_aggregate_and_proof:
+      return sszTypesFor(fork).SignedAggregateAndProof;
+    case GossipType.beacon_attestation:
+      return sszTypesFor(fork).SingleAttestation;
+    case GossipType.proposer_slashing:
+      return ssz.phase0.ProposerSlashing;
+    case GossipType.attester_slashing:
+      return sszTypesFor(fork).AttesterSlashing;
+    case GossipType.voluntary_exit:
+      return ssz.phase0.SignedVoluntaryExit;
+    case GossipType.sync_committee_contribution_and_proof:
+      return ssz.altair.SignedContributionAndProof;
+    case GossipType.sync_committee:
+      return ssz.altair.SyncCommitteeMessage;
+    case GossipType.light_client_optimistic_update:
+      return isForkPostAltair(fork)
+        ? sszTypesFor(fork).LightClientOptimisticUpdate
+        : ssz.altair.LightClientOptimisticUpdate;
+    case GossipType.light_client_finality_update:
+      return isForkPostAltair(fork)
+        ? sszTypesFor(fork).LightClientFinalityUpdate
+        : ssz.altair.LightClientFinalityUpdate;
+    case GossipType.bls_to_execution_change:
+      return ssz.capella.SignedBLSToExecutionChange;
+  }
+}
+
+/**
+ * Deserialize a gossip serialized data into an ssz object.
+ */
+export function sszDeserialize<T extends GossipTopic>(topic: T, serializedData: Uint8Array): SSZTypeOfGossipTopic<T> {
+  const sszType = getGossipSSZType(topic);
+  try {
+    return sszType.deserialize(serializedData) as SSZTypeOfGossipTopic<T>;
+  } catch (_e) {
+    throw new GossipActionError(GossipAction.REJECT, {code: GossipErrorCode.INVALID_SERIALIZED_BYTES_ERROR_CODE});
+  }
+}
+
+/**
+ * @deprecated
+ * Deserialize a gossip serialized data into an Attestation object.
+ * No longer used post-electra. Use `sszDeserializeSingleAttestation` instead
+ */
+export function sszDeserializeAttestation(fork: ForkName, serializedData: Uint8Array): Attestation {
+  try {
+    return sszTypesFor(fork).Attestation.deserialize(serializedData);
+  } catch (_e) {
+    throw new GossipActionError(GossipAction.REJECT, {code: GossipErrorCode.INVALID_SERIALIZED_BYTES_ERROR_CODE});
+  }
+}
+
+/**
+ * Deserialize a gossip seralized data into an SingleAttestation object.
+ */
+export function sszDeserializeSingleAttestation(fork: ForkName, serializedData: Uint8Array): SingleAttestation {
+  try {
+    if (isForkPostElectra(fork)) {
+      return sszTypesFor(fork).SingleAttestation.deserialize(serializedData);
+    }
+    return sszTypesFor(fork).Attestation.deserialize(serializedData) as SingleAttestation;
+  } catch (_e) {
+    throw new GossipActionError(GossipAction.REJECT, {code: GossipErrorCode.INVALID_SERIALIZED_BYTES_ERROR_CODE});
+  }
+}
+
+// Parsing
+
+const gossipTopicRegex = /^\/eth2\/(\w+)\/(\w+)\/(\w+)/;
+
+/**
+ * Parse a `GossipTopic` object from its stringified form.
+ * A gossip topic has the format
+ * ```ts
+ * /eth2/$FORK_DIGEST/$GOSSIP_TYPE/$ENCODING
+ * ```
+ */
+export function parseGossipTopic(forkDigestContext: ForkDigestContext, topicStr: string): Required<GossipTopic> {
+  try {
+    const matches = topicStr.match(gossipTopicRegex);
+    if (matches === null) {
+      throw Error(`Must match regex ${gossipTopicRegex}`);
+    }
+
+    const [, forkDigestHexNoPrefix, gossipTypeStr, encodingStr] = matches;
+
+    const boundary = forkDigestContext.forkDigest2ForkBoundary(forkDigestHexNoPrefix);
+    const encoding = parseEncodingStr(encodingStr);
+
+    // Inline-d the parseGossipTopicType() function since spreading the resulting object x4 the time to parse a topicStr
+    switch (gossipTypeStr) {
+      case GossipType.beacon_block:
+      case GossipType.beacon_aggregate_and_proof:
+      case GossipType.voluntary_exit:
+      case GossipType.proposer_slashing:
+      case GossipType.attester_slashing:
+      case GossipType.sync_committee_contribution_and_proof:
+      case GossipType.light_client_finality_update:
+      case GossipType.light_client_optimistic_update:
+      case GossipType.bls_to_execution_change:
+        return {type: gossipTypeStr, boundary, encoding};
+    }
+
+    for (const gossipType of [GossipType.beacon_attestation as const, GossipType.sync_committee as const]) {
+      if (gossipTypeStr.startsWith(gossipType)) {
+        const subnetStr = gossipTypeStr.slice(gossipType.length + 1); // +1 for '_' concatenating the topic name and the subnet
+        const subnet = parseInt(subnetStr, 10);
+        if (Number.isNaN(subnet)) throw Error(`Subnet ${subnetStr} is not a number`);
+        return {type: gossipType, subnet, boundary, encoding};
+      }
+    }
+
+    if (gossipTypeStr.startsWith(GossipType.blob_sidecar)) {
+      const subnetStr = gossipTypeStr.slice(GossipType.blob_sidecar.length + 1); // +1 for '_' concatenating the topic name and the subnet
+      const subnet = parseInt(subnetStr, 10);
+      if (Number.isNaN(subnet)) throw Error(`subnet ${subnetStr} is not a number`);
+      return {type: GossipType.blob_sidecar, subnet, boundary, encoding};
+    }
+
+    if (gossipTypeStr.startsWith(GossipType.data_column_sidecar)) {
+      const subnetStr = gossipTypeStr.slice(GossipType.data_column_sidecar.length + 1); // +1 for '_' concatenating the topic name and the subnet
+      const subnet = parseInt(subnetStr, 10);
+      if (Number.isNaN(subnet)) throw Error(`subnet ${subnetStr} is not a number`);
+      return {type: GossipType.data_column_sidecar, subnet, boundary, encoding};
+    }
+
+    throw Error(`Unknown gossip type ${gossipTypeStr}`);
+  } catch (e) {
+    (e as Error).message = `Invalid gossip topic ${topicStr}: ${(e as Error).message}`;
+    throw e;
+  }
+}
+
+/**
+ * De-duplicate logic to pick fork topics between subscribeCoreTopicsAtFork and unsubscribeCoreTopicsAtFork
+ */
+export function getCoreTopicsAtFork(
+  networkConfig: NetworkConfig,
+  fork: ForkName,
+  opts: {subscribeAllSubnets?: boolean; disableLightClientServer?: boolean}
+): GossipTopicTypeMap[keyof GossipTopicTypeMap][] {
+  // Common topics for all forks
+  const topics: GossipTopicTypeMap[keyof GossipTopicTypeMap][] = [
+    {type: GossipType.beacon_block},
+    {type: GossipType.beacon_aggregate_and_proof},
+    {type: GossipType.voluntary_exit},
+    {type: GossipType.proposer_slashing},
+    {type: GossipType.attester_slashing},
+  ];
+
+  // After fulu also track data_column_sidecar_{index}
+  if (ForkSeq[fork] >= ForkSeq.fulu) {
+    topics.push(...getDataColumnSidecarTopics(networkConfig));
+  }
+
+  // After Deneb also track blob_sidecar_{subnet_id}
+  if (ForkSeq[fork] >= ForkSeq.deneb) {
+    const {config} = networkConfig;
+    const subnetCount = isForkPostElectra(fork)
+      ? config.BLOB_SIDECAR_SUBNET_COUNT_ELECTRA
+      : config.BLOB_SIDECAR_SUBNET_COUNT;
+
+    for (let subnet = 0; subnet < subnetCount; subnet++) {
+      topics.push({type: GossipType.blob_sidecar, subnet});
+    }
+  }
+
+  // capella
+  if (ForkSeq[fork] >= ForkSeq.capella) {
+    topics.push({type: GossipType.bls_to_execution_change});
+  }
+
+  // Any fork after altair included
+  if (ForkSeq[fork] >= ForkSeq.altair) {
+    topics.push({type: GossipType.sync_committee_contribution_and_proof});
+    if (!opts.disableLightClientServer) {
+      topics.push({type: GossipType.light_client_optimistic_update});
+      topics.push({type: GossipType.light_client_finality_update});
+    }
+  }
+
+  if (opts.subscribeAllSubnets) {
+    for (let subnet = 0; subnet < ATTESTATION_SUBNET_COUNT; subnet++) {
+      topics.push({type: GossipType.beacon_attestation, subnet});
+    }
+    if (ForkSeq[fork] >= ForkSeq.altair) {
+      for (let subnet = 0; subnet < SYNC_COMMITTEE_SUBNET_COUNT; subnet++) {
+        topics.push({type: GossipType.sync_committee, subnet});
+      }
+    }
+  }
+
+  return topics;
+}
+
+/**
+ * Pick data column subnets to subscribe to post-fulu.
+ */
+export function getDataColumnSidecarTopics(
+  networkConfig: NetworkConfig
+): GossipTopicTypeMap[keyof GossipTopicTypeMap][] {
+  const topics: GossipTopicTypeMap[keyof GossipTopicTypeMap][] = [];
+
+  const subnets = networkConfig.custodyConfig.sampledSubnets;
+  for (const subnet of subnets) {
+    topics.push({type: GossipType.data_column_sidecar, subnet});
+  }
+
+  return topics;
+}
+
+/**
+ * Validate that a `encodingStr` is a known `GossipEncoding`
+ */
+function parseEncodingStr(encodingStr: string): GossipEncoding {
+  switch (encodingStr) {
+    case GossipEncoding.ssz_snappy:
+      return encodingStr;
+
+    default:
+      throw Error(`Unknown encoding ${encodingStr}`);
+  }
+}
+
+// TODO: Review which yes, and which not
+export const gossipTopicIgnoreDuplicatePublishError: Record<GossipType, boolean> = {
+  [GossipType.beacon_block]: true,
+  [GossipType.blob_sidecar]: true,
+  [GossipType.data_column_sidecar]: true,
+  [GossipType.beacon_aggregate_and_proof]: true,
+  [GossipType.beacon_attestation]: true,
+  [GossipType.voluntary_exit]: true,
+  [GossipType.proposer_slashing]: false, // Why not this ones?
+  [GossipType.attester_slashing]: false,
+  [GossipType.sync_committee_contribution_and_proof]: true,
+  [GossipType.sync_committee]: true,
+  [GossipType.light_client_finality_update]: false,
+  [GossipType.light_client_optimistic_update]: false,
+  [GossipType.bls_to_execution_change]: true,
+};

package/src/network/index.ts

@@ -0,0 +1,8 @@
+export * from "./events.js";
+export * from "./gossip/index.js";
+export * from "./interface.js";
+export * from "./libp2p/index.js";
+export * from "./network.js";
+export * from "./peers/index.js";
+export * from "./reqresp/ReqRespBeaconNode.js";
+export * from "./util.js";