@chainsafe/lodestar 1.35.0-dev.8644a83c62 → 1.35.0-dev.8961b06c11

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,
+};

package/src/cmds/bootnode/options.ts

@@ -0,0 +1,109 @@
+import {CliCommandOptions, CliOptionDefinition} from "@lodestar/utils";
+import {MetricsArgs, options as metricsOptions} from "../../options/beaconNodeOptions/metrics.js";
+import {defaultListenAddress, defaultListenAddress6, defaultP2pPort} from "../../options/beaconNodeOptions/network.js";
+import {LogArgs, logOptions} from "../../options/logOptions.js";
+
+type BootnodeExtraArgs = {
+  listenAddress?: string;
+  port?: number;
+  listenAddress6?: string;
+  port6?: number;
+  bootnodes?: string[];
+  bootnodesFile?: string;
+  persistNetworkIdentity?: boolean;
+  "enr.ip"?: string;
+  "enr.ip6"?: string;
+  "enr.udp"?: number;
+  "enr.udp6"?: number;
+  nat?: boolean;
+};
+
+export const bootnodeExtraOptions: CliCommandOptions<BootnodeExtraArgs> = {
+  listenAddress: {
+    type: "string",
+    description: "The IPv4 address to listen for discv5 connections",
+    defaultDescription: defaultListenAddress,
+    group: "network",
+  },
+
+  port: {
+    alias: "discoveryPort",
+    description: "The UDP port to listen on",
+    type: "number",
+    defaultDescription: String(defaultP2pPort),
+    group: "network",
+  },
+
+  listenAddress6: {
+    type: "string",
+    description: "The IPv6 address to listen for discv5 connections",
+    defaultDescription: defaultListenAddress6,
+    group: "network",
+  },
+
+  port6: {
+    alias: "discoveryPort6",
+    description: "The UDP port to listen on",
+    type: "number",
+    defaultDescription: String(defaultP2pPort),
+    group: "network",
+  },
+
+  bootnodes: {
+    type: "array",
+    description: "Additional bootnodes for discv5 discovery",
+    defaultDescription: JSON.stringify([]),
+    // Each bootnode entry could be comma separated, just deserialize it into a single array
+    // as comma separated entries are generally most friendly in ansible kind of setups, i.e.
+    // [ "en1", "en2,en3" ] => [ 'en1', 'en2', 'en3' ]
+    coerce: (args: string[]) => args.flatMap((item) => item.split(",")),
+    group: "network",
+  },
+
+  bootnodesFile: {
+    description: "Additional bootnodes for discv5 discovery file path",
+    type: "string",
+    group: "network",
+  },
+
+  persistNetworkIdentity: {
+    description: "Whether to reuse the same peer-id across restarts",
+    default: true,
+    type: "boolean",
+    group: "network",
+  },
+
+  "enr.ip": {
+    description: "Override ENR IP entry",
+    type: "string",
+    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.udp6": {
+    description: "Override ENR (IPv6-specific) UDP entry",
+    type: "number",
+    group: "enr",
+  },
+  nat: {
+    type: "boolean",
+    description: "Allow ENR configuration of non-local addresses",
+    group: "enr",
+  },
+};
+
+export type BootnodeArgs = BootnodeExtraArgs & LogArgs & MetricsArgs;
+
+export const bootnodeOptions: {[k: string]: CliOptionDefinition} = {
+  ...bootnodeExtraOptions,
+  ...logOptions,
+  ...metricsOptions,
+};

package/src/cmds/dev/files.ts

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import path from "node:path";
+import {Keystore} from "@chainsafe/bls-keystore";
+import {nodeUtils} from "@lodestar/beacon-node";
+import {ChainForkConfig, chainConfigToJson} from "@lodestar/config";
+import {interopSecretKey} from "@lodestar/state-transition";
+import {dumpYaml} from "@lodestar/utils";
+import {PersistedKeysBackend} from "../validator/keymanager/persistedKeys.js";
+
+export async function writeTestnetFiles(
+  config: ChainForkConfig,
+  targetDir: string,
+  genesisValidators: number
+): Promise<void> {
+  const genesisTime = Math.floor(Date.now() / 1000);
+  const eth1BlockHash = Buffer.alloc(32, 0);
+
+  const {state} = nodeUtils.initDevState(config, genesisValidators, {genesisTime, eth1BlockHash});
+
+  // Write testnet data
+  fs.mkdirSync(targetDir, {recursive: true});
+  fs.writeFileSync(path.join(targetDir, "genesis.ssz"), state.serialize());
+  fs.writeFileSync(path.join(targetDir, "config.yaml"), dumpYaml(chainConfigToJson(config)));
+  fs.writeFileSync(path.join(targetDir, "deploy_block.txt"), "0");
+
+  const persistedKeystoresBackend = new PersistedKeysBackend({
+    keystoresDir: path.join(targetDir, "keystores"),
+    secretsDir: path.join(targetDir, "secrets"),
+    remoteKeysDir: path.join(targetDir, "remote_keys"),
+    proposerDir: path.join(targetDir, "proposer"),
+  });
+
+  const password = "test_password";
+
+  // Write keystores
+  for (let i = 0; i < genesisValidators; i++) {
+    console.log(`Generating keystore ${i}`);
+
+    const sk = interopSecretKey(i);
+
+    const keystore = await Keystore.create(password, sk.toBytes(), sk.toPublicKey().toBytes(), "");
+
+    persistedKeystoresBackend.writeKeystore({
+      keystoreStr: keystore.stringify(),
+      password,
+      // Not used immediately
+      lockBeforeWrite: false,
+      // Return duplicate status if already found
+      persistIfDuplicate: false,
+    });
+  }
+}

package/src/cmds/dev/handler.ts

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import {rimraf} from "rimraf";
+import {nodeUtils} from "@lodestar/beacon-node";
+import {fromHex, toHex} from "@lodestar/utils";
+import {getBeaconConfigFromArgs} from "../../config/beaconParams.js";
+import {GlobalArgs} from "../../options/index.js";
+import {mkdir, onGracefulShutdown} from "../../util/index.js";
+import {beaconHandler} from "../beacon/handler.js";
+import {getBeaconPaths} from "../beacon/paths.js";
+import {validatorHandler} from "../validator/handler.js";
+import {getValidatorPaths} from "../validator/paths.js";
+import {writeTestnetFiles} from "./files.js";
+import {IDevArgs} from "./options.js";
+
+/**
+ * Run a beacon node with validator
+ */
+export async function devHandler(args: IDevArgs & GlobalArgs): Promise<void> {
+  const {config} = getBeaconConfigFromArgs(args);
+
+  if (args.dumpTestnetFiles) {
+    await writeTestnetFiles(config, args.dumpTestnetFiles, args.genesisValidators);
+    return;
+  }
+
+  // TODO: Is this necessary?
+  const network = "dev";
+  if (args.network && args.network !== network) {
+    throw Error(`Must not run dev command with network '${args.network}', only 'dev' network`);
+  }
+
+  // Note: defaults to network "dev", to all paths are custom and don't conflict with networks.
+  // Flag --reset cleans up the custom dirs on dev stop
+  const beaconDbDir = getBeaconPaths(args, network).dbDir;
+  const validatorsDbDir = getValidatorPaths(args, network).validatorsDbDir;
+
+  // Remove slashing protection db. Otherwise the validators won't be able to propose nor attest
+  // until the clock reach a higher slot than the previous run of the dev command
+  if (args.genesisTime === undefined) {
+    await rimraf(beaconDbDir);
+    await rimraf(validatorsDbDir);
+  }
+
+  mkdir(beaconDbDir);
+  mkdir(validatorsDbDir);
+
+  if (args.reset) {
+    onGracefulShutdown(async () => {
+      await rimraf(beaconDbDir);
+      await rimraf(validatorsDbDir);
+    });
+  }
+
+  // To be able to recycle beacon handler pass the genesis state via file
+  if (args.genesisStateFile) {
+    // Already set, skip
+  } else {
+    // Generate and write state to disk
+    const validatorCount = args.genesisValidators ?? 8;
+    const genesisTime = args.genesisTime ?? Math.floor(Date.now() / 1000) + 5;
+    const eth1BlockHash = fromHex(args.genesisEth1Hash ?? toHex(Buffer.alloc(32, 0x0b)));
+
+    const {state} = nodeUtils.initDevState(config, validatorCount, {genesisTime, eth1BlockHash});
+
+    args.genesisStateFile = "genesis.ssz";
+    fs.writeFileSync(args.genesisStateFile, state.serialize());
+
+    // Set logger format to Eph with provided genesisTime
+    if (args.logFormatGenesisTime === undefined) args.logFormatGenesisTime = genesisTime;
+  }
+
+  // Note: recycle entire beacon handler
+  await beaconHandler(args);
+
+  if (args.startValidators) {
+    // TODO: Map dev option to validator's option
+    args.interopIndexes = args.startValidators;
+
+    // Note: recycle entire validator handler:
+    // - keystore handling
+    // - metrics
+    // - monitoring
+    // - keymanager server
+    await validatorHandler(args);
+  }
+}

package/src/cmds/dev/index.ts

@@ -0,0 +1,18 @@
+import {CliCommand, CliCommandOptions} from "@lodestar/utils";
+import {GlobalArgs} from "../../options/index.js";
+import {devHandler} from "./handler.js";
+import {IDevArgs, devOptions} from "./options.js";
+
+export const dev: CliCommand<IDevArgs, GlobalArgs> = {
+  command: "dev",
+  describe: "Quickly bootstrap a beacon node and multiple validators. Use for development and testing",
+  docsFolder: "contribution",
+  examples: [
+    {
+      command: "dev --genesisValidators 8 --reset",
+      description: "Start a single beacon node with 8 interop validators",
+    },
+  ],
+  options: devOptions as CliCommandOptions<IDevArgs>,
+  handler: devHandler,
+};

package/src/cmds/dev/options.ts

@@ -0,0 +1,110 @@
+import {CliCommandOptions, CliOptionDefinition} from "@lodestar/utils";
+import {NetworkName} from "../../networks/index.js";
+import {beaconNodeOptions, globalOptions} from "../../options/index.js";
+import {BeaconArgs, beaconOptions} from "../beacon/options.js";
+import {IValidatorCliArgs, validatorOptions} from "../validator/options.js";
+
+type IDevOwnArgs = {
+  genesisEth1Hash?: string;
+  genesisValidators: number;
+  startValidators?: string;
+  genesisTime?: number;
+  reset?: boolean;
+  dumpTestnetFiles?: string;
+};
+
+const devOwnOptions: CliCommandOptions<IDevOwnArgs> = {
+  genesisEth1Hash: {
+    description: "If present it will create genesis with this eth1 hash.",
+    type: "string",
+    group: "dev",
+  },
+
+  genesisValidators: {
+    alias: ["c"],
+    description: "If present it will create genesis with interop validators and start chain.",
+    default: 8,
+    type: "number",
+    group: "dev",
+  },
+
+  startValidators: {
+    description: "Start interop validators in inclusive range with notation '0..7'",
+    type: "string",
+    group: "dev",
+  },
+
+  genesisTime: {
+    description: "genesis_time to initialize interop genesis state",
+    defaultDescription: "now",
+    type: "number",
+    group: "dev",
+  },
+
+  reset: {
+    description: "To delete chain and validator directories",
+    alias: ["r"],
+    type: "boolean",
+    group: "dev",
+  },
+
+  dumpTestnetFiles: {
+    description: "Dump testnet files and exit",
+    type: "string",
+    group: "dev",
+  },
+};
+
+/**
+ * Add custom defaults different than the ones in `beaconOptions`:
+ * - In dev command we don't wanna connect to other peers,
+ * - but we do wanna get out of syncing (min peers)
+ * - and have api enabled by default (as it's used by validator)
+ * Note: use beaconNodeOptions and globalOptions to make sure option key is correct
+ */
+const externalOptionsOverrides: Partial<Record<"network" | keyof typeof beaconNodeOptions, CliOptionDefinition>> = {
+  // Custom paths different than regular beacon, validator paths
+  // network="dev" will store all data in separate dir than other networks
+  network: {
+    ...globalOptions.network,
+    default: "dev" as NetworkName,
+  },
+
+  "sync.isSingleNode": {
+    ...beaconNodeOptions["sync.isSingleNode"],
+    defaultDescription: undefined,
+    default: true,
+  },
+  "network.allowPublishToZeroPeers": {
+    ...beaconNodeOptions["network.allowPublishToZeroPeers"],
+    defaultDescription: undefined,
+    default: true,
+  },
+  eth1: {
+    ...beaconNodeOptions.eth1,
+    defaultDescription: undefined,
+    default: false,
+  },
+  rest: {
+    ...beaconNodeOptions.rest,
+    defaultDescription: undefined,
+    default: true,
+  },
+  "rest.stacktraces": {
+    ...beaconNodeOptions["rest.stacktraces"],
+    default: true,
+  },
+  "rest.swaggerUI": {
+    ...beaconNodeOptions["rest.swaggerUI"],
+    default: true,
+  },
+};
+
+export const devOptions = {
+  ...beaconOptions,
+  ...validatorOptions,
+  ...externalOptionsOverrides,
+  ...devOwnOptions,
+};
+
+export type IDevArgs = BeaconArgs & IValidatorCliArgs & IDevOwnArgs;

package/src/cmds/index.ts

@@ -0,0 +1,15 @@
+import {CliCommand} from "@lodestar/utils";
+import {GlobalArgs} from "../options/index.js";
+import {beacon} from "./beacon/index.js";
+import {bootnode} from "./bootnode/index.js";
+import {dev} from "./dev/index.js";
+import {lightclient} from "./lightclient/index.js";
+import {validator} from "./validator/index.js";
+
+export const cmds: Required<CliCommand<GlobalArgs, Record<never, never>>>["subcommands"] = [
+  beacon,
+  validator,
+  lightclient,
+  dev,
+  bootnode,
+];