Merge pull request #166 from input-output-hk/NPG-1371-requirement-for-voter-reward

Requirement for voter reward - component tests

Author: nicopado

.gitignore

@@ -1,4 +1,7 @@
 /.vscode
+/.vs
+/.idea
+
 
 qr-code.svg
 

catalyst-toolbox/src/rewards/voters.rs

@@ -136,49 +136,79 @@ mod tests {
     use crate::utils::assert_are_close;
     use jormungandr_lib::crypto::{account::Identifier, hash::Hash};
     use snapshot_lib::registration::{Delegations, VotingRegistration};
-    use snapshot_lib::Fraction;
     use snapshot_lib::Snapshot;
+    use snapshot_lib::{Fraction, RawSnapshot};
     use test_strategy::proptest;
 
+    const DEFAULT_TEST_THRESHOLD: usize = 1;
+    const DEFAULT_SNAPSHOT_THRESHOLD: u64 = 1;
+
     #[proptest]
-    fn test_all_active(snapshot: Snapshot) {
+    fn test_all_active_voters(raw_snapshot: RawSnapshot) {
+        let snapshot = Snapshot::from_raw_snapshot(
+            raw_snapshot,
+            DEFAULT_SNAPSHOT_THRESHOLD.into(),
+            Fraction::from(1),
+            &|_vk: &Identifier| String::new(),
+        )
+        .unwrap();
+
         let votes_count = snapshot
             .voting_keys()
             .into_iter()
             .map(|key| (key.clone(), HashSet::from([Hash::from([0u8; 32])])))
             .collect::<VoteCount>();
-        let n_voters = votes_count.len();
+
+        let number_of_voters = votes_count.len();
+
         let voters = snapshot.to_full_snapshot_info();
         let rewards = calc_voter_rewards(
             votes_count,
             voters,
-            Threshold::new(1, HashMap::new(), Vec::new()).unwrap(),
+            Threshold::new(DEFAULT_TEST_THRESHOLD, HashMap::new(), Vec::new()).unwrap(),
             Rewards::ONE,
         )
         .unwrap();
-        if n_voters > 0 {
+        if number_of_voters > 0 {
             assert_are_close(rewards.values().sum::<Rewards>(), Rewards::ONE)
         } else {
             assert_eq!(rewards.len(), 0);
         }
     }
 
     #[proptest]
-    fn test_all_inactive(snapshot: Snapshot) {
+    fn test_all_inactive_voters(raw_snapshot: RawSnapshot) {
+        let snapshot = Snapshot::from_raw_snapshot(
+            raw_snapshot,
+            DEFAULT_SNAPSHOT_THRESHOLD.into(),
+            Fraction::from(1),
+            &|_vk: &Identifier| String::new(),
+        )
+        .unwrap();
+
         let votes_count = VoteCount::new();
+
         let voters = snapshot.to_full_snapshot_info();
         let rewards = calc_voter_rewards(
             votes_count,
             voters,
-            Threshold::new(1, HashMap::new(), Vec::new()).unwrap(),
+            Threshold::new(DEFAULT_TEST_THRESHOLD, HashMap::new(), Vec::new()).unwrap(),
             Rewards::ONE,
         )
         .unwrap();
         assert_eq!(rewards.len(), 0);
     }
 
     #[proptest]
-    fn test_small(snapshot: Snapshot) {
+    fn test_active_and_inactive_voters(raw_snapshot: RawSnapshot) {
+        let snapshot = Snapshot::from_raw_snapshot(
+            raw_snapshot,
+            DEFAULT_SNAPSHOT_THRESHOLD.into(),
+            Fraction::from(1),
+            &|_vk: &Identifier| String::new(),
+        )
+        .unwrap();
+
         let voting_keys = snapshot.voting_keys().collect::<Vec<_>>();
 
         let votes_count = voting_keys
@@ -188,54 +218,59 @@ mod tests {
                 (
                     key.to_owned(),
                     if i % 2 == 0 {
+                        // generating a random set of half active & half inactive votes
                         HashSet::from([Hash::from([0u8; 32])])
                     } else {
                         HashSet::new()
                     },
                 )
             })
             .collect::<VoteCount>();
-        let n_voters = votes_count
+
+        let number_of_active_voters = votes_count
             .iter()
             .filter(|(_, votes)| !votes.is_empty())
             .count();
+
         let voters = snapshot.to_full_snapshot_info();
-        let voters_active = voters
+
+        let active_voters = voters
             .clone()
             .into_iter()
             .enumerate()
             .filter(|(i, _utxo)| i % 2 == 0)
             .map(|(_, utxo)| utxo)
             .collect::<Vec<_>>();
 
-        let mut rewards = calc_voter_rewards(
+        let mut all_rewards = calc_voter_rewards(
             votes_count.clone(),
             voters,
             Threshold::new(1, HashMap::new(), Vec::new()).unwrap(),
             Rewards::ONE,
         )
         .unwrap();
+
         let rewards_no_inactive = calc_voter_rewards(
             votes_count,
-            voters_active,
-            Threshold::new(1, HashMap::new(), Vec::new()).unwrap(),
+            active_voters,
+            Threshold::new(DEFAULT_TEST_THRESHOLD, HashMap::new(), Vec::new()).unwrap(),
             Rewards::ONE,
         )
         .unwrap();
         // Rewards should ignore inactive voters
-        assert_eq!(rewards, rewards_no_inactive);
-        if n_voters > 0 {
-            assert_are_close(rewards.values().sum::<Rewards>(), Rewards::ONE);
+        assert_eq!(all_rewards, rewards_no_inactive);
+        if number_of_active_voters > 0 {
+            assert_are_close(all_rewards.values().sum::<Rewards>(), Rewards::ONE);
         } else {
-            assert_eq!(rewards.len(), 0);
+            assert_eq!(all_rewards.len(), 0);
         }
 
-        let (active, inactive): (Vec<_>, Vec<_>) = voting_keys
+        let (active_voters_keys, inactive_voters_keys): (Vec<_>, Vec<_>) = voting_keys
             .into_iter()
             .enumerate()
             .partition(|(i, _vk)| i % 2 == 0);
 
-        let active_reward_addresses = active
+        let active_reward_addresses = active_voters_keys
             .into_iter()
             .flat_map(|(_, vk)| {
                 snapshot
@@ -247,27 +282,27 @@ mod tests {
 
         assert!(active_reward_addresses
             .iter()
-            .all(|addr| rewards.remove(addr).unwrap() > Rewards::ZERO));
+            .all(|addr| all_rewards.remove(addr).unwrap() > Rewards::ZERO));
 
-        // partial test: does not check that rewards for addresses that delegated to both
-        // active and inactive voters only come from active ones
-        for (_, vk) in inactive {
-            for contrib in snapshot.contributions_for_voting_key(vk.clone()) {
-                assert!(rewards.get(&contrib.reward_address).is_none());
+        for (_, voting_key) in inactive_voters_keys {
+            for contrib in snapshot.contributions_for_voting_key(voting_key.clone()) {
+                assert!(all_rewards.get(&contrib.reward_address).is_none());
             }
         }
     }
 
     #[test]
     fn test_mapping() {
         let mut raw_snapshot = Vec::new();
-        let voting_pub_key = Identifier::from_hex(&hex::encode([0; 32])).unwrap();
+        let voting_public_key = Identifier::from_hex(&hex::encode([0; 32])).unwrap();
 
         let mut total_stake = 0u64;
+
         for i in 1..10u64 {
             let stake_public_key = i.to_string();
             let reward_address = i.to_string();
-            let delegations = Delegations::New(vec![(voting_pub_key.clone(), 1)]);
+
+            let delegations = Delegations::New(vec![(voting_public_key.clone(), 1)]);
             raw_snapshot.push(VotingRegistration {
                 stake_public_key,
                 voting_power: i.into(),
@@ -282,7 +317,7 @@ mod tests {
             raw_snapshot.into(),
             0.into(),
             Fraction::from(1u64),
-            &|_vk: &Identifier| String::new(),
+            &|_voting_key: &Identifier| String::new(),
         )
         .unwrap();
 
@@ -295,11 +330,13 @@ mod tests {
             Rewards::ONE,
         )
         .unwrap();
+
         assert_eq!(rewards.values().sum::<Rewards>(), Rewards::ONE);
-        for (addr, reward) in rewards {
+
+        for (mainnet_addresses, reward) in rewards {
             assert_eq!(
                 reward,
-                addr.parse::<Rewards>().unwrap() / Rewards::from(total_stake)
+                mainnet_addresses.parse::<Rewards>().unwrap() / Rewards::from(total_stake)
             );
         }
     }
@@ -309,10 +346,10 @@ mod tests {
         let mut raw_snapshot = Vec::new();
 
         for i in 1..10u64 {
-            let voting_pub_key = Identifier::from_hex(&hex::encode([i as u8; 32])).unwrap();
+            let voting_public_key = Identifier::from_hex(&hex::encode([i as u8; 32])).unwrap();
             let stake_public_key = i.to_string();
             let reward_address = i.to_string();
-            let delegations = Delegations::New(vec![(voting_pub_key.clone(), 1)]);
+            let delegations = Delegations::New(vec![(voting_public_key.clone(), 1)]);
             raw_snapshot.push(VotingRegistration {
                 stake_public_key,
                 voting_power: i.into(),
@@ -346,7 +383,15 @@ mod tests {
     }
 
     #[proptest]
-    fn test_per_category_threshold(snapshot: Snapshot) {
+    fn test_per_category_threshold(raw_snapshot: RawSnapshot) {
+        let snapshot = Snapshot::from_raw_snapshot(
+            raw_snapshot,
+            DEFAULT_SNAPSHOT_THRESHOLD.into(),
+            Fraction::from(1),
+            &|_vk: &Identifier| String::new(),
+        )
+        .unwrap();
+
         use vit_servicing_station_tests::common::data::ArbitrarySnapshotGenerator;
 
         let voters = snapshot.to_full_snapshot_info();
@@ -401,15 +446,20 @@ mod tests {
         let rewards = calc_voter_rewards(
             votes_count,
             voters.clone(),
-            Threshold::new(1, per_challenge_threshold.clone(), proposals.clone()).unwrap(),
+            Threshold::new(
+                DEFAULT_TEST_THRESHOLD,
+                per_challenge_threshold.clone(),
+                proposals.clone(),
+            )
+            .unwrap(),
             Rewards::ONE,
         )
         .unwrap();
 
         let rewards_only_active = calc_voter_rewards(
             only_active,
             voters,
-            Threshold::new(1, per_challenge_threshold, proposals).unwrap(),
+            Threshold::new(DEFAULT_TEST_THRESHOLD, per_challenge_threshold, proposals).unwrap(),
             Rewards::ONE,
         )
         .unwrap();

snapshot-lib/src/lib.rs

@@ -1,5 +1,6 @@
 pub use fraction::Fraction;
 use jormungandr_lib::{crypto::account::Identifier, interfaces::Value};
+use proptest::prelude::Arbitrary;
 use registration::{Delegations, MainnetRewardAddress, VotingRegistration};
 use serde::{Deserialize, Serialize};
 use std::{borrow::Borrow, collections::BTreeMap, iter::Iterator, num::NonZeroU64};