@lodestar/beacon-node 1.42.0-dev.1d50253953 → 1.42.0-dev.5007d8c6d6

package/src/network/gossip/encoding.ts

@@ -24,12 +24,28 @@ const decoder = new snappyWasm.Decoder();
 // Shared buffer to convert msgId to string
 const sharedMsgIdBuf = Buffer.alloc(20);
 
+// Cache topic -> seed to avoid per-message allocations on the hot path.
+// Topics are a fixed set per fork (changes only at fork boundaries).
+const topicSeedCache = new Map<string, bigint>();
+
 /**
  * The function used to generate a gossipsub message id
  * We use the first 8 bytes of SHA256(data) for content addressing
  */
 export function fastMsgIdFn(rpcMsg: RPC.Message): string {
   if (rpcMsg.data) {
+    if (rpcMsg.topic) {
+      // Use topic-derived seed to prevent cross-topic deduplication of identical messages.
+      // SyncCommitteeMessages are published to multiple sync_committee_{subnet} topics with
+      // identical data, so hashing only the data incorrectly deduplicates across subnets.
+      // See https://github.com/ChainSafe/lodestar/issues/8294
+      let topicSeed = topicSeedCache.get(rpcMsg.topic);
+      if (topicSeed === undefined) {
+        topicSeed = xxhash.h64Raw(Buffer.from(rpcMsg.topic), h64Seed);
+        topicSeedCache.set(rpcMsg.topic, topicSeed);
+      }
+      return xxhash.h64Raw(rpcMsg.data, topicSeed).toString(16);
+    }
     return xxhash.h64Raw(rpcMsg.data, h64Seed).toString(16);
   }
   return "0000000000000000";

package/src/network/processor/gossipHandlers.ts

@@ -777,9 +777,9 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       const {serializedData} = gossipData;
       const syncCommittee = sszDeserialize(topic, serializedData);
       const {subnet} = topic;
-      let indexInSubcommittee = 0;
+      let indicesInSubcommittee: number[] = [0];
       try {
-        indexInSubcommittee = (await validateGossipSyncCommittee(chain, syncCommittee, subnet)).indexInSubcommittee;
+        indicesInSubcommittee = (await validateGossipSyncCommittee(chain, syncCommittee, subnet)).indicesInSubcommittee;
       } catch (e) {
         if (e instanceof SyncCommitteeError && e.action === GossipAction.REJECT) {
           chain.persistInvalidSszValue(ssz.altair.SyncCommitteeMessage, syncCommittee, "gossip_reject");
@@ -787,11 +787,12 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         throw e;
       }
 
-      // Handler
-
+      // Handler — add for ALL positions this validator holds in the subcommittee
       try {
-        const insertOutcome = chain.syncCommitteeMessagePool.add(subnet, syncCommittee, indexInSubcommittee);
-        metrics?.opPool.syncCommitteeMessagePoolInsertOutcome.inc({insertOutcome});
+        for (const indexInSubcommittee of indicesInSubcommittee) {
+          const insertOutcome = chain.syncCommitteeMessagePool.add(subnet, syncCommittee, indexInSubcommittee);
+          metrics?.opPool.syncCommitteeMessagePoolInsertOutcome.inc({insertOutcome});
+        }
       } catch (e) {
         logger.debug("Error adding to syncCommittee pool", {subnet}, e as Error);
       }

package/src/sync/unknownBlock.ts

@@ -481,7 +481,7 @@ export class BlockInputSync {
    * From a set of shuffled peers:
    *   - fetch the block
    *   - from deneb, fetch all missing blobs
-   *   - from peerDAS, fetch sampled colmns
+   *   - from peerDAS, fetch sampled columns
    * TODO: this means we only have block root, and nothing else. Consider to reflect this in the function name
    * prefulu, will attempt a max of `MAX_ATTEMPTS_PER_BLOCK` on different peers, postfulu we may attempt more as defined in `getMaxDownloadAttempts()` function
    * Also verifies the received block root + returns the peer that provided the block for future downscoring.
@@ -489,10 +489,7 @@ export class BlockInputSync {
   private async fetchBlockInput(cacheItem: BlockInputSyncCacheItem): Promise<PendingBlockInput> {
     const rootHex = getBlockInputSyncCacheItemRootHex(cacheItem);
     const excludedPeers = new Set<PeerIdStr>();
-    const defaultPendingColumns =
-      this.config.getForkSeq(this.chain.clock.currentSlot) >= ForkSeq.fulu
-        ? new Set(this.network.custodyConfig.sampledColumns)
-        : null;
+    const defaultPendingColumns = new Set(this.network.custodyConfig.sampledColumns);
 
     const fetchStartSec = Date.now() / 1000;
     let slot = isPendingBlockInput(cacheItem) ? cacheItem.blockInput.slot : undefined;
@@ -506,14 +503,10 @@ export class BlockInputSync {
         isPendingBlockInput(cacheItem) && isBlockInputColumns(cacheItem.blockInput)
           ? new Set(cacheItem.blockInput.getMissingSampledColumnMeta().missing)
           : defaultPendingColumns;
-      // pendingDataColumns is null pre-fulu
       const peerMeta = this.peerBalancer.bestPeerForPendingColumns(pendingColumns, excludedPeers);
       if (peerMeta === null) {
         // no more peer with needed columns to try, throw error
-        let message = `Error fetching UnknownBlockRoot slot=${slot} root=${rootHex} after ${i}: cannot find peer`;
-        if (pendingColumns) {
-          message += ` with needed columns=${prettyPrintIndices(Array.from(pendingColumns))}`;
-        }
+        const message = `Error fetching UnknownBlockRoot slot=${slot} root=${rootHex} after ${i}: cannot find peer with needed columns=${prettyPrintIndices(Array.from(pendingColumns))}`;
         this.metrics?.blockInputSync.fetchTimeSec.observe(
           {result: FetchResult.FailureTriedAllPeers},
           Date.now() / 1000 - fetchStartSec
@@ -650,7 +643,7 @@ export class BlockInputSync {
       // TODO(fulu): why is this commented out here?
       //
       //   this.knownBadBlocks.add(block.blockRootHex);
-      //   for (const peerIdStr of block.peerIdStrs) {
+      //   for (const peerIdStr of block.peerIdStrings) {
       //     // TODO: Refactor peerRpcScores to work with peerIdStr only
       //     this.network.reportPeer(peerIdStr, PeerAction.LowToleranceError, "BadBlockByRoot");
       //   }
@@ -729,11 +722,11 @@ export class UnknownBlockPeerBalancer {
   }
 
   /**
-   * called from fetchUnknownBlockRoot() where we only have block root and nothing else
+   * called from fetchBlockInput() where we only have block root and nothing else
    * excludedPeers are the peers that we requested already so we don't want to try again
    * pendingColumns is empty for prefulu, or the 1st time we we download a block by root
    */
-  bestPeerForPendingColumns(pendingColumns: Set<number> | null, excludedPeers: Set<PeerIdStr>): PeerSyncMeta | null {
+  bestPeerForPendingColumns(pendingColumns: Set<number>, excludedPeers: Set<PeerIdStr>): PeerSyncMeta | null {
     const eligiblePeers = this.filterPeers(pendingColumns, excludedPeers);
     if (eligiblePeers.length === 0) {
       return null;
@@ -750,37 +743,6 @@ export class UnknownBlockPeerBalancer {
     return this.peersMeta.get(bestPeerId) ?? null;
   }
 
-  /**
-   * called from fetchUnavailableBlockInput() where we have either BlockInput or NullBlockInput
-   * excludedPeers are the peers that we requested already so we don't want to try again
-   */
-  bestPeerForBlockInput(blockInput: IBlockInput, excludedPeers: Set<PeerIdStr>): PeerSyncMeta | null {
-    const eligiblePeers: PeerIdStr[] = [];
-
-    if (isBlockInputColumns(blockInput)) {
-      const pendingDataColumns: Set<number> = new Set(blockInput.getMissingSampledColumnMeta().missing);
-      // there could be no pending column in case when block is still missing
-      eligiblePeers.push(...this.filterPeers(pendingDataColumns, excludedPeers));
-    } else {
-      // prefulu
-      eligiblePeers.push(...this.filterPeers(null, excludedPeers));
-    }
-
-    if (eligiblePeers.length === 0) {
-      return null;
-    }
-
-    const sortedEligiblePeers = sortBy(
-      shuffle(eligiblePeers),
-      // prefer peers with least active req
-      (peerId) => this.activeRequests.get(peerId) ?? 0
-    );
-
-    const bestPeerId = sortedEligiblePeers[0];
-    this.onRequest(bestPeerId);
-    return this.peersMeta.get(bestPeerId) ?? null;
-  }
-
   /**
    * Consumers don't need to call this method directly, it is called internally by bestPeer*() methods
    * make this public for testing
@@ -804,8 +766,7 @@ export class UnknownBlockPeerBalancer {
     return totalActiveRequests;
   }
 
-  // pendingDataColumns could be null for prefulu
-  private filterPeers(pendingDataColumns: Set<number> | null, excludedPeers: Set<PeerIdStr>): PeerIdStr[] {
+  private filterPeers(pendingDataColumns: Set<number>, excludedPeers: Set<PeerIdStr>): PeerIdStr[] {
     let maxColumnCount = 0;
     const considerPeers: {peerId: PeerIdStr; columnCount: number}[] = [];
     for (const [peerId, syncMeta] of this.peersMeta.entries()) {
@@ -820,13 +781,12 @@ export class UnknownBlockPeerBalancer {
         continue;
       }
 
-      if (pendingDataColumns === null || pendingDataColumns.size === 0) {
-        // prefulu, no pending columns
+      if (pendingDataColumns.size === 0) {
         considerPeers.push({peerId, columnCount: 0});
         continue;
       }
 
-      // postfulu, find peers that have custody columns that we need
+      // find peers that have custody columns that we need
       const {custodyColumns: peerColumns} = syncMeta;
       // check if the peer has all needed columns
       // get match