@lodestar/validator 1.35.0-dev.e18102ed8c → 1.35.0-dev.f2a741bbe4

package/src/services/externalSignerSync.ts

@@ -0,0 +1,81 @@
+import {PublicKey} from "@chainsafe/blst";
+import {ChainForkConfig} from "@lodestar/config";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {fromHex, toPrintableUrl} from "@lodestar/utils";
+import {externalSignerGetKeys} from "../util/externalSignerClient.js";
+import {LoggerVc} from "../util/index.js";
+import {SignerType, ValidatorStore} from "./validatorStore.js";
+
+export type ExternalSignerOptions = {
+  url?: string;
+  fetch?: boolean;
+  fetchInterval?: number;
+};
+
+/**
+ * This service is responsible for keeping the keys managed by the connected
+ * external signer and the validator client in sync by adding newly discovered keys
+ * and removing no longer present keys on external signer from the validator store.
+ */
+export function pollExternalSignerPubkeys(
+  config: ChainForkConfig,
+  logger: LoggerVc,
+  signal: AbortSignal,
+  validatorStore: ValidatorStore,
+  opts?: ExternalSignerOptions
+): void {
+  const externalSigner = opts ?? {};
+
+  if (!externalSigner.url || !externalSigner.fetch) {
+    return; // Disabled
+  }
+
+  async function fetchExternalSignerPubkeys(): Promise<void> {
+    // External signer URL is already validated earlier
+    const externalSignerUrl = externalSigner.url as string;
+    const printableUrl = toPrintableUrl(externalSignerUrl);
+
+    try {
+      logger.debug("Fetching public keys from external signer", {url: printableUrl});
+      const externalPubkeys = await externalSignerGetKeys(externalSignerUrl);
+      assertValidPubkeysHex(externalPubkeys);
+      logger.debug("Received public keys from external signer", {url: printableUrl, count: externalPubkeys.length});
+
+      const localPubkeys = validatorStore.getRemoteSignerPubkeys(externalSignerUrl);
+      logger.debug("Local public keys stored for external signer", {url: printableUrl, count: localPubkeys.length});
+
+      const localPubkeysSet = new Set(localPubkeys);
+      for (const pubkey of externalPubkeys) {
+        if (!localPubkeysSet.has(pubkey)) {
+          await validatorStore.addSigner({type: SignerType.Remote, pubkey, url: externalSignerUrl});
+          logger.info("Added remote signer", {pubkey, url: printableUrl});
+        }
+      }
+
+      const externalPubkeysSet = new Set(externalPubkeys);
+      for (const pubkey of localPubkeys) {
+        if (!externalPubkeysSet.has(pubkey)) {
+          validatorStore.removeSigner(pubkey);
+          logger.info("Removed remote signer", {pubkey, url: printableUrl});
+        }
+      }
+    } catch (e) {
+      logger.error("Failed to fetch public keys from external signer", {url: printableUrl}, e as Error);
+    }
+  }
+
+  const interval = setInterval(
+    fetchExternalSignerPubkeys,
+    externalSigner.fetchInterval ??
+      // Once per epoch by default
+      SLOTS_PER_EPOCH * config.SLOT_DURATION_MS
+  );
+  signal.addEventListener("abort", () => clearInterval(interval), {once: true});
+}
+
+function assertValidPubkeysHex(pubkeysHex: string[]): void {
+  for (const pubkeyHex of pubkeysHex) {
+    const pubkeyBytes = fromHex(pubkeyHex);
+    PublicKey.fromBytes(pubkeyBytes, true);
+  }
+}

package/src/services/indices.ts

@@ -0,0 +1,165 @@
+import {ApiClient, routes} from "@lodestar/api";
+import {ValidatorIndex} from "@lodestar/types";
+import {Logger, MapDef, toPubkeyHex} from "@lodestar/utils";
+import {Metrics} from "../metrics.js";
+import {batchItems} from "../util/index.js";
+
+/**
+ * This is to prevent the "Request body is too large" issue for http post.
+ * Typical servers accept up to 1MB (2 ** 20 bytes) of request body, for example fastify and nginx.
+ * A hex encoded public key with "0x"-prefix has a size of 98 bytes + 2 bytes to account for commas
+ * and other JSON padding. `Math.floor(2 ** 20 / 100) == 10485`, we can send up to ~10k keys per request.
+ */
+const PUBKEYS_PER_REQUEST = 10_000;
+
+// To assist with readability
+type PubkeyHex = string;
+
+// To assist with logging statuses, we only log the statuses that are not active_exiting or withdrawal_possible
+type SimpleValidatorStatus = "pending" | "active" | "exited" | "withdrawn";
+
+const statusToSimpleStatusMapping = (status: routes.beacon.ValidatorStatus): SimpleValidatorStatus => {
+  switch (status) {
+    case "active_exiting":
+    case "active_slashed":
+    case "active_ongoing":
+      return "active";
+
+    case "withdrawal_possible":
+    case "exited_slashed":
+    case "exited_unslashed":
+      return "exited";
+
+    case "pending_initialized":
+    case "pending_queued":
+      return "pending";
+
+    case "withdrawal_done":
+      return "withdrawn";
+  }
+};
+
+export class IndicesService {
+  readonly index2pubkey = new Map<ValidatorIndex, PubkeyHex>();
+  /** Indexed by pubkey in hex 0x prefixed */
+  readonly pubkey2index = new Map<PubkeyHex, ValidatorIndex>();
+  // Request indices once
+  private pollValidatorIndicesPromise: Promise<ValidatorIndex[]> | null = null;
+
+  constructor(
+    private readonly logger: Logger,
+    private readonly api: ApiClient,
+    private readonly metrics: Metrics | null
+  ) {
+    if (metrics) {
+      metrics.indices.addCollect(() => metrics.indices.set(this.index2pubkey.size));
+    }
+  }
+
+  get indexCount(): number {
+    return this.index2pubkey.size;
+  }
+
+  /** Returns the validator index for a given validator pubkey */
+  getValidatorIndex(pubKey: PubkeyHex): ValidatorIndex | undefined {
+    return this.pubkey2index.get(pubKey);
+  }
+
+  /** Return all known indices from the validatorStore pubkeys */
+  getAllLocalIndices(): ValidatorIndex[] {
+    return Array.from(this.index2pubkey.keys());
+  }
+
+  /** Return true if `index` is active part of this validator client */
+  hasValidatorIndex(index: ValidatorIndex): boolean {
+    return this.index2pubkey.has(index);
+  }
+
+  async pollValidatorIndices(pubkeysHex: PubkeyHex[]): Promise<ValidatorIndex[]> {
+    // Ensures pollValidatorIndicesInternal() is not called more than once at the same time.
+    // AttestationDutiesService, SyncCommitteeDutiesService and DoppelgangerService will call this function at the same time, so this will
+    // cache the promise and return it to the second caller, preventing calling the API twice for the same data.
+    if (this.pollValidatorIndicesPromise) {
+      return this.pollValidatorIndicesPromise;
+    }
+
+    this.pollValidatorIndicesPromise = this.pollValidatorIndicesInternal(pubkeysHex).finally(() => {
+      // Once the pollValidatorIndicesInternal() resolves or rejects null the cached promise so it can be called again.
+      this.pollValidatorIndicesPromise = null;
+    });
+    return this.pollValidatorIndicesPromise;
+  }
+
+  removeForKey(pubkey: PubkeyHex): boolean {
+    for (const [index, value] of this.index2pubkey) {
+      if (value === pubkey) {
+        this.index2pubkey.delete(index);
+      }
+    }
+    return this.pubkey2index.delete(pubkey);
+  }
+
+  /** Iterate through all the voting pubkeys in the `ValidatorStore` and attempt to learn any unknown
+      validator indices. Returns the new discovered indexes */
+  private async pollValidatorIndicesInternal(pubkeysHex: PubkeyHex[]): Promise<ValidatorIndex[]> {
+    const pubkeysHexToDiscover = pubkeysHex.filter((pubkey) => !this.pubkey2index.has(pubkey));
+
+    if (pubkeysHexToDiscover.length === 0) {
+      return [];
+    }
+
+    // Query the remote BN to resolve a pubkey to a validator index.
+    // support up to 10k pubkeys per poll
+    const pubkeysHexBatches = batchItems(pubkeysHexToDiscover, {batchSize: PUBKEYS_PER_REQUEST});
+
+    const newIndices: number[] = [];
+    for (const pubkeysHexBatch of pubkeysHexBatches) {
+      const validatorIndicesArr = await this.fetchValidatorIndices(pubkeysHexBatch);
+      newIndices.push(...validatorIndicesArr);
+    }
+
+    this.metrics?.discoveredIndices.inc(newIndices.length);
+
+    return newIndices;
+  }
+
+  private async fetchValidatorIndices(pubkeysHex: string[]): Promise<ValidatorIndex[]> {
+    const validators = (await this.api.beacon.postStateValidators({stateId: "head", validatorIds: pubkeysHex})).value();
+
+    const newIndices = [];
+
+    const allValidatorStatuses = new MapDef<SimpleValidatorStatus, number>(() => 0);
+
+    for (const validator of validators) {
+      // Group all validators by status
+      const status = statusToSimpleStatusMapping(validator.status);
+      allValidatorStatuses.set(status, allValidatorStatuses.getOrDefault(status) + 1);
+
+      const pubkeyHex = toPubkeyHex(validator.validator.pubkey);
+      if (!this.pubkey2index.has(pubkeyHex)) {
+        this.logger.info("Validator seen on beacon chain", {
+          validatorIndex: validator.index,
+          pubKey: pubkeyHex,
+        });
+        this.pubkey2index.set(pubkeyHex, validator.index);
+        this.index2pubkey.set(validator.index, pubkeyHex);
+        newIndices.push(validator.index);
+      }
+    }
+
+    // The number of validators that are not in the beacon chain
+    const pendingCount = pubkeysHex.length - validators.length;
+
+    allValidatorStatuses.set("pending", allValidatorStatuses.getOrDefault("pending") + pendingCount);
+
+    // Retrieve the number of validators for each status
+    const statuses = Object.fromEntries(Array.from(allValidatorStatuses.entries()).filter((entry) => entry[1] > 0));
+
+    // The total number of validators
+    const total = pubkeysHex.length;
+
+    this.logger.info("Validator statuses", {...statuses, total});
+
+    return newIndices;
+  }
+}

package/src/services/prepareBeaconProposer.ts

@@ -0,0 +1,119 @@
+import {ApiClient, routes} from "@lodestar/api";
+import {BeaconConfig} from "@lodestar/config";
+import {GENESIS_EPOCH, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {Epoch, bellatrix} from "@lodestar/types";
+import {Metrics} from "../metrics.js";
+import {IClock, LoggerVc, batchItems} from "../util/index.js";
+import {ValidatorStore} from "./validatorStore.js";
+
+const REGISTRATION_CHUNK_SIZE = 512;
+/**
+ * This service is responsible for registering validators to beacon node with the
+ * proposer data (currently `feeRecipient`) so that it can issue advance fcUs to
+ * the engine for building execution payload with transactions.
+ *
+ * This needs to be done every epoch because the BN will cache it at most for
+ * two epochs.
+ */
+export function pollPrepareBeaconProposer(
+  config: BeaconConfig,
+  logger: LoggerVc,
+  api: ApiClient,
+  clock: IClock,
+  validatorStore: ValidatorStore,
+  _metrics: Metrics | null
+): void {
+  async function prepareBeaconProposer(epoch: Epoch): Promise<void> {
+    // Before bellatrix we don't need to update this data on bn/builder
+    if (epoch < config.BELLATRIX_FORK_EPOCH - 1) return;
+
+    // prepareBeaconProposer is not as time sensitive as attesting.
+    // Poll indices first, then call api.validator.prepareBeaconProposer once
+    await validatorStore.pollValidatorIndices().catch((e: Error) => {
+      logger.error("Error on pollValidatorIndices for prepareBeaconProposer", {epoch}, e);
+    });
+
+    const indicesChunks = batchItems(validatorStore.getAllLocalIndices(), {batchSize: REGISTRATION_CHUNK_SIZE});
+
+    for (const indices of indicesChunks) {
+      try {
+        const proposers = indices.map(
+          (index): routes.validator.ProposerPreparationData => ({
+            validatorIndex: index,
+            feeRecipient: validatorStore.getFeeRecipientByIndex(index),
+          })
+        );
+        (await api.validator.prepareBeaconProposer({proposers})).assertOk();
+        logger.debug("Registered proposers with beacon node", {epoch, count: proposers.length});
+      } catch (e) {
+        logger.error("Failed to register proposers with beacon node", {epoch}, e as Error);
+      }
+    }
+  }
+
+  clock.runEveryEpoch(prepareBeaconProposer);
+}
+
+/**
+ * This service is responsible for registering validators with the mev builder as they
+ * might prepare and keep ready the execution payloads of just registered validators.
+ *
+ * This needs to be done every epoch because the builder(s) will cache it at most for
+ * two epochs.
+ */
+export function pollBuilderValidatorRegistration(
+  config: BeaconConfig,
+  logger: LoggerVc,
+  api: ApiClient,
+  clock: IClock,
+  validatorStore: ValidatorStore,
+  _metrics: Metrics | null
+): void {
+  async function registerValidator(epoch: Epoch): Promise<void> {
+    // Don't send validator registrations pre-genesis as mev-boost-relay will reject
+    // those registrations anyways if timestamp is before genesis time and we wanna
+    // avoid caching and re-sending them in subsequent requests
+    if (epoch < GENESIS_EPOCH) return;
+
+    // Before bellatrix we don't need to update this data on bn/builder
+    if (epoch < config.BELLATRIX_FORK_EPOCH - 1) return;
+    const slot = epoch * SLOTS_PER_EPOCH;
+
+    // registerValidator is not as time sensitive as attesting.
+    // Poll indices first, then call api.validator.registerValidator once
+    await validatorStore.pollValidatorIndices().catch((e: Error) => {
+      logger.error("Error on pollValidatorIndices for registerValidator", {epoch}, e);
+    });
+    const pubkeyHexes = validatorStore
+      .getAllLocalIndices()
+      .map((index) => validatorStore.getPubkeyOfIndex(index))
+      .filter(
+        (pubkeyHex): pubkeyHex is string =>
+          pubkeyHex !== undefined &&
+          validatorStore.getBuilderSelectionParams(pubkeyHex).selection !==
+            routes.validator.BuilderSelection.ExecutionOnly
+      );
+
+    if (pubkeyHexes.length > 0) {
+      const pubkeyHexesChunks = batchItems(pubkeyHexes, {batchSize: REGISTRATION_CHUNK_SIZE});
+
+      for (const pubkeyHexes of pubkeyHexesChunks) {
+        try {
+          const registrations = await Promise.all(
+            pubkeyHexes.map((pubkeyHex): Promise<bellatrix.SignedValidatorRegistrationV1> => {
+              const feeRecipient = validatorStore.getFeeRecipient(pubkeyHex);
+              const gasLimit = validatorStore.getGasLimit(pubkeyHex);
+              return validatorStore.getValidatorRegistration(pubkeyHex, {feeRecipient, gasLimit}, slot);
+            })
+          );
+          (await api.validator.registerValidator({registrations})).assertOk();
+          logger.info("Published validator registrations to builder", {epoch, count: registrations.length});
+        } catch (e) {
+          logger.error("Failed to publish validator registrations to builder", {epoch}, e as Error);
+        }
+      }
+    }
+  }
+
+  clock.runEveryEpoch(registerValidator);
+}