Add dreps incentives command (#155)

* Add command to calculate incentives for dreps

* add tests

* use prop_assert_eq instead of assert_eq

* fix imports

Author: zeegomo

catalyst-toolbox/src/bin/cli/rewards/dreps.rs

@@ -0,0 +1,115 @@
+use catalyst_toolbox::rewards::voters::calc_voter_rewards;
+use catalyst_toolbox::rewards::{Rewards, Threshold};
+use color_eyre::Report;
+use jcli_lib::jcli_lib::block::Common;
+use jormungandr_lib::{crypto::account::Identifier, interfaces::AccountVotes};
+use snapshot_lib::{registration::MainnetRewardAddress, SnapshotInfo};
+use structopt::StructOpt;
+use vit_servicing_station_lib::db::models::proposals::FullProposalInfo;
+
+use std::collections::{BTreeMap, HashMap};
+use std::path::PathBuf;
+
+#[derive(StructOpt)]
+#[structopt(rename_all = "kebab-case")]
+pub struct DrepsRewards {
+    #[structopt(flatten)]
+    common: Common,
+    /// Reward (in dollars) to be distributed proportionally to delegated stake with respect to total stake.
+    /// The total amount will only be awarded if dreps control all of the stake.
+    #[structopt(long)]
+    total_rewards: u64,
+
+    /// Path to a json encoded list of `SnapshotInfo`
+    #[structopt(long)]
+    snapshot_info_path: PathBuf,
+
+    /// Path to a json-encoded list of proposal every user has voted for.
+    /// This can be retrived from the v1/account-votes-all endpoint exposed
+    /// by a Jormungandr node.
+    #[structopt(long)]
+    votes_count_path: PathBuf,
+
+    /// Number of global votes required to be able to receive voter rewards
+    #[structopt(long, default_value)]
+    vote_threshold: u64,
+
+    /// Path to a json-encoded map from challenge id to an optional required threshold
+    /// per-challenge in order to receive rewards.
+    #[structopt(long)]
+    per_challenge_threshold: Option<PathBuf>,
+
+    /// Path to the list of proposals active in this election.
+    /// Can be obtained from /api/v0/proposals.
+    #[structopt(long)]
+    proposals: PathBuf,
+}
+
+fn write_rewards_results(
+    common: Common,
+    rewards: &BTreeMap<MainnetRewardAddress, Rewards>,
+) -> Result<(), Report> {
+    let writer = common.open_output()?;
+    let header = ["Address", "Reward for the voter (lovelace)"];
+    let mut csv_writer = csv::Writer::from_writer(writer);
+    csv_writer.write_record(&header)?;
+
+    for (address, rewards) in rewards.iter() {
+        let record = [address.to_string(), rewards.trunc().to_string()];
+        csv_writer.write_record(&record)?;
+    }
+
+    Ok(())
+}
+
+impl DrepsRewards {
+    pub fn exec(self) -> Result<(), Report> {
+        let DrepsRewards {
+            common,
+            total_rewards,
+            snapshot_info_path,
+            votes_count_path,
+            vote_threshold,
+            per_challenge_threshold,
+            proposals,
+        } = self;
+
+        let proposals = serde_json::from_reader::<_, Vec<FullProposalInfo>>(
+            jcli_lib::utils::io::open_file_read(&Some(proposals))?,
+        )?;
+
+        let vote_count = super::extract_individual_votes(
+            proposals.clone(),
+            serde_json::from_reader::<_, HashMap<Identifier, Vec<AccountVotes>>>(
+                jcli_lib::utils::io::open_file_read(&Some(votes_count_path))?,
+            )?,
+        )?;
+
+        let snapshot: Vec<SnapshotInfo> = serde_json::from_reader(
+            jcli_lib::utils::io::open_file_read(&Some(snapshot_info_path))?,
+        )?;
+
+        let additional_thresholds: HashMap<i32, usize> = if let Some(file) = per_challenge_threshold
+        {
+            serde_json::from_reader(jcli_lib::utils::io::open_file_read(&Some(file))?)?
+        } else {
+            HashMap::new()
+        };
+
+        let results = calc_voter_rewards(
+            vote_count,
+            snapshot,
+            Threshold::new(
+                vote_threshold
+                    .try_into()
+                    .expect("vote threshold is too big"),
+                additional_thresholds,
+                proposals,
+            )?,
+            Rewards::from(total_rewards),
+        )?;
+
+        write_rewards_results(common, &results)?;
+        Ok(())
+    }
+}

catalyst-toolbox/src/bin/cli/rewards/mod.rs

@@ -1,16 +1,27 @@
 mod community_advisors;
+mod dreps;
 mod veterans;
 mod voters;
 
-use color_eyre::Report;
+use catalyst_toolbox::rewards::VoteCount;
+use color_eyre::{eyre::eyre, Report};
+use jormungandr_lib::{
+    crypto::{account::Identifier, hash::Hash},
+    interfaces::AccountVotes,
+};
+use std::collections::HashMap;
 use structopt::StructOpt;
+use vit_servicing_station_lib::db::models::proposals::FullProposalInfo;
 
 #[derive(StructOpt)]
 #[structopt(rename_all = "kebab-case")]
 pub enum Rewards {
     /// Calculate rewards for voters base on their stake
     Voters(voters::VotersRewards),
 
+    /// Calculate rewards for dreps based on their delegated stake
+    Dreps(dreps::DrepsRewards),
+
     /// Calculate community advisors rewards
     CommunityAdvisors(community_advisors::CommunityAdvisors),
 
@@ -24,6 +35,48 @@ impl Rewards {
             Rewards::Voters(cmd) => cmd.exec(),
             Rewards::CommunityAdvisors(cmd) => cmd.exec(),
             Rewards::Veterans(cmd) => cmd.exec(),
+            Rewards::Dreps(cmd) => cmd.exec(),
         }
     }
 }
+
+fn extract_individual_votes(
+    proposals: Vec<FullProposalInfo>,
+    votes: HashMap<Identifier, Vec<AccountVotes>>,
+) -> Result<VoteCount, Report> {
+    let proposals_per_voteplan =
+        proposals
+            .into_iter()
+            .fold(<HashMap<_, Vec<_>>>::new(), |mut acc, prop| {
+                let entry = acc
+                    .entry(prop.voteplan.chain_voteplan_id.clone())
+                    .or_default();
+                entry.push(prop);
+                entry.sort_by_key(|p| p.voteplan.chain_proposal_index);
+                acc
+            });
+
+    votes
+        .into_iter()
+        .try_fold(VoteCount::new(), |mut acc, (account, votes)| {
+            for vote in &votes {
+                let voteplan = vote.vote_plan_id;
+                let props = proposals_per_voteplan
+                    .get(&voteplan.to_string())
+                    .iter()
+                    .flat_map(|p| p.iter())
+                    .enumerate()
+                    .filter(|(i, _p)| vote.votes.contains(&(*i as u8)))
+                    .map(|(_, p)| {
+                        Ok::<_, Report>(Hash::from(
+                            <[u8; 32]>::try_from(p.proposal.chain_proposal_id.clone()).map_err(
+                                |v| eyre!("Invalid proposal hash length {}, expected 32", v.len()),
+                            )?,
+                        ))
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+                acc.entry(account.clone()).or_default().extend(props);
+            }
+            Ok::<_, Report>(acc)
+        })
+}

catalyst-toolbox/src/bin/cli/rewards/voters.rs

@@ -1,15 +1,12 @@
-use catalyst_toolbox::rewards::voters::{calc_voter_rewards, Rewards, Threshold, VoteCount};
+use catalyst_toolbox::rewards::voters::calc_voter_rewards;
+use catalyst_toolbox::rewards::{Rewards, Threshold};
 use catalyst_toolbox::utils::assert_are_close;
-use jormungandr_lib::{
-    crypto::{account::Identifier, hash::Hash},
-    interfaces::AccountVotes,
-};
-use snapshot_lib::{registration::MainnetRewardAddress, SnapshotInfo};
-use vit_servicing_station_lib::db::models::proposals::FullProposalInfo;
-
-use color_eyre::{eyre::eyre, Report};
+use color_eyre::Report;
 use jcli_lib::jcli_lib::block::Common;
+use jormungandr_lib::{crypto::account::Identifier, interfaces::AccountVotes};
+use snapshot_lib::{registration::MainnetRewardAddress, SnapshotInfo};
 use structopt::StructOpt;
+use vit_servicing_station_lib::db::models::proposals::FullProposalInfo;
 
 use std::collections::{BTreeMap, HashMap};
 use std::path::PathBuf;
@@ -78,43 +75,16 @@ impl VotersRewards {
             proposals,
         } = self;
 
-        let proposals_per_voteplan = serde_json::from_reader::<_, Vec<FullProposalInfo>>(
+        let proposals = serde_json::from_reader::<_, Vec<FullProposalInfo>>(
             jcli_lib::utils::io::open_file_read(&Some(proposals))?,
-        )?
-        .into_iter()
-        .fold(<HashMap<_, Vec<_>>>::new(), |mut acc, prop| {
-            let entry = acc
-                .entry(prop.voteplan.chain_voteplan_id.clone())
-                .or_default();
-            entry.push(prop);
-            entry.sort_by_key(|p| p.voteplan.chain_proposal_index);
-            acc
-        });
-        let vote_count = serde_json::from_reader::<_, HashMap<Identifier, Vec<AccountVotes>>>(
-            jcli_lib::utils::io::open_file_read(&Some(votes_count_path))?,
-        )?
-        .into_iter()
-        .try_fold(VoteCount::new(), |mut acc, (account, votes)| {
-            for vote in &votes {
-                let voteplan = vote.vote_plan_id;
-                let props = proposals_per_voteplan
-                    .get(&voteplan.to_string())
-                    .iter()
-                    .flat_map(|p| p.iter())
-                    .enumerate()
-                    .filter(|(i, _p)| vote.votes.contains(&(*i as u8)))
-                    .map(|(_, p)| {
-                        Ok::<_, Report>(Hash::from(
-                            <[u8; 32]>::try_from(p.proposal.chain_proposal_id.clone()).map_err(
-                                |v| eyre!("Invalid proposal hash length {}, expected 32", v.len()),
-                            )?,
-                        ))
-                    })
-                    .collect::<Result<Vec<_>, _>>()?;
-                acc.entry(account.clone()).or_default().extend(props);
-            }
-            Ok::<_, Report>(acc)
-        })?;
+        )?;
+
+        let vote_count = super::extract_individual_votes(
+            proposals.clone(),
+            serde_json::from_reader::<_, HashMap<Identifier, Vec<AccountVotes>>>(
+                jcli_lib::utils::io::open_file_read(&Some(votes_count_path))?,
+            )?,
+        )?;
 
         let snapshot: Vec<SnapshotInfo> = serde_json::from_reader(
             jcli_lib::utils::io::open_file_read(&Some(snapshot_info_path))?,
@@ -130,14 +100,7 @@ impl VotersRewards {
         let results = calc_voter_rewards(
             vote_count,
             snapshot,
-            Threshold::new(
-                vote_threshold,
-                additional_thresholds,
-                proposals_per_voteplan
-                    .into_iter()
-                    .flat_map(|(_k, v)| v.into_iter())
-                    .collect(),
-            )?,
+            Threshold::new(vote_threshold, additional_thresholds, proposals)?,
             Rewards::from(total_rewards),
         )?;