fmt + cleanup after cherrypicking commits from #388

apps/src/lib/client/rpc.rs

@@ -21,7 +21,8 @@ use namada::ledger::pos::types::{
     decimal_mult_u64, Epoch as PosEpoch, WeightedValidator,
 };
 use namada::ledger::pos::{
-    self, is_validator_slashes_key, BondId, Bonds, PosParams, Slash, Unbonds, into_tm_voting_power,
+    self, into_tm_voting_power, is_validator_slashes_key, BondId, Bonds,
+    PosParams, Slash, Unbonds,
 };
 use namada::ledger::queries::{self, RPC};
 use namada::types::address::Address;
@@ -899,17 +900,18 @@ pub async fn query_voting_power(ctx: Context, args: args::QueryVotingPower) {
         Some(validator) => {
             let validator = ctx.get(&validator);
             // Find voting power for the given validator
-            let validator_deltas_key =
-                pos::validator_deltas_key(&validator);
-            let validator_deltas = query_storage_value::<
-                pos::ValidatorDeltas,
-            >(&client, &validator_deltas_key)
+            let validator_deltas_key = pos::validator_deltas_key(&validator);
+            let validator_deltas = query_storage_value::<pos::ValidatorDeltas>(
+                &client,
+                &validator_deltas_key,
+            )
             .await;
             match validator_deltas.and_then(|data| data.get(epoch)) {
                 Some(val_stake) => {
                     let bonded_stake: u64 = val_stake.try_into().expect(
-                            "The sum of the bonded stake deltas shouldn't be negative",
-                        );
+                        "The sum of the bonded stake deltas shouldn't be \
+                         negative",
+                    );
                     let weighted = WeightedValidator {
                         address: validator.clone(),
                         bonded_stake,
@@ -962,22 +964,23 @@ pub async fn query_voting_power(ctx: Context, args: args::QueryVotingPower) {
         }
     }
     let total_deltas_key = pos::total_deltas_key();
-    let total_deltas = query_storage_value::<pos::TotalDeltas>(
-        &client,
-        &total_deltas_key,
-    )
-    .await
-    .expect("Total bonded stake should always be set");
+    let total_deltas =
+        query_storage_value::<pos::TotalDeltas>(&client, &total_deltas_key)
+            .await
+            .expect("Total bonded stake should always be set");
     let total_bonded_stake = total_deltas
         .get(epoch)
         .expect("Total bonded stake should be always set in the current epoch");
     let pos_params_key = pos::params_key();
     let pos_params = query_storage_value::<pos::PosParams>(&client, &pos_params_key)
         .await
         .expect("PoS parameters should always exist in storage");
-    let total_bonded_stake: u64 = total_bonded_stake.try_into().expect("total_bonded_stake should be a positive value");
-    let total_voting_power = into_tm_voting_power(pos_params.tm_votes_per_token, total_bonded_stake);
-
+    let total_bonded_stake: u64 = total_bonded_stake
+        .try_into()
+        .expect("total_bonded_stake should be a positive value");
+    let total_voting_power =
+        into_tm_voting_power(pos_params.tm_votes_per_token, total_bonded_stake);
+
     println!("Total voting power: {}", total_voting_power);
 }
 
@@ -1908,8 +1911,7 @@ async fn get_validator_stake(
     .expect("Total deltas should be defined");
     let validator_stake = validator_deltas.get(epoch);
 
-    VotePower::try_from(validator_stake.unwrap_or_default())
-        .unwrap_or_default()
+    VotePower::try_from(validator_stake.unwrap_or_default()).unwrap_or_default()
 }
 
 pub async fn get_delegators_delegation(

apps/src/lib/node/ledger/shell/init_chain.rs

@@ -273,7 +273,10 @@ where
                 sum: Some(key_to_tendermint(&consensus_key).unwrap()),
             };
             abci_validator.pub_key = Some(pub_key);
-            abci_validator.power = into_tm_voting_power(genesis.pos_params.tm_votes_per_token, validator.pos_data.tokens);
+            abci_validator.power = into_tm_voting_power(
+                genesis.pos_params.tm_votes_per_token,
+                validator.pos_data.tokens,
+            );
             response.validators.push(abci_validator);
         }
         Ok(response)

apps/src/lib/node/ledger/shell/queries.rs

@@ -2,6 +2,7 @@
 
 use borsh::{BorshDeserialize, BorshSerialize};
 use ferveo_common::TendermintValidator;
+use namada::ledger::pos::into_tm_voting_power;
 use namada::ledger::queries::{RequestCtx, ResponseQuery};
 use namada::ledger::storage_api;
 use namada::types::address::Address;

proof_of_stake/src/lib.rs

@@ -34,15 +34,16 @@ use parameters::PosParams;
 use rust_decimal::Decimal;
 use thiserror::Error;
 use types::{
-    decimal_mult_i128, decimal_mult_u64, ActiveValidator, Bonds, CommissionRates, Epoch, GenesisValidator, Slash,
-    SlashType, Slashes, TotalVotingPowers, Unbond, Unbonds,
-    ValidatorConsensusKeys, ValidatorSet, ValidatorSetUpdate, ValidatorSets,
-    ValidatorState, ValidatorStates, ValidatorDeltas,
-    TotalDeltas
+    ActiveValidator, Bonds, CommissionRates, Epoch, GenesisValidator, Slash,
+    SlashType, Slashes, TotalDeltas, Unbond, Unbonds, ValidatorConsensusKeys,
+    ValidatorDeltas, ValidatorSet, ValidatorSetUpdate, ValidatorSets,
+    ValidatorState, ValidatorStates,
 };
 
 use crate::btree_set::BTreeSetShims;
-use crate::types::{Bond, BondId, WeightedValidator};
+use crate::types::{
+    decimal_mult_i128, decimal_mult_u64, Bond, BondId, WeightedValidator,
+};
 
 /// Read-only part of the PoS system
 pub trait PosReadOnly {
@@ -158,7 +159,9 @@ pub trait PosReadOnly {
         &self,
     ) -> Result<ValidatorSets<Self::Address>, Self::Error>;
     /// Read PoS total deltas for all validators (active and inactive)
-    fn read_total_deltas(&self) -> Result<TotalDeltas<Self::TokenChange>, Self::Error>;
+    fn read_total_deltas(
+        &self,
+    ) -> Result<TotalDeltas<Self::TokenChange>, Self::Error>;
 }
 
 /// PoS system trait to be implemented in integration that can read and write
@@ -248,7 +251,6 @@ pub trait PosActions: PosReadOnly {
         &mut self,
         value: TotalDeltas<Self::TokenChange>,
     ) -> Result<(), Self::Error>;
-    ) -> Result<(), Self::Error>;
     /// Delete an emptied PoS bond (validator self-bond or a delegation).
     fn delete_bond(
         &mut self,
@@ -353,8 +355,7 @@ pub trait PosActions: PosReadOnly {
             validator: validator.clone(),
         };
         let bond = self.read_bond(&bond_id)?;
-        let validator_deltas =
-            self.read_validator_deltas(validator)?;
+        let validator_deltas = self.read_validator_deltas(validator)?;
         let mut total_deltas = self.read_total_deltas()?;
         let mut validator_set = self.read_validator_set()?;
 
@@ -409,9 +410,8 @@ pub trait PosActions: PosReadOnly {
             None => return Err(UnbondError::NoBondFound.into()),
         };
         let unbond = self.read_unbond(&bond_id)?;
-        let mut validator_deltas = self
-            .read_validator_deltas(validator)?
-            .ok_or_else(|| {
+        let mut validator_deltas =
+            self.read_validator_deltas(validator)?.ok_or_else(|| {
                 UnbondError::ValidatorHasNoBonds(validator.clone())
             })?;
         let slashes = self.read_validator_slashes(validator)?;
@@ -1267,7 +1267,8 @@ where
     } in validators.clone()
     {
         total_bonded_balance += *tokens;
-        // is some extra error handling needed here for casting the delta as i64? (TokenChange)
+        // is some extra error handling needed here for casting the delta as
+        // i64? (TokenChange)
         let delta = TokenChange::from(*tokens);
         total_bonded_delta = total_bonded_delta + delta;
         active.insert(WeightedValidator {

proof_of_stake/src/types.rs

@@ -5,12 +5,10 @@ use std::collections::{BTreeSet, HashMap};
 use std::convert::TryFrom;
 use std::fmt::Display;
 use std::hash::Hash;
-use std::num::TryFromIntError;
-use std::ops::{Add, AddAssign, Sub, SubAssign};
+use std::ops::{Add, AddAssign, Sub};
 
 use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
-use rust_decimal::prelude::ToPrimitive;
-use rust_decimal::Decimal;
+use rust_decimal::prelude::{Decimal, ToPrimitive};
 
 use crate::epoched::{
     Epoched, EpochedDelta, OffsetPipelineLen, OffsetUnbondingLen,
@@ -36,7 +34,8 @@ pub type Unbonds<TokenAmount> =
 pub type ValidatorSets<Address> =
     Epoched<ValidatorSet<Address>, OffsetUnbondingLen>;
 /// Epoched total deltas.
-pub type TotalDeltas<TokenChange> = EpochedDelta<TokenChange, OffsetUnbondingLen>;
+pub type TotalDeltas<TokenChange> =
+    EpochedDelta<TokenChange, OffsetUnbondingLen>;
 /// Epoched validator commission rate
 pub type CommissionRates = Epoched<Decimal, OffsetPipelineLen>;
 
@@ -546,8 +545,12 @@ pub fn decimal_mult_i128(dec: Decimal, int: i128) -> i128 {
     prod.to_i128().expect("Product is out of bounds")
 }
 
-/// Calculate voting power in the tendermint context (which is stored as i64) from the number of tokens
-pub fn into_tm_voting_power(votes_per_token: Decimal, tokens: impl Into<u64>) -> i64 {
+/// Calculate voting power in the tendermint context (which is stored as i64)
+/// from the number of tokens
+pub fn into_tm_voting_power(
+    votes_per_token: Decimal,
+    tokens: impl Into<u64>,
+) -> i64 {
     let prod = decimal_mult_u64(votes_per_token, tokens.into());
     i64::try_from(prod).expect("Invalid voting power")
 }

proof_of_stake/src/validation.rs

@@ -17,10 +17,10 @@ use crate::btree_set::BTreeSetShims;
 use crate::epoched::DynEpochOffset;
 use crate::parameters::PosParams;
 use crate::types::{
-    decimal_mult_i128, decimal_mult_u64, BondId, Bonds, CommissionRates, Epoch, PublicKeyTmRawHash, Slash, Slashes,
-    Unbonds, ValidatorConsensusKeys, ValidatorSets,
-    ValidatorState, ValidatorStates, ValidatorDeltas,
-    WeightedValidator, TotalDeltas,
+    decimal_mult_i128, decimal_mult_u64, BondId, Bonds, CommissionRates, Epoch,
+    PublicKeyTmRawHash, Slash, Slashes, TotalDeltas, Unbonds,
+    ValidatorConsensusKeys, ValidatorDeltas, ValidatorSets, ValidatorState,
+    ValidatorStates, WeightedValidator,
 };
 
 #[allow(missing_docs)]
@@ -487,7 +487,9 @@ where
                                     // Any validator who's total deltas changed,
                                     // should
                                     // be up-to-date
-                                    if validator.bonded_stake != Into::<u64>::into(*stake_post) {
+                                    if validator.bonded_stake
+                                        != Into::<u64>::into(*stake_post)
+                                    {
                                         errors.push(
                                             Error::InvalidActiveValidator(
                                                 validator.clone(),
@@ -529,7 +531,9 @@ where
                                             {
                                                 is_valid = validator
                                                     .bonded_stake
-                                                    == Into::<u64>::into(*last_total_stake);
+                                                    == Into::<u64>::into(
+                                                        *last_total_stake,
+                                                    );
                                                 break;
                                             } else {
                                                 search_epoch -= 1;
@@ -552,7 +556,9 @@ where
                             // be up-to-date
                             match total_stakes.get(&validator.address) {
                                 Some((_stake_pre, stake_post)) => {
-                                    if validator.bonded_stake != Into::<u64>::into(*stake_post) {
+                                    if validator.bonded_stake
+                                        != Into::<u64>::into(*stake_post)
+                                    {
                                         errors.push(
                                             Error::InvalidInactiveValidator(
                                                 validator.clone(),
@@ -594,7 +600,9 @@ where
                                             {
                                                 is_valid = validator
                                                     .bonded_stake
-                                                    == Into::<u64>::into(*last_total_stake);
+                                                    == Into::<u64>::into(
+                                                        *last_total_stake,
+                                                    );
                                                 break;
                                             } else {
                                                 search_epoch -= 1;
@@ -1948,10 +1956,7 @@ where
     fn total_deltas(
         constants: &Constants,
         errors: &mut Vec<Error<Address, TokenChange, PublicKey>>,
-        total_delta_by_epoch: &mut HashMap<
-            Epoch,
-            TokenChange,
-        >,
+        total_delta_by_epoch: &mut HashMap<Epoch, TokenChange>,
         data: Data<TotalDeltas<TokenChange>>,
     ) {
         match (data.pre, data.post) {

shared/src/ledger/governance/utils.rs

@@ -9,7 +9,7 @@ use thiserror::Error;
 use crate::ledger::governance::storage as gov_storage;
 use crate::ledger::pos;
 use crate::ledger::pos::types::decimal_mult_u64;
-use crate::ledger::pos::{BondId, Bonds, ValidatorSets, ValidatorDeltas};
+use crate::ledger::pos::{BondId, Bonds, ValidatorDeltas, ValidatorSets};
 use crate::ledger::storage::{DBIter, Storage, StorageHasher, DB};
 use crate::types::address::Address;
 use crate::types::governance::{ProposalVote, TallyResult, VotePower};

shared/src/ledger/pos/mod.rs

@@ -6,7 +6,7 @@ pub mod vp;
 pub use namada_proof_of_stake;
 pub use namada_proof_of_stake::parameters::PosParams;
 pub use namada_proof_of_stake::types::{
-    self, Slash, Slashes, ValidatorStates, decimal_mult_u64
+    self, decimal_mult_u64, Slash, Slashes, ValidatorStates,
 };
 use namada_proof_of_stake::PosBase;
 use rust_decimal::Decimal;
@@ -31,8 +31,12 @@ pub fn staking_token_address() -> Address {
     address::nam()
 }
 
-/// Calculate voting power in the tendermint context (which is stored as i64) from the number of tokens
-pub fn into_tm_voting_power(votes_per_token: Decimal, tokens: impl Into<u64>) -> i64 {
+/// Calculate voting power in the tendermint context (which is stored as i64)
+/// from the number of tokens
+pub fn into_tm_voting_power(
+    votes_per_token: Decimal,
+    tokens: impl Into<u64>,
+) -> i64 {
     let prod = decimal_mult_u64(votes_per_token, tokens.into());
     i64::try_from(prod).expect("Invalid validator voting power (i64)")
 }
@@ -271,7 +275,6 @@ mod macros {
                 let value =
                     $crate::ledger::storage_api::StorageRead::read_bytes(self, &total_deltas_key())?.unwrap();
                 Ok($crate::ledger::storage::types::decode(value).unwrap())
-                Ok($crate::ledger::storage::types::decode(value).unwrap())
             }
         }
     }

shared/src/ledger/pos/storage.rs

@@ -1,14 +1,12 @@
 //! Proof-of-Stake storage keys and storage integration via [`PosBase`] trait.
 
 use namada_proof_of_stake::parameters::PosParams;
-use namada_proof_of_stake::types::{
-ValidatorStates,
-};
+use namada_proof_of_stake::types::ValidatorStates;
 use namada_proof_of_stake::{types, PosBase};
 
 use super::{
-    BondId, Bonds, CommissionRates, ValidatorConsensusKeys, ValidatorSets, ValidatorDeltas, TotalDeltas,
-    ADDRESS,
+    BondId, Bonds, CommissionRates, TotalDeltas, ValidatorConsensusKeys,
+    ValidatorDeltas, ValidatorSets, ADDRESS,
 };
 use crate::ledger::storage::types::{decode, encode};
 use crate::ledger::storage::{self, Storage, StorageHasher};
@@ -421,8 +419,7 @@ where
         &self,
         key: &Self::Address,
     ) -> Option<types::ValidatorDeltas<Self::TokenChange>> {
-        let (value, _gas) =
-            self.read(&validator_deltas_key(key)).unwrap();
+        let (value, _gas) = self.read(&validator_deltas_key(key)).unwrap();
         value.map(|value| decode(value).unwrap())
     }
 

shared/src/ledger/pos/vp.rs

@@ -7,23 +7,21 @@ use borsh::BorshDeserialize;
 use itertools::Itertools;
 pub use namada_proof_of_stake;
 pub use namada_proof_of_stake::parameters::PosParams;
-pub use namada_proof_of_stake::types::{
-    self, Slash, Slashes, ValidatorStates
-};
+pub use namada_proof_of_stake::types::{self, Slash, Slashes, ValidatorStates};
 use namada_proof_of_stake::validation::validate;
 use namada_proof_of_stake::{validation, PosReadOnly};
 use rust_decimal::Decimal;
 use thiserror::Error;
 
 use super::{
-    bond_key, is_bond_key, is_params_key, is_total_deltas_key,
-    is_unbond_key, is_validator_set_key, is_validator_deltas_key,
-    params_key, staking_token_address, unbond_key, validator_commission_rate_key,
-    validator_consensus_key_key, validator_max_commission_rate_change_key,
-    validator_set_key, validator_slashes_key, validator_state_key, total_deltas_key,
-    validator_deltas_key, BondId, Bonds,
-    CommissionRates, Unbonds, ValidatorConsensusKeys, ValidatorSets,
-    ValidatorDeltas,
+    bond_key, is_bond_key, is_params_key, is_total_deltas_key, is_unbond_key,
+    is_validator_deltas_key, is_validator_set_key, params_key,
+    staking_token_address, total_deltas_key, unbond_key,
+    validator_commission_rate_key, validator_consensus_key_key,
+    validator_deltas_key, validator_max_commission_rate_change_key,
+    validator_set_key, validator_slashes_key, validator_state_key, BondId,
+    Bonds, CommissionRates, Unbonds, ValidatorConsensusKeys, ValidatorDeltas,
+    ValidatorSets,
 };
 use crate::impl_pos_read_only;
 use crate::ledger::governance::vp::is_proposal_accepted;