@chainsafe/lodestar 1.35.0-dev.6dd6cec93a → 1.35.0-dev.792fcea33a

package/src/options/beaconNodeOptions/chain.ts

@@ -0,0 +1,326 @@
+import {ArchiveMode, DEFAULT_ARCHIVE_MODE, IBeaconNodeOptions, defaultOptions} from "@lodestar/beacon-node";
+import {CliCommandOptions} from "@lodestar/utils";
+import {ensure0xPrefix} from "../../util/format.js";
+
+export type ChainArgs = {
+  suggestedFeeRecipient: string;
+  serveHistoricalState?: boolean;
+  "chain.blacklistedBlocks"?: string[];
+  "chain.blsVerifyAllMultiThread"?: boolean;
+  "chain.blsVerifyAllMainThread"?: boolean;
+  "chain.disableBlsBatchVerify"?: boolean;
+  "chain.persistProducedBlocks"?: boolean;
+  "chain.persistInvalidSszObjects"?: boolean;
+  // No need to define chain.persistInvalidSszObjects as part of ChainArgs
+  // as this is defined as part of BeaconPaths
+  // "chain.persistInvalidSszObjectsDir": string;
+  "chain.persistOrphanedBlocks"?: boolean;
+  "chain.proposerBoost"?: boolean;
+  "chain.proposerBoostReorg"?: boolean;
+  "chain.disableImportExecutionFcU"?: boolean;
+  "chain.preaggregateSlotDistance"?: number;
+  "chain.attDataCacheSlotDistance"?: number;
+  "chain.computeUnrealized"?: boolean;
+  "chain.assertCorrectProgressiveBalances"?: boolean;
+  "chain.maxSkipSlots"?: number;
+  "safe-slots-to-import-optimistically": number;
+  emitPayloadAttributes?: boolean;
+  broadcastValidationStrictness?: string;
+  "chain.minSameMessageSignatureSetsToBatch"?: number;
+  "chain.maxShufflingCacheEpochs"?: number;
+  "chain.archiveStateEpochFrequency": number;
+  "chain.archiveDataEpochs"?: number;
+  "chain.archiveMode": ArchiveMode;
+  "chain.nHistoricalStates"?: boolean;
+  "chain.nHistoricalStatesFileDataStore"?: boolean;
+  "chain.maxBlockStates"?: number;
+  "chain.maxCPStateEpochsInMemory"?: number;
+
+  "chain.pruneHistory"?: boolean;
+};
+
+export function parseArgs(args: ChainArgs): IBeaconNodeOptions["chain"] {
+  return {
+    suggestedFeeRecipient: args.suggestedFeeRecipient,
+    serveHistoricalState: args.serveHistoricalState,
+    blacklistedBlocks: args["chain.blacklistedBlocks"],
+    blsVerifyAllMultiThread: args["chain.blsVerifyAllMultiThread"],
+    blsVerifyAllMainThread: args["chain.blsVerifyAllMainThread"],
+    disableBlsBatchVerify: args["chain.disableBlsBatchVerify"],
+    persistProducedBlocks: args["chain.persistProducedBlocks"],
+    persistInvalidSszObjects: args["chain.persistInvalidSszObjects"],
+    // biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+    persistInvalidSszObjectsDir: undefined as any,
+    persistOrphanedBlocks: args["chain.persistOrphanedBlocks"],
+    // biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+    persistOrphanedBlocksDir: undefined as any,
+    proposerBoost: args["chain.proposerBoost"],
+    proposerBoostReorg: args["chain.proposerBoostReorg"],
+    disableImportExecutionFcU: args["chain.disableImportExecutionFcU"],
+    preaggregateSlotDistance: args["chain.preaggregateSlotDistance"],
+    attDataCacheSlotDistance: args["chain.attDataCacheSlotDistance"],
+    computeUnrealized: args["chain.computeUnrealized"],
+    assertCorrectProgressiveBalances: args["chain.assertCorrectProgressiveBalances"],
+    maxSkipSlots: args["chain.maxSkipSlots"],
+    safeSlotsToImportOptimistically: args["safe-slots-to-import-optimistically"],
+    emitPayloadAttributes: args.emitPayloadAttributes,
+    broadcastValidationStrictness: args.broadcastValidationStrictness,
+    minSameMessageSignatureSetsToBatch:
+      args["chain.minSameMessageSignatureSetsToBatch"] ?? defaultOptions.chain.minSameMessageSignatureSetsToBatch,
+    maxShufflingCacheEpochs: args["chain.maxShufflingCacheEpochs"] ?? defaultOptions.chain.maxShufflingCacheEpochs,
+    archiveStateEpochFrequency: args["chain.archiveStateEpochFrequency"],
+    archiveDataEpochs: args["chain.archiveDataEpochs"],
+    archiveMode: args["chain.archiveMode"] ?? defaultOptions.chain.archiveMode,
+    nHistoricalStates: args["chain.nHistoricalStates"] ?? defaultOptions.chain.nHistoricalStates,
+    nHistoricalStatesFileDataStore:
+      args["chain.nHistoricalStatesFileDataStore"] ?? defaultOptions.chain.nHistoricalStatesFileDataStore,
+    maxBlockStates: args["chain.maxBlockStates"] ?? defaultOptions.chain.maxBlockStates,
+    maxCPStateEpochsInMemory: args["chain.maxCPStateEpochsInMemory"] ?? defaultOptions.chain.maxCPStateEpochsInMemory,
+    pruneHistory: args["chain.pruneHistory"],
+  };
+}
+
+export const options: CliCommandOptions<ChainArgs> = {
+  suggestedFeeRecipient: {
+    type: "string",
+    description:
+      "Specify fee recipient default for collecting the EL block fees and rewards (a hex string representing 20 bytes address: ^0x[a-fA-F0-9]{40}$) in case validator fails to update for a validator index before calling `produceBlock`.",
+    default: defaultOptions.chain.suggestedFeeRecipient,
+    group: "chain",
+  },
+
+  emitPayloadAttributes: {
+    type: "boolean",
+    defaultDescription: String(defaultOptions.chain.emitPayloadAttributes),
+    description: "Flag to SSE emit execution `payloadAttributes` before every slot",
+    group: "chain",
+  },
+
+  serveHistoricalState: {
+    description:
+      "Enable regenerating finalized state to serve historical data. Fetching this data is expensive and may affect validator performance.",
+    type: "boolean",
+    default: defaultOptions.chain.serveHistoricalState,
+    group: "chain",
+  },
+
+  "chain.blsVerifyAllMultiThread": {
+    hidden: true,
+    type: "boolean",
+    description: "Always use worker threads for BLS verification",
+    defaultDescription: String(defaultOptions.chain.blsVerifyAllMultiThread),
+    group: "chain",
+  },
+
+  "chain.blsVerifyAllMainThread": {
+    hidden: true,
+    type: "boolean",
+    description: "Always use main threads for BLS verification",
+    defaultDescription: String(defaultOptions.chain.blsVerifyAllMainThread),
+    group: "chain",
+  },
+
+  "chain.blacklistedBlocks": {
+    hidden: true,
+    type: "array",
+    string: true,
+    description:
+      "Comma-separated list of 0x-prefixed root hex's for blocks that should not be allowed through processing",
+    group: "chain",
+    coerce: (blocks: string[]): string[] =>
+      blocks
+        .flatMap((hex) => hex.split(","))
+        .map((hex) => hex.trim())
+        .map(ensure0xPrefix),
+  },
+
+  "chain.disableBlsBatchVerify": {
+    hidden: true,
+    type: "boolean",
+    description:
+      "Do not use BLS batch verify to validate all block signatures at once. \
+Will double processing times. Use only for debugging purposes.",
+    defaultDescription: String(defaultOptions.chain.blsVerifyAllMultiThread),
+    group: "chain",
+  },
+
+  "chain.persistProducedBlocks": {
+    hidden: true,
+    type: "boolean",
+    description: "Persist produced blocks or not for debugging purpose",
+    group: "chain",
+  },
+
+  "chain.persistInvalidSszObjects": {
+    hidden: true,
+    type: "boolean",
+    description: "Persist invalid ssz objects or not for debugging purpose",
+    group: "chain",
+  },
+
+  "chain.persistOrphanedBlocks": {
+    hidden: true,
+    type: "boolean",
+    description: "Whether to persist orphaned blocks",
+    group: "chain",
+  },
+
+  "chain.proposerBoost": {
+    alias: ["chain.proposerBoostEnabled"],
+    hidden: true,
+    type: "boolean",
+    description: "Enable proposer boost to reward a timely block",
+    defaultDescription: String(defaultOptions.chain.proposerBoost),
+    group: "chain",
+  },
+
+  "chain.proposerBoostReorg": {
+    hidden: true,
+    type: "boolean",
+    description: "Enable proposer boost reorg to reorg out a late block",
+    defaultDescription: String(defaultOptions.chain.proposerBoostReorg),
+    group: "chain",
+  },
+
+  "chain.disableImportExecutionFcU": {
+    hidden: true,
+    type: "boolean",
+    description: "Disable issuing FcUs to the execution engine on block import",
+    group: "chain",
+  },
+
+  "chain.preaggregateSlotDistance": {
+    hidden: true,
+    type: "number",
+    description: "Only preaggregate attestations or sync committee message since clockSlot - preaggregateSlotDistance",
+    group: "chain",
+  },
+
+  "chain.attDataCacheSlotDistance": {
+    hidden: true,
+    type: "number",
+    description: "Only cache AttestationData since clockSlot - attDataCacheSlotDistance",
+    group: "chain",
+  },
+
+  "chain.computeUnrealized": {
+    hidden: true,
+    type: "boolean",
+    description: "Compute unrealized checkpoints and use it in fork choice or not",
+    defaultDescription: String(defaultOptions.chain.computeUnrealized),
+    group: "chain",
+  },
+
+  "chain.maxSkipSlots": {
+    hidden: true,
+    type: "number",
+    description: "Refuse to skip more than this many slots when processing a block or attestation",
+    group: "chain",
+  },
+
+  "chain.assertCorrectProgressiveBalances": {
+    hidden: true,
+    description: "Enable asserting the progressive balances",
+    type: "boolean",
+    group: "chain",
+  },
+
+  "safe-slots-to-import-optimistically": {
+    hidden: true,
+    type: "number",
+    description:
+      "Slots from current (clock) slot till which its safe to import a block optimistically if the merge is not justified yet.",
+    default: defaultOptions.chain.safeSlotsToImportOptimistically,
+    group: "chain",
+  },
+
+  "chain.archiveStateEpochFrequency": {
+    description: "Minimum number of epochs between archived states",
+    default: defaultOptions.chain.archiveStateEpochFrequency,
+    type: "number",
+    group: "chain",
+  },
+
+  "chain.archiveMode": {
+    hidden: true,
+    choices: Object.values(ArchiveMode),
+    description: `Strategy to manage archive states, only support ${DEFAULT_ARCHIVE_MODE} at this time`,
+    default: defaultOptions.chain.archiveMode,
+    type: "string",
+    group: "chain",
+  },
+
+  broadcastValidationStrictness: {
+    // TODO: hide the option till validations fully implemented
+    hidden: true,
+    description:
+      "'warn' or 'error' - options to either throw error or to log warning when broadcast validation can't be performed",
+    type: "string",
+    default: "warn",
+  },
+
+  "chain.minSameMessageSignatureSetsToBatch": {
+    hidden: true,
+    description: "Minimum number of same message signature sets to batch",
+    type: "number",
+    default: defaultOptions.chain.minSameMessageSignatureSetsToBatch,
+    group: "chain",
+  },
+
+  "chain.maxShufflingCacheEpochs": {
+    hidden: true,
+    description: "Maximum ShufflingCache epochs to keep in memory",
+    type: "number",
+    default: defaultOptions.chain.maxShufflingCacheEpochs,
+    group: "chain",
+  },
+
+  "chain.archiveDataEpochs": {
+    alias: "chain.archiveBlobEpochs",
+    description:
+      "Number of epochs to retain finalized blobs/columns (minimum of MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS/MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS)",
+    type: "number",
+    group: "chain",
+  },
+
+  "chain.nHistoricalStates": {
+    hidden: true,
+    description:
+      "Use the new FIFOBlockStateCache and PersistentCheckpointStateCache or not which make lodestar heap size bounded instead of unbounded as before",
+    type: "boolean",
+    default: defaultOptions.chain.nHistoricalStates,
+    group: "chain",
+  },
+
+  "chain.nHistoricalStatesFileDataStore": {
+    hidden: true,
+    description: "Use fs to store checkpoint state for PersistentCheckpointStateCache or not",
+    type: "boolean",
+    default: defaultOptions.chain.nHistoricalStatesFileDataStore,
+    group: "chain",
+  },
+
+  "chain.maxBlockStates": {
+    hidden: true,
+    description: "Max block states to cache in memory, used for FIFOBlockStateCache",
+    type: "number",
+    default: defaultOptions.chain.maxBlockStates,
+    group: "chain",
+  },
+
+  "chain.maxCPStateEpochsInMemory": {
+    hidden: true,
+    description: "Max epochs to cache checkpoint states in memory, used for PersistentCheckpointStateCache",
+    type: "number",
+    default: defaultOptions.chain.maxCPStateEpochsInMemory,
+    group: "chain",
+  },
+
+  "chain.pruneHistory": {
+    hidden: true,
+    description: "Prune historical blocks and state",
+    type: "boolean",
+    default: defaultOptions.chain.pruneHistory,
+    group: "chain",
+  },
+};

package/src/options/beaconNodeOptions/eth1.ts

@@ -0,0 +1,95 @@
+import fs from "node:fs";
+import {IBeaconNodeOptions, defaultOptions} from "@lodestar/beacon-node";
+import {CliCommandOptions} from "@lodestar/utils";
+import {extractJwtHexSecret} from "../../util/index.js";
+import {ExecutionEngineArgs} from "./execution.js";
+
+export type Eth1Args = {
+  eth1?: boolean;
+  "eth1.providerUrls"?: string[];
+  "eth1.depositContractDeployBlock"?: number;
+  "eth1.disableEth1DepositDataTracker"?: boolean;
+  "eth1.unsafeAllowDepositDataOverwrite"?: boolean;
+  "eth1.forcedEth1DataVote"?: string;
+};
+
+export function parseArgs(args: Eth1Args & Partial<ExecutionEngineArgs>): IBeaconNodeOptions["eth1"] {
+  let jwtSecretHex: string | undefined;
+  let jwtId: string | undefined;
+
+  let providerUrls = args["eth1.providerUrls"];
+
+  // If no providerUrls are explicitly provided, we should pick the execution endpoint
+  // because as per Kiln spec v2.1, execution *must* host the `eth_` methods necessary
+  // for deposit and merge trackers on engine endpoints as well protected by a
+  // jwt auth mechanism.
+  if (providerUrls === undefined && args["execution.urls"]) {
+    providerUrls = args["execution.urls"];
+    jwtSecretHex = args.jwtSecret ? extractJwtHexSecret(fs.readFileSync(args.jwtSecret, "utf-8").trim()) : undefined;
+    jwtId = args.jwtId;
+  }
+
+  return {
+    enabled: args.eth1,
+    providerUrls,
+    jwtSecretHex,
+    jwtId,
+    depositContractDeployBlock: args["eth1.depositContractDeployBlock"],
+    disableEth1DepositDataTracker: args["eth1.disableEth1DepositDataTracker"],
+    unsafeAllowDepositDataOverwrite: args["eth1.unsafeAllowDepositDataOverwrite"],
+    forcedEth1DataVote: args["eth1.forcedEth1DataVote"],
+  };
+}
+
+export const options: CliCommandOptions<Eth1Args> = {
+  eth1: {
+    description: "Whether to follow the eth1 chain",
+    type: "boolean",
+    defaultDescription: String(defaultOptions.eth1.enabled),
+    group: "eth1",
+  },
+
+  "eth1.providerUrls": {
+    description:
+      "Urls to Eth1 node with enabled rpc. If not explicitly provided and execution endpoint provided via execution.urls, it will use execution.urls. Otherwise will try connecting on the specified default(s)",
+    defaultDescription: defaultOptions.eth1.providerUrls?.join(","),
+    type: "array",
+    string: true,
+    coerce: (urls: string[]): string[] =>
+      // Parse ["url1,url2"] to ["url1", "url2"]
+      urls.flatMap((item) => item.split(",")),
+    group: "eth1",
+  },
+
+  "eth1.depositContractDeployBlock": {
+    hidden: true,
+    description: "Block number at which the deposit contract contract was deployed",
+    type: "number",
+    defaultDescription: String(defaultOptions.eth1.depositContractDeployBlock),
+    group: "eth1",
+  },
+
+  "eth1.disableEth1DepositDataTracker": {
+    hidden: true,
+    description: "Disable Eth1DepositDataTracker modules",
+    type: "boolean",
+    defaultDescription: String(defaultOptions.eth1.disableEth1DepositDataTracker),
+    group: "eth1",
+  },
+
+  "eth1.unsafeAllowDepositDataOverwrite": {
+    hidden: true,
+    description:
+      "Allow the deposit tracker to overwrite previously fetched and saved deposit event data. Warning!!! This is an unsafe operation, so enable this flag only if you know what you are doing.",
+    type: "boolean",
+    defaultDescription: String(defaultOptions.eth1.unsafeAllowDepositDataOverwrite),
+    group: "eth1",
+  },
+
+  "eth1.forcedEth1DataVote": {
+    hidden: true,
+    description: "Vote for a specific eth1_data regardless of all conditions. Hex encoded ssz serialized Eth1Data type",
+    type: "string",
+    group: "eth1",
+  },
+};

package/src/options/beaconNodeOptions/execution.ts

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import {IBeaconNodeOptions, defaultExecutionEngineHttpOpts} from "@lodestar/beacon-node";
+import {CliCommandOptions} from "@lodestar/utils";
+import {extractJwtHexSecret} from "../../util/index.js";
+
+export type ExecutionEngineArgs = {
+  "execution.urls": string[];
+  "execution.timeout"?: number;
+  "execution.retries": number;
+  "execution.retryDelay": number;
+  "execution.engineMock"?: boolean;
+  jwtSecret?: string;
+  jwtId?: string;
+};
+
+export function parseArgs(args: ExecutionEngineArgs): IBeaconNodeOptions["executionEngine"] {
+  if (args["execution.engineMock"]) {
+    return {
+      mode: "mock",
+      genesisBlockHash: "",
+    };
+  }
+
+  return {
+    urls: args["execution.urls"],
+    timeout: args["execution.timeout"],
+    retries: args["execution.retries"],
+    retryDelay: args["execution.retryDelay"],
+    /**
+     * jwtSecret is parsed as hex instead of bytes because the merge with defaults
+     * in beaconOptions messes up the bytes array as as index => value object
+     */
+    jwtSecretHex: args.jwtSecret ? extractJwtHexSecret(fs.readFileSync(args.jwtSecret, "utf-8").trim()) : undefined,
+    jwtId: args.jwtId,
+  };
+}
+
+export const options: CliCommandOptions<ExecutionEngineArgs> = {
+  "execution.urls": {
+    description: "Urls to execution client engine API",
+    default: defaultExecutionEngineHttpOpts.urls.join(","),
+    type: "array",
+    string: true,
+    coerce: (urls: string[]): string[] =>
+      // Parse ["url1,url2"] to ["url1", "url2"]
+      urls.flatMap((item) => item.split(",")),
+    group: "execution",
+  },
+
+  "execution.timeout": {
+    description: "Timeout in milliseconds for execution engine API HTTP client",
+    type: "number",
+    defaultDescription: String(defaultExecutionEngineHttpOpts.timeout),
+    group: "execution",
+  },
+
+  "execution.retries": {
+    alias: ["execution.retryAttempts"],
+    description: "Number of retries when calling execution engine API",
+    type: "number",
+    default: defaultExecutionEngineHttpOpts.retries,
+    group: "execution",
+  },
+
+  "execution.retryDelay": {
+    description: "Delay time in milliseconds between retries when retrying calls to the execution engine API",
+    type: "number",
+    default: defaultExecutionEngineHttpOpts.retryDelay,
+    group: "execution",
+  },
+
+  "execution.engineMock": {
+    description: "Set the execution engine to mock mode (development only)",
+    type: "boolean",
+    hidden: false,
+    group: "execution",
+  },
+
+  jwtSecret: {
+    description:
+      "File path to a shared hex-encoded jwt secret which will be used to generate and bundle HS256 encoded jwt tokens for authentication with the EL client's rpc server hosting engine apis. Secret to be exactly same as the one used by the corresponding EL client.",
+    type: "string",
+    group: "execution",
+  },
+
+  jwtId: {
+    description:
+      "An optional identifier to be set in the id field of the claims included in jwt tokens used for authentication with EL client's rpc server hosting engine apis",
+    type: "string",
+    group: "execution",
+  },
+};

package/src/options/beaconNodeOptions/index.ts

@@ -0,0 +1,50 @@
+import {IBeaconNodeOptions} from "@lodestar/beacon-node";
+import {RecursivePartial} from "@lodestar/utils";
+import {removeUndefinedRecursive} from "../../util/index.js";
+import * as api from "./api.js";
+import * as builder from "./builder.js";
+import * as chain from "./chain.js";
+import * as eth1 from "./eth1.js";
+import * as execution from "./execution.js";
+import * as metrics from "./metrics.js";
+import * as monitoring from "./monitoring.js";
+import * as network from "./network.js";
+import * as sync from "./sync.js";
+
+export type BeaconNodeArgs = api.ApiArgs &
+  chain.ChainArgs &
+  eth1.Eth1Args &
+  execution.ExecutionEngineArgs &
+  builder.ExecutionBuilderArgs &
+  metrics.MetricsArgs &
+  monitoring.MonitoringArgs &
+  network.NetworkArgs &
+  sync.SyncArgs;
+
+export function parseBeaconNodeArgs(args: BeaconNodeArgs): RecursivePartial<IBeaconNodeOptions> {
+  // Remove undefined values to allow deepmerge to inject default values downstream
+  return removeUndefinedRecursive({
+    api: api.parseArgs(args),
+    chain: chain.parseArgs(args),
+    // db: {},
+    eth1: eth1.parseArgs(args),
+    executionEngine: execution.parseArgs(args),
+    executionBuilder: builder.parseArgs(args),
+    metrics: metrics.parseArgs(args),
+    monitoring: monitoring.parseArgs(args),
+    network: network.parseArgs(args),
+    sync: sync.parseArgs(args),
+  });
+}
+
+export const beaconNodeOptions = {
+  ...api.options,
+  ...chain.options,
+  ...eth1.options,
+  ...execution.options,
+  ...builder.options,
+  ...metrics.options,
+  ...monitoring.options,
+  ...network.options,
+  ...sync.options,
+};

package/src/options/beaconNodeOptions/metrics.ts

@@ -0,0 +1,39 @@
+import {IBeaconNodeOptions, defaultOptions} from "@lodestar/beacon-node";
+import {CliCommandOptions} from "@lodestar/utils";
+
+export type MetricsArgs = {
+  metrics: boolean;
+  "metrics.port": number;
+  "metrics.address"?: string;
+};
+
+export function parseArgs(args: MetricsArgs): IBeaconNodeOptions["metrics"] {
+  return {
+    enabled: args.metrics,
+    port: args["metrics.port"],
+    address: args["metrics.address"],
+  };
+}
+
+export const options: CliCommandOptions<MetricsArgs> = {
+  metrics: {
+    type: "boolean",
+    description: "Enable the Prometheus metrics HTTP server",
+    default: defaultOptions.metrics.enabled,
+    group: "metrics",
+  },
+
+  "metrics.port": {
+    type: "number",
+    description: "Listen TCP port for the Prometheus metrics HTTP server",
+    default: defaultOptions.metrics.port,
+    group: "metrics",
+  },
+
+  "metrics.address": {
+    type: "string",
+    description: "Listen address for the Prometheus metrics HTTP server",
+    defaultDescription: String(defaultOptions.metrics.address),
+    group: "metrics",
+  },
+};

package/src/options/beaconNodeOptions/monitoring.ts

@@ -0,0 +1,61 @@
+import {IBeaconNodeOptions, defaultOptions} from "@lodestar/beacon-node";
+import {CliCommandOptions} from "@lodestar/utils";
+
+export type MonitoringArgs = {
+  "monitoring.endpoint"?: string;
+  "monitoring.interval"?: number;
+  "monitoring.initialDelay"?: number;
+  "monitoring.requestTimeout"?: number;
+  "monitoring.collectSystemStats"?: boolean;
+};
+
+export function parseArgs(args: MonitoringArgs): IBeaconNodeOptions["monitoring"] {
+  return {
+    endpoint: args["monitoring.endpoint"],
+    interval: args["monitoring.interval"],
+    initialDelay: args["monitoring.initialDelay"],
+    requestTimeout: args["monitoring.requestTimeout"],
+    collectSystemStats: args["monitoring.collectSystemStats"],
+  };
+}
+
+export const options: CliCommandOptions<MonitoringArgs> = {
+  "monitoring.endpoint": {
+    type: "string",
+    description:
+      "Enables monitoring service for sending clients stats to the specified endpoint of a remote service (e.g. beaconcha.in)",
+    group: "monitoring",
+  },
+
+  "monitoring.interval": {
+    type: "number",
+    description: "Interval in milliseconds between sending client stats to the remote service",
+    defaultDescription: String(defaultOptions.monitoring.interval),
+    group: "monitoring",
+  },
+
+  "monitoring.initialDelay": {
+    type: "number",
+    description: "Initial delay in milliseconds before client stats are sent to the remote service",
+    defaultDescription: String(defaultOptions.monitoring.initialDelay),
+    group: "monitoring",
+    hidden: true,
+  },
+
+  "monitoring.requestTimeout": {
+    type: "number",
+    description: "Timeout in milliseconds for sending client stats to the remote service",
+    defaultDescription: String(defaultOptions.monitoring.requestTimeout),
+    group: "monitoring",
+    hidden: true,
+  },
+
+  "monitoring.collectSystemStats": {
+    type: "boolean",
+    description:
+      "Enable collecting system stats. By default, the beacon node will collect system stats but this can also be handled by the validator client.",
+    defaultDescription: String(defaultOptions.monitoring.collectSystemStats),
+    group: "monitoring",
+    hidden: true,
+  },
+};