@chainsafe/lodestar 1.35.0-dev.b42a298a7c → 1.35.0-dev.be3c5220f4

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

package/src/cmds/lightclient/handler.ts

@@ -0,0 +1,36 @@
+import path from "node:path";
+import {getClient} from "@lodestar/api";
+import {Lightclient} from "@lodestar/light-client";
+import {LightClientRestTransport} from "@lodestar/light-client/transport";
+import {getNodeLogger} from "@lodestar/logger/node";
+import {fromHex} from "@lodestar/utils";
+import {getBeaconConfigFromArgs} from "../../config/beaconParams.js";
+import {GlobalArgs} from "../../options/index.js";
+import {getGlobalPaths} from "../../paths/global.js";
+import {parseLoggerArgs} from "../../util/logger.js";
+import {ILightClientArgs} from "./options.js";
+
+export async function lightclientHandler(args: ILightClientArgs & GlobalArgs): Promise<void> {
+  const {config, network} = getBeaconConfigFromArgs(args);
+  const globalPaths = getGlobalPaths(args, network);
+
+  const logger = getNodeLogger(
+    parseLoggerArgs(args, {defaultLogFilepath: path.join(globalPaths.dataDir, "lightclient.log")}, config)
+  );
+
+  const api = getClient({baseUrl: args.beaconApiUrl}, {config});
+  const {genesisTime, genesisValidatorsRoot} = (await api.beacon.getGenesis()).value();
+
+  const client = await Lightclient.initializeFromCheckpointRoot({
+    config,
+    logger,
+    genesisData: {
+      genesisTime,
+      genesisValidatorsRoot,
+    },
+    checkpointRoot: fromHex(args.checkpointRoot),
+    transport: new LightClientRestTransport(api),
+  });
+
+  void client.start();
+}

package/src/cmds/lightclient/index.ts

@@ -0,0 +1,18 @@
+import {CliCommand} from "@lodestar/utils";
+import {GlobalArgs} from "../../options/index.js";
+import {lightclientHandler} from "./handler.js";
+import {ILightClientArgs, lightclientOptions} from "./options.js";
+
+export const lightclient: CliCommand<ILightClientArgs, GlobalArgs> = {
+  command: "lightclient",
+  describe: "Run lightclient",
+  docsFolder: "libraries/lightclient-prover",
+  examples: [
+    {
+      command: "lightclient --network hoodi",
+      description: "Run lightclient with hoodi network",
+    },
+  ],
+  options: lightclientOptions,
+  handler: lightclientHandler,
+};

package/src/cmds/lightclient/options.ts

@@ -0,0 +1,21 @@
+import {CliCommandOptions} from "@lodestar/utils";
+import {LogArgs, logOptions} from "../../options/logOptions.js";
+
+export type ILightClientArgs = LogArgs & {
+  beaconApiUrl: string;
+  checkpointRoot: string;
+};
+
+export const lightclientOptions: CliCommandOptions<ILightClientArgs> = {
+  ...logOptions,
+  beaconApiUrl: {
+    description: "Url to a beacon node that support lightclient API",
+    type: "string",
+    demandOption: true,
+  },
+  checkpointRoot: {
+    description: "Checkpoint root hex string to sync the lightclient from, start with 0x",
+    type: "string",
+    demandOption: true,
+  },
+};

package/src/cmds/validator/blsToExecutionChange.ts

@@ -0,0 +1,91 @@
+import {SecretKey} from "@chainsafe/blst";
+import {getClient} from "@lodestar/api";
+import {createBeaconConfig} from "@lodestar/config";
+import {DOMAIN_BLS_TO_EXECUTION_CHANGE, ForkName} from "@lodestar/params";
+import {computeSigningRoot} from "@lodestar/state-transition";
+import {capella, ssz} from "@lodestar/types";
+import {CliCommand, fromHex} from "@lodestar/utils";
+import {getBeaconConfigFromArgs} from "../../config/index.js";
+import {GlobalArgs} from "../../options/index.js";
+import {IValidatorCliArgs} from "./options.js";
+
+type BlsToExecutionChangeArgs = {
+  publicKey: string;
+  fromBlsPrivkey: string;
+  toExecutionAddress: string;
+};
+
+export const blsToExecutionChange: CliCommand<BlsToExecutionChangeArgs, IValidatorCliArgs & GlobalArgs> = {
+  command: "bls-to-execution-change",
+
+  describe:
+    "Performs BLS To Execution Change for a given validator (as identified via `publicKey`.  \
+If no `publicKey` is provided, a prompt will ask the user which validator they would \
+like to choose for BLS To Execution Change.",
+
+  examples: [
+    {
+      command: "validator bls-to-execution-change --publicKey 0xF00 --fromBlsPrivkey ... --toExecutionAddress ...",
+      description: "Perform BLS To Execution Change for the validator who has a public key 0xF00",
+    },
+  ],
+
+  options: {
+    publicKey: {
+      description: "Validator public key for which to set withdrawal address hence enabling withdrawals",
+      type: "string",
+      demandOption: true,
+    },
+    fromBlsPrivkey: {
+      description: "Bls withdrawals private key to sign the message",
+      type: "string",
+      demandOption: true,
+    },
+    toExecutionAddress: {
+      description: "Address to which the validator's balances will be set to be withdrawn.",
+      type: "string",
+      demandOption: true,
+    },
+  },
+
+  handler: async (args) => {
+    const {publicKey} = args;
+    // Fetch genesisValidatorsRoot always from beacon node as anyway beacon node is needed for
+    // submitting the signed message
+    const {config: chainForkConfig} = getBeaconConfigFromArgs(args);
+    const client = getClient({urls: args.beaconNodes}, {config: chainForkConfig});
+    const {genesisValidatorsRoot} = (await client.beacon.getGenesis()).value();
+    const config = createBeaconConfig(chainForkConfig, genesisValidatorsRoot);
+
+    const validators = (await client.beacon.postStateValidators({stateId: "head", validatorIds: [publicKey]})).value();
+    const validator = validators[0];
+    if (validator === undefined) {
+      throw new Error(`Validator pubkey ${publicKey} not found in state`);
+    }
+
+    const blsPrivkey = SecretKey.fromBytes(fromHex(args.fromBlsPrivkey));
+    const fromBlsPubkey = blsPrivkey.toPublicKey().toBytes();
+
+    const blsToExecutionChange: capella.BLSToExecutionChange = {
+      validatorIndex: validator.index,
+      fromBlsPubkey,
+      toExecutionAddress: fromHex(args.toExecutionAddress),
+    };
+
+    const signatureFork = ForkName.phase0;
+    const domain = config.getDomainAtFork(signatureFork, DOMAIN_BLS_TO_EXECUTION_CHANGE);
+    const signingRoot = computeSigningRoot(ssz.capella.BLSToExecutionChange, blsToExecutionChange, domain);
+    const signedBLSToExecutionChange = {
+      message: blsToExecutionChange,
+      signature: blsPrivkey.sign(signingRoot).toBytes(),
+    };
+
+    (
+      await client.beacon.submitPoolBLSToExecutionChange({
+        blsToExecutionChanges: [signedBLSToExecutionChange],
+      })
+    ).assertOk();
+
+    console.log(`Submitted bls to execution change for ${publicKey}`);
+  },
+};