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

package/src/api/impl/lodestar/index.ts

@@ -1,257 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import {Tree} from "@chainsafe/persistent-merkle-tree";
-import {routes} from "@lodestar/api";
-import {ApplicationMethods} from "@lodestar/api/server";
-import {ChainForkConfig} from "@lodestar/config";
-import {Repository} from "@lodestar/db";
-import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {BeaconStateCapella, getLatestWeakSubjectivityCheckpointEpoch, loadState} from "@lodestar/state-transition";
-import {ssz} from "@lodestar/types";
-import {toHex, toRootHex} from "@lodestar/utils";
-import {BeaconChain} from "../../../chain/index.js";
-import {QueuedStateRegenerator, RegenRequest} from "../../../chain/regen/index.js";
-import {IBeaconDb} from "../../../db/interface.js";
-import {GossipType} from "../../../network/index.js";
-import {profileNodeJS, writeHeapSnapshot} from "../../../util/profile.js";
-import {getStateResponseWithRegen} from "../beacon/state/utils.js";
-import {ApiModules} from "../types.js";
-
-export function getLodestarApi({
-  chain,
-  config,
-  db,
-  network,
-  sync,
-}: Pick<ApiModules, "chain" | "config" | "db" | "network" | "sync">): ApplicationMethods<routes.lodestar.Endpoints> {
-  let writingHeapdump = false;
-  let writingProfile = false;
-  const defaultProfileMs = SLOTS_PER_EPOCH * config.SECONDS_PER_SLOT * 1000;
-
-  return {
-    async writeHeapdump({thread = "main", dirpath = "."}) {
-      if (writingHeapdump) {
-        throw Error("Already writing heapdump");
-      }
-
-      try {
-        writingHeapdump = true;
-        let filepath: string;
-        switch (thread) {
-          case "network":
-            filepath = await network.writeNetworkHeapSnapshot("network_thread", dirpath);
-            break;
-          case "discv5":
-            filepath = await network.writeDiscv5HeapSnapshot("discv5_thread", dirpath);
-            break;
-          default:
-            // main thread
-            filepath = await writeHeapSnapshot("main_thread", dirpath);
-            break;
-        }
-        return {data: {filepath}};
-      } finally {
-        writingHeapdump = false;
-      }
-    },
-
-    async writeProfile({thread = "network", duration = defaultProfileMs, dirpath = "."}) {
-      if (writingProfile) {
-        throw Error("Already writing network profile");
-      }
-      writingProfile = true;
-
-      try {
-        let filepath: string;
-        let profile: string;
-        switch (thread) {
-          case "network":
-            filepath = await network.writeNetworkThreadProfile(duration, dirpath);
-            break;
-          case "discv5":
-            filepath = await network.writeDiscv5Profile(duration, dirpath);
-            break;
-          default:
-            // main thread
-            profile = await profileNodeJS(duration);
-            filepath = path.join(dirpath, `main_thread_${new Date().toISOString()}.cpuprofile`);
-            fs.writeFileSync(filepath, profile);
-            break;
-        }
-        return {data: {filepath}};
-      } finally {
-        writingProfile = false;
-      }
-    },
-
-    async getLatestWeakSubjectivityCheckpointEpoch() {
-      const state = chain.getHeadState();
-      return {data: getLatestWeakSubjectivityCheckpointEpoch(config, state)};
-    },
-
-    async getSyncChainsDebugState() {
-      return {data: sync.getSyncChainsDebugState()};
-    },
-
-    async getGossipQueueItems({gossipType}) {
-      return {
-        data: await network.dumpGossipQueue(gossipType as GossipType),
-      };
-    },
-
-    async getRegenQueueItems() {
-      return {
-        data: (chain.regen as QueuedStateRegenerator).jobQueue.getItems().map((item) => ({
-          key: item.args[0].key,
-          args: regenRequestToJson(config, item.args[0]),
-          addedTimeMs: item.addedTimeMs,
-        })),
-      };
-    },
-
-    async getBlockProcessorQueueItems() {
-      return {
-        // biome-ignore lint/complexity/useLiteralKeys: The `blockProcessor` is a protected attribute
-        data: (chain as BeaconChain)["blockProcessor"].jobQueue.getItems().map((item) => {
-          const [blockInputs, opts] = item.args;
-          return {
-            blockSlots: blockInputs.map((blockInput) => blockInput.slot),
-            jobOpts: opts,
-            addedTimeMs: item.addedTimeMs,
-          };
-        }),
-      };
-    },
-
-    async getStateCacheItems() {
-      return {data: chain.regen.dumpCacheSummary()};
-    },
-
-    async getGossipPeerScoreStats() {
-      return {
-        data: Object.entries(await network.dumpGossipPeerScoreStats()).map(([peerId, stats]) => ({peerId, ...stats})),
-      };
-    },
-
-    async getLodestarPeerScoreStats() {
-      return {data: await network.dumpPeerScoreStats()};
-    },
-
-    async runGC() {
-      if (!global.gc) throw Error("You must expose GC running the Node.js process with 'node --expose_gc'");
-      global.gc();
-    },
-
-    async dropStateCache() {
-      chain.regen.dropCache();
-    },
-
-    async connectPeer({peerId, multiaddrs}) {
-      await network.connectToPeer(peerId, multiaddrs);
-    },
-
-    async disconnectPeer({peerId}) {
-      await network.disconnectPeer(peerId);
-    },
-
-    async getPeers({state, direction}) {
-      const peers = (await network.dumpPeers()).filter(
-        (nodePeer) =>
-          (!state || state.length === 0 || state.includes(nodePeer.state)) &&
-          (!direction || direction.length === 0 || (nodePeer.direction && direction.includes(nodePeer.direction)))
-      );
-
-      return {
-        data: peers,
-        meta: {count: peers.length},
-      };
-    },
-
-    async getBlacklistedBlocks() {
-      return {
-        data: Array.from(chain.blacklistedBlocks.entries()).map(([root, slot]) => ({root, slot})),
-      };
-    },
-
-    async discv5GetKadValues() {
-      return {
-        data: await network.dumpDiscv5KadValues(),
-      };
-    },
-
-    async dumpDbBucketKeys({bucket}) {
-      for (const repo of Object.values(db) as IBeaconDb[keyof IBeaconDb][]) {
-        // biome-ignore lint/complexity/useLiteralKeys: `bucket` is protected and `bucketId` is private
-        if (repo instanceof Repository && (String(repo["bucket"]) === bucket || repo["bucketId"] === bucket)) {
-          return {data: stringifyKeys(await repo.keys())};
-        }
-      }
-
-      throw Error(`Unknown Bucket '${bucket}'`);
-    },
-
-    async dumpDbStateIndex() {
-      return {data: await db.stateArchive.dumpRootIndexEntries()};
-    },
-
-    async getHistoricalSummaries({stateId}) {
-      const {state, executionOptimistic, finalized} = await getStateResponseWithRegen(chain, stateId);
-
-      const stateView = (
-        state instanceof Uint8Array ? loadState(config, chain.getHeadState(), state).state : state.clone()
-      ) as BeaconStateCapella;
-
-      const fork = config.getForkName(stateView.slot);
-      if (ForkSeq[fork] < ForkSeq.capella) {
-        throw new Error("Historical summaries are not supported before Capella");
-      }
-
-      const {gindex} = ssz[fork].BeaconState.getPathInfo(["historicalSummaries"]);
-      const proof = new Tree(stateView.node).getSingleProof(gindex);
-
-      return {
-        data: {
-          slot: stateView.slot,
-          historicalSummaries: stateView.historicalSummaries.toValue(),
-          proof: proof,
-        },
-        meta: {executionOptimistic, finalized, version: fork},
-      };
-    },
-  };
-}
-
-function regenRequestToJson(config: ChainForkConfig, regenRequest: RegenRequest): unknown {
-  switch (regenRequest.key) {
-    case "getBlockSlotState":
-      return {
-        root: regenRequest.args[0],
-        slot: regenRequest.args[1],
-      };
-
-    case "getCheckpointState":
-      return ssz.phase0.Checkpoint.toJson(regenRequest.args[0]);
-
-    case "getPreState": {
-      const slot = regenRequest.args[0].slot;
-      return {
-        root: toRootHex(config.getForkTypes(slot).BeaconBlock.hashTreeRoot(regenRequest.args[0])),
-        slot,
-      };
-    }
-
-    case "getState":
-      return {
-        root: regenRequest.args[0],
-      };
-  }
-}
-
-function stringifyKeys(keys: (Uint8Array | number | string)[]): string[] {
-  return keys.map((key) => {
-    if (key instanceof Uint8Array) {
-      return toHex(key);
-    }
-    return `${key}`;
-  });
-}

package/src/api/impl/node/index.ts

@@ -1,88 +0,0 @@
-import {routes} from "@lodestar/api";
-import {ApplicationMethods} from "@lodestar/api/server";
-import {ApiOptions} from "../../options.js";
-import {ApiError} from "../errors.js";
-import {ApiModules} from "../types.js";
-
-export function getNodeApi(
-  opts: ApiOptions,
-  {network, sync}: Pick<ApiModules, "network" | "sync">
-): ApplicationMethods<routes.node.Endpoints> {
-  return {
-    async getNetworkIdentity() {
-      return {
-        data: await network.getNetworkIdentity(),
-      };
-    },
-
-    async getPeer({peerId}) {
-      const peer = await network.dumpPeer(peerId);
-      if (!peer) {
-        throw new ApiError(404, "Node has not seen this peer");
-      }
-      return {data: peer};
-    },
-
-    async getPeers({state, direction}) {
-      const peers = (await network.dumpPeers()).filter(
-        (nodePeer) =>
-          (!state || state.length === 0 || state.includes(nodePeer.state)) &&
-          (!direction || direction.length === 0 || (nodePeer.direction && direction.includes(nodePeer.direction)))
-      );
-
-      return {
-        data: peers,
-        meta: {count: peers.length},
-      };
-    },
-
-    async getPeerCount() {
-      // TODO: Implement disconnect count with on-disk persistence
-      const data = {
-        disconnected: 0,
-        connecting: 0,
-        connected: 0,
-        disconnecting: 0,
-      };
-
-      for (const peer of await network.dumpPeers()) {
-        data[peer.state]++;
-      }
-
-      return {
-        data,
-      };
-    },
-
-    async getNodeVersion() {
-      return {
-        data: {
-          version: `Lodestar/${opts.version || "dev"}`,
-        },
-      };
-    },
-
-    async getSyncingStatus() {
-      return {data: sync.getSyncStatus()};
-    },
-
-    async getHealth({syncingStatus}) {
-      if (syncingStatus != null && (syncingStatus < 100 || syncingStatus > 599)) {
-        throw new ApiError(400, `Invalid syncing status code: ${syncingStatus}`);
-      }
-
-      const {isSyncing, isOptimistic, elOffline} = sync.getSyncStatus();
-
-      if (isSyncing || isOptimistic || elOffline) {
-        // 206: Node is syncing but can serve incomplete data
-        return {status: syncingStatus ?? routes.node.NodeHealth.SYNCING};
-      }
-      // 200: Node is ready
-      return {status: routes.node.NodeHealth.READY};
-      // else {
-      //   503: Node not initialized or having issues
-      //   NOTE: Lodestar does not start its API until fully initialized, so this status can never be served
-      // }
-    },
-  };
-}

package/src/api/impl/node/utils.ts

@@ -1,51 +0,0 @@
-import {Connection, StreamStatus} from "@libp2p/interface";
-import {routes} from "@lodestar/api";
-
-/**
- * Format a list of connections from libp2p connections manager into the API's format NodePeer
- */
-export function formatNodePeer(peerIdStr: string, connections: Connection[]): routes.node.NodePeer {
-  const conn = getRelevantConnection(connections);
-
-  return {
-    peerId: conn ? conn.remotePeer.toString() : peerIdStr,
-    // TODO: figure out how to get enr of peer
-    enr: "",
-    lastSeenP2pAddress: conn ? conn.remoteAddr.toString() : "",
-    direction: conn ? (conn.direction as routes.node.PeerDirection) : null,
-    state: conn ? getPeerState(conn.status) : "disconnected",
-  };
-}
-
-/**
- * From a list of connections, get the most relevant of a peer
- * - The first open connection if any
- * - Otherwise, the first closing connection
- * - Otherwise, the first closed connection
- */
-export function getRelevantConnection(connections: Connection[]): Connection | null {
-  const byStatus = new Map<StreamStatus, Connection>();
-  for (const conn of connections) {
-    if (conn.status === "open") return conn;
-    if (!byStatus.has(conn.status)) byStatus.set(conn.status, conn);
-  }
-
-  return byStatus.get("open") || byStatus.get("closing") || byStatus.get("closed") || null;
-}
-
-/**
- * Map libp2p connection status to the API's peer state notation
- * @param status
- */
-function getPeerState(status: StreamStatus): routes.node.PeerState {
-  switch (status) {
-    case "open":
-      return "connected";
-    case "closing":
-      return "disconnecting";
-    case "closed":
-      return "disconnected";
-    default:
-      return "disconnected";
-  }
-}

package/src/api/impl/proof/index.ts

@@ -1,60 +0,0 @@
-import {CompactMultiProof, ProofType, createProof} from "@chainsafe/persistent-merkle-tree";
-import {routes} from "@lodestar/api";
-import {ApplicationMethods} from "@lodestar/api/server";
-import {loadState} from "@lodestar/state-transition";
-import {ApiOptions} from "../../options.js";
-import {getBlockResponse} from "../beacon/blocks/utils.js";
-import {getStateResponseWithRegen} from "../beacon/state/utils.js";
-import {ApiModules} from "../types.js";
-
-export function getProofApi(
-  opts: ApiOptions,
-  {chain, config}: Pick<ApiModules, "chain" | "config" | "db">
-): ApplicationMethods<routes.proof.Endpoints> {
-  // It's currently possible to request gigantic proofs (eg: a proof of the entire beacon state)
-  // We want some some sort of resistance against this DoS vector.
-  const maxGindicesInProof = opts.maxGindicesInProof ?? 512;
-
-  return {
-    async getStateProof({stateId, descriptor}) {
-      // descriptor.length / 2 is a rough approximation of # of gindices
-      if (descriptor.length / 2 > maxGindicesInProof) {
-        throw new Error("Requested proof is too large.");
-      }
-
-      const res = await getStateResponseWithRegen(chain, stateId);
-
-      const state =
-        res.state instanceof Uint8Array ? loadState(config, chain.getHeadState(), res.state).state : res.state;
-
-      // Commit any changes before computing the state root. In normal cases the state should have no changes here
-      state.commit();
-      const stateNode = state.node;
-
-      const proof = createProof(stateNode, {type: ProofType.compactMulti, descriptor});
-
-      return {
-        data: proof as CompactMultiProof,
-        meta: {version: config.getForkName(state.slot)},
-      };
-    },
-    async getBlockProof({blockId, descriptor}) {
-      // descriptor.length / 2 is a rough approximation of # of gindices
-      if (descriptor.length / 2 > maxGindicesInProof) {
-        throw new Error("Requested proof is too large.");
-      }
-
-      const {block} = await getBlockResponse(chain, blockId);
-
-      // Commit any changes before computing the state root. In normal cases the state should have no changes here
-      const blockNode = config.getForkTypes(block.message.slot).BeaconBlock.toView(block.message).node;
-
-      const proof = createProof(blockNode, {type: ProofType.compactMulti, descriptor});
-
-      return {
-        data: proof as CompactMultiProof,
-        meta: {version: config.getForkName(block.message.slot)},
-      };
-    },
-  };
-}

package/src/api/impl/types.ts

@@ -1,17 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {Logger} from "@lodestar/utils";
-import {IBeaconChain} from "../../chain/index.js";
-import {IBeaconDb} from "../../db/index.js";
-import {Metrics} from "../../metrics/index.js";
-import {INetwork} from "../../network/index.js";
-import {IBeaconSync} from "../../sync/index.js";
-
-export type ApiModules = {
-  config: ChainForkConfig;
-  chain: IBeaconChain;
-  db: IBeaconDb;
-  logger: Logger;
-  metrics: Metrics | null;
-  network: INetwork;
-  sync: IBeaconSync;
-};

package/src/api/impl/utils.ts

@@ -1,25 +0,0 @@
-import {ApiError} from "./errors.js";
-
-/**
- * Ensures that the array contains unique values, and throws an ApiError
- * otherwise.
- * @param array - The array to check for uniqueness.
- * @param message - The message to put in the ApiError if the array contains
- * duplicates.
- */
-export function assertUniqueItems(array: unknown[] | undefined, message: string): void {
-  if (!array) {
-    return;
-  }
-
-  const duplicateItems = array.reduce((partialDuplicateItems: unknown[], item, index) => {
-    if (array.indexOf(item) !== index && !partialDuplicateItems.includes(item)) {
-      return partialDuplicateItems.concat(item);
-    }
-    return partialDuplicateItems;
-  }, []);
-
-  if (duplicateItems.length) {
-    throw new ApiError(400, `${message}: ${duplicateItems.join(", ")}`);
-  }
-}