@lodestar/beacon-node 1.41.0-dev.bb33751bfd → 1.41.0-dev.c11b797bd6

package/src/network/gossip/gossipsub.ts

@@ -11,7 +11,7 @@ import type {PeerScoreParams, PeerScoreStatsDump} from "@libp2p/gossipsub/score"
 import type {AddrInfo, PublishOpts, TopicStr} from "@libp2p/gossipsub/types";
 import type {PeerId} from "@libp2p/interface";
 import {peerIdFromString} from "@libp2p/peer-id";
-import {multiaddr} from "@multiformats/multiaddr";
+import {type Multiaddr, multiaddr} from "@multiformats/multiaddr";
 import {ENR} from "@chainsafe/enr";
 import {routes} from "@lodestar/api";
 import {BeaconConfig, ForkBoundary} from "@lodestar/config";
@@ -537,19 +537,24 @@ export function parseDirectPeers(directPeerStrs: routes.lodestar.DirectPeer[], l
         const enr = ENR.decodeTxt(peerStr);
         const peerId = enr.peerId;
 
-        // Get TCP multiaddr from ENR
-        const multiaddrTCP = enr.getLocationMultiaddr("tcp");
-        if (!multiaddrTCP) {
-          logger.warn("ENR does not contain TCP multiaddr", {enr: peerStr});
+        // Get all available transport multiaddrs from ENR
+        const addrs = [enr.getLocationMultiaddr("quic"), enr.getLocationMultiaddr("tcp")].filter(
+          (a): a is Multiaddr => a != null
+        );
+        if (addrs.length === 0) {
+          logger.warn("ENR does not contain any transport multiaddr", {enr: peerStr});
           continue;
         }
 
         directPeers.push({
           id: peerId,
-          addrs: [multiaddrTCP],
+          addrs,
         });
 
-        logger.info("Added direct peer from ENR", {peerId: peerId.toString(), addr: multiaddrTCP.toString()});
+        logger.info("Added direct peer from ENR", {
+          peerId: peerId.toString(),
+          addrs: addrs.map((a) => a.toString()).join(", "),
+        });
       } catch (e) {
         logger.warn("Failed to parse direct peer ENR", {enr: peerStr}, e as Error);
       }

package/src/network/libp2p/index.ts

@@ -5,11 +5,12 @@ import {mdns} from "@libp2p/mdns";
 import {mplex} from "@libp2p/mplex";
 import {prometheusMetrics} from "@libp2p/prometheus-metrics";
 import {tcp} from "@libp2p/tcp";
-import {createLibp2p} from "libp2p";
+import {Libp2pInit, createLibp2p} from "libp2p";
 import {Registry} from "prom-client";
 import {ENR} from "@chainsafe/enr";
 import {noise} from "@chainsafe/libp2p-noise";
 import {asCrypto, defaultCrypto} from "@chainsafe/libp2p-noise/crypto";
+import {quic} from "@chainsafe/libp2p-quic";
 import {Libp2p, LodestarComponents} from "../interface.js";
 import {NetworkOptions, defaultNetworkOptions} from "../options.js";
 import {Eth2PeerDataStore} from "../peers/datastore.js";
@@ -21,11 +22,14 @@ export type NodeJsLibp2pOpts = {
   metricsRegistry?: Registry;
 };
 
-export async function getDiscv5Multiaddrs(bootEnrs: string[]): Promise<string[]> {
+export async function getDiscv5Multiaddrs(bootEnrs: string[], quicEnabled?: boolean): Promise<string[]> {
   const bootMultiaddrs = [];
   for (const enrStr of bootEnrs) {
     const enr = ENR.decodeTxt(enrStr);
-    const multiaddrWithPeerId = (await enr.getFullMultiaddr("tcp"))?.toString();
+    // Prefer QUIC over TCP when available
+    const quicMultiaddr = quicEnabled ? (await enr.getFullMultiaddr("quic"))?.toString() : undefined;
+    const tcpMultiaddr = (await enr.getFullMultiaddr("tcp"))?.toString();
+    const multiaddrWithPeerId = quicMultiaddr ?? tcpMultiaddr;
     if (multiaddrWithPeerId) {
       bootMultiaddrs.push(multiaddrWithPeerId);
     }
@@ -53,7 +57,9 @@ export async function createNodeJsLibp2p(
     const bootMultiaddrs = [
       ...(networkOpts.bootMultiaddrs ?? defaultNetworkOptions.bootMultiaddrs ?? []),
       // Append discv5.bootEnrs to bootMultiaddrs if requested
-      ...(networkOpts.connectToDiscv5Bootnodes ? await getDiscv5Multiaddrs(networkOpts.discv5?.bootEnrs ?? []) : []),
+      ...(networkOpts.connectToDiscv5Bootnodes
+        ? await getDiscv5Multiaddrs(networkOpts.discv5?.bootEnrs ?? [], networkOpts.quic)
+        : []),
     ];
 
     if ((bootMultiaddrs.length ?? 0) > 0) {
@@ -64,6 +70,35 @@ export async function createNodeJsLibp2p(
       peerDiscovery.push(mdns());
     }
   }
+  const transports: Libp2pInit["transports"] = [];
+  if (networkOpts.tcp ?? true) {
+    transports.unshift(
+      tcp({
+        // Reject connections when the server's connection count gets high
+        maxConnections: networkOpts.maxPeers,
+        // socket option: the maximum length of the queue of pending connections
+        // https://nodejs.org/dist/latest-v18.x/docs/api/net.html#serverlisten
+        // it's not safe if we increase this number
+        backlog: 5,
+        closeServerOnMaxConnections: {
+          closeAbove: networkOpts.maxPeers ?? Infinity,
+          listenBelow: networkOpts.maxPeers ?? Infinity,
+        },
+      })
+    );
+  }
+  if (networkOpts.quic) {
+    transports.unshift(
+      quic({
+        handshakeTimeout: 5_000,
+        maxIdleTimeout: 10_000,
+        keepAliveInterval: 5_000,
+        maxConcurrentStreamLimit: 256,
+        maxStreamData: 10_000_000,
+        maxConnectionData: 15_000_000,
+      })
+    );
+  }
 
   const noiseCrypto = {
     ...defaultCrypto,
@@ -85,20 +120,7 @@ export async function createNodeJsLibp2p(
       announce: [],
     },
     connectionEncrypters: [noise({crypto: noiseCrypto})],
-    // Reject connections when the server's connection count gets high
-    transports: [
-      tcp({
-        maxConnections: networkOpts.maxPeers,
-        // socket option: the maximum length of the queue of pending connections
-        // https://nodejs.org/dist/latest-v18.x/docs/api/net.html#serverlisten
-        // it's not safe if we increase this number
-        backlog: 5,
-        closeServerOnMaxConnections: {
-          closeAbove: networkOpts.maxPeers ?? Infinity,
-          listenBelow: networkOpts.maxPeers ?? Infinity,
-        },
-      }),
-    ],
+    transports,
     streamMuxers: [mplex({disconnectThreshold})],
     peerDiscovery,
     metrics: nodeJsLibp2pOpts.metrics

package/src/network/metadata.ts

@@ -11,6 +11,7 @@ import {NetworkConfig} from "./networkConfig.js";
 
 export enum ENRKey {
   tcp = "tcp",
+  quic = "quic",
   eth2 = "eth2",
   attnets = "attnets",
   syncnets = "syncnets",

package/src/network/network.ts

@@ -539,7 +539,8 @@ export class Network implements INetwork {
         this.config.getForkSeq(this.clock.currentSlot) >= ForkSeq.altair ? [Version.V2] : [Version.V2, Version.V1],
         request
       ),
-      request
+      request,
+      this.chain.serializedCache
     );
   }
 

package/src/network/options.ts

@@ -29,7 +29,6 @@ export interface NetworkOptions
   useWorker?: boolean;
   maxYoungGenerationSizeMb?: number;
   disableLightClientServer?: boolean;
-
   /**
    * During E2E tests observe a lot of following `missing stream`:
    *
@@ -48,11 +47,14 @@ export interface NetworkOptions
    * We need to increase this only for the testing purpose
    */
   disconnectThreshold?: number;
+  quic?: boolean;
+  tcp?: boolean;
 }
 
 export const defaultNetworkOptions: NetworkOptions = {
   maxPeers: 210, // Allow some room above targetPeers for new inbound peers
   targetPeers: 200,
+  // In CLI usage this is typically overridden; when unset it serves as a fallback default (e.g. programmatic usage/tests)
   localMultiaddrs: ["/ip4/0.0.0.0/tcp/9000", "/ip6/::/tcp/9000"],
   bootMultiaddrs: [],
   /** disabled by default */
@@ -67,6 +69,8 @@ export const defaultNetworkOptions: NetworkOptions = {
   slotsToSubscribeBeforeAggregatorDuty: 2,
   // This will enable the light client server by default
   disableLightClientServer: false,
+  quic: false,
+  tcp: true,
   // specific option for fulu
   //   - this is the same to TARGET_SUBNET_PEERS
   //   - for fusaka-devnets, we have 25-30 peers per subnet

package/src/network/peers/discover.ts

@@ -59,6 +59,7 @@ export enum DiscoveredPeerStatus {
   cached = "cached",
   dropped = "dropped",
   no_multiaddrs = "no_multiaddrs",
+  transport_incompatible = "transport_incompatible",
   peer_cooling_down = "peer_cooling_down",
 }
 
@@ -88,7 +89,8 @@ export type SubnetDiscvQueryMs = {
 
 type CachedENR = {
   peerId: PeerId;
-  multiaddrTCP: Multiaddr;
+  multiaddrTCP?: Multiaddr;
+  multiaddrQUIC?: Multiaddr;
   subnets: Record<SubnetType, boolean[]>;
   addedUnixMs: number;
   // custodyGroups is null for pre-fulu
@@ -114,6 +116,7 @@ export class PeerDiscovery {
     attnets: new Map(),
     syncnets: new Map(),
   };
+  private transports: string[];
 
   private custodyGroupQueries: CustodyGroupQueries;
 
@@ -180,6 +183,17 @@ export class PeerDiscovery {
         }
       });
     }
+
+    // Transport tags vary by library: @libp2p/tcp uses '@libp2p/tcp', @chainsafe/libp2p-quic uses 'quic'
+    // Normalize to simple 'tcp' / 'quic' strings for matching
+    this.transports = libp2p.services.components.transportManager
+      .getTransports()
+      .map((t) => t[Symbol.toStringTag])
+      .map((tag) => {
+        if (tag?.includes("tcp")) return "tcp";
+        if (tag?.includes("quic")) return "quic";
+        return tag;
+      });
   }
 
   static async init(modules: PeerDiscoveryModules, opts: PeerDiscoveryOpts): Promise<PeerDiscovery> {
@@ -372,10 +386,15 @@ export class PeerDiscovery {
       return;
     }
 
+    // Select multiaddrs by protocol rather than index — libp2p discovery events
+    // don't guarantee ordering or number of addresses
+    const multiaddrTCP = multiaddrs.find((ma) => ma.toString().includes("/tcp/"));
+    const multiaddrQUIC = multiaddrs.find((ma) => ma.toString().includes("/quic-v1"));
+
     const attnets = zeroAttnets;
     const syncnets = zeroSyncnets;
 
-    const status = this.handleDiscoveredPeer(id, multiaddrs[0], attnets, syncnets, undefined);
+    const status = this.handleDiscoveredPeer(id, multiaddrTCP, multiaddrQUIC, attnets, syncnets, undefined);
     this.logger.debug("Discovered peer via libp2p", {peer: prettyPrintPeerId(id), status});
     this.metrics?.discovery.discoveredStatus.inc({status});
   };
@@ -388,13 +407,15 @@ export class PeerDiscovery {
       this.randomNodeQuery.count++;
     }
     const peerId = enr.peerId;
-    // tcp multiaddr is known to be be present, checked inside the worker
+    // At least one transport is known to be present, checked inside the worker
     const multiaddrTCP = enr.getLocationMultiaddr(ENRKey.tcp);
-    if (!multiaddrTCP) {
-      this.logger.warn("Discv5 worker sent enr without tcp multiaddr", {enr: enr.encodeTxt()});
+    const multiaddrQUIC = enr.getLocationMultiaddr(ENRKey.quic);
+    if (!multiaddrTCP && !multiaddrQUIC) {
+      this.logger.warn("Discv5 worker sent enr without any transport multiaddr", {enr: enr.encodeTxt()});
       this.metrics?.discovery.discoveredStatus.inc({status: DiscoveredPeerStatus.no_multiaddrs});
       return;
     }
+
     // Are this fields mandatory?
     const attnetsBytes = enr.kvs.get(ENRKey.attnets); // 64 bits
     const syncnetsBytes = enr.kvs.get(ENRKey.syncnets); // 4 bits
@@ -414,7 +435,7 @@ export class PeerDiscovery {
     const syncnets = syncnetsBytes ? deserializeEnrSubnets(syncnetsBytes, SYNC_COMMITTEE_SUBNET_COUNT) : zeroSyncnets;
     const custodyGroupCount = custodyGroupCountBytes ? bytesToInt(custodyGroupCountBytes, "be") : undefined;
 
-    const status = this.handleDiscoveredPeer(peerId, multiaddrTCP, attnets, syncnets, custodyGroupCount);
+    const status = this.handleDiscoveredPeer(peerId, multiaddrTCP, multiaddrQUIC, attnets, syncnets, custodyGroupCount);
     this.logger.debug("Discovered peer via discv5", {
       peer: prettyPrintPeerId(peerId),
       status,
@@ -428,7 +449,8 @@ export class PeerDiscovery {
    */
   private handleDiscoveredPeer(
     peerId: PeerId,
-    multiaddrTCP: Multiaddr,
+    multiaddrTCP: Multiaddr | undefined,
+    multiaddrQUIC: Multiaddr | undefined,
     attnets: boolean[],
     syncnets: boolean[],
     custodySubnetCount?: number
@@ -454,6 +476,13 @@ export class PeerDiscovery {
         return DiscoveredPeerStatus.already_connected;
       }
 
+      // ignore peers if they don't share any transport with us
+      const hasTcpMatch = this.transports.includes("tcp") && multiaddrTCP;
+      const hasQuicMatch = this.transports.includes("quic") && multiaddrQUIC;
+      if (!hasTcpMatch && !hasQuicMatch) {
+        return DiscoveredPeerStatus.transport_incompatible;
+      }
+
       // Ignore dialing peers
       if (
         this.libp2p.services.components.connectionManager
@@ -469,6 +498,7 @@ export class PeerDiscovery {
       const cachedPeer: CachedENR = {
         peerId,
         multiaddrTCP,
+        multiaddrQUIC,
         subnets: {attnets, syncnets},
         addedUnixMs: Date.now(),
         // for pre-fulu, custodyGroups is null
@@ -566,19 +596,24 @@ export class PeerDiscovery {
     // are not successful.
     this.peersToConnect = Math.max(this.peersToConnect - 1, 0);
 
-    const {peerId, multiaddrTCP} = cachedPeer;
+    const {peerId, multiaddrTCP, multiaddrQUIC} = cachedPeer;
 
     // Must add the multiaddrs array to the address book before dialing
     // https://github.com/libp2p/js-libp2p/blob/aec8e3d3bb1b245051b60c2a890550d262d5b062/src/index.js#L638
-    const peer = await this.libp2p.peerStore.merge(peerId, {multiaddrs: [multiaddrTCP]});
+    const peer = await this.libp2p.peerStore.merge(peerId, {
+      multiaddrs: [multiaddrQUIC, multiaddrTCP].filter(Boolean) as Multiaddr[],
+    });
     if (peer.addresses.length === 0) {
       this.metrics?.discovery.notDialReason.inc({reason: NotDialReason.no_multiaddrs});
       return;
     }
 
-    // Note: PeerDiscovery adds the multiaddrTCP beforehand
+    // Note: PeerDiscovery adds the multiaddrs beforehand
     const peerIdShort = prettyPrintPeerId(peerId);
-    this.logger.debug("Dialing discovered peer", {peer: peerIdShort});
+    this.logger.debug("Dialing discovered peer", {
+      peer: peerIdShort,
+      addresses: peer.addresses.map((a) => a.multiaddr.toString()).join(", "),
+    });
 
     this.metrics?.discovery.dialAttempts.inc();
     const timer = this.metrics?.discovery.dialTime.startTimer();

package/src/network/processor/gossipHandlers.ts

@@ -71,7 +71,7 @@ import {validateGossipPayloadAttestationMessage} from "../../chain/validation/pa
 import {OpSource} from "../../chain/validatorMonitor.js";
 import {Metrics} from "../../metrics/index.js";
 import {kzgCommitmentToVersionedHash} from "../../util/blobs.js";
-import {getBlobKzgCommitments} from "../../util/dataColumns.ts";
+import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import {INetworkCore} from "../core/index.js";
 import {NetworkEventBus} from "../events.js";
 import {
@@ -856,6 +856,11 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       } catch (e) {
         logger.error("Error adding to payloadAttestation pool", {}, e as Error);
       }
+      chain.forkChoice.notifyPtcMessages(
+        toRootHex(payloadAttestationMessage.data.beaconBlockRoot),
+        [validationResult.validatorCommitteeIndex],
+        payloadAttestationMessage.data.payloadPresent
+      );
     },
     [GossipType.execution_payload_bid]: async ({
       gossipData,

package/src/network/processor/gossipValidatorFn.ts

@@ -11,7 +11,7 @@ import {
   GossipValidatorBatchFn,
   GossipValidatorFn,
 } from "../gossip/interface.js";
-import {prettyPrintPeerIdStr} from "../util.ts";
+import {prettyPrintPeerIdStr} from "../util.js";
 
 export type ValidatorFnModules = {
   config: ChainForkConfig;

package/src/network/reqresp/ReqRespBeaconNode.ts

@@ -19,7 +19,7 @@ import {callInNextEventLoop} from "../../util/eventLoop.js";
 import {NetworkCoreMetrics} from "../core/metrics.js";
 import {INetworkEventBus, NetworkEvent} from "../events.js";
 import {MetadataController} from "../metadata.js";
-import {ClientKind} from "../peers/client.ts";
+import {ClientKind} from "../peers/client.js";
 import {PeersData} from "../peers/peersData.js";
 import {IPeerRpcScoreStore, PeerAction} from "../peers/score/index.js";
 import {StatusCache} from "../statusCache.js";

package/src/network/reqresp/handlers/beaconBlocksByRange.ts

@@ -6,7 +6,7 @@ import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {deneb, phase0} from "@lodestar/types";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
-import {prettyPrintPeerId} from "../../util.ts";
+import {prettyPrintPeerId} from "../../util.js";
 
 // TODO: Unit test
 
@@ -47,9 +47,10 @@ export async function* onBeaconBlocksByRange(
 
   // Non-finalized range of blocks
   if (endSlot > finalizedSlot) {
-    const headRoot = chain.forkChoice.getHeadRoot();
+    const headBlock = chain.forkChoice.getHead();
+    const headRoot = headBlock.blockRoot;
     // TODO DENEB: forkChoice should mantain an array of canonical blocks, and change only on reorg
-    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot);
+    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot, headBlock.payloadStatus);
     // getAllAncestorBlocks response includes the head node, so it's the full chain.
 
     // Iterate head chain with ascending block numbers

package/src/network/reqresp/handlers/blobSidecarsByRange.ts

@@ -34,9 +34,10 @@ export async function* onBlobSidecarsByRange(
 
   // Non-finalized range of blobs
   if (endSlot > finalizedSlot) {
-    const headRoot = chain.forkChoice.getHeadRoot();
+    const headBlock = chain.forkChoice.getHead();
+    const headRoot = headBlock.blockRoot;
     // TODO DENEB: forkChoice should mantain an array of canonical blocks, and change only on reorg
-    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot);
+    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot, headBlock.payloadStatus);
 
     // Iterate head chain with ascending block numbers
     for (let i = headChain.length - 1; i >= 0; i--) {

package/src/network/reqresp/handlers/blobSidecarsByRoot.ts

@@ -20,7 +20,7 @@ export async function* onBlobSidecarsByRoot(
   for (const blobIdentifier of requestBody) {
     const {blockRoot, index} = blobIdentifier;
     const blockRootHex = toRootHex(blockRoot);
-    const block = chain.forkChoice.getBlockHex(blockRootHex);
+    const block = chain.forkChoice.getBlockHexDefaultStatus(blockRootHex);
 
     // NOTE: Only support non-finalized blocks.
     // SPEC: Clients MUST support requesting blocks and sidecars since the latest finalized epoch.

package/src/network/reqresp/handlers/dataColumnSidecarsByRange.ts

@@ -7,7 +7,7 @@ import {ColumnIndex, fulu} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
-import {prettyPrintPeerId} from "../../util.ts";
+import {prettyPrintPeerId} from "../../util.js";
 import {
   handleColumnSidecarUnavailability,
   validateRequestedDataColumns,
@@ -78,8 +78,9 @@ export async function* onDataColumnSidecarsByRange(
 
   // Non-finalized range of columns
   if (endSlot > finalizedSlot) {
-    const headRoot = chain.forkChoice.getHeadRoot();
-    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot);
+    const headBlock = chain.forkChoice.getHead();
+    const headRoot = headBlock.blockRoot;
+    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot, headBlock.payloadStatus);
 
     // Iterate head chain with ascending block numbers
     for (let i = headChain.length - 1; i >= 0; i--) {

package/src/network/reqresp/handlers/dataColumnSidecarsByRoot.ts

@@ -6,7 +6,7 @@ import {toRootHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
 import {DataColumnSidecarsByRootRequest} from "../../../util/types.js";
-import {prettyPrintPeerId} from "../../util.ts";
+import {prettyPrintPeerId} from "../../util.js";
 import {
   handleColumnSidecarUnavailability,
   validateRequestedDataColumns,
@@ -34,7 +34,7 @@ export async function* onDataColumnSidecarsByRoot(
     }
 
     const blockRootHex = toRootHex(blockRoot);
-    const block = chain.forkChoice.getBlockHex(blockRootHex);
+    const block = chain.forkChoice.getBlockHexDefaultStatus(blockRootHex);
     // If the block is not in fork choice, it may be finalized. Attempt to find its slot in block archive
     const slot = block ? block.slot : await db.blockArchive.getSlotByRoot(blockRoot);
 

package/src/network/reqresp/utils/collect.ts

@@ -1,6 +1,6 @@
 import {Type} from "@chainsafe/ssz";
 import {RequestError, RequestErrorCode, ResponseIncoming} from "@lodestar/reqresp";
-import {SerializedCache} from "../../../util/serializedCache.ts";
+import {SerializedCache} from "../../../util/serializedCache.js";
 import {ResponseTypeGetter} from "../types.js";
 
 /**

package/src/network/reqresp/utils/collectSequentialBlocksInRange.ts

@@ -1,7 +1,7 @@
 import {ResponseIncoming} from "@lodestar/reqresp";
 import {SignedBeaconBlock, phase0} from "@lodestar/types";
 import {LodestarError} from "@lodestar/utils";
-import {SerializedCache} from "../../../util/serializedCache.ts";
+import {SerializedCache} from "../../../util/serializedCache.js";
 import {ReqRespMethod, responseSszTypeByMethod} from "../types.js";
 import {sszDeserializeResponse} from "./collect.js";
 

package/src/sync/utils/downloadByRoot.ts

@@ -6,7 +6,7 @@ import {LodestarError, byteArrayEquals, fromHex, prettyPrintIndices, toHex, toRo
 import {isBlockInputBlobs, isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
 import {BlockInputSource, IBlockInput} from "../../chain/blocks/blockInput/types.js";
 import {ChainEventEmitter} from "../../chain/emitter.js";
-import {IBeaconChain} from "../../chain/interface.ts";
+import {IBeaconChain} from "../../chain/interface.js";
 import {validateBlockBlobSidecars} from "../../chain/validation/blobSidecar.js";
 import {validateBlockDataColumnSidecars} from "../../chain/validation/dataColumnSidecar.js";
 import {INetwork} from "../../network/interface.js";

package/src/sync/utils/remoteSyncType.ts

@@ -1,7 +1,7 @@
 import {IForkChoice} from "@lodestar/fork-choice";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {Slot, Status} from "@lodestar/types";
-import {IBeaconChain} from "../../chain/interface.ts";
+import {IBeaconChain} from "../../chain/interface.js";
 import {ChainTarget} from "../range/utils/index.js";
 
 /** The type of peer relative to our current state */

package/src/util/serializedCache.ts

@@ -4,7 +4,7 @@
  * This is a thin wrapper around WeakMap
  */
 export class SerializedCache {
-  map: WeakMap<object, Uint8Array> = new WeakMap();
+  private map: WeakMap<object, Uint8Array> = new WeakMap();
 
   get(obj: object): Uint8Array | undefined {
     return this.map.get(obj);
@@ -15,11 +15,13 @@ export class SerializedCache {
   }
 
   /**
-   * Replace the internal WeakMap to force GC of all cached entries.
-   * Must only be called after all DB writes that may read from this cache have completed,
+   * Delete cached serialized entries for the provided object references.
+   * Must only be called after all DB writes that read from this cache for these objects have completed,
    * otherwise cached serialized bytes will be unavailable and data will be re-serialized unnecessarily.
    */
-  clear(): void {
-    this.map = new WeakMap();
+  delete(objs: object[]): void {
+    for (const obj of objs) {
+      this.map.delete(obj);
+    }
   }
 }