@lodestar/beacon-node 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/network/interface.ts

@@ -1,134 +0,0 @@
-import {Identify} from "@libp2p/identify";
-import {
-  ComponentLogger,
-  ConnectionGater,
-  ConnectionProtector,
-  ContentRouting,
-  Libp2pEvents,
-  Metrics,
-  NodeInfo,
-  PeerId,
-  PeerRouting,
-  PeerStore,
-  PrivateKey,
-  TypedEventTarget,
-  Upgrader,
-} from "@libp2p/interface";
-import type {AddressManager, ConnectionManager, Registrar, TransportManager} from "@libp2p/interface-internal";
-import type {Datastore} from "interface-datastore";
-import {Libp2p as ILibp2p} from "libp2p";
-import {
-  AttesterSlashing,
-  LightClientFinalityUpdate,
-  LightClientOptimisticUpdate,
-  SignedAggregateAndProof,
-  SignedBeaconBlock,
-  SingleAttestation,
-  Slot,
-  SlotRootHex,
-  SubnetID,
-  WithBytes,
-  altair,
-  capella,
-  deneb,
-  fulu,
-  phase0,
-} from "@lodestar/types";
-import {BlockInputSource} from "../chain/blocks/blockInput/types.js";
-import {CustodyConfig} from "../util/dataColumns.js";
-import {PeerIdStr} from "../util/peerId.js";
-import {BeaconBlocksByRootRequest, BlobSidecarsByRootRequest, DataColumnSidecarsByRootRequest} from "../util/types.js";
-import {INetworkCorePublic} from "./core/types.js";
-import {INetworkEventBus} from "./events.js";
-import {GossipType} from "./gossip/interface.js";
-import {PeerAction} from "./peers/index.js";
-import {PeerSyncMeta} from "./peers/peersData.js";
-import {PendingGossipsubMessage} from "./processor/types.js";
-
-/**
- * The architecture of the network looks like so:
- * - core:
- *   - INetworkCore - This interface encapsulates all functionality from BaseNetwork, its meant to act as an wrapper that makes multiple implementations more simple
- *   - NetworkCore - This _implementation_ contains all libp2p and dependent modules
- *   - WorkerNetworkCore - This _implementation_ wraps a NetworkCore in a Worker thread
- * - INetwork - This interface extends INetworkCore and crucially allows for a connection to the BeaconChain module.
- */
-
-export interface INetwork extends INetworkCorePublic {
-  readonly peerId: PeerId;
-  readonly custodyConfig: CustodyConfig;
-  readonly closed: boolean;
-  events: INetworkEventBus;
-
-  getConnectedPeers(): PeerIdStr[];
-  getConnectedPeerSyncMeta(peerId: PeerIdStr): PeerSyncMeta;
-  getConnectedPeerCount(): number;
-  isSubscribedToGossipCoreTopics(): boolean;
-  reportPeer(peer: PeerIdStr, action: PeerAction, actionName: string): void;
-  shouldAggregate(subnet: SubnetID, slot: Slot): boolean;
-  reStatusPeers(peers: PeerIdStr[]): Promise<void>;
-  searchUnknownSlotRoot(slotRoot: SlotRootHex, source: BlockInputSource, peer?: PeerIdStr): void;
-  // ReqResp
-  sendBeaconBlocksByRange(
-    peerId: PeerIdStr,
-    request: phase0.BeaconBlocksByRangeRequest
-  ): Promise<WithBytes<SignedBeaconBlock>[]>;
-  sendBeaconBlocksByRoot(
-    peerId: PeerIdStr,
-    request: BeaconBlocksByRootRequest
-  ): Promise<WithBytes<SignedBeaconBlock>[]>;
-  sendBlobSidecarsByRange(peerId: PeerIdStr, request: deneb.BlobSidecarsByRangeRequest): Promise<deneb.BlobSidecar[]>;
-  sendBlobSidecarsByRoot(peerId: PeerIdStr, request: BlobSidecarsByRootRequest): Promise<deneb.BlobSidecar[]>;
-  sendDataColumnSidecarsByRange(
-    peerId: PeerIdStr,
-    request: fulu.DataColumnSidecarsByRangeRequest
-  ): Promise<fulu.DataColumnSidecar[]>;
-  sendDataColumnSidecarsByRoot(
-    peerId: PeerIdStr,
-    request: DataColumnSidecarsByRootRequest
-  ): Promise<fulu.DataColumnSidecar[]>;
-
-  // Gossip
-  publishBeaconBlock(signedBlock: SignedBeaconBlock): Promise<number>;
-  publishBlobSidecar(blobSidecar: deneb.BlobSidecar): Promise<number>;
-  publishBeaconAggregateAndProof(aggregateAndProof: SignedAggregateAndProof): Promise<number>;
-  publishBeaconAttestation(attestation: SingleAttestation, subnet: SubnetID): Promise<number>;
-  publishDataColumnSidecar(dataColumnSideCar: fulu.DataColumnSidecar): Promise<number>;
-  publishVoluntaryExit(voluntaryExit: phase0.SignedVoluntaryExit): Promise<number>;
-  publishBlsToExecutionChange(blsToExecutionChange: capella.SignedBLSToExecutionChange): Promise<number>;
-  publishProposerSlashing(proposerSlashing: phase0.ProposerSlashing): Promise<number>;
-  publishAttesterSlashing(attesterSlashing: AttesterSlashing): Promise<number>;
-  publishSyncCommitteeSignature(signature: altair.SyncCommitteeMessage, subnet: SubnetID): Promise<number>;
-  publishContributionAndProof(contributionAndProof: altair.SignedContributionAndProof): Promise<number>;
-  publishLightClientFinalityUpdate(update: LightClientFinalityUpdate): Promise<number>;
-  publishLightClientOptimisticUpdate(update: LightClientOptimisticUpdate): Promise<number>;
-
-  // Debug
-  dumpGossipQueue(gossipType: GossipType): Promise<PendingGossipsubMessage[]>;
-  writeNetworkThreadProfile(durationMs: number, dirpath: string): Promise<string>;
-  writeDiscv5Profile(durationMs: number, dirpath: string): Promise<string>;
-  writeNetworkHeapSnapshot(prefix: string, dirpath: string): Promise<string>;
-  writeDiscv5HeapSnapshot(prefix: string, dirpath: string): Promise<string>;
-}
-
-export type LodestarComponents = {
-  peerId: PeerId;
-  privateKey: PrivateKey;
-  nodeInfo: NodeInfo;
-  logger: ComponentLogger;
-  events: TypedEventTarget<Libp2pEvents>;
-  addressManager: AddressManager;
-  peerStore: PeerStore;
-  upgrader: Upgrader;
-  registrar: Registrar;
-  connectionManager: ConnectionManager;
-  transportManager: TransportManager;
-  connectionGater: ConnectionGater;
-  contentRouting: ContentRouting;
-  peerRouting: PeerRouting;
-  datastore: Datastore;
-  connectionProtector?: ConnectionProtector;
-  metrics?: Metrics;
-};
-
-export type Libp2p = ILibp2p<{components: LodestarComponents; identify: Identify}>;

package/src/network/libp2p/error.ts

@@ -1,55 +0,0 @@
-export enum Libp2pError {
-  // https://github.com/libp2p/js-libp2p/blob/b936324a92038d9447983bb11db623c1b5a17a76/packages/libp2p/src/errors.ts#L6
-  MissingServiceError = "MissingServiceError",
-  UnmetServiceDependenciesError = "UnmetServiceDependenciesError",
-  NoContentRoutersError = "NoContentRoutersError",
-  NoPeerRoutersError = "NoPeerRoutersError",
-  QueriedForSelfError = "QueriedForSelfError",
-  UnhandledProtocolError = "UnhandledProtocolError",
-  DuplicateProtocolHandlerError = "DuplicateProtocolHandlerError",
-  DialDeniedError = "DialDeniedError",
-  UnsupportedListenAddressError = "UnsupportedListenAddressError",
-  UnsupportedListenAddressesError = "UnsupportedListenAddressesError",
-  NoValidAddressesError = "NoValidAddressesError",
-  ConnectionInterceptedError = "ConnectionInterceptedError",
-  ConnectionDeniedError = "ConnectionDeniedError",
-  MuxerUnavailableError = "MuxerUnavailableError",
-  EncryptionFailedError = "EncryptionFailedError",
-  TransportUnavailableError = "TransportUnavailableError",
-  // https://github.com/libp2p/js-libp2p/blob/b936324a92038d9447983bb11db623c1b5a17a76/packages/interface/src/errors.ts#L6
-  AbortError = "AbortError",
-  UnexpectedPeerError = "UnexpectedPeerError",
-  InvalidCryptoExchangeError = "InvalidCryptoExchangeError",
-  InvalidParametersError = "InvalidParametersError",
-  InvalidPublicKeyError = "InvalidPublicKeyError",
-  InvalidPrivateKeyError = "InvalidPrivateKeyError",
-  UnsupportedOperationError = "UnsupportedOperationError",
-  ConnectionClosingError = "ConnectionClosingError",
-  ConnectionClosedError = "ConnectionClosedError",
-  ConnectionFailedError = "ConnectionFailedError",
-  MuxerClosedError = "MuxerClosedError",
-  StreamResetError = "StreamResetError",
-  StreamStateError = "StreamStateError",
-  NotFoundError = "NotFoundError",
-  InvalidPeerIdError = "InvalidPeerIdError",
-  InvalidMultiaddrError = "InvalidMultiaddrError",
-  InvalidCidError = "InvalidCIDError",
-  InvalidMultihashError = "InvalidMultihashError",
-  UnsupportedProtocolError = "UnsupportedProtocolError",
-  InvalidMessageError = "InvalidMessageError",
-  ProtocolError = "ProtocolError",
-  TimeoutError = "TimeoutError",
-  NotStartedError = "NotStartedError",
-  AlreadyStartedError = "AlreadyStartedError",
-  DialError = "DialError",
-  ListenError = "ListenError",
-  LimitedConnectionError = "LimitedConnectionError",
-  TooManyInboundProtocolStreamsError = "TooManyInboundProtocolStreamsError",
-  TooManyOutboundProtocolStreamsError = "TooManyOutboundProtocolStreamsError",
-  UnsupportedKeyTypeError = "UnsupportedKeyTypeError",
-  OtherError = "OtherError",
-}
-
-export function getLibp2pError(error: Error): Libp2pError {
-  return Libp2pError[(error as unknown as {name: string}).name as keyof typeof Libp2pError] ?? Libp2pError.OtherError;
-}

package/src/network/libp2p/index.ts

@@ -1,153 +0,0 @@
-import {bootstrap} from "@libp2p/bootstrap";
-import {identify} from "@libp2p/identify";
-import {PrivateKey} from "@libp2p/interface";
-import {mdns} from "@libp2p/mdns";
-import {mplex} from "@libp2p/mplex";
-import {prometheusMetrics} from "@libp2p/prometheus-metrics";
-import {tcp} from "@libp2p/tcp";
-import {createLibp2p} from "libp2p";
-import {Registry} from "prom-client";
-import {ENR} from "@chainsafe/enr";
-import {noise} from "@chainsafe/libp2p-noise";
-import {asCrypto, defaultCrypto} from "@chainsafe/libp2p-noise/crypto";
-import {Libp2p, LodestarComponents} from "../interface.js";
-import {NetworkOptions, defaultNetworkOptions} from "../options.js";
-import {Eth2PeerDataStore} from "../peers/datastore.js";
-
-export type NodeJsLibp2pOpts = {
-  peerStoreDir?: string;
-  disablePeerDiscovery?: boolean;
-  metrics?: boolean;
-  metricsRegistry?: Registry;
-};
-
-export async function getDiscv5Multiaddrs(bootEnrs: string[]): Promise<string[]> {
-  const bootMultiaddrs = [];
-  for (const enrStr of bootEnrs) {
-    const enr = ENR.decodeTxt(enrStr);
-    const multiaddrWithPeerId = (await enr.getFullMultiaddr("tcp"))?.toString();
-    if (multiaddrWithPeerId) {
-      bootMultiaddrs.push(multiaddrWithPeerId);
-    }
-  }
-  return bootMultiaddrs;
-}
-
-export async function createNodeJsLibp2p(
-  privateKey: PrivateKey,
-  networkOpts: Partial<NetworkOptions> = {},
-  nodeJsLibp2pOpts: NodeJsLibp2pOpts = {}
-): Promise<Libp2p> {
-  const localMultiaddrs = networkOpts.localMultiaddrs || defaultNetworkOptions.localMultiaddrs;
-  const {peerStoreDir, disablePeerDiscovery} = nodeJsLibp2pOpts;
-
-  let datastore: undefined | Eth2PeerDataStore = undefined;
-  if (peerStoreDir) {
-    datastore = new Eth2PeerDataStore(peerStoreDir);
-    await datastore.open();
-  }
-
-  const peerDiscovery = [];
-  if (!disablePeerDiscovery) {
-    const bootMultiaddrs = [
-      ...(networkOpts.bootMultiaddrs ?? defaultNetworkOptions.bootMultiaddrs ?? []),
-      // Append discv5.bootEnrs to bootMultiaddrs if requested
-      ...(networkOpts.connectToDiscv5Bootnodes ? await getDiscv5Multiaddrs(networkOpts.discv5?.bootEnrs ?? []) : []),
-    ];
-
-    if ((bootMultiaddrs.length ?? 0) > 0) {
-      peerDiscovery.push(bootstrap({list: bootMultiaddrs}));
-    }
-
-    if (networkOpts.mdns) {
-      peerDiscovery.push(mdns());
-    }
-  }
-
-  const noiseCrypto = {
-    ...defaultCrypto,
-  };
-  if (globalThis.Bun) {
-    noiseCrypto.chaCha20Poly1305Decrypt = asCrypto.chaCha20Poly1305Decrypt;
-    noiseCrypto.chaCha20Poly1305Encrypt = asCrypto.chaCha20Poly1305Encrypt;
-  }
-
-  return createLibp2p({
-    privateKey,
-    addresses: {
-      listen: localMultiaddrs,
-      announce: [],
-    },
-    connectionEncrypters: [noise({crypto: noiseCrypto})],
-    // Reject connections when the server's connection count gets high
-    transports: [
-      tcp({
-        maxConnections: networkOpts.maxPeers,
-        // socket option: the maximum length of the queue of pending connections
-        // https://nodejs.org/dist/latest-v18.x/docs/api/net.html#serverlisten
-        // it's not safe if we increase this number
-        backlog: 5,
-        closeServerOnMaxConnections: {
-          closeAbove: networkOpts.maxPeers ?? Infinity,
-          listenBelow: networkOpts.maxPeers ?? Infinity,
-        },
-      }),
-    ],
-    streamMuxers: [mplex({maxInboundStreams: 256, disconnectThreshold: networkOpts.disconnectThreshold})],
-    peerDiscovery,
-    metrics: nodeJsLibp2pOpts.metrics
-      ? prometheusMetrics({
-          collectDefaultMetrics: false,
-          preserveExistingMetrics: true,
-          registry: nodeJsLibp2pOpts.metricsRegistry,
-        })
-      : undefined,
-    connectionManager: {
-      // dialer config
-      maxParallelDials: 100,
-      maxPeerAddrsToDial: 4,
-      dialTimeout: 30_000,
-      // the maximum number of pending connections libp2p will accept before it starts rejecting incoming connections.
-      // make it the same to backlog option above
-      maxIncomingPendingConnections: 5,
-    },
-    // rely on lodestar's peer manager to ping peers
-    connectionMonitor: {
-      enabled: false,
-    },
-    // for our purposes, we don't want peer store data to expire
-    // see https://github.com/libp2p/js-libp2p/pull/3019
-    peerStore: {
-      maxAddressAge: Infinity,
-      maxPeerAge: Infinity,
-    },
-    datastore,
-    services: {
-      identify: identify({
-        agentVersion: networkOpts.private ? "" : networkOpts.version ? `lodestar/${networkOpts.version}` : "lodestar",
-        runOnConnectionOpen: false,
-      }),
-      // individual components are specified because the components object is a Proxy
-      // and passing it here directly causes problems downstream, not to mention is slowwww
-      components: (components: LodestarComponents) => ({
-        peerId: components.peerId,
-        privateKey: components.privateKey,
-        nodeInfo: components.nodeInfo,
-        logger: components.logger,
-        events: components.events,
-        addressManager: components.addressManager,
-        peerStore: components.peerStore,
-        upgrader: components.upgrader,
-        registrar: components.registrar,
-        connectionManager: components.connectionManager,
-        transportManager: components.transportManager,
-        connectionGater: components.connectionGater,
-        contentRouting: components.contentRouting,
-        peerRouting: components.peerRouting,
-        datastore: components.datastore,
-        connectionProtector: components.connectionProtector,
-        metrics: components.metrics,
-      }),
-    },
-  });
-}

package/src/network/metadata.ts

@@ -1,162 +0,0 @@
-import {BitArray} from "@chainsafe/ssz";
-import {BeaconConfig} from "@lodestar/config";
-import {ForkSeq} from "@lodestar/params";
-import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {Epoch, fulu, phase0, ssz} from "@lodestar/types";
-import {Logger, toHex} from "@lodestar/utils";
-import {FAR_FUTURE_EPOCH} from "../constants/index.js";
-import {serializeCgc} from "../util/metadata.js";
-import {getCurrentAndNextForkBoundary} from "./forks.js";
-import {NetworkConfig} from "./networkConfig.js";
-
-export enum ENRKey {
-  tcp = "tcp",
-  eth2 = "eth2",
-  attnets = "attnets",
-  syncnets = "syncnets",
-  cgc = "cgc",
-  nfd = "nfd",
-}
-export enum SubnetType {
-  attnets = "attnets",
-  syncnets = "syncnets",
-}
-
-export type MetadataOpts = {
-  metadata?: fulu.Metadata;
-};
-
-export type MetadataModules = {
-  networkConfig: NetworkConfig;
-  logger: Logger;
-  onSetValue: (key: string, value: Uint8Array) => void;
-};
-
-/**
- * Implementation of Ethereum Consensus p2p MetaData.
- * For the spec that this code is based on, see:
- * https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#metadata
- */
-export class MetadataController {
-  private onSetValue: (key: string, value: Uint8Array) => void;
-  private networkConfig: NetworkConfig;
-  private logger: Logger;
-  private _metadata: fulu.Metadata;
-
-  constructor(opts: MetadataOpts, modules: MetadataModules) {
-    this.networkConfig = modules.networkConfig;
-    this.logger = modules.logger;
-    this.onSetValue = modules.onSetValue;
-    this._metadata = opts.metadata ?? {
-      ...ssz.fulu.Metadata.defaultValue(),
-      custodyGroupCount: modules.networkConfig.custodyConfig.targetCustodyGroupCount,
-    };
-  }
-
-  upstreamValues(currentEpoch: Epoch): void {
-    // updateEth2Field() MUST be called with clock epoch
-    this.updateEth2Field(currentEpoch);
-
-    this.onSetValue(ENRKey.attnets, ssz.phase0.AttestationSubnets.serialize(this._metadata.attnets));
-
-    const config = this.networkConfig.config;
-
-    if (config.getForkSeq(computeStartSlotAtEpoch(currentEpoch)) >= ForkSeq.altair) {
-      // Only persist syncnets if altair fork is already activated. If currentFork is altair but head is phase0
-      // adding syncnets to the ENR is not a problem, we will just have a useless field for a few hours.
-      this.onSetValue(ENRKey.syncnets, ssz.altair.SyncSubnets.serialize(this._metadata.syncnets));
-    }
-
-    // Set CGC regardless of fork. It may be useful to clients before Fulu, and will be ignored otherwise.
-    this.onSetValue(ENRKey.cgc, serializeCgc(this._metadata.custodyGroupCount));
-  }
-
-  get seqNumber(): bigint {
-    return this._metadata.seqNumber;
-  }
-
-  get syncnets(): BitArray {
-    return this._metadata.syncnets;
-  }
-
-  set syncnets(syncnets: BitArray) {
-    this.onSetValue(ENRKey.syncnets, ssz.altair.SyncSubnets.serialize(syncnets));
-    this._metadata.seqNumber++;
-    this._metadata.syncnets = syncnets;
-  }
-
-  get attnets(): BitArray {
-    return this._metadata.attnets;
-  }
-
-  set attnets(attnets: BitArray) {
-    this.onSetValue(ENRKey.attnets, ssz.phase0.AttestationSubnets.serialize(attnets));
-    this._metadata.seqNumber++;
-    this._metadata.attnets = attnets;
-  }
-
-  get custodyGroupCount(): number {
-    return this._metadata.custodyGroupCount;
-  }
-
-  set custodyGroupCount(custodyGroupCount: number) {
-    if (custodyGroupCount === this._metadata.custodyGroupCount) {
-      return;
-    }
-    this.onSetValue(ENRKey.cgc, serializeCgc(custodyGroupCount));
-    this.logger.debug("Updated cgc field in ENR", {custodyGroupCount});
-    this._metadata.seqNumber++;
-    this._metadata.custodyGroupCount = custodyGroupCount;
-  }
-
-  /** Consumers that need the phase0.Metadata type can just ignore the .syncnets property */
-  get json(): fulu.Metadata {
-    return this._metadata;
-  }
-
-  /**
-   * From spec:
-   *   fork_digest is compute_fork_digest(current_fork_version, genesis_validators_root) where
-   *   - current_fork_version is the fork version at the node's current epoch defined by the wall-clock time (not
-   *     necessarily the epoch to which the node is sync)
-   *   - genesis_validators_root is the static Root found in state.genesis_validators_root
-   *   - epoch of fork boundary is used to get blob parameters of current Blob Parameter Only (BPO) fork
-   *
-   * 1. MUST be called on start to populate ENR
-   * 2. Network MUST call this method on fork transition.
-   *    Current Clock implementation ensures no race conditions, epoch is correct if re-fetched
-   */
-  updateEth2Field(epoch: Epoch): void {
-    const config = this.networkConfig.config;
-    const enrForkId = getENRForkID(config, epoch);
-    const {forkDigest, nextForkVersion, nextForkEpoch} = enrForkId;
-    this.onSetValue(ENRKey.eth2, ssz.phase0.ENRForkID.serialize(enrForkId));
-    this.logger.debug("Updated eth2 field in ENR", {
-      forkDigest: toHex(forkDigest),
-      nextForkVersion: toHex(nextForkVersion),
-      nextForkEpoch,
-    });
-
-    const nextForkDigest =
-      nextForkEpoch !== FAR_FUTURE_EPOCH
-        ? config.forkBoundary2ForkDigest(config.getForkBoundaryAtEpoch(nextForkEpoch))
-        : ssz.ForkDigest.defaultValue();
-    this.onSetValue(ENRKey.nfd, nextForkDigest);
-    this.logger.debug("Updated nfd field in ENR", {nextForkDigest: toHex(nextForkDigest)});
-  }
-}
-
-export function getENRForkID(config: BeaconConfig, clockEpoch: Epoch): phase0.ENRForkID {
-  const {currentBoundary, nextBoundary} = getCurrentAndNextForkBoundary(config, clockEpoch);
-
-  return {
-    // Current fork digest
-    forkDigest: config.forkBoundary2ForkDigest(currentBoundary),
-    // Next planned fork version
-    nextForkVersion: nextBoundary
-      ? config.forks[nextBoundary.fork].version
-      : config.forks[currentBoundary.fork].version,
-    // Next fork epoch
-    nextForkEpoch: nextBoundary ? nextBoundary.epoch : FAR_FUTURE_EPOCH,
-  };
-}