Lower Quorum absolute & relative agreement thresholds

neurons/Cargo.toml

@@ -13,6 +13,7 @@ serde = { version = "1.0.197", features = ["derive"] }
 serde_json = "1.0.114"
 serde_repr = "0.1.18"
 wasm-bindgen = "0.2"
+web-sys = { version = "0.3.77", features = ["console"] }
 
 [dev-dependencies]
 uuid = { version = "1.16.0", features = ["v4"] }

neurons/rustfmt.toml

@@ -1,3 +1,3 @@
-max_width = 100
+max_width = 120
 fn_call_width = 100
 chain_width = 100

neurons/src/assigned_reputation.rs

@@ -119,28 +119,17 @@ mod tests {
 
     #[test]
     fn neuron_run() {
-        let users: Vec<String> = vec![
-            "user1".to_string(),
-            "user2".to_string(),
-            "user3".to_string(),
-        ];
+        let users: Vec<String> = vec!["user1".to_string(), "user2".to_string(), "user3".to_string()];
         let mut users_reputation: HashMap<String, ReputationTier> = HashMap::new();
         users_reputation.insert("user1".to_string(), ReputationTier::Navigator);
         users_reputation.insert("user2".to_string(), ReputationTier::Pilot);
         users_reputation.insert("user3".to_string(), ReputationTier::Verified);
 
         let mut users_discord_roles: HashMap<String, Vec<String>> = HashMap::new();
-        users_discord_roles.insert(
-            "user1".to_string(),
-            vec![
-                "SDF".to_string(),
-                "SCF Project".to_string(),
-                "Moderator".to_string(),
-            ],
-        );
-        users_discord_roles.insert("user2".to_string(), vec![]);
         users_discord_roles
-            .insert("user3".to_string(), vec!["Public Good Contributor".to_string()]);
+            .insert("user1".to_string(), vec!["SDF".to_string(), "SCF Project".to_string(), "Moderator".to_string()]);
+        users_discord_roles.insert("user2".to_string(), vec![]);
+        users_discord_roles.insert("user3".to_string(), vec!["Public Good Contributor".to_string()]);
 
         let neuron = AssignedReputationNeuron::from_data(users_reputation, users_discord_roles);
         let resut = neuron.calculate_result(&users);

neurons/src/lib.rs

@@ -30,62 +30,41 @@ pub fn run_neurons(
         Ok(users_base) => users_base,
         Err(err) => return Err(format!("users_base json parsing error {}", err.to_string())),
     };
-    let previous_rounds_for_users: HashMap<String, Vec<u32>> =
-        match serde_json::from_str(previous_rounds_for_users) {
-            Ok(previous_rounds_for_users) => previous_rounds_for_users,
-            Err(err) => {
-                return Err(format!(
-                    "previous_rounds_for_users json parsing error {}",
-                    err.to_string()
-                ))
-            }
-        };
-    let users_reputation: HashMap<String, ReputationTier> =
-        match serde_json::from_str(users_reputation) {
-            Ok(users_reputation) => users_reputation,
-            Err(err) => {
-                return Err(format!("users_reputation json parsing error {}", err.to_string()))
-            }
-        };
-    let users_discord_roles: HashMap<String, Vec<String>> =
-        match serde_json::from_str(users_discord_roles) {
-            Ok(users_discord_roles) => users_discord_roles,
-            Err(err) => {
-                return Err(format!("users_discord_roles json parsing error {}", err.to_string()))
-            }
-        };
+    let previous_rounds_for_users: HashMap<String, Vec<u32>> = match serde_json::from_str(previous_rounds_for_users) {
+        Ok(previous_rounds_for_users) => previous_rounds_for_users,
+        Err(err) => return Err(format!("previous_rounds_for_users json parsing error {}", err.to_string())),
+    };
+    let users_reputation: HashMap<String, ReputationTier> = match serde_json::from_str(users_reputation) {
+        Ok(users_reputation) => users_reputation,
+        Err(err) => return Err(format!("users_reputation json parsing error {}", err.to_string())),
+    };
+    let users_discord_roles: HashMap<String, Vec<String>> = match serde_json::from_str(users_discord_roles) {
+        Ok(users_discord_roles) => users_discord_roles,
+        Err(err) => return Err(format!("users_discord_roles json parsing error {}", err.to_string())),
+    };
     println!("users_discord_roles: {:?}", users_discord_roles);
     let trusted_for_user_per_round: HashMap<u32, HashMap<String, Vec<String>>> =
         match serde_json::from_str(trusted_for_user_per_round) {
             Ok(trusted_for_user_per_round) => trusted_for_user_per_round,
-            Err(err) => {
-                return Err(format!(
-                    "trusted_for_user_per_round json parsing error {}",
-                    err.to_string()
-                ))
-            }
+            Err(err) => return Err(format!("trusted_for_user_per_round json parsing error {}", err.to_string())),
         };
     // create neurons
-    let prior_voting_history_neuron =
-        PriorVotingHistoryNeuron::from_data(previous_rounds_for_users);
+    let prior_voting_history_neuron = PriorVotingHistoryNeuron::from_data(previous_rounds_for_users);
 
-    let assigned_reputation_neuron =
-        AssignedReputationNeuron::from_data(users_reputation, users_discord_roles);
+    let assigned_reputation_neuron = AssignedReputationNeuron::from_data(users_reputation, users_discord_roles);
 
     // prepare and run trust neurons for previous rounds
     let mut trust_graph_neurons: Vec<Box<dyn Neuron>> = vec![];
     trusted_for_user_per_round.iter().for_each(|(round, trusted_for_user)| {
         if *round == current_round || *round == current_round - 1 {
-            trust_graph_neurons
-                .push(Box::new(TrustGraphNeuron::from_data(trusted_for_user.clone(), *round)));
+            trust_graph_neurons.push(Box::new(TrustGraphNeuron::from_data(trusted_for_user.clone(), *round)));
         }
     });
 
     let trust_graph_neurons_results: HashMap<String, HashMap<String, f64>> =
         calculate_trust_neuron_results(&users_base, trust_graph_neurons);
 
-    let trust_history_neuron =
-        TrustHistoryNeuron::from_data(current_round as usize, trust_graph_neurons_results);
+    let trust_history_neuron = TrustHistoryNeuron::from_data(current_round as usize, trust_graph_neurons_results);
 
     // run all neurons
     let results = calculate_neuron_results(
@@ -101,11 +80,7 @@ pub fn run_neurons(
 }
 
 #[wasm_bindgen]
-pub fn run_votes_normalization(
-    votes: &str,
-    submissions: &str,
-    delegatees_for_user: &str,
-) -> Result<String, String> {
+pub fn run_votes_normalization(votes: &str, submissions: &str, delegatees_for_user: &str) -> Result<String, String> {
     let votes: HashMap<String, HashMap<String, Vote>> = match serde_json::from_str(votes) {
         Ok(votes) => votes,
         Err(err) => return Err(format!("votes json parsing error {}", err.to_string())),
@@ -116,14 +91,10 @@ pub fn run_votes_normalization(
         Err(err) => return Err(format!("submissions json parsing error {}", err.to_string())),
     };
 
-    let delegatees_for_user: HashMap<String, DelegateesForUser> =
-        match serde_json::from_str(delegatees_for_user) {
-            Ok(delegatees_for_user) => delegatees_for_user,
-            Err(err) => {
-                return Err(format!("delegatees_for_user json parsing error {}", err.to_string()))
-            }
-        };
-
+    let delegatees_for_user: HashMap<String, DelegateesForUser> = match serde_json::from_str(delegatees_for_user) {
+        Ok(delegatees_for_user) => delegatees_for_user,
+        Err(err) => return Err(format!("delegatees_for_user json parsing error {}", err.to_string())),
+    };
     let normalized_votes = match normalize_votes(votes, &submissions, &delegatees_for_user) {
         Ok(normalized_votes) => normalized_votes,
         Err(err) => return Err(format!("error normalizing votes {}", err.to_string())),
@@ -152,10 +123,8 @@ fn calculate_neuron_results(
     for neuron in neurons {
         println!("running {}", neuron.name());
         let result = neuron.calculate_result(users);
-        let result: HashMap<String, String> = result
-            .into_iter()
-            .map(|(key, value)| (key, to_fixed_point_decimal(value).to_string()))
-            .collect();
+        let result: HashMap<String, String> =
+            result.into_iter().map(|(key, value)| (key, to_fixed_point_decimal(value).to_string())).collect();
         results.insert(neuron.name(), result);
     }
     results

neurons/src/prior_voting_history.rs

@@ -11,22 +11,11 @@ pub struct PriorVotingHistoryNeuron {
 
 impl PriorVotingHistoryNeuron {
     pub fn from_data(users_round_history: HashMap<String, Vec<u32>>) -> Self {
-        Self {
-            users_round_history,
-        }
+        Self { users_round_history }
     }
 }
 
-fn generalised_logistic_function(
-    a: f64,
-    k: f64,
-    c: f64,
-    q: f64,
-    b: f64,
-    nu: f64,
-    x_off: f64,
-    x: f64,
-) -> f64 {
+fn generalised_logistic_function(a: f64, k: f64, c: f64, q: f64, b: f64, nu: f64, x_off: f64, x: f64) -> f64 {
     a + (k - a) / (f64::powf(c + q * f64::exp(-b * (x - x_off)), 1.0 / nu))
 }
 
@@ -52,9 +41,7 @@ impl Neuron for PriorVotingHistoryNeuron {
         let mut result = HashMap::new();
 
         for user in users {
-            let bonus = calculate_bonus(
-                &self.users_round_history.get(user).cloned().unwrap_or_else(Vec::new),
-            );
+            let bonus = calculate_bonus(&self.users_round_history.get(user).cloned().unwrap_or_else(Vec::new));
             result.insert(user.into(), bonus);
         }