@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fcf8d024ea

package/src/network/util.ts

@@ -0,0 +1,29 @@
+import type {Connection, PeerId} from "@libp2p/interface";
+import type {PeerIdStr} from "../util/peerId.js";
+import type {Libp2p} from "./interface.js";
+
+export function prettyPrintPeerId(peerId: PeerId): string {
+  return prettyPrintPeerIdStr(peerId.toString());
+}
+
+export function prettyPrintPeerIdStr(id: PeerIdStr): string {
+  return `${id.slice(0, 2)}...${id.slice(id.length - 6, id.length)}`;
+}
+
+/**
+ * Get the connections map from a connection manager
+ */
+// Compat function for efficiency reasons
+export function getConnectionsMap(libp2p: Libp2p): Map<string, {key: PeerId; value: Connection[]}> {
+  // biome-ignore lint/complexity/useLiteralKeys: access of private property
+  return libp2p.services.components.connectionManager.getConnectionsMap()["map"];
+}
+
+export function getConnection(libp2p: Libp2p, peerIdStr: string): Connection | undefined {
+  return getConnectionsMap(libp2p).get(peerIdStr)?.value[0] ?? undefined;
+}
+
+// https://github.com/ChainSafe/js-libp2p-gossipsub/blob/3475242ed254f7647798ab7f36b21909f6cb61da/src/index.ts#L2009
+export function isPublishToZeroPeersError(e: Error): boolean {
+  return e.message.includes("PublishError.InsufficientPeers");
+}

package/src/node/index.ts

@@ -0,0 +1,2 @@
+export * from "./nodejs.js";
+export * as nodeUtils from "./utils/state.js";

package/src/node/nodejs.ts

@@ -0,0 +1,349 @@
+import {setMaxListeners} from "node:events";
+import {PrivateKey} from "@libp2p/interface";
+import {Registry} from "prom-client";
+import {hasher} from "@chainsafe/persistent-merkle-tree";
+import {BeaconApiMethods} from "@lodestar/api/beacon/server";
+import {BeaconConfig} from "@lodestar/config";
+import type {LoggerNode} from "@lodestar/logger/node";
+import {BeaconStateAllForks} from "@lodestar/state-transition";
+import {phase0} from "@lodestar/types";
+import {sleep} from "@lodestar/utils";
+import {ProcessShutdownCallback} from "@lodestar/validator";
+import {BeaconRestApiServer, getApi} from "../api/index.js";
+import {BeaconChain, IBeaconChain, initBeaconMetrics} from "../chain/index.js";
+import {ValidatorMonitor, createValidatorMonitor} from "../chain/validatorMonitor.js";
+import {IBeaconDb} from "../db/index.js";
+import {initializeEth1ForBlockProduction} from "../eth1/index.js";
+import {initializeExecutionBuilder, initializeExecutionEngine} from "../execution/index.js";
+import {HttpMetricsServer, Metrics, createMetrics, getHttpMetricsServer} from "../metrics/index.js";
+import {MonitoringService} from "../monitoring/index.js";
+import {Network, getReqRespHandlers} from "../network/index.js";
+import {BackfillSync} from "../sync/backfill/index.js";
+import {BeaconSync, IBeaconSync} from "../sync/index.js";
+import {Clock} from "../util/clock.js";
+import {runNodeNotifier} from "./notifier.js";
+import {IBeaconNodeOptions} from "./options.js";
+
+export * from "./options.js";
+
+export type BeaconNodeModules = {
+  opts: IBeaconNodeOptions;
+  config: BeaconConfig;
+  db: IBeaconDb;
+  metrics: Metrics | null;
+  validatorMonitor: ValidatorMonitor | null;
+  network: Network;
+  chain: IBeaconChain;
+  api: BeaconApiMethods;
+  sync: IBeaconSync;
+  backfillSync: BackfillSync | null;
+  metricsServer: HttpMetricsServer | null;
+  monitoring: MonitoringService | null;
+  restApi?: BeaconRestApiServer;
+  controller?: AbortController;
+};
+
+export type BeaconNodeInitModules = {
+  opts: IBeaconNodeOptions;
+  config: BeaconConfig;
+  db: IBeaconDb;
+  logger: LoggerNode;
+  processShutdownCallback: ProcessShutdownCallback;
+  privateKey: PrivateKey;
+  dataDir: string;
+  peerStoreDir?: string;
+  anchorState: BeaconStateAllForks;
+  wsCheckpoint?: phase0.Checkpoint;
+  metricsRegistries?: Registry[];
+};
+
+export enum BeaconNodeStatus {
+  started = "started",
+  closing = "closing",
+  closed = "closed",
+}
+
+enum LoggerModule {
+  api = "api",
+  backfill = "backfill",
+  chain = "chain",
+  eth1 = "eth1",
+  execution = "execution",
+  metrics = "metrics",
+  monitoring = "monitoring",
+  network = "network",
+  /** validator monitor */
+  vmon = "vmon",
+  rest = "rest",
+  sync = "sync",
+}
+
+/**
+ * Short delay before closing db to give async operations sufficient time to complete
+ * and prevent "Database is not open" errors when shutting down beacon node.
+ */
+const DELAY_BEFORE_CLOSING_DB_MS = 500;
+
+/**
+ * The main Beacon Node class.  Contains various components for getting and processing data from the
+ * Ethereum Consensus ecosystem as well as systems for getting beacon node metadata.
+ */
+export class BeaconNode {
+  opts: IBeaconNodeOptions;
+  config: BeaconConfig;
+  db: IBeaconDb;
+  metrics: Metrics | null;
+  metricsServer: HttpMetricsServer | null;
+  monitoring: MonitoringService | null;
+  validatorMonitor: ValidatorMonitor | null;
+  network: Network;
+  chain: IBeaconChain;
+  api: BeaconApiMethods;
+  restApi?: BeaconRestApiServer;
+  sync: IBeaconSync;
+  backfillSync: BackfillSync | null;
+
+  status: BeaconNodeStatus;
+  private controller?: AbortController;
+
+  constructor({
+    opts,
+    config,
+    db,
+    metrics,
+    metricsServer,
+    monitoring,
+    validatorMonitor,
+    network,
+    chain,
+    api,
+    restApi,
+    sync,
+    backfillSync,
+    controller,
+  }: BeaconNodeModules) {
+    this.opts = opts;
+    this.config = config;
+    this.metrics = metrics;
+    this.metricsServer = metricsServer;
+    this.monitoring = monitoring;
+    this.validatorMonitor = validatorMonitor;
+    this.db = db;
+    this.chain = chain;
+    this.api = api;
+    this.restApi = restApi;
+    this.network = network;
+    this.sync = sync;
+    this.backfillSync = backfillSync;
+    this.controller = controller;
+
+    this.status = BeaconNodeStatus.started;
+  }
+
+  /**
+   * Initialize a beacon node.  Initializes and `start`s the varied sub-component services of the
+   * beacon node
+   */
+  static async init<T extends BeaconNode = BeaconNode>({
+    opts,
+    config,
+    db,
+    logger,
+    processShutdownCallback,
+    privateKey,
+    dataDir,
+    peerStoreDir,
+    anchorState,
+    wsCheckpoint,
+    metricsRegistries = [],
+  }: BeaconNodeInitModules): Promise<T> {
+    if (hasher.name !== "hashtree") {
+      logger.warn(`hashtree is not supported, using hasher ${hasher.name}`);
+    }
+
+    const controller = new AbortController();
+    // We set infinity to prevent MaxListenersExceededWarning which get logged when listeners > 10
+    // Since it is perfectly fine to have listeners > 10
+    setMaxListeners(Infinity, controller.signal);
+    const signal = controller.signal;
+
+    let metrics = null;
+    if (
+      opts.metrics.enabled ||
+      // monitoring relies on metrics data
+      opts.monitoring.endpoint
+    ) {
+      metrics = createMetrics(opts.metrics, anchorState.genesisTime, metricsRegistries);
+      initBeaconMetrics(metrics, anchorState);
+      // Since the db is instantiated before this, metrics must be injected manually afterwards
+      db.setMetrics(metrics.db);
+      signal.addEventListener("abort", metrics.close, {once: true});
+    }
+
+    const validatorMonitor =
+      opts.metrics.enabled || opts.validatorMonitor.validatorMonitorLogs
+        ? createValidatorMonitor(
+            metrics?.register ?? null,
+            config,
+            anchorState.genesisTime,
+            logger.child({module: LoggerModule.vmon}),
+            opts.validatorMonitor
+          )
+        : null;
+
+    const clock = new Clock({config, genesisTime: anchorState.genesisTime, signal});
+
+    // Prune hot db repos
+    // TODO: Should this call be awaited?
+    await db.pruneHotDb();
+
+    const monitoring = opts.monitoring.endpoint
+      ? new MonitoringService(
+          "beacon",
+          {...opts.monitoring, endpoint: opts.monitoring.endpoint},
+          {register: (metrics as Metrics).register, logger: logger.child({module: LoggerModule.monitoring})}
+        )
+      : null;
+
+    const chain = new BeaconChain(opts.chain, {
+      privateKey,
+      config,
+      clock,
+      dataDir,
+      db,
+      dbName: opts.db.name,
+      logger: logger.child({module: LoggerModule.chain}),
+      processShutdownCallback,
+      metrics,
+      validatorMonitor,
+      anchorState,
+      eth1: initializeEth1ForBlockProduction(opts.eth1, {
+        config,
+        db,
+        metrics,
+        logger: logger.child({module: LoggerModule.eth1}),
+        signal,
+      }),
+      executionEngine: initializeExecutionEngine(opts.executionEngine, {
+        metrics,
+        signal,
+        logger: logger.child({module: LoggerModule.execution}),
+      }),
+      executionBuilder: opts.executionBuilder.enabled
+        ? initializeExecutionBuilder(opts.executionBuilder, config, metrics, logger)
+        : undefined,
+    });
+
+    // Load persisted data from disk to in-memory caches
+    await chain.init();
+
+    // Network needs to be initialized before the sync
+    // See https://github.com/ChainSafe/lodestar/issues/4543
+    const network = await Network.init({
+      opts: opts.network,
+      config,
+      logger: logger.child({module: LoggerModule.network}),
+      metrics,
+      chain,
+      db,
+      privateKey,
+      peerStoreDir,
+      getReqRespHandler: getReqRespHandlers({db, chain}),
+    });
+
+    const sync = new BeaconSync(opts.sync, {
+      config,
+      db,
+      chain,
+      metrics,
+      network,
+      wsCheckpoint,
+      logger: logger.child({module: LoggerModule.sync}),
+    });
+
+    const backfillSync =
+      opts.sync.backfillBatchSize > 0
+        ? await BackfillSync.init(opts.sync, {
+            config,
+            db,
+            chain,
+            metrics,
+            network,
+            wsCheckpoint,
+            anchorState,
+            logger: logger.child({module: LoggerModule.backfill}),
+            signal,
+          })
+        : null;
+
+    const api = getApi(opts.api, {
+      config,
+      logger: logger.child({module: LoggerModule.api}),
+      db,
+      sync,
+      network,
+      chain,
+      metrics,
+    });
+
+    // only start server if metrics are explicitly enabled
+    const metricsServer = opts.metrics.enabled
+      ? await getHttpMetricsServer(opts.metrics, {
+          register: (metrics as Metrics).register,
+          getOtherMetrics: async () => Promise.all([network.scrapeMetrics(), chain.archiveStore.scrapeMetrics()]),
+          logger: logger.child({module: LoggerModule.metrics}),
+        })
+      : null;
+
+    const restApi = new BeaconRestApiServer(opts.api.rest, {
+      config,
+      logger: logger.child({module: LoggerModule.rest}),
+      api,
+      metrics: metrics ? metrics.apiRest : null,
+    });
+    if (opts.api.rest.enabled) {
+      await restApi.registerRoutes(opts.api.version);
+      await restApi.listen();
+    }
+
+    void runNodeNotifier({network, chain, sync, config, logger, signal});
+
+    return new BeaconNode({
+      opts,
+      config,
+      db,
+      metrics,
+      metricsServer,
+      monitoring,
+      validatorMonitor,
+      network,
+      chain,
+      api,
+      restApi,
+      sync,
+      backfillSync,
+      controller,
+    }) as T;
+  }
+
+  /**
+   * Stop beacon node and its sub-components.
+   */
+  async close(): Promise<void> {
+    if (this.status === BeaconNodeStatus.started) {
+      this.status = BeaconNodeStatus.closing;
+      this.sync.close();
+      this.backfillSync?.close();
+      if (this.restApi) await this.restApi.close();
+      await this.network.close();
+      if (this.metricsServer) await this.metricsServer.close();
+      if (this.monitoring) this.monitoring.close();
+      await this.chain.persistToDisk();
+      await this.chain.close();
+      if (this.controller) this.controller.abort();
+      await sleep(DELAY_BEFORE_CLOSING_DB_MS);
+      await this.db.close();
+      this.status = BeaconNodeStatus.closed;
+    }
+  }
+}

package/src/node/notifier.ts

@@ -0,0 +1,206 @@
+import {BeaconConfig} from "@lodestar/config";
+import {ExecutionStatus, ProtoBlock} from "@lodestar/fork-choice";
+import {EPOCHS_PER_SYNC_COMMITTEE_PERIOD, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {
+  CachedBeaconStateAllForks,
+  computeEpochAtSlot,
+  computeStartSlotAtEpoch,
+  isExecutionCachedStateType,
+  isMergeTransitionComplete,
+} from "@lodestar/state-transition";
+import {Epoch} from "@lodestar/types";
+import {ErrorAborted, Logger, prettyBytes, prettyBytesShort, sleep} from "@lodestar/utils";
+import {IBeaconChain} from "../chain/index.js";
+import {ExecutionEngineState} from "../execution/index.js";
+import {INetwork} from "../network/index.js";
+import {IBeaconSync, SyncState} from "../sync/index.js";
+import {prettyTimeDiffSec} from "../util/time.js";
+import {TimeSeries} from "../util/timeSeries.js";
+
+/** Create a warning log whenever the peer count is at or below this value */
+const WARN_PEER_COUNT = 1;
+
+type NodeNotifierModules = {
+  network: INetwork;
+  chain: IBeaconChain;
+  sync: IBeaconSync;
+  config: BeaconConfig;
+  logger: Logger;
+  signal: AbortSignal;
+};
+
+/**
+ * Runs a notifier service that periodically logs information about the node.
+ */
+export async function runNodeNotifier(modules: NodeNotifierModules): Promise<void> {
+  const {network, chain, sync, config, logger, signal} = modules;
+
+  const headSlotTimeSeries = new TimeSeries({maxPoints: 10});
+  const tdTimeSeries = new TimeSeries({maxPoints: 50});
+
+  const SLOTS_PER_SYNC_COMMITTEE_PERIOD = SLOTS_PER_EPOCH * EPOCHS_PER_SYNC_COMMITTEE_PERIOD;
+  let hasLowPeerCount = false;
+  let isFirstTime = true;
+
+  try {
+    while (!signal.aborted) {
+      const connectedPeerCount = network.getConnectedPeerCount();
+
+      if (connectedPeerCount <= WARN_PEER_COUNT) {
+        // Only log once and prevent peer count warning on startup
+        if (!hasLowPeerCount && !isFirstTime) {
+          logger.warn("Low peer count", {peers: connectedPeerCount});
+          hasLowPeerCount = true;
+        }
+      } else {
+        hasLowPeerCount = false;
+      }
+
+      const clockSlot = chain.clock.currentSlot;
+      const clockEpoch = computeEpochAtSlot(clockSlot);
+
+      if (clockEpoch >= config.BELLATRIX_FORK_EPOCH && computeStartSlotAtEpoch(clockEpoch) === clockSlot) {
+        if (chain.executionEngine.state === ExecutionEngineState.OFFLINE) {
+          logger.warn("Execution client is offline");
+        } else if (chain.executionEngine.state === ExecutionEngineState.AUTH_FAILED) {
+          logger.error("Execution client authentication failed. Verify if the JWT secret matches on both clients");
+        }
+      }
+
+      const headInfo = chain.forkChoice.getHead();
+      const headState = chain.getHeadState();
+      const finalizedEpoch = headState.finalizedCheckpoint.epoch;
+      const finalizedRoot = headState.finalizedCheckpoint.root;
+      const headSlot = headInfo.slot;
+      headSlotTimeSeries.addPoint(headSlot, Math.floor(Date.now() / 1000));
+
+      const peersRow = `peers: ${connectedPeerCount}`;
+      const clockSlotRow = `slot: ${clockSlot}`;
+
+      // Give info about empty slots if head < clock
+      const skippedSlots = clockSlot - headInfo.slot;
+      // headDiffInfo to have space suffix if its a non empty string
+      const headDiffInfo =
+        skippedSlots > 0 ? (skippedSlots > 1000 ? `${headInfo.slot} ` : `(slot -${skippedSlots}) `) : "";
+      const headRow = `head: ${headDiffInfo}${prettyBytes(headInfo.blockRoot)}`;
+
+      const executionInfo = getHeadExecutionInfo(config, clockEpoch, headState, headInfo);
+      const finalizedCheckpointRow = `finalized: ${prettyBytes(finalizedRoot)}:${finalizedEpoch}`;
+
+      // Log in TD progress in separate line to not clutter regular status update.
+      // This line will only exist between BELLATRIX_FORK_EPOCH and TTD, a window of some days / weeks max.
+      // Notifier log lines must be kept at a reasonable max width otherwise it's very hard to read
+      const tdProgress = chain.eth1.getTDProgress();
+      if (tdProgress !== null && !tdProgress.ttdHit) {
+        tdTimeSeries.addPoint(tdProgress.tdDiffScaled, tdProgress.timestamp);
+
+        const timestampTDD = tdTimeSeries.computeY0Point();
+        // It is possible to get ttd estimate with an error at imminent merge
+        const secToTTD = Math.max(Math.floor(timestampTDD - Date.now() / 1000), 0);
+        const timeLeft = Number.isFinite(secToTTD) ? prettyTimeDiffSec(secToTTD) : "?";
+
+        logger.info(`TTD in ${timeLeft} current TD ${tdProgress.td} / ${tdProgress.ttd}`);
+      }
+
+      let nodeState: string[];
+      switch (sync.state) {
+        case SyncState.SyncingFinalized:
+        case SyncState.SyncingHead: {
+          const slotsPerSecond = Math.max(headSlotTimeSeries.computeLinearSpeed(), 0);
+          const distance = Math.max(clockSlot - headSlot, 0);
+          const secondsLeft = distance / slotsPerSecond;
+          const timeLeft = Number.isFinite(secondsLeft) ? prettyTimeDiffSec(secondsLeft) : "?";
+          // Syncing - time left - speed - head - finalized - clock - peers
+          nodeState = [
+            "Syncing",
+            `${timeLeft} left`,
+            `${slotsPerSecond.toPrecision(3)} slots/s`,
+            clockSlotRow,
+            headRow,
+            ...executionInfo,
+            finalizedCheckpointRow,
+            peersRow,
+          ];
+          break;
+        }
+
+        case SyncState.Synced: {
+          // Synced - clock - head - finalized - peers
+          nodeState = ["Synced", clockSlotRow, headRow, ...executionInfo, finalizedCheckpointRow, peersRow];
+          break;
+        }
+
+        case SyncState.Stalled: {
+          // Searching peers - peers - head - finalized - clock
+          nodeState = ["Searching peers", peersRow, clockSlotRow, headRow, ...executionInfo, finalizedCheckpointRow];
+        }
+      }
+      logger.info(nodeState.join(" - "));
+
+      // Log important chain time-based events
+      // Log sync committee change
+      if (clockEpoch > config.ALTAIR_FORK_EPOCH && clockSlot % SLOTS_PER_SYNC_COMMITTEE_PERIOD === 0) {
+        const period = Math.floor(clockEpoch / EPOCHS_PER_SYNC_COMMITTEE_PERIOD);
+        logger.info(`New sync committee period ${period}`);
+      }
+
+      // Log halfway through each slot
+      await sleep(timeToNextHalfSlot(config, chain, isFirstTime), signal);
+      isFirstTime = false;
+    }
+  } catch (e) {
+    if (e instanceof ErrorAborted) {
+      return; // Ok
+    }
+    logger.error("Node notifier error", {}, e as Error);
+  }
+}
+
+function timeToNextHalfSlot(config: BeaconConfig, chain: IBeaconChain, isFirstTime: boolean): number {
+  const msPerSlot = config.SECONDS_PER_SLOT * 1000;
+  const msPerHalfSlot = msPerSlot / 2;
+  const msFromGenesis = Date.now() - chain.genesisTime * 1000;
+  const msToNextSlot =
+    msFromGenesis < 0
+      ? // For future genesis time, calculate time left in the slot
+        -msFromGenesis % msPerSlot
+      : // For past genesis time, calculate time until the next slot
+        msPerSlot - (msFromGenesis % msPerSlot);
+  if (isFirstTime) {
+    // at the 1st time we may miss middle of the current clock slot
+    return msToNextSlot > msPerHalfSlot ? msToNextSlot - msPerHalfSlot : msToNextSlot + msPerHalfSlot;
+  }
+  // after the 1st time always wait until middle of next clock slot
+  return msToNextSlot + msPerHalfSlot;
+}
+
+function getHeadExecutionInfo(
+  config: BeaconConfig,
+  clockEpoch: Epoch,
+  headState: CachedBeaconStateAllForks,
+  headInfo: ProtoBlock
+): string[] {
+  if (clockEpoch < config.BELLATRIX_FORK_EPOCH) {
+    return [];
+  }
+
+  const executionStatusStr = headInfo.executionStatus.toLowerCase();
+
+  // Add execution status to notifier only if head is on/post bellatrix
+  if (isExecutionCachedStateType(headState)) {
+    if (isMergeTransitionComplete(headState)) {
+      const executionPayloadHashInfo =
+        headInfo.executionStatus !== ExecutionStatus.PreMerge ? headInfo.executionPayloadBlockHash : "empty";
+      const executionPayloadNumberInfo =
+        headInfo.executionStatus !== ExecutionStatus.PreMerge ? headInfo.executionPayloadNumber : NaN;
+      return [
+        `exec-block: ${executionStatusStr}(${executionPayloadNumberInfo} ${prettyBytesShort(
+          executionPayloadHashInfo
+        )})`,
+      ];
+    }
+    return [`exec-block: ${executionStatusStr}`];
+  }
+
+  return [];
+}

package/src/node/options.ts

@@ -0,0 +1,51 @@
+import {ApiOptions, defaultApiOptions} from "../api/options.js";
+import {ArchiveMode, DEFAULT_ARCHIVE_MODE, IChainOptions, defaultChainOptions} from "../chain/options.js";
+import {ValidatorMonitorOpts, defaultValidatorMonitorOpts} from "../chain/validatorMonitor.js";
+import {DatabaseOptions, defaultDbOptions} from "../db/options.js";
+import {Eth1Options, defaultEth1Options} from "../eth1/options.js";
+import {
+  ExecutionBuilderOpts,
+  ExecutionEngineOpts,
+  defaultExecutionBuilderHttpOpts,
+  defaultExecutionBuilderOpts,
+  defaultExecutionEngineHttpOpts,
+  defaultExecutionEngineOpts,
+} from "../execution/index.js";
+import {MetricsOptions, defaultMetricsOptions} from "../metrics/options.js";
+import {MonitoringOptions, defaultMonitoringOptions} from "../monitoring/options.js";
+import {NetworkOptions, defaultNetworkOptions} from "../network/options.js";
+import {SyncOptions, defaultSyncOptions} from "../sync/options.js";
+
+// Re-export so the CLI doesn't need to depend on lodestar-api
+export {allNamespaces} from "../api/rest/index.js";
+
+// Re-export to use as default values in CLI args
+export {defaultExecutionEngineHttpOpts, defaultExecutionBuilderHttpOpts, ArchiveMode, DEFAULT_ARCHIVE_MODE};
+
+export interface IBeaconNodeOptions {
+  api: ApiOptions;
+  chain: IChainOptions;
+  db: DatabaseOptions;
+  eth1: Eth1Options;
+  executionEngine: ExecutionEngineOpts;
+  executionBuilder: ExecutionBuilderOpts;
+  metrics: MetricsOptions;
+  validatorMonitor: ValidatorMonitorOpts;
+  monitoring: MonitoringOptions;
+  network: NetworkOptions;
+  sync: SyncOptions;
+}
+
+export const defaultOptions: IBeaconNodeOptions = {
+  api: defaultApiOptions,
+  chain: defaultChainOptions,
+  db: defaultDbOptions,
+  eth1: defaultEth1Options,
+  executionEngine: defaultExecutionEngineOpts,
+  executionBuilder: defaultExecutionBuilderOpts,
+  metrics: defaultMetricsOptions,
+  validatorMonitor: defaultValidatorMonitorOpts,
+  monitoring: defaultMonitoringOptions,
+  network: defaultNetworkOptions,
+  sync: defaultSyncOptions,
+};

package/src/node/utils/interop/deposits.ts

@@ -0,0 +1,53 @@
+import {digest} from "@chainsafe/as-sha256";
+import {Tree, toGindex} from "@chainsafe/persistent-merkle-tree";
+import {ChainConfig} from "@lodestar/config";
+import {
+  BLS_WITHDRAWAL_PREFIX,
+  DOMAIN_DEPOSIT,
+  ETH1_ADDRESS_WITHDRAWAL_PREFIX,
+  MAX_EFFECTIVE_BALANCE,
+} from "@lodestar/params";
+import {ZERO_HASH, computeDomain, computeSigningRoot, interopSecretKeys} from "@lodestar/state-transition";
+import {phase0, ssz} from "@lodestar/types";
+import {DepositTree} from "../../../db/repositories/depositDataRoot.js";
+
+/**
+ * Compute and return deposit data from other validators.
+ */
+export function interopDeposits(
+  config: ChainConfig,
+  depositDataRootList: DepositTree,
+  validatorCount: number,
+  {withEth1Credentials}: {withEth1Credentials?: boolean} = {}
+): phase0.Deposit[] {
+  depositDataRootList.commit();
+  const depositTreeDepth = depositDataRootList.type.depth;
+  // set credentials if we want withdrawal on or off
+  const withdrawalCredentialsPrefix = withEth1Credentials ? ETH1_ADDRESS_WITHDRAWAL_PREFIX : BLS_WITHDRAWAL_PREFIX;
+
+  return interopSecretKeys(validatorCount).map((secretKey, i) => {
+    const pubkey = secretKey.toPublicKey().toBytes();
+
+    // create DepositData
+    const withdrawalCredentials = digest(pubkey);
+    withdrawalCredentials[0] = withdrawalCredentialsPrefix;
+    const data: phase0.DepositData = {
+      pubkey,
+      withdrawalCredentials,
+      amount: MAX_EFFECTIVE_BALANCE,
+      signature: Buffer.alloc(0),
+    };
+
+    const domain = computeDomain(DOMAIN_DEPOSIT, config.GENESIS_FORK_VERSION, ZERO_HASH);
+    const signingRoot = computeSigningRoot(ssz.phase0.DepositMessage, data, domain);
+    data.signature = secretKey.sign(signingRoot).toBytes();
+
+    // Add to merkle tree
+    depositDataRootList.push(ssz.phase0.DepositData.hashTreeRoot(data));
+    depositDataRootList.commit();
+    return {
+      proof: new Tree(depositDataRootList.node).getSingleProof(toGindex(depositTreeDepth, BigInt(i))),
+      data,
+    };
+  });
+}