@chainsafe/lodestar 1.35.0-dev.e18102ed8c → 1.35.0-dev.f2a741bbe4

package/src/cmds/beacon/initPeerIdAndEnr.ts

@@ -0,0 +1,199 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {generateKeyPair} from "@libp2p/crypto/keys";
+import type {PrivateKey} from "@libp2p/interface";
+import {peerIdFromPrivateKey} from "@libp2p/peer-id";
+import {Multiaddr} from "@multiformats/multiaddr";
+import {SignableENR} from "@chainsafe/enr";
+import {Logger} from "@lodestar/utils";
+import {exportToJSON, readPrivateKey} from "../../config/index.js";
+import {parseListenArgs} from "../../options/beaconNodeOptions/network.js";
+import {writeFile600Perm} from "../../util/file.js";
+import {BeaconArgs} from "./options.js";
+
+/**
+ * Check if multiaddr belongs to the local network interfaces.
+ */
+export function isLocalMultiAddr(multiaddr: Multiaddr | undefined): boolean {
+  if (!multiaddr) return false;
+
+  const protoNames = multiaddr.protoNames();
+  if (protoNames.length !== 2 && protoNames[1] !== "udp") {
+    throw new Error("Invalid udp multiaddr");
+  }
+
+  const interfaces = os.networkInterfaces();
+  const tuples = multiaddr.tuples();
+  const family = tuples[0][0];
+  const isIPv4: boolean = family === 4;
+  const ip = tuples[0][1];
+
+  if (!ip) {
+    return false;
+  }
+
+  const ipStr = isIPv4
+    ? Array.from(ip).join(".")
+    : Array.from(Uint16Array.from(ip))
+        .map((n) => n.toString(16))
+        .join(":");
+
+  for (const networkInterfaces of Object.values(interfaces)) {
+    for (const networkInterface of networkInterfaces || []) {
+      // since node version 18, the netowrkinterface family returns 4 | 6 instead of ipv4 | ipv6,
+      // even though the documentation says otherwise.
+      // This might be a bug that would be corrected in future version, in the meantime
+      // the check using endsWith ensures things work in node version 18 and earlier
+      if (String(networkInterface.family).endsWith(String(family)) && networkInterface.address === ipStr) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Only update the enr if the value has changed
+ */
+function maybeUpdateEnr<T extends "ip" | "tcp" | "udp" | "ip6" | "tcp6" | "udp6">(
+  enr: SignableENR,
+  key: T,
+  value: SignableENR[T] | undefined
+): void {
+  if (enr[key] !== value) {
+    enr[key] = value;
+  }
+}
+
+export function overwriteEnrWithCliArgs(
+  enr: SignableENR,
+  args: BeaconArgs,
+  logger: Logger,
+  opts?: {newEnr?: boolean; bootnode?: boolean}
+): void {
+  const preSeq = enr.seq;
+  const {port, discoveryPort, port6, discoveryPort6} = parseListenArgs(args);
+  maybeUpdateEnr(enr, "ip", args["enr.ip"] ?? enr.ip);
+  maybeUpdateEnr(enr, "ip6", args["enr.ip6"] ?? enr.ip6);
+  maybeUpdateEnr(enr, "udp", args["enr.udp"] ?? discoveryPort ?? enr.udp);
+  maybeUpdateEnr(enr, "udp6", args["enr.udp6"] ?? discoveryPort6 ?? enr.udp6);
+  if (!opts?.bootnode) {
+    maybeUpdateEnr(enr, "tcp", args["enr.tcp"] ?? port ?? enr.tcp);
+    maybeUpdateEnr(enr, "tcp6", args["enr.tcp6"] ?? port6 ?? enr.tcp6);
+  }
+
+  function testMultiaddrForLocal(mu: Multiaddr, ip4: boolean): void {
+    const isLocal = isLocalMultiAddr(mu);
+    if (args.nat) {
+      if (isLocal) {
+        logger.warn("--nat flag is set with no purpose");
+      }
+    } else {
+      if (!isLocal) {
+        logger.warn(
+          `Configured ENR ${ip4 ? "IPv4" : "IPv6"} address is not local, clearing ENR ${ip4 ? "ip" : "ip6"} and ${
+            ip4 ? "udp" : "udp6"
+          }. Set the --nat flag to prevent this`
+        );
+        if (ip4) {
+          enr.delete("ip");
+          enr.delete("udp");
+        } else {
+          enr.delete("ip6");
+          enr.delete("udp6");
+        }
+      }
+    }
+  }
+  const udpMultiaddr4 = enr.getLocationMultiaddr("udp4");
+  if (udpMultiaddr4) {
+    testMultiaddrForLocal(udpMultiaddr4, true);
+  }
+  const udpMultiaddr6 = enr.getLocationMultiaddr("udp6");
+  if (udpMultiaddr6) {
+    testMultiaddrForLocal(udpMultiaddr6, false);
+  }
+
+  if (enr.seq !== preSeq) {
+    // If the enr is newly created, its sequence number can be set to 1
+    // It's especially clean for fully configured bootnodes whose enrs never change
+    // Otherwise, we can increment the sequence number as little as possible
+    if (opts?.newEnr) {
+      enr.seq = BigInt(1);
+    } else {
+      enr.seq = preSeq + BigInt(1);
+    }
+    // invalidate cached signature
+    // biome-ignore lint/complexity/useLiteralKeys: `_signature` is a private attribute
+    delete enr["_signature"];
+  }
+}
+
+/**
+ * Create new PeerId and ENR by default, unless persistNetworkIdentity is provided
+ */
+export async function initPrivateKeyAndEnr(
+  args: BeaconArgs,
+  beaconDir: string,
+  logger: Logger,
+  bootnode?: boolean
+): Promise<{privateKey: PrivateKey; enr: SignableENR}> {
+  const {persistNetworkIdentity} = args;
+
+  const newPrivateKeyAndENR = async (): Promise<{privateKey: PrivateKey; enr: SignableENR}> => {
+    const privateKey = await generateKeyPair("secp256k1");
+    const enr = SignableENR.createFromPrivateKey(privateKey);
+    return {privateKey, enr};
+  };
+
+  const readPersistedPrivateKeyAndENR = async (
+    peerIdFile: string,
+    enrFile: string
+  ): Promise<{privateKey: PrivateKey; enr: SignableENR; newEnr: boolean}> => {
+    let privateKey: PrivateKey;
+    let enr: SignableENR;
+
+    // attempt to read stored private key
+    try {
+      privateKey = readPrivateKey(peerIdFile);
+    } catch (e) {
+      if ((e as {code: string}).code === "ENOENT") {
+        logger.debug("peerIdFile not found, creating a new peer id", {peerIdFile});
+      } else {
+        logger.warn("Unable to read peerIdFile, creating a new peer id", {peerIdFile}, e as Error);
+      }
+      return {...(await newPrivateKeyAndENR()), newEnr: true};
+    }
+    // attempt to read stored enr
+    try {
+      enr = SignableENR.decodeTxt(fs.readFileSync(enrFile, "utf-8"), privateKey.raw);
+    } catch (_e) {
+      logger.warn("Unable to decode stored local ENR, creating a new ENR");
+      enr = SignableENR.createFromPrivateKey(privateKey);
+      return {privateKey, enr, newEnr: true};
+    }
+    // check stored peer id against stored enr
+    if (!peerIdFromPrivateKey(privateKey).equals(enr.peerId)) {
+      logger.warn("Stored local ENR doesn't match peerIdFile, creating a new ENR");
+      enr = SignableENR.createFromPrivateKey(privateKey);
+      return {privateKey, enr, newEnr: true};
+    }
+    return {privateKey, enr, newEnr: false};
+  };
+
+  if (persistNetworkIdentity) {
+    const enrFile = path.join(beaconDir, "enr");
+    const peerIdFile = path.join(beaconDir, "peer-id.json");
+    const {privateKey, enr, newEnr} = await readPersistedPrivateKeyAndENR(peerIdFile, enrFile);
+    overwriteEnrWithCliArgs(enr, args, logger, {newEnr, bootnode});
+    // Re-persist peer-id and enr
+    writeFile600Perm(peerIdFile, exportToJSON(privateKey));
+    writeFile600Perm(enrFile, enr.encodeTxt());
+    return {privateKey, enr};
+  }
+  const {privateKey, enr} = await newPrivateKeyAndENR();
+  overwriteEnrWithCliArgs(enr, args, logger, {newEnr: true, bootnode});
+  return {privateKey, enr};
+}

package/src/cmds/beacon/options.ts

@@ -0,0 +1,214 @@
+import {CliCommandOptions, CliOptionDefinition} from "@lodestar/utils";
+import {BeaconNodeArgs, beaconNodeOptions, paramsOptions} from "../../options/index.js";
+import {LogArgs, logOptions} from "../../options/logOptions.js";
+import {BeaconPaths, defaultBeaconPaths} from "./paths.js";
+
+type BeaconExtraArgs = {
+  forceGenesis?: boolean;
+  genesisStateFile?: string;
+  configFile?: string;
+  bootnodesFile?: string;
+  checkpointSyncUrl?: string;
+  checkpointState?: string;
+  wssCheckpoint?: string;
+  forceCheckpointSync?: boolean;
+  ignoreWeakSubjectivityCheck?: boolean;
+  beaconDir?: string;
+  dbDir?: string;
+  persistInvalidSszObjectsDir?: string;
+  persistInvalidSszObjectsRetentionHours?: number;
+  persistOrphanedBlocksDir?: string;
+  peerStoreDir?: string;
+  persistNetworkIdentity?: boolean;
+  private?: boolean;
+  validatorMonitorLogs?: boolean;
+  attachToGlobalThis?: boolean;
+  disableLightClientServer?: boolean;
+};
+
+export const beaconExtraOptions: CliCommandOptions<BeaconExtraArgs> = {
+  forceGenesis: {
+    description: "Force beacon to create genesis without file",
+    type: "boolean",
+    hidden: true,
+  },
+
+  genesisStateFile: {
+    description: "Path or URL to download a genesis state file in ssz-encoded format",
+    type: "string",
+  },
+
+  configFile: {
+    hidden: true,
+    description: "[DEPRECATED] Beacon node configuration file path",
+    type: "string",
+  },
+
+  bootnodesFile: {
+    hidden: true,
+    description: "Bootnodes file path",
+    type: "string",
+  },
+
+  checkpointSyncUrl: {
+    description:
+      "Server url hosting Beacon Node APIs to fetch weak subjectivity state. Fetch latest finalized by default, else set --wssCheckpoint",
+    type: "string",
+    group: "weak subjectivity",
+  },
+
+  checkpointState: {
+    description: "Set a checkpoint state to start syncing from",
+    type: "string",
+    group: "weak subjectivity",
+  },
+
+  wssCheckpoint: {
+    description:
+      "Start beacon node off a state at the provided weak subjectivity checkpoint, to be supplied in <blockRoot>:<epoch> format. For example, 0x1234:100 will sync and start off from the weak subjectivity state at checkpoint of epoch 100 with block root 0x1234.",
+    type: "string",
+    group: "weak subjectivity",
+  },
+
+  forceCheckpointSync: {
+    description:
+      "Force syncing from checkpoint state even if db state is within weak subjectivity period. This helps to avoid long sync times after node has been offline for a while.",
+    type: "boolean",
+    group: "weak subjectivity",
+  },
+
+  ignoreWeakSubjectivityCheck: {
+    description:
+      "Ignore the checkpoint sync state failing the weak subjectivity check. This is relevant in testnets where the weak subjectivity period is too small for even few epochs of non finalization causing last finalized to be out of range. This flag is not recommended for mainnet use.",
+    type: "boolean",
+    group: "weak subjectivity",
+  },
+
+  beaconDir: {
+    description: "Beacon root directory",
+    defaultDescription: defaultBeaconPaths.beaconDir,
+    hidden: true,
+    type: "string",
+  },
+
+  dbDir: {
+    description: "Beacon DB directory",
+    defaultDescription: defaultBeaconPaths.dbDir,
+    hidden: true,
+    type: "string",
+  },
+
+  persistInvalidSszObjectsDir: {
+    description: "Enable and specify a directory to persist invalid ssz objects",
+    defaultDescription: defaultBeaconPaths.persistInvalidSszObjectsDir,
+    hidden: true,
+    type: "string",
+  },
+
+  persistInvalidSszObjectsRetentionHours: {
+    description: "Number of hours to keep invalid SSZ objects on local disk",
+    hidden: true,
+    type: "number",
+  },
+
+  persistOrphanedBlocksDir: {
+    description: "Enable and specify a directory to persist orphaned blocks",
+    defaultDescription: defaultBeaconPaths.persistOrphanedBlocksDir,
+    hidden: true,
+    type: "string",
+  },
+
+  peerStoreDir: {
+    hidden: true,
+    description: "Peer store directory",
+    defaultDescription: defaultBeaconPaths.peerStoreDir,
+    type: "string",
+  },
+
+  persistNetworkIdentity: {
+    description:
+      "Whether to reuse the same peer-id across restarts. Validator custody requires custody group count to persist relative to a given ENR. Setting to false will reset ENR and validator custody requirements on restarts.",
+    default: true,
+    type: "boolean",
+  },
+
+  private: {
+    description:
+      "Do not send implementation details over p2p identify protocol and in builder, execution engine and eth1 requests",
+    type: "boolean",
+  },
+
+  validatorMonitorLogs: {
+    description: "Log validator monitor events as info.",
+    type: "boolean",
+  },
+
+  attachToGlobalThis: {
+    hidden: true,
+    description: "Attach the beacon node to `globalThis`. Useful to inspect a running beacon node.",
+    type: "boolean",
+  },
+
+  disableLightClientServer: {
+    description: "Disable light client server.",
+    type: "boolean",
+  },
+};
+
+type ENRArgs = {
+  "enr.ip"?: string;
+  "enr.tcp"?: number;
+  "enr.ip6"?: string;
+  "enr.udp"?: number;
+  "enr.tcp6"?: number;
+  "enr.udp6"?: number;
+  nat?: boolean;
+};
+
+const enrOptions: CliCommandOptions<ENRArgs> = {
+  "enr.ip": {
+    description: "Override ENR IP entry",
+    type: "string",
+    group: "enr",
+  },
+  "enr.tcp": {
+    description: "Override ENR TCP entry",
+    type: "number",
+    group: "enr",
+  },
+  "enr.udp": {
+    description: "Override ENR UDP entry",
+    type: "number",
+    group: "enr",
+  },
+  "enr.ip6": {
+    description: "Override ENR IPv6 entry",
+    type: "string",
+    group: "enr",
+  },
+  "enr.tcp6": {
+    description: "Override ENR (IPv6-specific) TCP entry",
+    type: "number",
+    group: "enr",
+  },
+  "enr.udp6": {
+    description: "Override ENR (IPv6-specific) UDP entry",
+    type: "number",
+    group: "enr",
+  },
+  nat: {
+    type: "boolean",
+    description: "Allow configuration of non-local addresses",
+    group: "enr",
+  },
+};
+
+export type BeaconArgs = BeaconExtraArgs & LogArgs & BeaconPaths & BeaconNodeArgs & ENRArgs;
+
+export const beaconOptions: {[k: string]: CliOptionDefinition} = {
+  ...beaconExtraOptions,
+  ...logOptions,
+  ...beaconNodeOptions,
+  ...paramsOptions,
+  ...enrOptions,
+};

package/src/cmds/beacon/paths.ts

@@ -0,0 +1,62 @@
+import path from "node:path";
+import {GlobalArgs} from "../../options/index.js";
+import {GlobalPaths, getGlobalPaths} from "../../paths/global.js";
+
+export type BeaconPathsPartial = Partial<{
+  beaconDir: string;
+  peerStoreDir: string;
+  dbDir: string;
+  persistInvalidSszObjectsDir: string;
+  persistOrphanedBlocksDir?: string;
+}>;
+
+export type BeaconPaths = {
+  beaconDir: string;
+  peerStoreDir: string;
+  dbDir: string;
+  persistInvalidSszObjectsDir: string;
+  persistOrphanedBlocksDir: string;
+};
+
+/**
+ * Defines the path structure of the files relevant to the beacon node
+ *
+ * ```bash
+ * $dataDir
+ * └── $beaconDir
+ *     ├── beacon.config.json
+ *     ├── peer-id.json
+ *     ├── enr
+ *     ├── chain-db
+ *     └── beacon.log
+ * ```
+ */
+export function getBeaconPaths(
+  // Using Pick<GlobalArgs, "dataDir"> make changes in GlobalArgs throw a type error here
+  args: BeaconPathsPartial & Pick<GlobalArgs, "dataDir">,
+  network: string
+): GlobalPaths & Required<BeaconPathsPartial> {
+  // Compute global paths first
+  const globalPaths = getGlobalPaths(args, network);
+
+  const dataDir = globalPaths.dataDir;
+  const beaconDir = dataDir;
+  const dbDir = args.dbDir ?? path.join(beaconDir, "chain-db");
+  const persistInvalidSszObjectsDir = args.persistInvalidSszObjectsDir ?? path.join(beaconDir, "invalidSszObjects");
+  const peerStoreDir = args.peerStoreDir ?? path.join(beaconDir, "peerstore");
+  const persistOrphanedBlocksDir = args.persistOrphanedBlocksDir ?? path.join(beaconDir, "orphaned_blocks");
+
+  return {
+    ...globalPaths,
+    beaconDir,
+    dbDir,
+    persistInvalidSszObjectsDir,
+    peerStoreDir,
+    persistOrphanedBlocksDir,
+  };
+}
+
+/**
+ * Constructs representations of the path structure to show in command's description
+ */
+export const defaultBeaconPaths = getBeaconPaths({dataDir: "$dataDir"}, "$network");

package/src/cmds/bootnode/handler.ts

@@ -0,0 +1,203 @@
+import path from "node:path";
+import {PrivateKey} from "@libp2p/interface";
+import {Multiaddr, multiaddr} from "@multiformats/multiaddr";
+import {Discv5, Discv5EventEmitter} from "@chainsafe/discv5";
+import {ENR, ENRData, SignableENR} from "@chainsafe/enr";
+import {
+  HttpMetricsServer,
+  IBeaconNodeOptions,
+  RegistryMetricCreator,
+  getHttpMetricsServer,
+} from "@lodestar/beacon-node";
+import {ErrorAborted, Logger} from "@lodestar/utils";
+import {getBeaconConfigFromArgs} from "../../config/index.js";
+import {getNetworkBootnodes, isKnownNetworkName, readBootnodes} from "../../networks/index.js";
+import {parseArgs as parseMetricsArgs} from "../../options/beaconNodeOptions/metrics.js";
+import {parseArgs as parseNetworkArgs} from "../../options/beaconNodeOptions/network.js";
+import {GlobalArgs} from "../../options/index.js";
+import {mkdir, onGracefulShutdown, writeFile600Perm} from "../../util/index.js";
+import {getVersionData} from "../../util/version.js";
+import {initLogger} from "../beacon/handler.js";
+import {initPrivateKeyAndEnr} from "../beacon/initPeerIdAndEnr.js";
+import {BeaconArgs} from "../beacon/options.js";
+import {getBeaconPaths} from "../beacon/paths.js";
+import {BootnodeArgs} from "./options.js";
+
+/**
+ * Runs a bootnode.
+ */
+export async function bootnodeHandler(args: BootnodeArgs & GlobalArgs): Promise<void> {
+  const {discv5Args, metricsArgs, bootnodeDir, network, version, commit, privateKey, enr, logger} =
+    await bootnodeHandlerInit(args);
+
+  const abortController = new AbortController();
+  const bindAddrs = discv5Args.bindAddrs;
+
+  logger.info("Lodestar Bootnode", {network, version, commit});
+  logger.info("Bind address", bindAddrs);
+  logger.info("Advertised address", {
+    ip4: enr.getLocationMultiaddr("udp4")?.toString(),
+    ip6: enr.getLocationMultiaddr("udp6")?.toString(),
+  });
+  logger.info("Identity", {peerId: enr.peerId.toString(), nodeId: enr.nodeId});
+  logger.info("ENR", {enr: enr.encodeTxt()});
+
+  // bootnode setup
+  try {
+    let metricsRegistry: RegistryMetricCreator | undefined;
+    let metricsServer: HttpMetricsServer | undefined;
+    if (metricsArgs.enabled) {
+      metricsRegistry = new RegistryMetricCreator();
+      metricsRegistry.static({
+        name: "bootnode_version",
+        help: "Bootnode version",
+        value: {version, commit, network},
+      });
+      metricsServer = await getHttpMetricsServer(metricsArgs, {register: metricsRegistry, logger});
+    }
+
+    const discv5 = Discv5.create({
+      enr,
+      privateKey,
+      bindAddrs: {
+        ip4: (bindAddrs.ip4 ? multiaddr(bindAddrs.ip4) : undefined) as Multiaddr,
+        ip6: bindAddrs.ip6 ? multiaddr(bindAddrs.ip6) : undefined,
+      },
+      config: {enrUpdate: !enr.ip && !enr.ip6},
+      metricsRegistry,
+    }) as Discv5 & Discv5EventEmitter;
+
+    // If there are any bootnodes, add them to the routing table
+    for (const bootEnrStr of Array.from(new Set(discv5Args.bootEnrs).values())) {
+      const bootEnr = ENR.decodeTxt(bootEnrStr);
+      logger.info("Adding bootnode", {
+        ip4: bootEnr.getLocationMultiaddr("udp4")?.toString(),
+        ip6: bootEnr.getLocationMultiaddr("udp6")?.toString(),
+        peerId: bootEnr.peerId.toString(),
+        nodeId: enr.nodeId,
+      });
+      discv5.addEnr(bootEnr);
+    }
+
+    // start the server
+    await discv5.start();
+
+    // if there are peers in the local routing table, establish a session by running a query
+    if (discv5.kadValues().length) {
+      void discv5.findRandomNode();
+    }
+
+    discv5.on("multiaddrUpdated", (addr: ENRData) => {
+      logger.info("Advertised socket address updated", {addr: addr.toString()});
+    });
+
+    // respond with metrics every 10 seconds
+    const printInterval = setInterval(() => {
+      let ip4Only = 0;
+      let ip6Only = 0;
+      let ip4ip6 = 0;
+      let unreachable = 0;
+      for (const kadEnr of discv5.kadValues()) {
+        const hasIp4 = kadEnr.getLocationMultiaddr("udp4");
+        const hasIp6 = kadEnr.getLocationMultiaddr("udp6");
+        if (hasIp4 && hasIp6) {
+          ip4ip6++;
+        } else if (hasIp4) {
+          ip4Only++;
+        } else if (hasIp6) {
+          ip6Only++;
+        } else {
+          unreachable++;
+        }
+      }
+      logger.info("Server metrics", {
+        connectedPeers: discv5.connectedPeerCount,
+        activeSessions: discv5.sessionService.sessionsSize(),
+        ip4Nodes: ip4Only,
+        ip6Nodes: ip6Only,
+        ip4AndIp6Nodes: ip4ip6,
+        unreachableNodes: unreachable,
+      });
+    }, 10_000);
+
+    // Intercept SIGINT signal, to perform final ops before exiting
+    onGracefulShutdown(async () => {
+      if (args.persistNetworkIdentity) {
+        try {
+          const enrPath = path.join(bootnodeDir, "enr");
+          writeFile600Perm(enrPath, enr.encodeTxt());
+        } catch (e) {
+          logger.warn("Unable to persist enr", {}, e as Error);
+        }
+      }
+      abortController.abort();
+    }, logger.info.bind(logger));
+
+    abortController.signal.addEventListener(
+      "abort",
+      async () => {
+        try {
+          discv5.removeAllListeners();
+          clearInterval(printInterval);
+
+          await metricsServer?.close();
+          await discv5.stop();
+          logger.debug("Bootnode closed");
+        } catch (e) {
+          logger.error("Error closing bootnode", {}, e as Error);
+          // Must explicitly exit process due to potential active handles
+          process.exit(1);
+        }
+      },
+      {once: true}
+    );
+  } catch (e) {
+    if (e instanceof ErrorAborted) {
+      logger.info(e.message); // Let the user know the abort was received but don't print as error
+    } else {
+      throw e;
+    }
+  }
+}
+
+export type BootNodeInitOptions = {
+  discv5Args: Exclude<IBeaconNodeOptions["network"]["discv5"], null>;
+  metricsArgs: IBeaconNodeOptions["metrics"];
+  bootnodeDir: string;
+  network: string;
+  version: string;
+  commit: string;
+  privateKey: PrivateKey;
+  enr: SignableENR;
+  logger: Logger;
+};
+
+/** Separate function to simplify unit testing of options merging */
+export async function bootnodeHandlerInit(args: BootnodeArgs & GlobalArgs): Promise<BootNodeInitOptions> {
+  const {config, network} = getBeaconConfigFromArgs(args);
+  const {version, commit} = getVersionData();
+  const beaconPaths = getBeaconPaths(args, network);
+  // Use a separate directory to store bootnode enr + peer-id
+  const bootnodeDir = path.join(beaconPaths.dataDir, "bootnode");
+  const {discv5: discv5Args} = parseNetworkArgs(args);
+  const metricsArgs = parseMetricsArgs(args);
+  if (!discv5Args) {
+    // Unreachable because bootnode requires discv5 to be enabled - duh
+    throw new Error("unreachable - bootnode requires discv5 to be enabled");
+  }
+
+  // initialize directories
+  mkdir(beaconPaths.dataDir);
+  mkdir(bootnodeDir);
+
+  // Fetch extra bootnodes
+  discv5Args.bootEnrs = (discv5Args.bootEnrs ?? []).concat(
+    args.bootnodesFile ? readBootnodes(args.bootnodesFile) : [],
+    isKnownNetworkName(network) ? await getNetworkBootnodes(network) : []
+  );
+
+  const logger = initLogger(args, beaconPaths.dataDir, config, "bootnode.log");
+  const {privateKey, enr} = await initPrivateKeyAndEnr(args as unknown as BeaconArgs, bootnodeDir, logger, true);
+
+  return {discv5Args, metricsArgs, bootnodeDir, network, version, commit, privateKey, enr, logger};
+}

package/src/cmds/bootnode/index.ts

@@ -0,0 +1,13 @@
+import {CliCommand, CliCommandOptions} from "@lodestar/utils";
+import {GlobalArgs} from "../../options/index.js";
+import {bootnodeHandler} from "./handler.js";
+import {BootnodeArgs, bootnodeOptions} from "./options.js";
+
+export const bootnode: CliCommand<BootnodeArgs, GlobalArgs> = {
+  command: "bootnode",
+  describe:
+    "Run a discv5 bootnode. This will NOT perform any beacon node functions, rather, it will run a discv5 service that allows nodes on the network to discover one another.",
+  docsFolder: "run/bootnode",
+  options: bootnodeOptions as CliCommandOptions<BootnodeArgs>,
+  handler: bootnodeHandler,
+};