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

package/src/network/util.ts

@@ -1,29 +0,0 @@
-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

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

package/src/node/nodejs.ts

@@ -1,349 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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,
-    };
-  });
-}