added voters active command for active voters calculation

Author: dkijania

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))?,
         )?

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),

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(),
         };

catalyst-toolbox/src/bin/cli/stats/voters/active.rs

@@ -0,0 +1,73 @@
+use catalyst_toolbox::stats::distribution::Stats;
+use catalyst_toolbox::stats::voters::calculate_active_wallet_distribution;
+use std::ops::Range;
+use std::path::PathBuf;
+use structopt::StructOpt;
+
+#[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(subcommand)]
+    pub command: Command,
+}
+
+#[derive(StructOpt, Debug)]
+pub enum Command {
+    Count,
+    Ada,
+    Votes,
+}
+
+impl ActiveVotersCommand {
+    pub fn exec(&self) -> Result<(), catalyst_toolbox::stats::Error> {
+        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(casted_votes_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 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),
+    ]
+}

catalyst-toolbox/src/bin/cli/stats/voters.rs renamed to 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(())

catalyst-toolbox/src/bin/cli/stats/voters/mod.rs

@@ -0,0 +1,21 @@
+mod active;
+mod initials;
+
+use active::ActiveVotersCommand;
+use initials::InitialVotersCommand;
+use structopt::StructOpt;
+
+#[derive(StructOpt, Debug)]
+pub enum VotersCommand {
+    Initials(InitialVotersCommand),
+    Active(ActiveVotersCommand),
+}
+
+impl VotersCommand {
+    pub fn exec(self) -> Result<(), catalyst_toolbox::stats::Error> {
+        match self {
+            Self::Initials(initials) => initials.exec(),
+            Self::Active(active) => active.exec(),
+        }
+    }
+}

catalyst-toolbox/src/recovery/tally.rs

@@ -1,7 +1,6 @@
 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},
     block::{Block, BlockDate, HeaderId},
@@ -464,11 +463,8 @@ impl FragmentReplayer {
                         value: utxo.value,
                     };
                     wallet
-                        .set_state(
-                            utxo.value.into(),
-                            SpendingCounterIncreasing::default().get_valid_counters(),
-                        )
-                        .unwrap();
+                        .set_state(utxo.value.into(), Default::default())
+                        .expect("cannot update wallet state");
                     wallets.insert(utxo.address.clone(), wallet);
                     if committee_members.contains(&utxo.address) {
                         trace!("Committee account found {}", &utxo.address);

catalyst-toolbox/src/rewards/voters.rs

@@ -108,6 +108,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>,

catalyst-toolbox/src/stats/distribution.rs

@@ -3,8 +3,12 @@ use std::collections::HashMap;
 
 fn levels(threshold: u64) -> Vec<Range<u64>> {
     vec![
-        (0..threshold),
-        (threshold..10_000),
+        (0..450),
+        (450..threshold),
+        (500..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),
@@ -31,24 +35,32 @@ pub struct Stats {
 
 impl Stats {
     pub fn new(threshold: u64) -> Self {
+        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);