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

package/src/network/interface.ts

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

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

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

@@ -0,0 +1,162 @@
+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,
+  };
+}