Caplin: Simplified peer refreshing (#18123) (#18152)

We actually never use metadata, so let's do one less network call

Co-authored-by: Giulio rebuffo <[email protected]>

Author: domiwei

cl/beacon/handler/node.go

@@ -103,6 +103,9 @@ func (a *ApiHandler) GetEthV1NodePeersInfos(w http.ResponseWriter, r *http.Reque
 	}
 	peers := make([]peer, 0, len(ret.Peers))
 	for i := range ret.Peers {
+		if ret.Peers[i].Enr == "" {
+			continue
+		}
 		peers = append(peers, peer{
 			PeerID:             ret.Peers[i].Pid,
 			State:              ret.Peers[i].State,
@@ -128,6 +131,9 @@ func (a *ApiHandler) GetEthV1NodePeerInfos(w http.ResponseWriter, r *http.Reques
 	// find the peer with matching enr
 	for _, p := range ret.Peers {
 		if p.Pid == pid {
+			if p.Enr == "" {
+				continue
+			}
 			return newBeaconResponse(peer{
 				PeerID:             p.Pid,
 				State:              p.State,

cl/rpc/peer_selection.go

@@ -67,9 +67,8 @@ type peerDataKey struct {
 }
 
 type peerData struct {
-	pid                   string
-	mask                  map[uint64]bool
-	earliestAvailableSlot uint64
+	pid  string
+	mask map[uint64]bool
 }
 
 func (c *columnDataPeers) refreshPeers(ctx context.Context) {
@@ -106,46 +105,26 @@ func (c *columnDataPeers) refreshPeers(ctx context.Context) {
 				log.Debug("[peerSelector] empty cgc", "peer", pid)
 				continue
 			}
-			// request status
-			buf := new(bytes.Buffer)
-			forkDigest, err := c.ethClock.CurrentForkDigest()
-			if err != nil {
-				log.Debug("[peerSelector] failed to get fork digest", "peer", pid, "err", err)
-				continue
-			}
-			myStatus := &cltypes.Status{
-				ForkDigest:            forkDigest,
-				FinalizedRoot:         c.beaconState.FinalizedCheckpoint().Root,
-				FinalizedEpoch:        c.beaconState.FinalizedCheckpoint().Epoch,
-				HeadRoot:              c.beaconState.FinalizedCheckpoint().Root,
-				HeadSlot:              c.beaconState.FinalizedCheckpoint().Epoch * c.beaconConfig.SlotsPerEpoch,
-				EarliestAvailableSlot: new(uint64),
-			}
-			if err := ssz_snappy.EncodeAndWrite(buf, myStatus); err != nil {
-				log.Debug("[peerSelector] failed to encode my status", "peer", pid, "err", err)
-				continue
-			}
-			status := &cltypes.Status{}
-			if err := c.simpleReuqest(ctx, pid, communication.StatusProtocolV2, status, buf.Bytes()); err != nil {
-				log.Debug("[peerSelector] failed to request peer status", "peer", pid, "err", err)
-				continue
-			}
-			if status.EarliestAvailableSlot == nil {
-				log.Debug("[peerSelector] empty earliest available slot", "peer", pid)
-				continue
+			custodyIndices := map[cltypes.CustodyIndex]bool{}
+			if peer.EnodeId == "" {
+				// fill all custody indices
+				for i := cltypes.CustodyIndex(0); i < c.beaconConfig.NumberOfCustodyGroups; i++ {
+					custodyIndices[i] = true
+				}
+			} else {
+				// get custody indices
+				enodeId := enode.HexID(peer.EnodeId)
+				custodyIndices, err = peerdasutils.GetCustodyColumns(enodeId, *metadata.CustodyGroupCount)
+				if err != nil {
+					log.Debug("[peerSelector] failed to get custody indices", "peer", pid, "err", err)
+					continue
+				}
 			}
 
-			// get custody indices
-			enodeId := enode.HexID(peer.EnodeId)
-			custodyIndices, err := peerdasutils.GetCustodyColumns(enodeId, *metadata.CustodyGroupCount)
-			if err != nil {
-				log.Debug("[peerSelector] failed to get custody indices", "peer", pid, "err", err)
-				continue
-			}
-			data := &peerData{pid: pid, mask: custodyIndices, earliestAvailableSlot: *status.EarliestAvailableSlot}
+			data := &peerData{pid: pid, mask: custodyIndices}
 			c.peerMetaCache.Add(peerKey, data)
 			newPeers = append(newPeers, *data)
-			log.Debug("[peerSelector] added peer", "peer", pid, "custodies", len(custodyIndices), "earliestAvailableSlot", *status.EarliestAvailableSlot)
+			log.Debug("[peerSelector] added peer", "peer", pid, "custodies", len(custodyIndices))
 		}
 		c.peersMutex.Lock()
 		c.peersQueue = newPeers

cl/sentinel/sentinel.go

@@ -521,23 +521,20 @@ func (s *Sentinel) GetPeersInfos() *sentinelproto.PeersInfoResponse {
 			entry.State = "disconnected"
 		}
 		conns := s.host.Network().ConnsToPeer(p)
-		if len(conns) == 0 {
-			continue
-		}
-		if conns[0].Stat().Direction == network.DirOutbound {
+		if len(conns) == 0 || conns[0].Stat().Direction == network.DirOutbound {
 			entry.Direction = "outbound"
 		} else {
 			entry.Direction = "inbound"
 		}
 		if enr, ok := s.pidToEnr.Load(p); ok {
 			entry.Enr = enr.(string)
 		} else {
-			continue
+			entry.Enr = ""
 		}
 		if enodeId, ok := s.pidToEnodeId.Load(p); ok {
 			entry.EnodeId = enodeId.(enode.ID).String()
 		} else {
-			continue
+			entry.EnodeId = ""
 		}
 		agent, err := s.host.Peerstore().Get(p, "AgentVersion")
 		if err == nil {