@chainsafe/lodestar 1.35.0-dev.e9dd48f165 → 1.35.0-dev.fcf8d024ea

package/src/options/beaconNodeOptions/network.ts

@@ -0,0 +1,401 @@
+import {multiaddr} from "@multiformats/multiaddr";
+import {ENR} from "@chainsafe/enr";
+import {IBeaconNodeOptions, defaultOptions} from "@lodestar/beacon-node";
+import {CliCommandOptions} from "@lodestar/utils";
+import {YargsError} from "../../util/index.js";
+
+export const defaultListenAddress = "0.0.0.0";
+export const defaultListenAddress6 = "::";
+export const defaultP2pPort = 9000;
+
+export type NetworkArgs = {
+  discv5?: boolean;
+  listenAddress?: string;
+  port?: number;
+  discoveryPort?: number;
+  listenAddress6?: string;
+  port6?: number;
+  discoveryPort6?: number;
+  bootnodes?: string[];
+  targetPeers?: number;
+  subscribeAllSubnets?: boolean;
+  slotsToSubscribeBeforeAggregatorDuty?: number;
+  disablePeerScoring?: boolean;
+  mdns?: boolean;
+  "network.maxPeers"?: number;
+  "network.connectToDiscv5Bootnodes"?: boolean;
+  "network.discv5FirstQueryDelayMs"?: number;
+  "network.dontSendGossipAttestationsToForkchoice"?: boolean;
+  "network.allowPublishToZeroPeers"?: boolean;
+  "network.gossipsubD"?: number;
+  "network.gossipsubDLow"?: number;
+  "network.gossipsubDHigh"?: number;
+  "network.gossipsubAwaitHandler"?: boolean;
+  "network.disableFloodPublish"?: boolean;
+  "network.rateLimitMultiplier"?: number;
+  "network.maxGossipTopicConcurrency"?: number;
+  "network.useWorker"?: boolean;
+  "network.maxYoungGenerationSizeMb"?: number;
+  "network.targetGroupPeers"?: number;
+
+  /** @deprecated This option is deprecated and should be removed in next major release. */
+  "network.requestCountPeerLimit"?: number;
+  /** @deprecated This option is deprecated and should be removed in next major release. */
+  "network.blockCountTotalLimit"?: number;
+  /** @deprecated This option is deprecated and should be removed in next major release. */
+  "network.blockCountPeerLimit"?: number;
+  /** @deprecated This option is deprecated and should be removed in next major release. */
+  "network.rateTrackerTimeoutMs"?: number;
+};
+
+function validateMultiaddrArg<T extends Record<string, string | undefined>>(args: T, key: keyof T): void {
+  if (args[key]) {
+    try {
+      multiaddr(args[key]);
+    } catch (e) {
+      throw new YargsError(`Invalid ${key as string}: ${(e as Error).message}`);
+    }
+  }
+}
+
+export function parseListenArgs(args: NetworkArgs) {
+  // If listenAddress is explicitly set, use it
+  // If listenAddress6 is not set, use defaultListenAddress
+  const listenAddress = args.listenAddress ?? (args.listenAddress6 ? undefined : defaultListenAddress);
+  const port = listenAddress ? (args.port ?? defaultP2pPort) : undefined;
+  const discoveryPort = listenAddress ? (args.discoveryPort ?? args.port ?? defaultP2pPort) : undefined;
+
+  // If listenAddress6 is explicitly set, use it
+  // If listenAddress is not set, use defaultListenAddress6
+  const listenAddress6 = args.listenAddress6 ?? (args.listenAddress ? undefined : defaultListenAddress6);
+  const port6 = listenAddress6 ? (args.port6 ?? defaultP2pPort) : undefined;
+  const discoveryPort6 = listenAddress6 ? (args.discoveryPort6 ?? args.port6 ?? defaultP2pPort) : undefined;
+
+  return {listenAddress, port, discoveryPort, listenAddress6, port6, discoveryPort6};
+}
+
+export function parseArgs(args: NetworkArgs): IBeaconNodeOptions["network"] {
+  const {listenAddress, port, discoveryPort, listenAddress6, port6, discoveryPort6} = parseListenArgs(args);
+  // validate ip, ip6, ports
+  const muArgs = {
+    listenAddress: listenAddress ? `/ip4/${listenAddress}` : undefined,
+    port: listenAddress ? `/tcp/${port}` : undefined,
+    discoveryPort: listenAddress ? `/udp/${discoveryPort}` : undefined,
+    listenAddress6: listenAddress6 ? `/ip6/${listenAddress6}` : undefined,
+    port6: listenAddress6 ? `/tcp/${port6}` : undefined,
+    discoveryPort6: listenAddress6 ? `/udp/${discoveryPort6}` : undefined,
+  };
+
+  for (const key of [
+    "listenAddress",
+    "port",
+    "discoveryPort",
+    "listenAddress6",
+    "port6",
+    "discoveryPort6",
+  ] as (keyof typeof muArgs)[]) {
+    validateMultiaddrArg(muArgs, key);
+  }
+
+  const bindMu = listenAddress ? `${muArgs.listenAddress}${muArgs.discoveryPort}` : undefined;
+  const localMu = listenAddress ? `${muArgs.listenAddress}${muArgs.port}` : undefined;
+  const bindMu6 = listenAddress6 ? `${muArgs.listenAddress6}${muArgs.discoveryPort6}` : undefined;
+  const localMu6 = listenAddress6 ? `${muArgs.listenAddress6}${muArgs.port6}` : undefined;
+
+  const targetPeers = args.targetPeers;
+  const maxPeers = args["network.maxPeers"] ?? (targetPeers !== undefined ? Math.floor(targetPeers * 1.1) : undefined);
+  if (targetPeers != null && maxPeers != null && targetPeers > maxPeers) {
+    throw new YargsError("network.maxPeers must be greater than or equal to targetPeers");
+  }
+  // Set discv5 opts to null to disable only if explicitly disabled
+  const enableDiscv5 = args.discv5 ?? true;
+
+  // TODO: Okay to set to empty array?
+  const bootEnrs = args.bootnodes ?? [];
+  // throw if user-provided enrs are invalid
+  for (const enrStr of bootEnrs) {
+    try {
+      ENR.decodeTxt(enrStr);
+    } catch (_e) {
+      throw new YargsError(`Provided ENR in bootnodes is invalid:\n    ${enrStr}`);
+    }
+  }
+
+  return {
+    discv5: enableDiscv5
+      ? {
+          config: {},
+          bindAddrs: {
+            ip4: bindMu as string,
+            ip6: bindMu6,
+          },
+          bootEnrs,
+          // biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+          enr: undefined as any,
+        }
+      : null,
+    maxPeers: maxPeers ?? defaultOptions.network.maxPeers,
+    targetPeers: targetPeers ?? defaultOptions.network.targetPeers,
+    localMultiaddrs: [localMu, localMu6].filter(Boolean) as string[],
+    subscribeAllSubnets: args.subscribeAllSubnets,
+    slotsToSubscribeBeforeAggregatorDuty:
+      args.slotsToSubscribeBeforeAggregatorDuty ?? defaultOptions.network.slotsToSubscribeBeforeAggregatorDuty,
+    disablePeerScoring: args.disablePeerScoring,
+    connectToDiscv5Bootnodes: args["network.connectToDiscv5Bootnodes"],
+    discv5FirstQueryDelayMs: args["network.discv5FirstQueryDelayMs"],
+    dontSendGossipAttestationsToForkchoice: args["network.dontSendGossipAttestationsToForkchoice"],
+    allowPublishToZeroPeers: args["network.allowPublishToZeroPeers"],
+    gossipsubD: args["network.gossipsubD"],
+    gossipsubDLow: args["network.gossipsubDLow"],
+    gossipsubDHigh: args["network.gossipsubDHigh"],
+    gossipsubAwaitHandler: args["network.gossipsubAwaitHandler"],
+    disableFloodPublish: args["network.disableFloodPublish"],
+    mdns: args.mdns,
+    rateLimitMultiplier: args["network.rateLimitMultiplier"],
+    maxGossipTopicConcurrency: args["network.maxGossipTopicConcurrency"],
+    useWorker: args["network.useWorker"],
+    maxYoungGenerationSizeMb: args["network.maxYoungGenerationSizeMb"],
+    targetGroupPeers: args["network.targetGroupPeers"] ?? defaultOptions.network.targetGroupPeers,
+  };
+}
+
+export const options: CliCommandOptions<NetworkArgs> = {
+  discv5: {
+    type: "boolean",
+    // TODO: Add `network.discv5.enabled` to the `IDiscv5DiscoveryInputOptions` type
+    description: "Enable discv5",
+    defaultDescription: String(true),
+    group: "network",
+  },
+
+  listenAddress: {
+    type: "string",
+    description: "The IPv4 address to listen for p2p UDP and TCP connections",
+    defaultDescription: defaultListenAddress,
+    group: "network",
+  },
+
+  port: {
+    description: "The TCP/UDP port to listen on. The UDP port can be modified by the --discoveryPort flag.",
+    type: "number",
+    // TODO: Derive from BeaconNode defaults
+    defaultDescription: String(defaultP2pPort),
+    group: "network",
+  },
+
+  discoveryPort: {
+    description: "The UDP port that discovery will listen on. Defaults to `port`",
+    type: "number",
+    defaultDescription: "`port`",
+    group: "network",
+  },
+
+  listenAddress6: {
+    type: "string",
+    description: "The IPv6 address to listen for p2p UDP and TCP connections",
+    defaultDescription: defaultListenAddress6,
+    group: "network",
+  },
+
+  port6: {
+    description: "The TCP/UDP port to listen on. The UDP port can be modified by the --discoveryPort6 flag.",
+    type: "number",
+    // TODO: Derive from BeaconNode defaults
+    defaultDescription: String(defaultP2pPort),
+    group: "network",
+  },
+
+  discoveryPort6: {
+    description: "The UDP port that discovery will listen on. Defaults to `port6`",
+    type: "number",
+    defaultDescription: "`port6`",
+    group: "network",
+  },
+
+  bootnodes: {
+    type: "array",
+    description: "Bootnodes for discv5 discovery",
+    defaultDescription: JSON.stringify(defaultOptions.network.discv5?.bootEnrs || []),
+    group: "network",
+    // 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(",")),
+  },
+
+  targetPeers: {
+    type: "number",
+    description: "The target connected peers. Above this number peers will be disconnected",
+    defaultDescription: String(defaultOptions.network.targetPeers),
+    group: "network",
+  },
+
+  subscribeAllSubnets: {
+    type: "boolean",
+    description: "Subscribe to all subnets regardless of validator count",
+    defaultDescription: String(defaultOptions.network.subscribeAllSubnets === true),
+    group: "network",
+  },
+
+  slotsToSubscribeBeforeAggregatorDuty: {
+    hidden: true,
+    type: "number",
+    description: "Number of slots before an aggregator duty to subscribe to subnets",
+    defaultDescription: String(defaultOptions.network.slotsToSubscribeBeforeAggregatorDuty),
+    group: "network",
+  },
+
+  disablePeerScoring: {
+    type: "boolean",
+    description: "Disable peer scoring, used for testing on devnets",
+    defaultDescription: String(defaultOptions.network.disablePeerScoring === true),
+    group: "network",
+  },
+
+  mdns: {
+    type: "boolean",
+    description: "Enable mdns local peer discovery",
+    defaultDescription: String(defaultOptions.network.mdns === true),
+    group: "network",
+  },
+
+  "network.maxPeers": {
+    hidden: true,
+    type: "number",
+    description: "The maximum number of connections allowed",
+    defaultDescription: String(defaultOptions.network.maxPeers),
+    group: "network",
+  },
+
+  "network.connectToDiscv5Bootnodes": {
+    type: "boolean",
+    description: "Attempt direct libp2p peer connection to discv5 bootnodes",
+    hidden: true,
+    defaultDescription: String(defaultOptions.network.connectToDiscv5Bootnodes === true),
+    group: "network",
+  },
+
+  "network.discv5FirstQueryDelayMs": {
+    type: "number",
+    description: "Delay the 1st heart beat of Peer Manager after starting Discv5",
+    hidden: true,
+    defaultDescription: String(defaultOptions.network.discv5FirstQueryDelayMs),
+    group: "network",
+  },
+
+  "network.requestCountPeerLimit": {
+    type: "number",
+    description: "Max block req/resp requests per peer per rateTrackerTimeoutMs",
+    hidden: true,
+    group: "network",
+    deprecated: true,
+  },
+
+  "network.blockCountTotalLimit": {
+    type: "number",
+    description: "Max block count requested per rateTrackerTimeoutMs",
+    hidden: true,
+    group: "network",
+    deprecated: true,
+  },
+
+  "network.blockCountPeerLimit": {
+    type: "number",
+    description: "Max block count requested per peer per rateTrackerTimeoutMs",
+    hidden: true,
+    group: "network",
+    deprecated: true,
+  },
+
+  "network.rateTrackerTimeoutMs": {
+    type: "number",
+    description: "Time window to track rate limit in milliseconds",
+    hidden: true,
+    group: "network",
+    deprecated: true,
+  },
+
+  "network.dontSendGossipAttestationsToForkchoice": {
+    hidden: true,
+    type: "boolean",
+    description: "Pass gossip attestations to forkchoice or not",
+    group: "network",
+  },
+
+  "network.allowPublishToZeroPeers": {
+    hidden: true,
+    type: "boolean",
+    description: "Don't error when publishing to zero peers",
+    group: "network",
+  },
+
+  "network.gossipsubD": {
+    hidden: true,
+    type: "number",
+    description: "Gossipsub D param",
+    group: "network",
+  },
+
+  "network.gossipsubDLow": {
+    hidden: true,
+    type: "number",
+    description: "Gossipsub D param low",
+    group: "network",
+  },
+
+  "network.gossipsubDHigh": {
+    hidden: true,
+    type: "number",
+    description: "Gossipsub D param high",
+    group: "network",
+  },
+
+  "network.gossipsubAwaitHandler": {
+    hidden: true,
+    type: "boolean",
+    group: "network",
+  },
+
+  "network.disableFloodPublish": {
+    hidden: true,
+    description: "Disable gossipsub flood publish",
+    type: "boolean",
+    group: "network",
+  },
+
+  "network.rateLimitMultiplier": {
+    type: "number",
+    description: "The multiplier to increase the rate limits. Set to zero to disable rate limiting.",
+    hidden: true,
+    defaultDescription: String(defaultOptions.network.rateLimitMultiplier),
+    group: "network",
+  },
+
+  "network.maxGossipTopicConcurrency": {
+    type: "number",
+    hidden: true,
+    group: "network",
+  },
+
+  "network.useWorker": {
+    type: "boolean",
+    hidden: true,
+    group: "network",
+  },
+
+  "network.maxYoungGenerationSizeMb": {
+    type: "number",
+    hidden: true,
+    group: "network",
+    description: "Max size of young generation in megabytes. Defaults to 152mb",
+    defaultDescription: String(defaultOptions.network.maxYoungGenerationSizeMb),
+  },
+
+  "network.targetGroupPeers": {
+    type: "number",
+    hidden: true,
+    group: "network",
+    description: "Target number of peers per sampling group",
+    defaultDescription: String(defaultOptions.network.targetGroupPeers),
+  },
+};

package/src/options/beaconNodeOptions/sync.ts

@@ -0,0 +1,65 @@
+import {IBeaconNodeOptions, defaultOptions} from "@lodestar/beacon-node";
+import {CliCommandOptions} from "@lodestar/utils";
+
+export type SyncArgs = {
+  "sync.isSingleNode"?: boolean;
+  "sync.disableProcessAsChainSegment"?: boolean;
+  "sync.disableRangeSync"?: boolean;
+  "sync.backfillBatchSize"?: number;
+  "sync.slotImportTolerance"?: number;
+};
+
+export function parseArgs(args: SyncArgs): IBeaconNodeOptions["sync"] {
+  return {
+    isSingleNode: args["sync.isSingleNode"],
+    disableProcessAsChainSegment: args["sync.disableProcessAsChainSegment"],
+    backfillBatchSize: args["sync.backfillBatchSize"] ?? defaultOptions.sync.backfillBatchSize,
+    disableRangeSync: args["sync.disableRangeSync"],
+    slotImportTolerance: args["sync.slotImportTolerance"] ?? defaultOptions.sync.slotImportTolerance,
+  };
+}
+
+export const options: CliCommandOptions<SyncArgs> = {
+  "sync.isSingleNode": {
+    hidden: true,
+    type: "boolean",
+    description:
+      "Allow node to consider itself synced without being connected to a peer. \
+Use only for local networks with a single node, can be dangerous in regular networks.",
+    defaultDescription: String(defaultOptions.sync.isSingleNode),
+    group: "sync",
+  },
+
+  "sync.disableRangeSync": {
+    hidden: true,
+    type: "boolean",
+    description: "Disable range sync completely. Should only be used for debugging or testing.",
+    defaultDescription: String(defaultOptions.sync.disableRangeSync),
+    group: "sync",
+  },
+
+  "sync.slotImportTolerance": {
+    hidden: true,
+    type: "number",
+    description: "Number of slot tolerance to trigger range sync and to measure if node is synced.",
+    defaultDescription: String(defaultOptions.sync.slotImportTolerance),
+    group: "sync",
+  },
+
+  "sync.disableProcessAsChainSegment": {
+    hidden: true,
+    type: "boolean",
+    description:
+      "For RangeSync disable processing batches of blocks at once. Should only be used for debugging or testing.",
+    defaultDescription: String(defaultOptions.sync.disableProcessAsChainSegment),
+    group: "sync",
+  },
+
+  "sync.backfillBatchSize": {
+    hidden: true,
+    type: "number",
+    description: "Batch size for backfill sync to sync/process blocks, set non zero to enable backfill sync",
+    defaultDescription: String(defaultOptions.sync.backfillBatchSize),
+    group: "sync",
+  },
+};

package/src/options/globalOptions.ts

@@ -0,0 +1,72 @@
+import {ACTIVE_PRESET} from "@lodestar/params";
+import {CliCommandOptions} from "@lodestar/utils";
+import {NetworkName, networkNames} from "../networks/index.js";
+import {readFile} from "../util/index.js";
+import {IParamsArgs, paramsOptions} from "./paramsOptions.js";
+
+type GlobalSingleArgs = {
+  dataDir?: string;
+  network?: NetworkName;
+  paramsFile?: string;
+  preset: string;
+  presetFile?: string;
+  rcConfig?: string;
+  supernode?: boolean;
+};
+
+export const defaultNetwork: NetworkName = "mainnet";
+
+const globalSingleOptions: CliCommandOptions<GlobalSingleArgs> = {
+  dataDir: {
+    description: "Lodestar root data directory",
+    type: "string",
+  },
+
+  network: {
+    description: "Name of the Ethereum Consensus chain network to join",
+    type: "string",
+    defaultDescription: defaultNetwork,
+    choices: networkNames,
+  },
+
+  paramsFile: {
+    description: "Network configuration file",
+    type: "string",
+  },
+
+  // hidden option to allow for LODESTAR_PRESET to be set
+  preset: {
+    hidden: true,
+    type: "string",
+    default: ACTIVE_PRESET,
+  },
+
+  presetFile: {
+    hidden: true,
+    description: "Preset configuration file to override the active preset with custom values",
+    type: "string",
+  },
+
+  rcConfig: {
+    description: "RC file to supplement command line args, accepted formats: .yml, .yaml, .json",
+    type: "string",
+  },
+
+  supernode: {
+    description: "Subscribe to and custody all data column sidecar subnets",
+    type: "boolean",
+  },
+};
+
+export const rcConfigOption: [string, string, (configPath: string) => Record<string, unknown>] = [
+  "rcConfig",
+  globalSingleOptions.rcConfig.description as string,
+  (configPath: string): Record<string, unknown> => readFile(configPath, ["json", "yml", "yaml"]),
+];
+
+export type GlobalArgs = GlobalSingleArgs & IParamsArgs;
+
+export const globalOptions = {
+  ...globalSingleOptions,
+  ...paramsOptions,
+};

package/src/options/index.ts

@@ -0,0 +1,3 @@
+export * from "./beaconNodeOptions/index.js";
+export * from "./globalOptions.js";
+export * from "./paramsOptions.js";

package/src/options/logOptions.ts

@@ -0,0 +1,70 @@
+import {LogLevel, logFormats} from "@lodestar/logger";
+import {CliCommandOptions, LogLevels} from "@lodestar/utils";
+import {LOG_FILE_DISABLE_KEYWORD} from "../util/logger.js";
+
+export type LogArgs = {
+  logLevel: LogLevel;
+  logFile?: string;
+  logFileLevel: LogLevel;
+  logFileDailyRotate: number;
+  logFormatGenesisTime?: number;
+  logPrefix?: string;
+  logFormat?: string;
+  logLevelModule?: string[];
+};
+
+export const logOptions: CliCommandOptions<LogArgs> = {
+  logLevel: {
+    choices: LogLevels,
+    description: "Logging verbosity level for emitting logs to terminal",
+    default: LogLevel.info,
+    type: "string",
+  },
+
+  logFile: {
+    description: `Path to output all logs to a persistent log file, use '${LOG_FILE_DISABLE_KEYWORD}' to disable`,
+    type: "string",
+  },
+
+  logFileLevel: {
+    choices: LogLevels,
+    description: "Logging verbosity level for emitting logs to file",
+    default: LogLevel.debug,
+    type: "string",
+  },
+
+  logFileDailyRotate: {
+    description:
+      "Daily rotate log files, set to an integer to limit the file count, set to 0 (zero) to disable rotation",
+    default: 5,
+    type: "number",
+  },
+
+  logFormatGenesisTime: {
+    hidden: true,
+    description:
+      "Use epoch slot timestamp format, instead or regular timestamp. Must provide genesisTime to compute relative time",
+    type: "number",
+  },
+
+  logPrefix: {
+    hidden: true,
+    description: "Logger prefix module field with a string ID",
+    type: "string",
+  },
+
+  logFormat: {
+    hidden: true,
+    description: "Log format used when emitting logs to the terminal and / or file",
+    choices: logFormats,
+    type: "string",
+  },
+
+  logLevelModule: {
+    hidden: true,
+    description: "Set log level for a specific module by name: 'chain=debug' or 'network=debug,chain=debug'",
+    type: "array",
+    string: true,
+    coerce: (args: string[]) => args.flatMap((item) => item.split(",")),
+  },
+};

package/src/options/paramsOptions.ts

@@ -0,0 +1,72 @@
+import {ChainConfig, chainConfigTypes} from "@lodestar/config";
+import {CliCommandOptions, CliOptionDefinition} from "@lodestar/utils";
+import {IBeaconParamsUnparsed} from "../config/types.js";
+import {ObjectKeys} from "../util/index.js";
+
+// No options are statically declared
+// If an arbitrary key notation is used, it removes type safety on most of this CLI arg parsing code.
+// Params will be parsed from an args object assuming to contain the required keys
+
+export type ITerminalPowArgs = {
+  "terminal-total-difficulty-override"?: string;
+  "terminal-block-hash-override"?: string;
+  "terminal-block-hash-epoch-override"?: string;
+};
+export type IParamsArgs = Record<never, never> & ITerminalPowArgs;
+
+const getArgKey = (key: keyof IBeaconParamsUnparsed): string => `params.${key}`;
+
+export function parseBeaconParamsArgs(args: Record<string, string | number>): IBeaconParamsUnparsed {
+  return ObjectKeys(chainConfigTypes).reduce((beaconParams: Partial<IBeaconParamsUnparsed>, key) => {
+    const value = args[getArgKey(key)];
+    if (value != null) beaconParams[key] = value;
+    return beaconParams;
+  }, {});
+}
+
+const paramsOptionsByName = ObjectKeys(chainConfigTypes).reduce(
+  (options: Record<string, CliOptionDefinition>, key): Record<string, CliOptionDefinition> => {
+    options[getArgKey(key)] = {
+      hidden: true,
+      type: "string",
+      group: "params",
+    };
+    return options;
+  },
+  {}
+);
+
+const terminalArgsToParamsMap: {[K in keyof ITerminalPowArgs]: keyof ChainConfig} = {
+  "terminal-total-difficulty-override": "TERMINAL_TOTAL_DIFFICULTY",
+  "terminal-block-hash-override": "TERMINAL_BLOCK_HASH",
+  "terminal-block-hash-epoch-override": "TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH",
+};
+
+export function parseTerminalPowArgs(args: ITerminalPowArgs): IBeaconParamsUnparsed {
+  const parsedArgs = ObjectKeys(terminalArgsToParamsMap).reduce((beaconParams: Partial<IBeaconParamsUnparsed>, key) => {
+    const paramOption = terminalArgsToParamsMap[key];
+    const value = args[key];
+    if (paramOption != null && value != null) beaconParams[paramOption] = value;
+    return beaconParams;
+  }, {});
+  return parsedArgs;
+}
+
+export const paramsOptions: CliCommandOptions<IParamsArgs> = {
+  ...paramsOptionsByName,
+
+  "terminal-total-difficulty-override": {
+    description: "Terminal PoW block TTD override",
+    type: "string",
+  },
+
+  "terminal-block-hash-override": {
+    description: "Terminal PoW block hash override",
+    type: "string",
+  },
+
+  "terminal-block-hash-epoch-override": {
+    description: "Terminal PoW block hash override activation epoch",
+    type: "string",
+  },
+};