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

package/src/networks/index.ts

@@ -0,0 +1,236 @@
+import fs from "node:fs";
+import {ENR} from "@chainsafe/enr";
+import {WireFormat, getClient} from "@lodestar/api";
+import {getStateSlotFromBytes} from "@lodestar/beacon-node";
+import {ChainConfig, ChainForkConfig} from "@lodestar/config";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {
+  BeaconStateAllForks,
+  computeCheckpointEpochAtStateSlot,
+  getLatestBlockRoot,
+  loadState,
+} from "@lodestar/state-transition";
+import {Slot, sszTypesFor} from "@lodestar/types";
+import {Checkpoint} from "@lodestar/types/phase0";
+import {Logger, callFnWhenAwait, fetch, formatBytes, fromHex} from "@lodestar/utils";
+import {parseBootnodesFile} from "../util/format.js";
+import * as chiado from "./chiado.js";
+import * as dev from "./dev.js";
+import * as ephemery from "./ephemery.js";
+import * as gnosis from "./gnosis.js";
+import * as holesky from "./holesky.js";
+import * as hoodi from "./hoodi.js";
+import * as mainnet from "./mainnet.js";
+import * as sepolia from "./sepolia.js";
+
+export type NetworkName = "mainnet" | "dev" | "gnosis" | "sepolia" | "holesky" | "hoodi" | "chiado" | "ephemery";
+export const networkNames: NetworkName[] = [
+  "mainnet",
+  "gnosis",
+  "sepolia",
+  "holesky",
+  "hoodi",
+  "chiado",
+  "ephemery",
+
+  // Leave always as last network. The order matters for the --help printout
+  "dev",
+];
+
+export function isKnownNetworkName(network: string): network is NetworkName {
+  return networkNames.includes(network as NetworkName);
+}
+
+export type WeakSubjectivityFetchOptions = {
+  weakSubjectivityServerUrl: string;
+  weakSubjectivityCheckpoint?: string;
+};
+
+// log to screen every 30s when downloading state from a lodestar node
+const GET_STATE_LOG_INTERVAL = 30 * 1000;
+
+export function getNetworkData(network: NetworkName): {
+  chainConfig: ChainConfig;
+  depositContractDeployBlock: number;
+  genesisFileUrl: string | null;
+  genesisStateRoot: string | null;
+  bootnodesFileUrl: string | null;
+  bootEnrs: string[];
+} {
+  switch (network) {
+    case "mainnet":
+      return mainnet;
+    case "dev":
+      return dev;
+    case "gnosis":
+      return gnosis;
+    case "sepolia":
+      return sepolia;
+    case "holesky":
+      return holesky;
+    case "hoodi":
+      return hoodi;
+    case "chiado":
+      return chiado;
+    case "ephemery":
+      return ephemery;
+    default:
+      throw Error(`Network not supported: ${network}`);
+  }
+}
+
+export function getNetworkBeaconParams(network: NetworkName): ChainConfig {
+  return getNetworkData(network).chainConfig;
+}
+
+/**
+ * Get genesisStateFile URL to download. Returns null if not available
+ */
+export function getGenesisFileUrl(network: NetworkName): string | null {
+  return getNetworkData(network).genesisFileUrl;
+}
+
+/**
+ * Get expected genesisStateRoot for validation. Returns null if not available.
+ * For example, this returns null for Ephemery, since its genesis state root
+ * changes with each iteration and we don't know the permanent state root.
+ */
+export function getGenesisStateRoot(network: NetworkName | undefined): string | null {
+  if (!network) {
+    return null;
+  }
+  return getNetworkData(network).genesisStateRoot;
+}
+
+/**
+ * Fetches the latest list of bootnodes for a network
+ * Bootnodes file is expected to contain bootnode ENR's concatenated by newlines
+ */
+export async function fetchBootnodes(network: NetworkName): Promise<string[]> {
+  const bootnodesFileUrl = getNetworkData(network).bootnodesFileUrl;
+  if (bootnodesFileUrl === null) {
+    return [];
+  }
+
+  const res = await fetch(bootnodesFileUrl);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch bootnodes: ${res.status} ${res.statusText}`);
+  }
+  const bootnodesFile = await res.text();
+  return parseBootnodesFile(bootnodesFile);
+}
+
+export async function getNetworkBootnodes(network: NetworkName): Promise<string[]> {
+  const bootnodes = [...getNetworkData(network).bootEnrs];
+
+  // Hidden option for testing
+  if (!process.env.SKIP_FETCH_NETWORK_BOOTNODES) {
+    try {
+      const bootEnrs = await fetchBootnodes(network);
+      bootnodes.push(...bootEnrs);
+    } catch (e) {
+      console.error(`Error fetching latest bootnodes: ${(e as Error).stack}`);
+    }
+  }
+
+  return bootnodes;
+}
+
+/**
+ * Reads and parses a list of bootnodes for a network from a file.
+ */
+export function readBootnodes(bootnodesFilePath: string): string[] {
+  const bootnodesFile = fs.readFileSync(bootnodesFilePath, "utf8");
+
+  const bootnodes = parseBootnodesFile(bootnodesFile);
+  for (const enrStr of bootnodes) {
+    try {
+      ENR.decodeTxt(enrStr);
+    } catch (_e) {
+      throw new Error(`Invalid ENR found in ${bootnodesFilePath}:\n    ${enrStr}`);
+    }
+  }
+
+  if (bootnodes.length === 0) {
+    throw new Error(`No bootnodes found on file ${bootnodesFilePath}`);
+  }
+
+  return bootnodes;
+}
+
+/**
+ * Fetch weak subjectivity state from a remote beacon node
+ */
+export async function fetchWeakSubjectivityState(
+  config: ChainForkConfig,
+  logger: Logger,
+  {checkpointSyncUrl, wssCheckpoint}: {checkpointSyncUrl: string; wssCheckpoint?: string},
+  {
+    lastDbState,
+    lastDbValidatorsBytes,
+  }: {lastDbState: BeaconStateAllForks | null; lastDbValidatorsBytes: Uint8Array | null}
+): Promise<{wsState: BeaconStateAllForks; wsStateBytes: Uint8Array; wsCheckpoint: Checkpoint}> {
+  try {
+    let wsCheckpoint: Checkpoint | null;
+    let stateId: Slot | "finalized";
+
+    const api = getClient({baseUrl: checkpointSyncUrl}, {config});
+    if (wssCheckpoint) {
+      wsCheckpoint = getCheckpointFromArg(wssCheckpoint);
+      stateId = wsCheckpoint.epoch * SLOTS_PER_EPOCH;
+    } else {
+      // Fetch current finalized state and extract checkpoint from it
+      stateId = "finalized";
+      wsCheckpoint = null;
+    }
+
+    // getStateV2 should be available for all forks including phase0
+    const getStatePromise = api.debug.getStateV2({stateId}, {responseWireFormat: WireFormat.ssz});
+
+    const {wsStateBytes, fork} = await callFnWhenAwait(
+      getStatePromise,
+      () => logger.info("Download in progress, please wait..."),
+      GET_STATE_LOG_INTERVAL
+    ).then((res) => {
+      return {wsStateBytes: res.ssz(), fork: res.meta().version};
+    });
+
+    const wsSlot = getStateSlotFromBytes(wsStateBytes);
+    const logData = {stateId, size: formatBytes(wsStateBytes.length)};
+    logger.info("Download completed", typeof stateId === "number" ? logData : {...logData, slot: wsSlot});
+
+    let wsState: BeaconStateAllForks;
+    if (lastDbState && lastDbValidatorsBytes) {
+      // use lastDbState to load wsState if possible to share the same state tree
+      wsState = loadState(config, lastDbState, wsStateBytes, lastDbValidatorsBytes).state;
+    } else {
+      wsState = sszTypesFor(fork).BeaconState.deserializeToViewDU(wsStateBytes);
+    }
+
+    return {
+      wsState,
+      wsStateBytes,
+      wsCheckpoint: wsCheckpoint ?? getCheckpointFromState(wsState),
+    };
+  } catch (e) {
+    throw new Error("Unable to fetch weak subjectivity state: " + (e as Error).message);
+  }
+}
+
+export function getCheckpointFromArg(checkpointStr: string): Checkpoint {
+  const checkpointRegex = /^(?:0x)?([0-9a-f]{64}):([0-9]+)$/;
+  const match = checkpointRegex.exec(checkpointStr.toLowerCase());
+  if (!match) {
+    throw new Error(`Could not parse checkpoint string: ${checkpointStr}`);
+  }
+  return {root: fromHex(match[1]), epoch: parseInt(match[2])};
+}
+
+export function getCheckpointFromState(state: BeaconStateAllForks): Checkpoint {
+  return {
+    // the correct checkpoint is based on state's slot, its latestBlockHeader's slot's epoch can be
+    // behind the state
+    epoch: computeCheckpointEpochAtStateSlot(state.slot),
+    root: getLatestBlockRoot(state),
+  };
+}

package/src/networks/mainnet.ts

@@ -0,0 +1,34 @@
+export {mainnetChainConfig as chainConfig} from "@lodestar/config/networks";
+
+export const depositContractDeployBlock = 11052984;
+export const genesisFileUrl =
+  "https://raw.githubusercontent.com/eth-clients/mainnet/refs/heads/main/metadata/genesis.ssz";
+export const genesisStateRoot = "0x7e76880eb67bbdc86250aa578958e9d0675e64e714337855204fb5abaaf82c2b";
+export const bootnodesFileUrl =
+  "https://raw.githubusercontent.com/eth-clients/mainnet/refs/heads/main/metadata/bootstrap_nodes.yaml";
+
+export const bootEnrs = [
+  // Teku team's bootnodes
+  "enr:-Iu4QLm7bZGdAt9NSeJG0cEnJohWcQTQaI9wFLu3Q7eHIDfrI4cwtzvEW3F3VbG9XdFXlrHyFGeXPn9snTCQJ9bnMRABgmlkgnY0gmlwhAOTJQCJc2VjcDI1NmsxoQIZdZD6tDYpkpEfVo5bgiU8MGRjhcOmHGD2nErK0UKRrIN0Y3CCIyiDdWRwgiMo",
+  "enr:-Iu4QEDJ4Wa_UQNbK8Ay1hFEkXvd8psolVK6OhfTL9irqz3nbXxxWyKwEplPfkju4zduVQj6mMhUCm9R2Lc4YM5jPcIBgmlkgnY0gmlwhANrfESJc2VjcDI1NmsxoQJCYz2-nsqFpeEj6eov9HSi9QssIVIVNr0I89J1vXM9foN0Y3CCIyiDdWRwgiMo",
+  // Prylab team's bootnodes
+  "enr:-Ku4QImhMc1z8yCiNJ1TyUxdcfNucje3BGwEHzodEZUan8PherEo4sF7pPHPSIB1NNuSg5fZy7qFsjmUKs2ea1Whi0EBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpD1pf1CAAAAAP__________gmlkgnY0gmlwhBLf22SJc2VjcDI1NmsxoQOVphkDqal4QzPMksc5wnpuC3gvSC8AfbFOnZY_On34wIN1ZHCCIyg",
+  "enr:-Ku4QP2xDnEtUXIjzJ_DhlCRN9SN99RYQPJL92TMlSv7U5C1YnYLjwOQHgZIUXw6c-BvRg2Yc2QsZxxoS_pPRVe0yK8Bh2F0dG5ldHOIAAAAAAAAAACEZXRoMpD1pf1CAAAAAP__________gmlkgnY0gmlwhBLf22SJc2VjcDI1NmsxoQMeFF5GrS7UZpAH2Ly84aLK-TyvH-dRo0JM1i8yygH50YN1ZHCCJxA",
+  "enr:-Ku4QPp9z1W4tAO8Ber_NQierYaOStqhDqQdOPY3bB3jDgkjcbk6YrEnVYIiCBbTxuar3CzS528d2iE7TdJsrL-dEKoBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpD1pf1CAAAAAP__________gmlkgnY0gmlwhBLf22SJc2VjcDI1NmsxoQMw5fqqkw2hHC4F5HZZDPsNmPdB1Gi8JPQK7pRc9XHh-oN1ZHCCKvg",
+  // Lighthouse team's bootnodes
+  "enr:-Le4QPUXJS2BTORXxyx2Ia-9ae4YqA_JWX3ssj4E_J-3z1A-HmFGrU8BpvpqhNabayXeOZ2Nq_sbeDgtzMJpLLnXFgAChGV0aDKQtTA_KgEAAAAAIgEAAAAAAIJpZIJ2NIJpcISsaa0Zg2lwNpAkAIkHAAAAAPA8kv_-awoTiXNlY3AyNTZrMaEDHAD2JKYevx89W0CcFJFiskdcEzkH_Wdv9iW42qLK79ODdWRwgiMohHVkcDaCI4I",
+  "enr:-Le4QLHZDSvkLfqgEo8IWGG96h6mxwe_PsggC20CL3neLBjfXLGAQFOPSltZ7oP6ol54OvaNqO02Rnvb8YmDR274uq8ChGV0aDKQtTA_KgEAAAAAIgEAAAAAAIJpZIJ2NIJpcISLosQxg2lwNpAqAX4AAAAAAPA8kv_-ax65iXNlY3AyNTZrMaEDBJj7_dLFACaxBfaI8KZTh_SSJUjhyAyfshimvSqo22WDdWRwgiMohHVkcDaCI4I",
+  "enr:-Le4QH6LQrusDbAHPjU_HcKOuMeXfdEB5NJyXgHWFadfHgiySqeDyusQMvfphdYWOzuSZO9Uq2AMRJR5O4ip7OvVma8BhGV0aDKQtTA_KgEAAAAAIgEAAAAAAIJpZIJ2NIJpcISLY9ncg2lwNpAkAh8AgQIBAAAAAAAAAAmXiXNlY3AyNTZrMaECDYCZTZEksF-kmgPholqgVt8IXr-8L7Nu7YrZ7HUpgxmDdWRwgiMohHVkcDaCI4I",
+  "enr:-Le4QIqLuWybHNONr933Lk0dcMmAB5WgvGKRyDihy1wHDIVlNuuztX62W51voT4I8qD34GcTEOTmag1bcdZ_8aaT4NUBhGV0aDKQtTA_KgEAAAAAIgEAAAAAAIJpZIJ2NIJpcISLY04ng2lwNpAkAh8AgAIBAAAAAAAAAA-fiXNlY3AyNTZrMaEDscnRV6n1m-D9ID5UsURk0jsoKNXt1TIrj8uKOGW6iluDdWRwgiMohHVkcDaCI4I",
+  // EF bootnodes
+  "enr:-Ku4QHqVeJ8PPICcWk1vSn_XcSkjOkNiTg6Fmii5j6vUQgvzMc9L1goFnLKgXqBJspJjIsB91LTOleFmyWWrFVATGngBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhAMRHkWJc2VjcDI1NmsxoQKLVXFOhp2uX6jeT0DvvDpPcU8FWMjQdR4wMuORMhpX24N1ZHCCIyg",
+  "enr:-Ku4QG-2_Md3sZIAUebGYT6g0SMskIml77l6yR-M_JXc-UdNHCmHQeOiMLbylPejyJsdAPsTHJyjJB2sYGDLe0dn8uYBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhBLY-NyJc2VjcDI1NmsxoQORcM6e19T1T9gi7jxEZjk_sjVLGFscUNqAY9obgZaxbIN1ZHCCIyg",
+  "enr:-Ku4QPn5eVhcoF1opaFEvg1b6JNFD2rqVkHQ8HApOKK61OIcIXD127bKWgAtbwI7pnxx6cDyk_nI88TrZKQaGMZj0q0Bh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhDayLMaJc2VjcDI1NmsxoQK2sBOLGcUb4AwuYzFuAVCaNHA-dy24UuEKkeFNgCVCsIN1ZHCCIyg",
+  "enr:-Ku4QEWzdnVtXc2Q0ZVigfCGggOVB2Vc1ZCPEc6j21NIFLODSJbvNaef1g4PxhPwl_3kax86YPheFUSLXPRs98vvYsoBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhDZBrP2Jc2VjcDI1NmsxoQM6jr8Rb1ktLEsVcKAPa08wCsKUmvoQ8khiOl_SLozf9IN1ZHCCIyg",
+  // Nimbus team's bootnodes
+  "enr:-LK4QA8FfhaAjlb_BXsXxSfiysR7R52Nhi9JBt4F8SPssu8hdE1BXQQEtVDC3qStCW60LSO7hEsVHv5zm8_6Vnjhcn0Bh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhAN4aBKJc2VjcDI1NmsxoQJerDhsJ-KxZ8sHySMOCmTO6sHM3iCFQ6VMvLTe948MyYN0Y3CCI4yDdWRwgiOM",
+  "enr:-LK4QKWrXTpV9T78hNG6s8AM6IO4XH9kFT91uZtFg1GcsJ6dKovDOr1jtAAFPnS2lvNltkOGA9k29BUN7lFh_sjuc9QBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhANAdd-Jc2VjcDI1NmsxoQLQa6ai7y9PMN5hpLe5HmiJSlYzMuzP7ZhwRiwHvqNXdoN0Y3CCI4yDdWRwgiOM",
+  // Lodestar team's bootnodes
+  "enr:-IS4QPi-onjNsT5xAIAenhCGTDl4z-4UOR25Uq-3TmG4V3kwB9ljLTb_Kp1wdjHNj-H8VVLRBSSWVZo3GUe3z6k0E-IBgmlkgnY0gmlwhKB3_qGJc2VjcDI1NmsxoQMvAfgB4cJXvvXeM6WbCG86CstbSxbQBSGx31FAwVtOTYN1ZHCCIyg",
+  "enr:-KG4QCb8NC3gEM3I0okStV5BPX7Bg6ZXTYCzzbYyEXUPGcZtHmvQtiJH4C4F2jG7azTcb9pN3JlgpfxAnRVFzJ3-LykBgmlkgnY0gmlwhFPlR9KDaXA2kP6AAAAAAAAAAlBW__4my5iJc2VjcDI1NmsxoQLdUv9Eo9sxCt0tc_CheLOWnX59yHJtkBSOL7kpxdJ6GYN1ZHCCIyiEdWRwNoIjKA",
+];

package/src/networks/sepolia.ts

@@ -0,0 +1,17 @@
+export {sepoliaChainConfig as chainConfig} from "@lodestar/config/networks";
+
+export const depositContractDeployBlock = 1273020;
+export const genesisFileUrl = "https://github.com/eth-clients/sepolia/raw/main/metadata/genesis.ssz";
+export const genesisStateRoot = "0xfb9afe32150fa39f4b346be2519a67e2a4f5efcd50a1dc192c3f6b3d013d2798";
+export const bootnodesFileUrl =
+  "https://raw.githubusercontent.com/eth-clients/sepolia/main/metadata/bootstrap_nodes.yaml";
+
+export const bootEnrs = [
+  "enr:-KO4QP7MmB3juk8rUjJHcUoxZDU9Np4FlW0HyDEGIjSO7GD9PbSsabu7713cWSUWKDkxIypIXg1A-6lG7ySRGOMZHeGCAmuEZXRoMpDTH2GRkAAAc___________gmlkgnY0gmlwhBSoyGOJc2VjcDI1NmsxoQNta5b_bexSSwwrGW2Re24MjfMntzFd0f2SAxQtMj3ueYN0Y3CCIyiDdWRwgiMo",
+  "enr:-Ku4QDZ_rCowZFsozeWr60WwLgOfHzv1Fz2cuMvJqN5iJzLxKtVjoIURY42X_YTokMi3IGstW5v32uSYZyGUXj9Q_IECh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhIpEe5iJc2VjcDI1NmsxoQNHTpFdaNSCEWiN_QqT396nb0PzcUpLe3OVtLph-AciBYN1ZHCCIy0",
+  "enr:-Ku4QHRyRwEPT7s0XLYzJ_EeeWvZTXBQb4UCGy1F_3m-YtCNTtDlGsCMr4UTgo4uR89pv11uM-xq4w6GKfKhqU31hTgCh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhIrFM7WJc2VjcDI1NmsxoQI4diTwChN3zAAkarf7smOHCdFb1q3DSwdiQ_Lc_FdzFIN1ZHCCIy0",
+  "enr:-Ku4QOkvvf0u5Hg4-HhY-SJmEyft77G5h3rUM8VF_e-Hag5cAma3jtmFoX4WElLAqdILCA-UWFRN1ZCDJJVuEHrFeLkDh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhJK-AWeJc2VjcDI1NmsxoQLFcT5VE_NMiIC8Ll7GypWDnQ4UEmuzD7hF_Hf4veDJwIN1ZHCCIy0",
+  "enr:-Ku4QH6tYsHKITYeHUu5kdfXgEZWI18EWk_2RtGOn1jBPlx2UlS_uF3Pm5Dx7tnjOvla_zs-wwlPgjnEOcQDWXey51QCh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhIs7Mc6Jc2VjcDI1NmsxoQIET4Mlv9YzhrYhX_H9D7aWMemUrvki6W4J2Qo0YmFMp4N1ZHCCIy0",
+  "enr:-Ku4QDmz-4c1InchGitsgNk4qzorWMiFUoaPJT4G0IiF8r2UaevrekND1o7fdoftNucirj7sFFTTn2-JdC2Ej0p1Mn8Ch2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhKpA-liJc2VjcDI1NmsxoQMpHP5U1DK8O_JQU6FadmWbE42qEdcGlllR8HcSkkfWq4N1ZHCCIy0",
+  "enr:-KG4QJejf8KVtMeAPWFhN_P0c4efuwu1pZHELTveiXUeim6nKYcYcMIQpGxxdgT2Xp9h-M5pr9gn2NbbwEAtxzu50Y8BgmlkgnY0gmlwhEEVkQCDaXA2kCoBBPnAEJg4AAAAAAAAAAGJc2VjcDI1NmsxoQLEh_eVvk07AQABvLkTGBQTrrIOQkzouMgSBtNHIRUxOIN1ZHCCIyiEdWRwNoIjKA",
+];

package/src/options/beaconNodeOptions/api.ts

@@ -0,0 +1,110 @@
+import {IBeaconNodeOptions, allNamespaces, defaultOptions} from "@lodestar/beacon-node";
+import {CliCommandOptions} from "@lodestar/utils";
+
+const enabledAll = "*";
+
+export type ApiArgs = {
+  "api.maxGindicesInProof"?: number;
+  "rest.namespace"?: string[];
+  "rest.cors"?: string;
+  rest: boolean;
+  "rest.address"?: string;
+  "rest.port": number;
+  "rest.headerLimit"?: number;
+  "rest.bodyLimit"?: number;
+  "rest.stacktraces"?: boolean;
+  "rest.swaggerUI"?: boolean;
+};
+
+export function parseArgs(args: ApiArgs): IBeaconNodeOptions["api"] {
+  return {
+    maxGindicesInProof: args["api.maxGindicesInProof"],
+    rest: {
+      api: args["rest.namespace"] as IBeaconNodeOptions["api"]["rest"]["api"],
+      cors: args["rest.cors"],
+      enabled: args.rest,
+      address: args["rest.address"],
+      port: args["rest.port"],
+      headerLimit: args["rest.headerLimit"],
+      bodyLimit: args["rest.bodyLimit"],
+      stacktraces: args["rest.stacktraces"],
+      swaggerUI: args["rest.swaggerUI"],
+    },
+  };
+}
+
+export const options: CliCommandOptions<ApiArgs> = {
+  rest: {
+    type: "boolean",
+    description: "Enable/disable HTTP API",
+    default: defaultOptions.api.rest.enabled,
+    group: "api",
+  },
+
+  "api.maxGindicesInProof": {
+    hidden: true,
+    type: "number",
+    description: "Limit max number of gindices in a single proof request. DoS vector protection",
+    defaultDescription: String(defaultOptions.api.maxGindicesInProof),
+    group: "api",
+  },
+
+  "rest.namespace": {
+    type: "array",
+    choices: [...allNamespaces, enabledAll],
+    description: `Pick namespaces to expose for HTTP API. Set to '${enabledAll}' to enable all namespaces`,
+    defaultDescription: JSON.stringify(defaultOptions.api.rest.api),
+    group: "api",
+    coerce: (namespaces: string[]): string[] => {
+      // Enable all
+      if (namespaces.includes(enabledAll)) return allNamespaces;
+      // Parse ["debug,lodestar"] to ["debug", "lodestar"]
+      return namespaces.flatMap((val) => val.split(","));
+    },
+  },
+
+  "rest.cors": {
+    type: "string",
+    description: "Configures the Access-Control-Allow-Origin CORS header for HTTP API",
+    defaultDescription: defaultOptions.api.rest.cors,
+    group: "api",
+  },
+
+  "rest.address": {
+    type: "string",
+    description: "Set host for HTTP API",
+    defaultDescription: defaultOptions.api.rest.address,
+    group: "api",
+  },
+
+  "rest.port": {
+    type: "number",
+    description: "Set port for HTTP API",
+    default: defaultOptions.api.rest.port,
+    group: "api",
+  },
+  "rest.headerLimit": {
+    hidden: true,
+    type: "number",
+    description: "Defines the maximum length of request headers, in bytes, the server is allowed to accept",
+  },
+  "rest.bodyLimit": {
+    hidden: true,
+    type: "number",
+    description: "Defines the maximum payload, in bytes, the server is allowed to accept",
+  },
+
+  "rest.stacktraces": {
+    hidden: true,
+    type: "boolean",
+    description: "Return stacktraces in HTTP error responses",
+    group: "api",
+  },
+
+  "rest.swaggerUI": {
+    type: "boolean",
+    description: "Enable Swagger UI for API exploration at http://{address}:{port}/documentation",
+    default: Boolean(defaultOptions.api.rest.swaggerUI),
+    group: "api",
+  },
+};

package/src/options/beaconNodeOptions/builder.ts

@@ -0,0 +1,63 @@
+import {IBeaconNodeOptions, defaultExecutionBuilderHttpOpts} from "@lodestar/beacon-node";
+import {CliCommandOptions} from "@lodestar/utils";
+import {YargsError} from "../../util/index.js";
+
+export type ExecutionBuilderArgs = {
+  builder: boolean;
+  "builder.url"?: string;
+  "builder.timeout"?: number;
+  "builder.faultInspectionWindow"?: number;
+  "builder.allowedFaults"?: number;
+};
+
+export function parseArgs(args: ExecutionBuilderArgs): IBeaconNodeOptions["executionBuilder"] {
+  if (Array.isArray(args["builder.url"]) || args["builder.url"]?.includes(",http")) {
+    throw new YargsError(
+      "Lodestar only supports a single builder URL. External tooling like mev-boost can be used to connect to multiple builder/relays"
+    );
+  }
+
+  return {
+    enabled: args.builder,
+    url: args["builder.url"] ?? defaultExecutionBuilderHttpOpts.url,
+    timeout: args["builder.timeout"],
+    faultInspectionWindow: args["builder.faultInspectionWindow"],
+    allowedFaults: args["builder.allowedFaults"],
+  };
+}
+
+export const options: CliCommandOptions<ExecutionBuilderArgs> = {
+  builder: {
+    description: "Enable external builder",
+    type: "boolean",
+    default: defaultExecutionBuilderHttpOpts.enabled,
+    group: "builder",
+  },
+
+  "builder.url": {
+    alias: ["builder.urls"],
+    description: "Url hosting the builder API",
+    defaultDescription: defaultExecutionBuilderHttpOpts.url,
+    type: "string",
+    group: "builder",
+  },
+
+  "builder.timeout": {
+    description: "Timeout in milliseconds for builder API HTTP client",
+    type: "number",
+    defaultDescription: String(defaultExecutionBuilderHttpOpts.timeout),
+    group: "builder",
+  },
+
+  "builder.faultInspectionWindow": {
+    type: "number",
+    description: "Window to inspect missed slots for enabling/disabling builder circuit breaker",
+    group: "builder",
+  },
+
+  "builder.allowedFaults": {
+    type: "number",
+    description: "Number of missed slots allowed in the `faultInspectionWindow` for builder circuit",
+    group: "builder",
+  },
+};