fix: limit single indexer success rate

Author: Theodus

Cargo.lock

@@ -82,8 +82,9 @@ impl Performance {
         // This results in decay pulling success rate upward.
         successful_responses += 1.0;
         let failed_responses: f64 = self.latency_failure.map(|f| f.response_count).sum();
-        Normalized::new(successful_responses / (successful_responses + failed_responses).max(1.0))
-            .unwrap()
+        let success_rate = successful_responses / (successful_responses + failed_responses);
+        // Limit an individual indexer's success rate to 99%.
+        Normalized::new(success_rate.min(0.99)).unwrap()
     }
 
     fn latency_success(&self) -> NotNan<f64> {

candidate-selection/src/criteria/performance.rs

@@ -6,7 +6,7 @@ edition = "2021"
 [dependencies]
 candidate-selection = { path = "../candidate-selection" }
 custom_debug = "0.6.1"
-thegraph-core = "0.4.0"
+thegraph-core = "0.3.2"
 url = "2.5.0"
 
 [dev-dependencies]

indexer-selection/Cargo.toml

@@ -1,16 +1,15 @@
-use std::collections::hash_map::DefaultHasher;
-use std::f64::consts::E;
-use std::fmt::Display;
-use std::hash::{Hash as _, Hasher as _};
-
-use custom_debug::CustomDebug;
-use thegraph_core::types::alloy_primitives::Address;
-use thegraph_core::types::DeploymentId;
-use url::Url;
-
 use candidate_selection::criteria::performance::expected_value_probabilities;
 pub use candidate_selection::criteria::performance::{ExpectedPerformance, Performance};
 pub use candidate_selection::{ArrayVec, Normalized};
+use custom_debug::CustomDebug;
+use std::{
+    collections::hash_map::DefaultHasher,
+    f64::consts::E,
+    fmt::Display,
+    hash::{Hash as _, Hasher as _},
+};
+use thegraph_core::types::{alloy_primitives::Address, DeploymentId};
+use url::Url;
 
 #[cfg(test)]
 mod test;
@@ -23,6 +22,7 @@ pub struct Candidate {
     pub url: Url,
     pub perf: ExpectedPerformance,
     pub fee: Normalized,
+    /// seconds behind chain head
     pub seconds_behind: u32,
     pub slashable_grt: u64,
     /// subgraph versions behind latest deployment

indexer-selection/src/lib.rs

@@ -116,7 +116,7 @@ fn sensitivity_seconds_behind() {
                 .into(),
             url: "https://example.com".parse().unwrap(),
             perf: ExpectedPerformance {
-                success_rate: Normalized::ONE,
+                success_rate: Normalized::new(0.99).unwrap(),
                 latency_success_ms: 0,
                 latency_failure_ms: 0,
             },
@@ -164,3 +164,68 @@ fn sensitivity_seconds_behind() {
         "select candidate closer to chain head",
     );
 }
+
+#[test]
+fn multi_selection_preference() {
+    let candidates = [
+        Candidate {
+            indexer: hex!("0000000000000000000000000000000000000000").into(),
+            deployment: hex!("0000000000000000000000000000000000000000000000000000000000000000")
+                .into(),
+            url: "https://example.com/".parse().unwrap(),
+            perf: ExpectedPerformance {
+                success_rate: Normalized::new(0.99).unwrap(),
+                latency_success_ms: 93,
+                latency_failure_ms: 0,
+            },
+            fee: Normalized::ZERO,
+            seconds_behind: 0,
+            slashable_grt: 9445169,
+            versions_behind: 0,
+            zero_allocation: false,
+        },
+        Candidate {
+            indexer: hex!("0000000000000000000000000000000000000001").into(),
+            deployment: hex!("0000000000000000000000000000000000000000000000000000000000000000")
+                .into(),
+            url: "https://example.com/".parse().unwrap(),
+            perf: ExpectedPerformance {
+                success_rate: Normalized::new(0.99).unwrap(),
+                latency_success_ms: 0,
+                latency_failure_ms: 0,
+            },
+            fee: Normalized::ZERO,
+            seconds_behind: 0,
+            slashable_grt: 1330801,
+            versions_behind: 0,
+            zero_allocation: false,
+        },
+        Candidate {
+            indexer: hex!("0000000000000000000000000000000000000002").into(),
+            deployment: hex!("0000000000000000000000000000000000000000000000000000000000000000")
+                .into(),
+            url: "https://example.com/".parse().unwrap(),
+            perf: ExpectedPerformance {
+                success_rate: Normalized::new(0.99).unwrap(),
+                latency_success_ms: 224,
+                latency_failure_ms: 0,
+            },
+            fee: Normalized::ZERO,
+            seconds_behind: 0,
+            slashable_grt: 2675210,
+            versions_behind: 0,
+            zero_allocation: false,
+        },
+    ];
+
+    for c in &candidates {
+        println!("{} {:?}", c.indexer, c.score());
+    }
+    let combined_score =
+        Candidate::score_many::<3>(&candidates.iter().collect::<ArrayVec<&Candidate, 3>>());
+    assert!(candidates.iter().all(|c| c.score() < combined_score));
+
+    let selected: ArrayVec<&Candidate, 3> = crate::select(&candidates);
+    println!("{:#?}", selected);
+    assert_eq!(3, selected.len(), "all indexers selected");
+}