Merge pull request #186 from AdExNetwork/fix-game-theoretical-failure

Fix game theoretical failure

Author: Ivo Georgiev

docs/config/dev.toml

@@ -8,6 +8,7 @@ msgs_find_limit = 10
 
 heartbeat_time = 30000
 health_threshold_promilles = 950
+health_unsignable_promilles = 750
 propagation_timeout = 1000
 
 list_timeout = 5000
@@ -24,4 +25,4 @@ creators_whitelist = []
 minimal_deposit = "0"
 minimal_fee = "0"
 token_address_whitelist = []
-validators_whitelist = []
+validators_whitelist = []

docs/config/prod.toml

@@ -10,6 +10,7 @@ msgs_find_limit = 10
 
 heartbeat_time = 60000
 health_threshold_promilles = 970
+health_unsignable_promilles = 770
 propagation_timeout = 3000
 
 list_timeout = 10000

primitives/src/config.rs

@@ -25,6 +25,7 @@ pub struct Config {
     pub channels_find_limit: u32,
     pub events_find_limit: u32,
     pub health_threshold_promilles: u32,
+    pub health_unsignable_promilles: u32,
     pub propagation_timeout: u32,
     pub fetch_timeout: u32,
     pub list_timeout: u32,

validator_worker/src/core/follower_rules.rs

@@ -15,12 +15,7 @@ pub fn is_valid_transition(channel: &Channel, prev: &BalancesMap, next: &Balance
     sum_next >= sum_prev && sum_next <= deposit && prev_checks
 }
 
-pub fn is_healthy(
-    channel: &Channel,
-    our: &BalancesMap,
-    approved: &BalancesMap,
-    health_threshold: &BigNum,
-) -> bool {
+pub fn get_health(channel: &Channel, our: &BalancesMap, approved: &BalancesMap) -> u64 {
     let sum_our: BigNum = our.values().sum();
 
     let zero = BigNum::from(0);
@@ -30,26 +25,21 @@ pub fn is_healthy(
         .sum();
 
     if sum_approved_mins >= sum_our {
-        return true;
+        return 1_000;
     }
 
-    let deposit = &channel.deposit_amount;
-    let health_threshold_neg = &BigNum::from(1_000) - health_threshold;
-    let acceptable_difference = deposit * &health_threshold_neg / &BigNum::from(1_000);
-
-    sum_our - sum_approved_mins < acceptable_difference
+    let diff = sum_our - sum_approved_mins;
+    let health_penalty = diff * &BigNum::from(1_000) / &channel.deposit_amount;
+    1_000 - health_penalty.to_u64().unwrap_or(1_000)
 }
 
 #[cfg(test)]
 mod test {
-    use lazy_static::lazy_static;
     use primitives::util::tests::prep_db::DUMMY_CHANNEL;
 
     use super::*;
 
-    lazy_static! {
-        static ref HEALTH_THRESHOLD: BigNum = BigNum::from(950);
-    }
+    const HEALTH_THRESHOLD: u64 = 950;
 
     fn get_dummy_channel<T: Into<BigNum>>(deposit: T) -> Channel {
         Channel {
@@ -161,107 +151,114 @@ mod test {
     }
 
     #[test]
-    fn is_healthy_the_approved_balance_tree_gte_our_accounting_is_healthy() {
+    fn get_health_the_approved_balance_tree_gte_our_accounting_is_healthy() {
         let channel = get_dummy_channel(50);
         let our = vec![("a".into(), 50.into())].into_iter().collect();
-        assert!(is_healthy(&channel, &our, &our, &HEALTH_THRESHOLD));
-
-        assert!(is_healthy(
-            &channel,
-            &our,
-            &vec![("a".into(), 60.into())].into_iter().collect(),
-            &HEALTH_THRESHOLD
-        ));
+        assert!(get_health(&channel, &our, &our) >= HEALTH_THRESHOLD);
+
+        assert!(
+            get_health(
+                &channel,
+                &our,
+                &vec![("a".into(), 60.into())].into_iter().collect()
+            ) >= HEALTH_THRESHOLD
+        );
     }
 
     #[test]
-    fn is_healthy_the_approved_balance_tree_is_positive_our_accounting_is_0_and_it_is_healthy() {
+    fn get_health_the_approved_balance_tree_is_positive_our_accounting_is_0_and_it_is_healthy() {
         let approved = vec![("a".into(), 50.into())].into_iter().collect();
 
-        assert!(is_healthy(
-            &get_dummy_channel(50),
-            &BalancesMap::default(),
-            &approved,
-            &HEALTH_THRESHOLD
-        ));
+        assert!(
+            get_health(&get_dummy_channel(50), &BalancesMap::default(), &approved)
+                >= HEALTH_THRESHOLD
+        );
     }
 
     #[test]
-    fn is_healthy_the_approved_balance_tree_has_less_but_within_margin_it_is_healthy() {
+    fn get_health_the_approved_balance_tree_has_less_but_within_margin_it_is_healthy() {
         let channel = get_dummy_channel(80);
 
-        assert!(is_healthy(
-            &channel,
-            &vec![("a".into(), 80.into())].into_iter().collect(),
-            &vec![("a".into(), 79.into())].into_iter().collect(),
-            &HEALTH_THRESHOLD
-        ));
-
-        assert!(is_healthy(
-            &channel,
-            &vec![("a".into(), 2.into())].into_iter().collect(),
-            &vec![("a".into(), 1.into())].into_iter().collect(),
-            &HEALTH_THRESHOLD
-        ));
+        assert!(
+            get_health(
+                &channel,
+                &vec![("a".into(), 80.into())].into_iter().collect(),
+                &vec![("a".into(), 79.into())].into_iter().collect()
+            ) >= HEALTH_THRESHOLD
+        );
+
+        assert!(
+            get_health(
+                &channel,
+                &vec![("a".into(), 2.into())].into_iter().collect(),
+                &vec![("a".into(), 1.into())].into_iter().collect()
+            ) >= HEALTH_THRESHOLD
+        );
     }
 
     #[test]
-    fn is_healthy_the_approved_balance_tree_has_less_it_is_unhealthy() {
+    fn get_health_the_approved_balance_tree_has_less_it_is_unhealthy() {
         let channel = get_dummy_channel(80);
 
-        assert!(!is_healthy(
-            &channel,
-            &vec![("a".into(), 80.into())].into_iter().collect(),
-            &vec![("a".into(), 70.into())].into_iter().collect(),
-            &HEALTH_THRESHOLD
-        ));
+        assert!(
+            get_health(
+                &channel,
+                &vec![("a".into(), 80.into())].into_iter().collect(),
+                &vec![("a".into(), 70.into())].into_iter().collect()
+            ) < HEALTH_THRESHOLD
+        );
     }
 
     #[test]
-    fn is_healthy_they_have_the_same_sum_but_different_entities_are_earning() {
+    fn get_health_they_have_the_same_sum_but_different_entities_are_earning() {
         let channel = get_dummy_channel(80);
 
-        assert!(!is_healthy(
-            &channel,
-            &vec![("a".into(), 80.into())].into_iter().collect(),
-            &vec![("b".into(), 80.into())].into_iter().collect(),
-            &HEALTH_THRESHOLD
-        ));
-
-        assert!(!is_healthy(
-            &channel,
-            &vec![("a".into(), 80.into())].into_iter().collect(),
-            &vec![("b".into(), 40.into()), ("a".into(), 40.into())]
-                .into_iter()
-                .collect(),
-            &HEALTH_THRESHOLD
-        ));
-
-        assert!(!is_healthy(
-            &channel,
-            &vec![("a".into(), 80.into())].into_iter().collect(),
-            &vec![("b".into(), 20.into()), ("a".into(), 60.into())]
-                .into_iter()
-                .collect(),
-            &HEALTH_THRESHOLD
-        ));
-
-        assert!(is_healthy(
-            &channel,
-            &vec![("a".into(), 80.into())].into_iter().collect(),
-            &vec![("b".into(), 2.into()), ("a".into(), 78.into())]
-                .into_iter()
-                .collect(),
-            &HEALTH_THRESHOLD
-        ));
-
-        assert!(is_healthy(
-            &channel,
-            &vec![("a".into(), 100.into()), ("b".into(), 1.into())]
-                .into_iter()
-                .collect(),
-            &vec![("a".into(), 100.into())].into_iter().collect(),
-            &HEALTH_THRESHOLD
-        ));
+        assert!(
+            get_health(
+                &channel,
+                &vec![("a".into(), 80.into())].into_iter().collect(),
+                &vec![("b".into(), 80.into())].into_iter().collect()
+            ) < HEALTH_THRESHOLD
+        );
+
+        assert!(
+            get_health(
+                &channel,
+                &vec![("a".into(), 80.into())].into_iter().collect(),
+                &vec![("b".into(), 40.into()), ("a".into(), 40.into())]
+                    .into_iter()
+                    .collect()
+            ) < HEALTH_THRESHOLD
+        );
+
+        assert!(
+            get_health(
+                &channel,
+                &vec![("a".into(), 80.into())].into_iter().collect(),
+                &vec![("b".into(), 20.into()), ("a".into(), 60.into())]
+                    .into_iter()
+                    .collect()
+            ) < HEALTH_THRESHOLD
+        );
+
+        assert!(
+            get_health(
+                &channel,
+                &vec![("a".into(), 80.into())].into_iter().collect(),
+                &vec![("b".into(), 2.into()), ("a".into(), 78.into())]
+                    .into_iter()
+                    .collect()
+            ) >= HEALTH_THRESHOLD
+        );
+
+        assert!(
+            get_health(
+                &channel,
+                &vec![("a".into(), 100.into()), ("b".into(), 1.into())]
+                    .into_iter()
+                    .collect(),
+                &vec![("a".into(), 100.into())].into_iter().collect()
+            ) >= HEALTH_THRESHOLD
+        );
     }
 }

validator_worker/src/follower.rs

@@ -4,7 +4,7 @@ use primitives::adapter::Adapter;
 use primitives::validator::{ApproveState, MessageTypes, NewState, RejectState};
 use primitives::BalancesMap;
 
-use crate::core::follower_rules::{is_healthy, is_valid_transition};
+use crate::core::follower_rules::{get_health, is_valid_transition};
 use crate::heartbeat::heartbeat;
 use crate::sentry_interface::SentryApi;
 use crate::{get_state_root_hash, producer};
@@ -14,6 +14,7 @@ enum InvalidNewState {
     RootHash,
     Signature,
     Transition,
+    Health,
 }
 
 enum NewStateResult {
@@ -82,20 +83,20 @@ async fn on_new_state<'a, A: Adapter + 'static>(
         return Ok(on_error(&iface, &new_state, InvalidNewState::Transition).await);
     }
 
+    let health = get_health(&iface.channel, balances, &proposed_balances);
+    if health < u64::from(iface.config.health_unsignable_promilles) {
+        return Ok(on_error(&iface, &new_state, InvalidNewState::Health).await);
+    }
+
     let signature = iface.adapter.sign(&new_state.state_root)?;
-    let health_threshold = u64::from(iface.config.health_threshold_promilles).into();
-    let health = is_healthy(
-        &iface.channel,
-        balances,
-        &proposed_balances,
-        &health_threshold,
-    );
+    let health_threshold = u64::from(iface.config.health_threshold_promilles);
+    let is_healthy = health >= health_threshold;
 
     iface
         .propagate(&[&MessageTypes::ApproveState(ApproveState {
             state_root: proposed_state_root,
             signature,
-            is_healthy: health,
+            is_healthy,
         })])
         .await;
 
@@ -112,6 +113,7 @@ async fn on_error<'a, A: Adapter + 'static>(
         RootHash => "InvalidRootHash",
         Signature => "InvalidSignature",
         Transition => "InvalidTransition",
+        Health => "TooLowHealth",
     }
     .to_string();