@lodestar/beacon-node 1.35.0-dev.98d359db41 → 1.35.0-dev.b42a298a7c

package/src/network/gossip/scoringParameters.ts

@@ -1,333 +0,0 @@
-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.SECONDS_PER_SLOT * 1000;
-  const decayToZero = 0.01;
-  const epochDurationMs = config.SECONDS_PER_SLOT * SLOTS_PER_EPOCH * 1000;
-  const slotDurationMs = config.SECONDS_PER_SLOT * 1000;
-  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.SECONDS_PER_SLOT * decaySlots * 1000;
-    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

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

@@ -1,8 +0,0 @@
-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";