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

package/src/network/core/networkCoreWorker.ts

@@ -1,176 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import worker from "node:worker_threads";
-import {privateKeyFromProtobuf} from "@libp2p/crypto/keys";
-import {peerIdFromPrivateKey} from "@libp2p/peer-id";
-import type {ModuleThread} from "@chainsafe/threads";
-import {expose} from "@chainsafe/threads/worker";
-import {chainConfigFromJson, createBeaconConfig} from "@lodestar/config";
-import {getNodeLogger} from "@lodestar/logger/node";
-import {RegistryMetricCreator, collectNodeJSMetrics} from "../../metrics/index.js";
-import {AsyncIterableBridgeCaller, AsyncIterableBridgeHandler} from "../../util/asyncIterableToEvents.js";
-import {Clock} from "../../util/clock.js";
-import {peerIdToString} from "../../util/peerId.js";
-import {profileNodeJS, writeHeapSnapshot} from "../../util/profile.js";
-import {wireEventsOnWorkerThread} from "../../util/workerEvents.js";
-import {NetworkEventBus, NetworkEventData, networkEventDirection} from "../events.js";
-import {
-  NetworkWorkerThreadEventType,
-  ReqRespBridgeEventBus,
-  ReqRespBridgeEventData,
-  getReqRespBridgeReqEvents,
-  getReqRespBridgeRespEvents,
-  reqRespBridgeEventDirection,
-} from "./events.js";
-import {getNetworkCoreWorkerMetrics} from "./metrics.js";
-import {NetworkCore} from "./networkCore.js";
-import {NetworkWorkerApi, NetworkWorkerData} from "./types.js";
-
-// Cloned data from instantiation
-const workerData = worker.workerData as NetworkWorkerData;
-const parentPort = worker.parentPort;
-if (!workerData) throw Error("workerData must be defined");
-if (!parentPort) throw Error("parentPort must be defined");
-
-const config = createBeaconConfig(chainConfigFromJson(workerData.chainConfigJson), workerData.genesisValidatorsRoot);
-const privateKey = privateKeyFromProtobuf(workerData.privateKeyProto);
-const peerId = peerIdFromPrivateKey(privateKey);
-
-// TODO: Pass options from main thread for logging
-// TODO: Logging won't be visible in file loggers
-const logger = getNodeLogger(workerData.loggerOpts);
-
-// Alive and consistency check
-logger.info("libp2p worker started", {peer: peerIdToString(peerId)});
-
-const abortController = new AbortController();
-
-// Set up metrics, nodejs and discv5-specific
-const metricsRegister = workerData.metricsEnabled ? new RegistryMetricCreator() : null;
-if (metricsRegister) {
-  const closeMetrics = collectNodeJSMetrics(metricsRegister, "network_worker_");
-  abortController.signal.addEventListener("abort", closeMetrics, {once: true});
-}
-
-// Main event bus shared across the stack
-const events = new NetworkEventBus();
-const reqRespBridgeEventBus = new ReqRespBridgeEventBus();
-const clock = new Clock({config, genesisTime: workerData.genesisTime, signal: abortController.signal});
-
-// ReqResp event bridge
-//
-// The ReqRespHandler module handles app-level requests / responses from other peers,
-// fetching state from the chain and database as needed.
-//
-// On the worker's side the ReqResp module will call the async generator when the stream
-// is ready to send responses to the multiplexed libp2p stream.
-//
-// - libp2p inbound stream opened for reqresp method
-// - request data fully streamed
-// - ResResp handler called with request data and started
-// - stream calls next() on handler
-// - handler fetches block from DB, yields value
-// - stream calls next() again
-// - handler fetches block from DB, yields value
-// (case a)
-// - remote peer disconnects, stream aborted, calls return() on handler
-// (case b)
-// - handler has yielded all blocks, returns
-// (case c)
-// - handler encounters error, throws
-new AsyncIterableBridgeHandler(getReqRespBridgeReqEvents(reqRespBridgeEventBus), (data) =>
-  core.sendReqRespRequest(data)
-);
-const reqRespBridgeRespCaller = new AsyncIterableBridgeCaller(getReqRespBridgeRespEvents(reqRespBridgeEventBus));
-
-const networkCoreWorkerMetrics = metricsRegister ? getNetworkCoreWorkerMetrics(metricsRegister) : null;
-// respBridgeCaller metrics
-if (networkCoreWorkerMetrics) {
-  networkCoreWorkerMetrics.reqRespBridgeRespCallerPending.addCollect(() => {
-    networkCoreWorkerMetrics.reqRespBridgeRespCallerPending.set(reqRespBridgeRespCaller.pendingCount);
-  });
-}
-
-const core = await NetworkCore.init({
-  opts: workerData.opts,
-  config,
-  privateKey,
-  peerStoreDir: workerData.peerStoreDir,
-  logger,
-  metricsRegistry: metricsRegister,
-  events,
-  clock,
-  getReqRespHandler: (method) => (req, peerId) =>
-    reqRespBridgeRespCaller.getAsyncIterable({method, req, peerId: peerIdToString(peerId)}),
-  activeValidatorCount: workerData.activeValidatorCount,
-  initialStatus: workerData.initialStatus,
-  initialCustodyGroupCount: workerData.initialCustodyGroupCount,
-});
-
-wireEventsOnWorkerThread<NetworkEventData>(
-  NetworkWorkerThreadEventType.networkEvent,
-  events,
-  parentPort,
-  networkCoreWorkerMetrics,
-  networkEventDirection
-);
-wireEventsOnWorkerThread<ReqRespBridgeEventData>(
-  NetworkWorkerThreadEventType.reqRespBridgeEvents,
-  reqRespBridgeEventBus,
-  parentPort,
-  networkCoreWorkerMetrics,
-  reqRespBridgeEventDirection
-);
-
-const libp2pWorkerApi: NetworkWorkerApi = {
-  close: async () => {
-    abortController.abort();
-    await core.close();
-  },
-  scrapeMetrics: () => core.scrapeMetrics(),
-
-  updateStatus: (status) => core.updateStatus(status),
-
-  prepareBeaconCommitteeSubnets: (subscriptions) => core.prepareBeaconCommitteeSubnets(subscriptions),
-  prepareSyncCommitteeSubnets: (subscriptions) => core.prepareSyncCommitteeSubnets(subscriptions),
-  reportPeer: (peer, action, actionName) => core.reportPeer(peer, action, actionName),
-  reStatusPeers: (peers) => core.reStatusPeers(peers),
-  subscribeGossipCoreTopics: () => core.subscribeGossipCoreTopics(),
-  unsubscribeGossipCoreTopics: () => core.unsubscribeGossipCoreTopics(),
-
-  // sendReqRespRequest - handled via events with AsyncIterableBridgeHandler
-  publishGossip: (topic, data, opts) => core.publishGossip(topic, data, opts),
-
-  setTargetGroupCount: (count) => core.setTargetGroupCount(count),
-
-  // Debug
-
-  getNetworkIdentity: () => core.getNetworkIdentity(),
-  getConnectedPeers: () => core.getConnectedPeers(),
-  getConnectedPeerCount: () => core.getConnectedPeerCount(),
-  connectToPeer: (peer, multiaddr) => core.connectToPeer(peer, multiaddr),
-  disconnectPeer: (peer) => core.disconnectPeer(peer),
-  dumpPeers: () => core.dumpPeers(),
-  dumpPeer: (peerIdStr) => core.dumpPeer(peerIdStr),
-  dumpPeerScoreStats: () => core.dumpPeerScoreStats(),
-  dumpGossipPeerScoreStats: () => core.dumpGossipPeerScoreStats(),
-  dumpDiscv5KadValues: () => core.dumpDiscv5KadValues(),
-  dumpMeshPeers: () => core.dumpMeshPeers(),
-  writeProfile: async (durationMs: number, dirpath: string) => {
-    const profile = await profileNodeJS(durationMs);
-    const filePath = path.join(dirpath, `network_thread_${new Date().toISOString()}.cpuprofile`);
-    fs.writeFileSync(filePath, profile);
-    return filePath;
-  },
-  writeDiscv5Profile: async (durationMs: number, dirpath: string) => {
-    return core.writeDiscv5Profile(durationMs, dirpath);
-  },
-  writeHeapSnapshot: async (prefix: string, dirpath: string) => {
-    return writeHeapSnapshot(prefix, dirpath);
-  },
-  writeDiscv5HeapSnapshot: async (prefix: string, dirpath: string) => {
-    return core.writeDiscv5HeapSnapshot(prefix, dirpath);
-  },
-};
-
-expose(libp2pWorkerApi as ModuleThread<NetworkWorkerApi>);

package/src/network/core/networkCoreWorkerHandler.ts

@@ -1,284 +0,0 @@
-import path from "node:path";
-import workerThreads from "node:worker_threads";
-import {privateKeyToProtobuf} from "@libp2p/crypto/keys";
-import {PrivateKey} from "@libp2p/interface";
-import {PeerScoreStatsDump} from "@chainsafe/libp2p-gossipsub/score";
-import {PublishOpts} from "@chainsafe/libp2p-gossipsub/types";
-import {ModuleThread, Thread, Worker, spawn} from "@chainsafe/threads";
-import {routes} from "@lodestar/api";
-import {BeaconConfig, chainConfigToJson} from "@lodestar/config";
-import type {LoggerNode} from "@lodestar/logger/node";
-import {ResponseIncoming, ResponseOutgoing} from "@lodestar/reqresp";
-import {Status} from "@lodestar/types";
-import {Metrics} from "../../metrics/index.js";
-import {AsyncIterableBridgeCaller, AsyncIterableBridgeHandler} from "../../util/asyncIterableToEvents.js";
-import {PeerIdStr, peerIdFromString} from "../../util/peerId.js";
-import {terminateWorkerThread, wireEventsOnMainThread} from "../../util/workerEvents.js";
-import {NetworkEventBus, NetworkEventData, networkEventDirection} from "../events.js";
-import {NetworkOptions} from "../options.js";
-import {PeerAction, PeerScoreStats} from "../peers/index.js";
-import {GetReqRespHandlerFn, IncomingRequestArgs, OutgoingRequestArgs} from "../reqresp/types.js";
-import {CommitteeSubscription} from "../subnets/interface.js";
-import {
-  NetworkWorkerThreadEventType,
-  ReqRespBridgeEventBus,
-  ReqRespBridgeEventData,
-  getReqRespBridgeReqEvents,
-  getReqRespBridgeRespEvents,
-  reqRespBridgeEventDirection,
-} from "./events.js";
-import {INetworkCore, MultiaddrStr, NetworkWorkerApi, NetworkWorkerData} from "./types.js";
-
-// Worker constructor consider the path relative to the current working directory
-const workerDir = process.env.NODE_ENV === "test" ? "../../../lib/network/core/" : "./";
-
-export type WorkerNetworkCoreOpts = NetworkOptions & {
-  metricsEnabled: boolean;
-  peerStoreDir?: string;
-  activeValidatorCount: number;
-  genesisTime: number;
-  initialStatus: Status;
-  initialCustodyGroupCount: number;
-};
-
-export type WorkerNetworkCoreInitModules = {
-  opts: WorkerNetworkCoreOpts;
-  config: BeaconConfig;
-  logger: LoggerNode;
-  privateKey: PrivateKey;
-  events: NetworkEventBus;
-  metrics: Metrics | null;
-  getReqRespHandler: GetReqRespHandlerFn;
-};
-
-type WorkerNetworkCoreModules = WorkerNetworkCoreInitModules & {
-  networkThreadApi: ModuleThread<NetworkWorkerApi>;
-  worker: Worker;
-};
-
-const NETWORK_WORKER_EXIT_TIMEOUT_MS = 1000;
-const NETWORK_WORKER_EXIT_RETRY_COUNT = 3;
-
-/**
- * NetworkCore implementation using a Worker thread
- */
-export class WorkerNetworkCore implements INetworkCore {
-  private readonly reqRespBridgeReqCaller: AsyncIterableBridgeCaller<OutgoingRequestArgs, ResponseIncoming>;
-  protected readonly reqRespBridgeRespHandler: AsyncIterableBridgeHandler<IncomingRequestArgs, ResponseOutgoing>;
-  private readonly reqRespBridgeEventBus = new ReqRespBridgeEventBus();
-
-  constructor(private readonly modules: WorkerNetworkCoreModules) {
-    // Get called from main thread to issue a ReqResp request, and emits event to worker
-    this.reqRespBridgeReqCaller = new AsyncIterableBridgeCaller(getReqRespBridgeReqEvents(this.reqRespBridgeEventBus));
-    // Handles ReqResp response from worker and calls async generator in main thread
-    this.reqRespBridgeRespHandler = new AsyncIterableBridgeHandler(
-      getReqRespBridgeRespEvents(this.reqRespBridgeEventBus),
-      (data) => modules.getReqRespHandler(data.method)(data.req, peerIdFromString(data.peerId))
-    );
-
-    wireEventsOnMainThread<NetworkEventData>(
-      NetworkWorkerThreadEventType.networkEvent,
-      modules.events,
-      modules.worker as unknown as workerThreads.Worker,
-      modules.metrics,
-      networkEventDirection
-    );
-    wireEventsOnMainThread<ReqRespBridgeEventData>(
-      NetworkWorkerThreadEventType.reqRespBridgeEvents,
-      this.reqRespBridgeEventBus,
-      modules.worker as unknown as workerThreads.Worker,
-      modules.metrics,
-      reqRespBridgeEventDirection
-    );
-
-    Thread.errors(modules.networkThreadApi).subscribe((err) => {
-      this.modules.logger.error("Network worker thread error", {}, err);
-    });
-
-    const {metrics} = modules;
-    if (metrics) {
-      metrics.networkWorkerHandler.reqRespBridgeReqCallerPending.addCollect(() => {
-        metrics.networkWorkerHandler.reqRespBridgeReqCallerPending.set(this.reqRespBridgeReqCaller.pendingCount);
-      });
-    }
-  }
-
-  static async init(modules: WorkerNetworkCoreInitModules): Promise<WorkerNetworkCore> {
-    const {opts, config, privateKey} = modules;
-    const {
-      genesisTime,
-      peerStoreDir,
-      activeValidatorCount,
-      localMultiaddrs,
-      metricsEnabled,
-      initialStatus,
-      initialCustodyGroupCount,
-    } = opts;
-
-    const workerData: NetworkWorkerData = {
-      opts,
-      chainConfigJson: chainConfigToJson(config),
-      genesisValidatorsRoot: config.genesisValidatorsRoot,
-      privateKeyProto: privateKeyToProtobuf(privateKey),
-      localMultiaddrs,
-      metricsEnabled,
-      peerStoreDir,
-      genesisTime,
-      initialStatus,
-      initialCustodyGroupCount,
-      activeValidatorCount,
-      loggerOpts: modules.logger.toOpts(),
-    };
-
-    const workerOpts: ConstructorParameters<typeof Worker>[1] = {
-      workerData,
-    };
-    if (globalThis.Bun) {
-      workerOpts.suppressTranspileTS = true;
-    } else {
-      /**
-       * maxYoungGenerationSizeMb defaults to 152mb through the cli option defaults.
-       * That default value was determined via https://github.com/ChainSafe/lodestar/issues/2115 and
-       * should be tuned further as needed.  If we update network code and see substantial
-       * difference in the quantity of garbage collected this should get updated.  A value that is
-       * too low will result in too much GC time and a value that is too high causes increased mark
-       * and sweep for some reason (which is much much slower than scavenge).  A marginally too high
-       * number causes detrimental slowdown from increased variable lookup time.  Empirical evidence
-       * showed that there is a pretty big window of "correct" values but we can always tune as
-       * necessary
-       */
-      workerOpts.resourceLimits = {maxYoungGenerationSizeMb: opts.maxYoungGenerationSizeMb};
-    }
-
-    const worker = new Worker(path.join(workerDir, "networkCoreWorker.js"), workerOpts);
-
-    // biome-ignore lint/suspicious/noExplicitAny: Don't know any specific interface for the spawn
-    const networkThreadApi = (await spawn<any>(worker, {
-      // A Lodestar Node may do very expensive task at start blocking the event loop and causing
-      // the initialization to timeout. The number below is big enough to almost disable the timeout
-      timeout: 5 * 60 * 1000,
-      // TODO: types are broken on spawn, which claims that `NetworkWorkerApi` does not satisfies its contrains
-    })) as unknown as ModuleThread<NetworkWorkerApi>;
-
-    return new WorkerNetworkCore({
-      ...modules,
-      networkThreadApi,
-      worker,
-    });
-  }
-
-  async close(): Promise<void> {
-    this.modules.logger.debug("closing network core running in network worker");
-    await this.getApi().close();
-    this.modules.logger.debug("terminating network worker");
-    await terminateWorkerThread({
-      worker: this.getApi(),
-      retryCount: NETWORK_WORKER_EXIT_RETRY_COUNT,
-      retryMs: NETWORK_WORKER_EXIT_TIMEOUT_MS,
-      logger: this.modules.logger,
-    });
-    this.modules.logger.debug("terminated network worker");
-  }
-
-  async test(): Promise<void> {
-    return;
-  }
-
-  scrapeMetrics(): Promise<string> {
-    return this.getApi().scrapeMetrics();
-  }
-
-  updateStatus(status: Status): Promise<void> {
-    return this.getApi().updateStatus(status);
-  }
-  reStatusPeers(peers: PeerIdStr[]): Promise<void> {
-    return this.getApi().reStatusPeers(peers);
-  }
-  reportPeer(peer: PeerIdStr, action: PeerAction, actionName: string): Promise<void> {
-    return this.getApi().reportPeer(peer, action, actionName);
-  }
-
-  // TODO: Should this just be events? Do they need to report errors back?
-  prepareBeaconCommitteeSubnets(subscriptions: CommitteeSubscription[]): Promise<void> {
-    return this.getApi().prepareBeaconCommitteeSubnets(subscriptions);
-  }
-  prepareSyncCommitteeSubnets(subscriptions: CommitteeSubscription[]): Promise<void> {
-    return this.getApi().prepareSyncCommitteeSubnets(subscriptions);
-  }
-  subscribeGossipCoreTopics(): Promise<void> {
-    return this.getApi().subscribeGossipCoreTopics();
-  }
-  unsubscribeGossipCoreTopics(): Promise<void> {
-    return this.getApi().unsubscribeGossipCoreTopics();
-  }
-
-  // REST API queries
-
-  getConnectedPeerCount(): Promise<number> {
-    return this.getApi().getConnectedPeerCount();
-  }
-  getConnectedPeers(): Promise<PeerIdStr[]> {
-    return this.getApi().getConnectedPeers();
-  }
-  getNetworkIdentity(): Promise<routes.node.NetworkIdentity> {
-    return this.getApi().getNetworkIdentity();
-  }
-
-  // ReqResp and gossip outgoing
-
-  sendReqRespRequest(data: OutgoingRequestArgs): AsyncIterable<ResponseIncoming> {
-    return this.reqRespBridgeReqCaller.getAsyncIterable(data);
-  }
-  publishGossip(topic: string, data: Uint8Array, opts?: PublishOpts): Promise<number> {
-    return this.getApi().publishGossip(topic, data, opts);
-  }
-
-  // Custody
-
-  setTargetGroupCount(count: number): Promise<void> {
-    return this.getApi().setTargetGroupCount(count);
-  }
-
-  // Debug
-
-  connectToPeer(peer: PeerIdStr, multiaddr: MultiaddrStr[]): Promise<void> {
-    return this.getApi().connectToPeer(peer, multiaddr);
-  }
-  disconnectPeer(peer: PeerIdStr): Promise<void> {
-    return this.getApi().disconnectPeer(peer);
-  }
-  dumpPeers(): Promise<routes.lodestar.LodestarNodePeer[]> {
-    return this.getApi().dumpPeers();
-  }
-  dumpPeer(peerIdStr: string): Promise<routes.lodestar.LodestarNodePeer | undefined> {
-    return this.getApi().dumpPeer(peerIdStr);
-  }
-  dumpPeerScoreStats(): Promise<PeerScoreStats> {
-    return this.getApi().dumpPeerScoreStats();
-  }
-  dumpGossipPeerScoreStats(): Promise<PeerScoreStatsDump> {
-    return this.getApi().dumpGossipPeerScoreStats();
-  }
-  dumpDiscv5KadValues(): Promise<string[]> {
-    return this.getApi().dumpDiscv5KadValues();
-  }
-  dumpMeshPeers(): Promise<Record<string, string[]>> {
-    return this.getApi().dumpMeshPeers();
-  }
-  writeNetworkThreadProfile(durationMs: number, dirpath: string): Promise<string> {
-    return this.getApi().writeProfile(durationMs, dirpath);
-  }
-  writeDiscv5Profile(durationMs: number, dirpath: string): Promise<string> {
-    return this.getApi().writeDiscv5Profile(durationMs, dirpath);
-  }
-  writeNetworkHeapSnapshot(prefix: string, dirpath: string): Promise<string> {
-    return this.getApi().writeHeapSnapshot(prefix, dirpath);
-  }
-  writeDiscv5HeapSnapshot(prefix: string, dirpath: string): Promise<string> {
-    return this.getApi().writeDiscv5HeapSnapshot(prefix, dirpath);
-  }
-
-  private getApi(): ModuleThread<NetworkWorkerApi> {
-    return this.modules.networkThreadApi;
-  }
-}

package/src/network/core/types.ts

@@ -1,119 +0,0 @@
-import {PeerScoreStatsDump} from "@chainsafe/libp2p-gossipsub/score";
-import {PublishOpts} from "@chainsafe/libp2p-gossipsub/types";
-import {routes} from "@lodestar/api";
-import {SpecJson} from "@lodestar/config";
-import {LoggerNodeOpts} from "@lodestar/logger/node";
-import {ResponseIncoming} from "@lodestar/reqresp";
-import {Status} from "@lodestar/types";
-import {PeerIdStr} from "../../util/peerId.js";
-import {NetworkOptions} from "../options.js";
-import {PeerAction, PeerScoreStats} from "../peers/index.js";
-import {OutgoingRequestArgs} from "../reqresp/types.js";
-import {CommitteeSubscription} from "../subnets/interface.js";
-
-export type MultiaddrStr = string;
-
-// Interface shared by main Network class, and all backends
-export interface INetworkCorePublic {
-  // Peer manager control
-  prepareBeaconCommitteeSubnets(subscriptions: CommitteeSubscription[]): Promise<void>;
-  prepareSyncCommitteeSubnets(subscriptions: CommitteeSubscription[]): Promise<void>;
-  // reportPeer - Different interface depending on the backend
-
-  // REST API getters
-  getNetworkIdentity(): Promise<routes.node.NetworkIdentity>;
-
-  // Gossip control
-  subscribeGossipCoreTopics(): Promise<void>;
-  unsubscribeGossipCoreTopics(): Promise<void>;
-
-  // Debug
-  connectToPeer(peer: PeerIdStr, multiaddr: MultiaddrStr[]): Promise<void>;
-  disconnectPeer(peer: PeerIdStr): Promise<void>;
-  dumpPeers(): Promise<routes.lodestar.LodestarNodePeer[]>;
-  dumpPeer(peerIdStr: PeerIdStr): Promise<routes.lodestar.LodestarNodePeer | undefined>;
-  dumpPeerScoreStats(): Promise<PeerScoreStats>;
-  dumpGossipPeerScoreStats(): Promise<PeerScoreStatsDump>;
-  dumpDiscv5KadValues(): Promise<string[]>;
-  dumpMeshPeers(): Promise<Record<string, string[]>>;
-}
-
-/**
- * Contains core network functionality (libp2p and dependent modules)
- *
- * All properties/methods should be async to allow for a worker implementation
- */
-export interface INetworkCore extends INetworkCorePublic {
-  // Sync method
-  reportPeer(peer: PeerIdStr, action: PeerAction, actionName: string): void;
-  reStatusPeers(peers: PeerIdStr[]): Promise<void>;
-
-  // TODO: Duplicated methods with INetwork interface
-  getConnectedPeers(): Promise<PeerIdStr[]>;
-  getConnectedPeerCount(): Promise<number>;
-
-  /** Chain must push status updates to the network core */
-  updateStatus(status: Status): Promise<void>;
-
-  setTargetGroupCount(count: number): Promise<void>;
-  /** Opens stream to handle ReqResp outgoing request */
-  sendReqRespRequest(data: OutgoingRequestArgs): AsyncIterable<ResponseIncoming>;
-  /** Publish gossip message to peers */
-  publishGossip(topic: string, data: Uint8Array, opts?: PublishOpts): Promise<number>;
-
-  close(): Promise<void>;
-  scrapeMetrics(): Promise<string>;
-  writeNetworkThreadProfile(durationMs: number, dirpath: string): Promise<string>;
-  writeDiscv5Profile(durationMs: number, dirpath: string): Promise<string>;
-  writeNetworkHeapSnapshot(prefix: string, dirpath: string): Promise<string>;
-  writeDiscv5HeapSnapshot(prefix: string, dirpath: string): Promise<string>;
-}
-
-/**
- * libp2p worker contructor (start-up) data
- */
-export type NetworkWorkerData = {
-  // TODO: Review if NetworkOptions is safe for passing
-  opts: NetworkOptions;
-  chainConfigJson: SpecJson;
-  genesisValidatorsRoot: Uint8Array;
-  genesisTime: number;
-  activeValidatorCount: number;
-  initialStatus: Status;
-  initialCustodyGroupCount: number;
-  privateKeyProto: Uint8Array;
-  localMultiaddrs: string[];
-  metricsEnabled: boolean;
-  peerStoreDir?: string;
-  loggerOpts: LoggerNodeOpts;
-};
-
-/**
- * API exposed by the libp2p worker
- */
-export type NetworkWorkerApi = INetworkCorePublic & {
-  // To satisfy the constraint of `ModuleThread` type
-  // biome-ignore lint/suspicious/noExplicitAny: Explicitly needed the `any` type here
-  [string: string]: (...args: any[]) => Promise<any> | any;
-  // Async method through worker boundary
-  reportPeer(peer: PeerIdStr, action: PeerAction, actionName: string): Promise<void>;
-  reStatusPeers(peers: PeerIdStr[]): Promise<void>;
-
-  // TODO: Duplicated methods with INetwork interface
-  getConnectedPeers(): Promise<PeerIdStr[]>;
-  getConnectedPeerCount(): Promise<number>;
-  updateStatus(status: Status): Promise<void>;
-
-  setTargetGroupCount(count: number): Promise<void>;
-
-  // sendReqRespRequest - implemented via events
-  publishGossip(topic: string, data: Uint8Array, opts?: PublishOpts): Promise<number>;
-
-  close(): Promise<void>;
-  scrapeMetrics(): Promise<string>;
-  writeProfile(durationMs: number, dirpath: string): Promise<string>;
-  writeDiscv5Profile(durationMs: number, dirpath: string): Promise<string>;
-
-  // TODO: ReqResp outgoing
-  // TODO: ReqResp incoming
-};