saved

daemons/node/indexer/handler.go

@@ -178,6 +178,43 @@ func (ix *IndexerService) initNodeHandler() {
 	ix.Host.SetStreamHandler(common.ProtocolPublish, ix.handleNodePublish)
 	ix.Host.SetStreamHandler(common.ProtocolGet, ix.handleNodeGet)
 	ix.Host.SetStreamHandler(common.ProtocolIndexerGetNatives, ix.handleGetNatives)
+	ix.Host.SetStreamHandler(common.ProtocolIndexerConsensus, ix.handleIndexerConsensus)
+}
+
+// handleIndexerConsensus implements Phase 2 liveness voting (ProtocolIndexerConsensus).
+// The caller sends a list of candidate multiaddrs; this indexer replies with the
+// subset it considers currently alive (recent heartbeat in StreamRecords).
+func (ix *IndexerService) handleIndexerConsensus(stream network.Stream) {
+	defer stream.Reset()
+
+	var req common.IndexerConsensusRequest
+	if err := json.NewDecoder(stream).Decode(&req); err != nil {
+		return
+	}
+
+	ix.StreamMU.RLock()
+	streams := ix.StreamRecords[common.ProtocolHeartbeat]
+	ix.StreamMU.RUnlock()
+
+	alive := make([]string, 0, len(req.Candidates))
+	for _, addr := range req.Candidates {
+		ad, err := peer.AddrInfoFromString(addr)
+		if err != nil {
+			continue
+		}
+		ix.StreamMU.RLock()
+		rec, ok := streams[ad.ID]
+		ix.StreamMU.RUnlock()
+		if !ok || rec.HeartbeatStream == nil || rec.HeartbeatStream.UptimeTracker == nil {
+			continue
+		}
+		// D: consider alive only if recent heartbeat AND score above minimum quality bar.
+		if time.Since(rec.HeartbeatStream.UptimeTracker.LastSeen) <= 2*common.RecommendedHeartbeatInterval &&
+			rec.LastScore >= 30.0 {
+			alive = append(alive, addr)
+		}
+	}
+	json.NewEncoder(stream).Encode(common.IndexerConsensusResponse{Alive: alive})
 }
 
 func (ix *IndexerService) handleNodePublish(s network.Stream) {

daemons/node/indexer/native.go

@@ -40,6 +40,7 @@ const (
 // liveIndexerEntry tracks a registered indexer in the native's in-memory cache and DHT.
 // PubKey and Signature are forwarded from the IndexerRegistration so the DHT validator
 // can verify that the entry was produced by the peer owning the declared PeerID.
+// FillRate is the fraction of capacity used (0=empty, 1=full) at last registration.
 type liveIndexerEntry struct {
 	PeerID       string    `json:"peer_id"`
 	Addr         string    `json:"addr"`
@@ -47,6 +48,7 @@ type liveIndexerEntry struct {
 	RegTimestamp int64     `json:"reg_ts,omitempty"` // Timestamp from the original IndexerRegistration
 	PubKey       []byte    `json:"pub_key,omitempty"`
 	Signature    []byte    `json:"sig,omitempty"`
+	FillRate     float64   `json:"fill_rate,omitempty"`
 }
 
 // NativeState holds runtime state specific to native indexer operation.
@@ -265,6 +267,7 @@ func (ix *IndexerService) handleNativeSubscription(s network.Stream) {
 			RegTimestamp: reg.Timestamp,
 			PubKey:       reg.PubKey,
 			Signature:    reg.Signature,
+			FillRate:     reg.FillRate,
 		}
 
 		// Verify that the declared address is actually reachable before admitting
@@ -428,11 +431,40 @@ func (ix *IndexerService) handleNativeGetIndexers(s network.Stream) {
 					"native: fallback pool saturated, refusing self-delegation")
 			}
 		} else {
-			rand.Shuffle(len(reachable), func(i, j int) { reachable[i], reachable[j] = reachable[j], reachable[i] })
+			// Sort by fill rate ascending so less-full indexers are preferred for routing.
+			ix.Native.liveIndexersMu.RLock()
+			fillRates := make(map[string]float64, len(reachable))
+			for _, addr := range reachable {
+				ad, err := pp.AddrInfoFromString(addr)
+				if err != nil {
+					continue
+				}
+				for _, e := range ix.Native.liveIndexers {
+					if e.PeerID == ad.ID.String() {
+						fillRates[addr] = e.FillRate
+						break
+					}
+				}
+			}
+			ix.Native.liveIndexersMu.RUnlock()
+
+			// Sort by routing weight descending: weight = fillRate × (1 − fillRate).
+			// This prefers indexers in the "trust sweet spot" — proven popular (fillRate > 0)
+			// but not saturated (fillRate < 1). Peak at fillRate ≈ 0.5.
+			routingWeight := func(addr string) float64 {
+				f := fillRates[addr]
+				return f * (1 - f)
+			}
+			for i := 1; i < len(reachable); i++ {
+				for j := i; j > 0 && routingWeight(reachable[j]) > routingWeight(reachable[j-1]); j-- {
+					reachable[j], reachable[j-1] = reachable[j-1], reachable[j]
+				}
+			}
 			if req.Count > len(reachable) {
 				req.Count = len(reachable)
 			}
 			resp.Indexers = reachable[:req.Count]
+			resp.FillRates = fillRates
 		}
 
 		if err := json.NewEncoder(s).Encode(resp); err != nil {

daemons/node/indexer/service.go

@@ -96,9 +96,24 @@ func NewIndexerService(h host.Host, ps *pubsub.PubSub, maxNode int, isNative boo
 		ix.InitNative()
 	} else {
 		ix.initNodeHandler()
-		// Register with configured natives so this indexer appears in their cache
+		// Register with configured natives so this indexer appears in their cache.
+		// Pass a fill rate provider so the native can route new nodes to less-loaded indexers.
 		if nativeAddrs := conf.GetConfig().NativeIndexerAddresses; nativeAddrs != "" {
-			common.StartNativeRegistration(ix.Host, nativeAddrs)
+			fillRateFn := func() float64 {
+				ix.StreamMU.RLock()
+				n := len(ix.StreamRecords[common.ProtocolHeartbeat])
+				ix.StreamMU.RUnlock()
+				maxN := ix.MaxNodesConn()
+				if maxN <= 0 {
+					return 0
+				}
+				rate := float64(n) / float64(maxN)
+				if rate > 1 {
+					rate = 1
+				}
+				return rate
+			}
+			common.StartNativeRegistration(ix.Host, nativeAddrs, fillRateFn)
 		}
 	}
 	return ix