review fix vol. 2

Author: dkijania

catalyst-toolbox/src/bin/cli/stats/snapshot.rs

@@ -29,15 +29,15 @@ impl SnapshotCommand {
 
         match self.command {
             Command::Count => calculate_wallet_distribution_from_initials(
-                Stats::new(self.threshold),
+                Stats::new(self.threshold)?,
                 initials,
                 vec![],
                 self.support_lovelace,
                 |stats, _, _| stats.add(1),
             )?
             .print_count_per_level(),
             Command::Ada => calculate_wallet_distribution_from_initials(
-                Stats::new(self.threshold),
+                Stats::new(self.threshold)?,
                 initials,
                 vec![],
                 self.support_lovelace,

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

@@ -4,6 +4,7 @@ use color_eyre::Report;
 use std::ops::Range;
 use std::path::PathBuf;
 use structopt::StructOpt;
+use thiserror::Error;
 
 #[derive(StructOpt, Debug)]
 pub struct ActiveVotersCommand {
@@ -15,6 +16,8 @@ pub struct ActiveVotersCommand {
     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,
 }
@@ -30,23 +33,23 @@ impl ActiveVotersCommand {
     pub fn exec(&self) -> Result<(), Report> {
         match self.command {
             Command::Count => calculate_active_wallet_distribution(
-                Stats::new(self.threshold),
+                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),
+                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()),
+                Stats::new_with_levels(get_casted_votes_levels(&self.votes_count_levels)?),
                 &self.block0,
                 &self.votes_count_path,
                 self.support_lovelace,
@@ -59,7 +62,16 @@ impl ActiveVotersCommand {
     }
 }
 
-fn casted_votes_levels() -> Vec<Range<u64>> {
+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),
@@ -72,3 +84,12 @@ fn casted_votes_levels() -> Vec<Range<u64>> {
         (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),
+}

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

@@ -26,14 +26,14 @@ impl InitialVotersCommand {
         match self.command {
             Command::Count => calculate_wallet_distribution(
                 &self.block0,
-                Stats::new(self.threshold),
+                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),
+                Stats::new(self.threshold)?,
                 self.support_lovelace,
                 |stats, value, _| stats.add(value),
             )?

catalyst-toolbox/src/rewards/voters.rs

@@ -1,4 +1,8 @@
+use crate::snapshot::{registration::MainnetRewardAddress, SnapshotInfo};
 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, interfaces::Address};
 use rust_decimal::Decimal;
 use snapshot_lib::{registration::MainnetRewardAddress, SnapshotInfo};
 use std::collections::{BTreeMap, HashMap, HashSet};

catalyst-toolbox/src/stats/distribution.rs

@@ -1,8 +1,13 @@
 use core::ops::Range;
 use std::collections::HashMap;
+use thiserror::Error;
 
-fn levels(threshold: u64) -> Vec<Range<u64>> {
-    vec![
+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),
@@ -20,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)]
@@ -34,8 +39,8 @@ pub struct Stats {
 }
 
 impl Stats {
-    pub fn new(threshold: u64) -> Self {
-        Self::new_with_levels(levels(threshold))
+    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 {
@@ -110,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),
+}

catalyst-toolbox/src/stats/voters.rs

@@ -1,13 +1,13 @@
-use crate::rewards::voters::{account_hex_to_address, VoteCount};
+use crate::rewards::voters::VoteCount;
 use crate::stats::distribution::Stats;
 use chain_addr::{Discrimination, Kind};
 use chain_crypto::Ed25519;
 use chain_impl_mockchain::vote::CommitteeId;
 use jormungandr_automation::testing::block0::get_block;
-use jormungandr_lib::interfaces::Address;
-use jormungandr_lib::interfaces::Block0Configuration;
-use jormungandr_lib::interfaces::Initial;
-use jormungandr_lib::interfaces::InitialUTxO;
+use jormungandr_lib::{
+    crypto::account::Identifier,
+    interfaces::{Address, Block0Configuration, Initial, InitialUTxO},
+};
 use std::path::Path;
 
 fn blacklist_addresses(genesis: &Block0Configuration) -> Vec<Address> {
@@ -35,7 +35,7 @@ fn blacklist_addresses(genesis: &Block0Configuration) -> Vec<Address> {
         .collect()
 }
 
-fn vote_counts_as_addresses(
+fn vote_counts_as_utxo(
     votes_count: VoteCount,
     genesis: &Block0Configuration,
 ) -> Vec<(InitialUTxO, u32)> {
@@ -45,15 +45,8 @@ fn vote_counts_as_addresses(
         .filter_map(|initials| {
             if let Initial::Fund(funds) = initials {
                 for utxo in funds {
-                    if let Some((_, votes_count)) = votes_count.iter().find(|(address, _)| {
-                        account_hex_to_address(
-                            address.to_string(),
-                            genesis.blockchain_configuration.discrimination,
-                        )
-                        .unwrap()
-                            == utxo.address
-                    }) {
-                        return Some((utxo.clone(), *votes_count as u32));
+                    if let Some(vote_count) = votes_count.get(&addr_to_hex(&utxo.address)) {
+                        return Some((utxo.clone(), *vote_count as u32));
                     }
                 }
             }
@@ -62,6 +55,16 @@ fn vote_counts_as_addresses(
         .collect()
 }
 
+pub fn addr_to_hex(address: &Address) -> String {
+    match &address.1 .1 {
+        Kind::Account(pk) => {
+            let id: Identifier = pk.clone().into();
+            id.to_hex()
+        }
+        _ => unimplemented!(),
+    }
+}
+
 pub fn calculate_active_wallet_distribution<S: Into<String>, P: AsRef<Path>>(
     stats: Stats,
     block0: S,
@@ -77,7 +80,7 @@ pub fn calculate_active_wallet_distribution<S: Into<String>, P: AsRef<Path>>(
     )?)?;
 
     let blacklist = blacklist_addresses(&genesis);
-    let initials = vote_counts_as_addresses(vote_count, &genesis);
+    let initials = vote_counts_as_utxo(vote_count, &genesis);
 
     calculate_wallet_distribution_from_initials_utxo(
         stats,

catalyst-toolbox/tests/tally/generator.rs

@@ -45,7 +45,7 @@ fn account_from_slice<P>(
     }
 }
 
-impl<'a> VoteRoundGenerator {
+impl VoteRoundGenerator {
     pub fn new(blockchain: TestBlockchain) -> Self {
         let TestBlockchain {
             config,