refactor(sync): Refactor the sync scoring system

code/crates/app/src/spawn.rs

@@ -179,6 +179,7 @@ where
 
     let scoring_strategy = match config.scoring_strategy {
         malachitebft_config::ScoringStrategy::Ema => sync::scoring::Strategy::Ema,
+        malachitebft_config::ScoringStrategy::Credit => sync::scoring::Strategy::Credit,
     };
 
     let sync_config = sync::Config {
@@ -188,6 +189,7 @@ where
         request_timeout: config.request_timeout,
         parallel_requests: config.parallel_requests as u64,
         scoring_strategy,
+        initial_score: config.initial_score,
         inactive_threshold: (!config.inactive_threshold.is_zero())
             .then_some(config.inactive_threshold),
         batch_size: config.batch_size,

code/crates/config/src/lib.rs

@@ -529,6 +529,10 @@ pub struct ValueSyncConfig {
     #[serde(default)]
     pub scoring_strategy: ScoringStrategy,
 
+    /// Initial score for peers
+    #[serde(default = "default_initial_score")]
+    pub initial_score: f64,
+
     /// Threshold for considering a peer inactive
     #[serde(with = "humantime_serde")]
     pub inactive_threshold: Duration,
@@ -547,23 +551,33 @@ impl Default for ValueSyncConfig {
             max_response_size: ByteSize::mib(10),
             parallel_requests: 5,
             scoring_strategy: ScoringStrategy::default(),
+            initial_score: default_initial_score(),
             inactive_threshold: Duration::from_secs(60),
             batch_size: 5,
         }
     }
 }
 
+fn default_initial_score() -> f64 {
+    0.5
+}
+
+/// Peer scoring strategy
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ScoringStrategy {
+    /// Exponential Moving Average
     #[default]
     Ema,
+    /// Credit-based scoring
+    Credit,
 }
 
 impl ScoringStrategy {
     pub fn name(&self) -> &'static str {
         match self {
             Self::Ema => "ema",
+            Self::Credit => "credit",
         }
     }
 }
@@ -574,7 +588,10 @@ impl FromStr for ScoringStrategy {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "ema" => Ok(Self::Ema),
-            e => Err(format!("unknown scoring strategy: {e}, available: ema")),
+            "credit" => Ok(Self::Credit),
+            e => Err(format!(
+                "unknown scoring strategy: {e}, available: ema, credit"
+            )),
         }
     }
 }

code/crates/starknet/host/src/spawn.rs

@@ -161,6 +161,7 @@ async fn spawn_sync_actor(
 
     let scoring_strategy = match config.scoring_strategy {
         config::ScoringStrategy::Ema => sync::scoring::Strategy::Ema,
+        config::ScoringStrategy::Credit => sync::scoring::Strategy::Credit,
     };
 
     let sync_config = sync::Config {
@@ -170,6 +171,7 @@ async fn spawn_sync_actor(
         request_timeout: config.request_timeout,
         parallel_requests: config.parallel_requests as u64,
         scoring_strategy,
+        initial_score: config.initial_score,
         inactive_threshold: (!config.inactive_threshold.is_zero())
             .then_some(config.inactive_threshold),
         batch_size: config.batch_size,

code/crates/sync/src/config.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use crate::scoring::Strategy;
+use crate::scoring::{Score, Strategy};
 
 const DEFAULT_PARALLEL_REQUESTS: u64 = 5;
 const DEFAULT_BATCH_SIZE: usize = 5;
@@ -13,6 +13,7 @@ pub struct Config {
     pub max_response_size: usize,
     pub parallel_requests: u64,
     pub scoring_strategy: Strategy,
+    pub initial_score: Score,
     pub inactive_threshold: Option<Duration>,
     pub batch_size: usize,
 }
@@ -50,6 +51,11 @@ impl Config {
         self
     }
 
+    pub fn with_initial_score(mut self, initial_score: Score) -> Self {
+        self.initial_score = initial_score;
+        self
+    }
+
     pub fn with_inactive_threshold(mut self, inactive_threshold: Option<Duration>) -> Self {
         self.inactive_threshold = inactive_threshold;
         self
@@ -70,6 +76,7 @@ impl Default for Config {
             max_response_size: 10 * 1024 * 1024, // 10 MiB
             parallel_requests: DEFAULT_PARALLEL_REQUESTS,
             scoring_strategy: Strategy::default(),
+            initial_score: 0.5,
             inactive_threshold: None,
             batch_size: DEFAULT_BATCH_SIZE,
         }