Merge pull request #133 from input-output-hk/add_active_voter_stats_from_vote_count

dkijania · web-flow · commit ffe94ed97d58 · 2022-08-11T15:43:49.000+02:00
Add active voter stats from vote count
diff --git a/catalyst-toolbox/src/bin/cli/rewards/voters.rs b/catalyst-toolbox/src/bin/cli/rewards/voters.rs
@@ -90,7 +90,6 @@ impl VotersRewards {
             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))?,
         )?
diff --git a/catalyst-toolbox/src/bin/cli/stats/mod.rs b/catalyst-toolbox/src/bin/cli/stats/mod.rs
@@ -8,11 +8,11 @@ use color_eyre::Report;
 use live::LiveStatsCommand;
 use snapshot::SnapshotCommand;
 use structopt::StructOpt;
-use voters::InitialVotersCommand;
+use voters::VotersCommand;
 
 #[derive(StructOpt, Debug)]
 pub enum Stats {
-    Voters(InitialVotersCommand),
+    Voters(VotersCommand),
     Live(LiveStatsCommand),
     Archive(ArchiveCommand),
     Snapshot(SnapshotCommand),
diff --git a/catalyst-toolbox/src/bin/cli/stats/snapshot.rs b/catalyst-toolbox/src/bin/cli/stats/snapshot.rs
@@ -1,3 +1,4 @@
+use catalyst_toolbox::stats::distribution::Stats;
 use catalyst_toolbox::stats::snapshot::read_initials;
 use catalyst_toolbox::stats::voters::calculate_wallet_distribution_from_initials;
 use color_eyre::Report;
@@ -28,17 +29,19 @@ impl SnapshotCommand {
 
         match self.command {
             Command::Count => calculate_wallet_distribution_from_initials(
+                Stats::new(self.threshold)?,
                 initials,
                 vec![],
-                self.threshold,
                 self.support_lovelace,
+                |stats, _, _| stats.add(1),
             )?
             .print_count_per_level(),
             Command::Ada => calculate_wallet_distribution_from_initials(
+                Stats::new(self.threshold)?,
                 initials,
                 vec![],
-                self.threshold,
                 self.support_lovelace,
+                |stats, value, _| stats.add(value),
             )?
             .print_ada_per_level(),
         };
diff --git a/catalyst-toolbox/src/bin/cli/stats/voters/active.rs b/catalyst-toolbox/src/bin/cli/stats/voters/active.rs
@@ -0,0 +1,95 @@
+use catalyst_toolbox::stats::distribution::Stats;
+use catalyst_toolbox::stats::voters::calculate_active_wallet_distribution;
+use color_eyre::Report;
+use std::ops::Range;
+use std::path::PathBuf;
+use structopt::StructOpt;
+use thiserror::Error;
+
+#[derive(StructOpt, Debug)]
+pub struct ActiveVotersCommand {
+    #[structopt(long = "support-lovelace")]
+    pub support_lovelace: bool,
+    #[structopt(long = "block0")]
+    pub block0: String,
+    #[structopt(long = "threshold")]
+    pub threshold: u64,
+    #[structopt(long = "votes-count-file")]
+    pub votes_count_path: PathBuf,
+    #[structopt(long = "votes-count-levels")]
+    pub votes_count_levels: Option<PathBuf>,
+    #[structopt(subcommand)]
+    pub command: Command,
+}
+
+#[derive(StructOpt, Debug)]
+pub enum Command {
+    Count,
+    Ada,
+    Votes,
+}
+
+impl ActiveVotersCommand {
+    pub fn exec(&self) -> Result<(), Report> {
+        match self.command {
+            Command::Count => calculate_active_wallet_distribution(
+                Stats::new(self.threshold)?,
+                &self.block0,
+                &self.votes_count_path,
+                self.support_lovelace,
+                |stats, value, _| stats.add(value),
+            )?
+            .print_count_per_level(),
+            Command::Ada => calculate_active_wallet_distribution(
+                Stats::new(self.threshold)?,
+                &self.block0,
+                &self.votes_count_path,
+                self.support_lovelace,
+                |stats, value, _| stats.add(value),
+            )?
+            .print_ada_per_level(),
+            Command::Votes => calculate_active_wallet_distribution(
+                Stats::new_with_levels(get_casted_votes_levels(&self.votes_count_levels)?),
+                &self.block0,
+                &self.votes_count_path,
+                self.support_lovelace,
+                |stats, _, weight| stats.add_with_weight(1, weight as u32),
+            )?
+            .print_count_per_level(),
+        };
+
+        Ok(())
+    }
+}
+
+fn get_casted_votes_levels(path: &Option<PathBuf>) -> Result<Vec<Range<u64>>, Error> {
+    if let Some(path) = path {
+        serde_json::from_reader(jcli_lib::utils::io::open_file_read(&Some(path))?)
+            .map_err(Into::into)
+    } else {
+        Ok(default_casted_votes_levels())
+    }
+}
+
+fn default_casted_votes_levels() -> Vec<Range<u64>> {
+    vec![
+        (1..5),
+        (5..10),
+        (10..20),
+        (20..50),
+        (50..100),
+        (100..200),
+        (200..400),
+        (400..800),
+        (800..5_000),
+    ]
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error(transparent)]
+    Serde(#[from] serde_json::Error),
+}
diff --git a/catalyst-toolbox/src/bin/cli/stats/voters/initials.rs b/catalyst-toolbox/src/bin/cli/stats/voters/initials.rs
@@ -1,3 +1,4 @@
+use catalyst_toolbox::stats::distribution::Stats;
 use catalyst_toolbox::stats::voters::calculate_wallet_distribution;
 use color_eyre::Report;
 use structopt::StructOpt;
@@ -23,14 +24,20 @@ pub enum Command {
 impl InitialVotersCommand {
     pub fn exec(&self) -> Result<(), Report> {
         match self.command {
-            Command::Count => {
-                calculate_wallet_distribution(&self.block0, self.threshold, self.support_lovelace)?
-                    .print_count_per_level()
-            }
-            Command::Ada => {
-                calculate_wallet_distribution(&self.block0, self.threshold, self.support_lovelace)?
-                    .print_ada_per_level()
-            }
+            Command::Count => calculate_wallet_distribution(
+                &self.block0,
+                Stats::new(self.threshold)?,
+                self.support_lovelace,
+                |stats, value, _| stats.add(value),
+            )?
+            .print_count_per_level(),
+            Command::Ada => calculate_wallet_distribution(
+                &self.block0,
+                Stats::new(self.threshold)?,
+                self.support_lovelace,
+                |stats, value, _| stats.add(value),
+            )?
+            .print_ada_per_level(),
         };
 
         Ok(())
diff --git a/catalyst-toolbox/src/bin/cli/stats/voters/mod.rs b/catalyst-toolbox/src/bin/cli/stats/voters/mod.rs
@@ -0,0 +1,22 @@
+mod active;
+mod initials;
+
+use active::ActiveVotersCommand;
+use color_eyre::Report;
+use initials::InitialVotersCommand;
+use structopt::StructOpt;
+
+#[derive(StructOpt, Debug)]
+pub enum VotersCommand {
+    Initials(InitialVotersCommand),
+    Active(ActiveVotersCommand),
+}
+
+impl VotersCommand {
+    pub fn exec(self) -> Result<(), Report> {
+        match self {
+            Self::Initials(initials) => initials.exec(),
+            Self::Active(active) => active.exec(),
+        }
+    }
+}
diff --git a/catalyst-toolbox/src/recovery/tally.rs b/catalyst-toolbox/src/recovery/tally.rs
@@ -1,9 +1,9 @@
 use chain_addr::{Discrimination, Kind};
 use chain_core::property::Fragment as _;
 use chain_crypto::{Ed25519Extended, SecretKey};
-use chain_impl_mockchain::accounting::account::SpendingCounterIncreasing;
 use chain_impl_mockchain::{
     account::{self, LedgerError, SpendingCounter},
+    accounting::account::SpendingCounterIncreasing,
     block::{Block, BlockDate, HeaderId},
     certificate::{self, VoteCast, VotePlan, VotePlanId},
     chaineval::ConsensusEvalContext,
@@ -468,7 +468,7 @@ impl FragmentReplayer {
                             utxo.value.into(),
                             SpendingCounterIncreasing::default().get_valid_counters(),
                         )
-                        .unwrap();
+                        .expect("cannot update wallet state");
                     wallets.insert(utxo.address.clone(), wallet);
                     if committee_members.contains(&utxo.address) {
                         trace!("Committee account found {}", &utxo.address);
diff --git a/catalyst-toolbox/src/rewards/voters.rs b/catalyst-toolbox/src/rewards/voters.rs
@@ -1,4 +1,9 @@
-use jormungandr_lib::crypto::{account::Identifier, hash::Hash};
+use chain_addr::{Discrimination, Kind};
+use chain_impl_mockchain::transaction::UnspecifiedAccountIdentifier;
+use jormungandr_lib::{
+    crypto::{account::Identifier, hash::Hash},
+    interfaces::Address,
+};
 use rust_decimal::Decimal;
 use snapshot_lib::{registration::MainnetRewardAddress, SnapshotInfo};
 use std::collections::{BTreeMap, HashMap, HashSet};
@@ -108,6 +113,24 @@ fn filter_active_addresses(
         .collect()
 }
 
+pub fn account_hex_to_address(
+    account_hex: String,
+    discrimination: Discrimination,
+) -> Result<Address, hex::FromHexError> {
+    let mut buffer = [0u8; 32];
+    hex::decode_to_slice(account_hex, &mut buffer)?;
+    let identifier: UnspecifiedAccountIdentifier = UnspecifiedAccountIdentifier::from(buffer);
+    Ok(Address::from(chain_addr::Address(
+        discrimination,
+        Kind::Account(
+            identifier
+                .to_single_account()
+                .expect("Only single accounts are supported")
+                .into(),
+        ),
+    )))
+}
+
 fn rewards_to_mainnet_addresses(
     rewards: HashMap<Identifier, Rewards>,
     voters: Vec<SnapshotInfo>,
diff --git a/catalyst-toolbox/src/stats/distribution.rs b/catalyst-toolbox/src/stats/distribution.rs
@@ -1,10 +1,19 @@
 use core::ops::Range;
 use std::collections::HashMap;
+use thiserror::Error;
 
-fn levels(threshold: u64) -> Vec<Range<u64>> {
-    vec![
-        (0..threshold),
-        (threshold..10_000),
+fn levels(threshold: u64) -> Result<Vec<Range<u64>>, Error> {
+    if !(450..=1_000).contains(&threshold) {
+        return Err(Error::InvalidThreshold(threshold));
+    }
+
+    Ok(vec![
+        (0..450),
+        (450..threshold),
+        (threshold..1_000),
+        (1_000..2_000),
+        (2_000..5_000),
+        (5_000..10_000),
         (10_000..20_000),
         (20_000..50_000),
         (50_000..100_000),
@@ -16,7 +25,7 @@ fn levels(threshold: u64) -> Vec<Range<u64>> {
         (10_000_000..25_000_000),
         (25_000_000..50_000_000),
         (50_000_000..32_000_000_000),
-    ]
+    ])
 }
 
 #[derive(Default)]
@@ -30,25 +39,33 @@ pub struct Stats {
 }
 
 impl Stats {
-    pub fn new(threshold: u64) -> Self {
+    pub fn new(threshold: u64) -> Result<Self, Error> {
+        Ok(Self::new_with_levels(levels(threshold)?))
+    }
+
+    pub fn new_with_levels(levels: Vec<Range<u64>>) -> Self {
         Self {
-            content: levels(threshold)
+            content: levels
                 .into_iter()
                 .map(|range| (range, Default::default()))
                 .collect(),
         }
     }
 
-    pub fn add(&mut self, value: u64) {
+    pub fn add_with_weight(&mut self, value: u64, weight: u32) {
         for (range, record) in self.content.iter_mut() {
             if range.contains(&value) {
-                record.count += 1;
+                record.count += weight;
                 record.total += value;
                 return;
             }
         }
     }
 
+    pub fn add(&mut self, value: u64) {
+        self.add_with_weight(value, 1);
+    }
+
     pub fn print_count_per_level(&self) {
         let mut keys = self.content.keys().cloned().collect::<Vec<Range<u64>>>();
         keys.sort_by_key(|x| x.start);
@@ -86,7 +103,9 @@ impl Stats {
 }
 
 fn format_big_number(n: u64) -> String {
-    if n % 1_000_000_000 == 0 {
+    if n == 0 {
+        n.to_string()
+    } else if n % 1_000_000_000 == 0 {
         format!("{} MLD", n / 1_000_000)
     } else if n % 1_00000 == 0 {
         format!("{} M", n / 1_000_000)
@@ -96,3 +115,10 @@ fn format_big_number(n: u64) -> String {
         n.to_string()
     }
 }
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("invalid threshold for distribution levels ({0}). It should be more than 450 and less that 1000")]
+    InvalidThreshold(u64),
+}
diff --git a/catalyst-toolbox/src/stats/voters.rs b/catalyst-toolbox/src/stats/voters.rs
diff --git a/catalyst-toolbox/tests/tally/generator.rs b/catalyst-toolbox/tests/tally/generator.rs
