saved

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 {