chore: make fmt pass

Author: aesedepece

data_structures/src/chain/mod.rs

@@ -318,7 +318,7 @@ impl ConsensusConstantsWit2 {
                 4u16.saturating_mul(2u16.saturating_pow(epoch - prev_epoch))
             } else {
                 0
-            }
+            };
         } else {
             0
         }

data_structures/src/staking/stakes.rs

@@ -326,7 +326,10 @@ where
         self.by_key
             .iter()
             .map(move |(key, entry)| {
-                (key.clone(), entry.read_value().power(capability, current_epoch))
+                (
+                    key.clone(),
+                    entry.read_value().power(capability, current_epoch),
+                )
             })
             .sorted_by(|(key_1, power_1), (key_2, power_2)| {
                 if power_1 == power_2 {
@@ -417,7 +420,7 @@ where
     pub fn reset_mining_age<ISK>(
         &mut self,
         validator: ISK,
-        current_epoch: Epoch
+        current_epoch: Epoch,
     ) -> StakesResult<(), Address, Coins, Epoch>
     where
         ISK: Into<Address>,
@@ -427,15 +430,15 @@ where
         // order mining stake entries by rank, as for given current_epoch:
         // let stakes_clone = self.clone();
         let by_rank = self.by_rank(Capability::Mining, current_epoch);
-        
+
         // locate first entry whose validator matches the one searched for:
-        let winner_rank = by_rank.clone().position(|(key, _)| key.validator == validator);
-        
+        let winner_rank = by_rank
+            .clone()
+            .position(|(key, _)| key.validator == validator);
+
         if let Some(winner_rank) = winner_rank {
-            let stakers: Vec<StakeKey<Address>> = by_rank
-                .take(winner_rank + 1)
-                .map(|(key, _)| key)
-                .collect();
+            let stakers: Vec<StakeKey<Address>> =
+                by_rank.take(winner_rank + 1).map(|(key, _)| key).collect();
             // proportionally reset coin age on located entry and all those with a better mining rank:
             let mut index: usize = 0;
             stakers.iter().for_each(|key| {
@@ -444,7 +447,10 @@ where
                     let penalty_epochs = Epoch::from((1 + winner_rank - index) as u32);
                     log::debug!(
                         "Resetting mining power of {} (ranked as #{}) during +{} epochs to {}",
-                        key, index + 1, penalty_epochs, current_epoch + penalty_epochs
+                        key,
+                        index + 1,
+                        penalty_epochs,
+                        current_epoch + penalty_epochs
                     );
                     stake_entry
                         .value
@@ -1140,7 +1146,9 @@ mod tests {
             ]
         );
         assert_eq!(
-            stakes.by_rank(Capability::Witnessing, 100).collect::<Vec<_>>(),
+            stakes
+                .by_rank(Capability::Witnessing, 100)
+                .collect::<Vec<_>>(),
             [
                 (charlie_erin.into(), 2100),
                 (bob_david.into(), 1600),
@@ -1179,7 +1187,9 @@ mod tests {
             ]
         );
         assert_eq!(
-            stakes.by_rank(Capability::Witnessing, 101).collect::<Vec<_>>(),
+            stakes
+                .by_rank(Capability::Witnessing, 101)
+                .collect::<Vec<_>>(),
             [
                 (charlie_erin.into(), 2_130),
                 (bob_david.into(), 1_620),
@@ -1220,7 +1230,9 @@ mod tests {
             ]
         );
         assert_eq!(
-            stakes.by_rank(Capability::Witnessing, 300).collect::<Vec<_>>(),
+            stakes
+                .by_rank(Capability::Witnessing, 300)
+                .collect::<Vec<_>>(),
             [
                 (charlie_erin.into(), 8_100),
                 (bob_david.into(), 5_600),

node/src/actors/chain_manager/handlers.rs

@@ -15,8 +15,7 @@ use witnet_data_structures::{
         Hash, Hashable, NodeStats, PublicKeyHash, SuperBlockVote, SupplyInfo, ValueTransferOutput,
     },
     error::{ChainInfoError, TransactionError::DataRequestNotFound},
-    get_protocol_version,
-    refresh_protocol_version,
+    get_protocol_version, refresh_protocol_version,
     staking::{errors::StakesError, prelude::StakeKey},
     transaction::{
         DRTransaction, StakeTransaction, Transaction, UnstakeTransaction, VTTransaction,

node/src/actors/chain_manager/mining.rs

@@ -120,9 +120,10 @@ impl ChainManager {
         vrf_input.checkpoint = current_epoch;
 
         let target_hash = if protocol_version == V2_0 {
-            let replication_factor = self
-                .consensus_constants_wit2
-                .get_replication_factor(current_epoch, chain_info.highest_block_checkpoint.checkpoint);
+            let replication_factor = self.consensus_constants_wit2.get_replication_factor(
+                current_epoch,
+                chain_info.highest_block_checkpoint.checkpoint,
+            );
             let eligibility = self
                 .chain_state
                 .stakes

node/src/actors/chain_manager/mod.rs

@@ -3128,7 +3128,10 @@ pub fn process_validations(
     stakes: &StakesTracker,
     protocol_version: ProtocolVersion,
 ) -> Result<Diff, failure::Error> {
-    let replication_factor = consensus_constants_wit2.get_replication_factor(block.block_header.beacon.checkpoint, chain_beacon.checkpoint);
+    let replication_factor = consensus_constants_wit2.get_replication_factor(
+        block.block_header.beacon.checkpoint,
+        chain_beacon.checkpoint,
+    );
     if !resynchronizing {
         let mut signatures_to_verify = vec![];
         validate_block(

node/src/actors/session/handlers.rs

@@ -1,8 +1,8 @@
 use std::{cmp::Ordering, convert::TryFrom, io::Error, net::SocketAddr};
 
 use actix::{
-    ActorContext, ActorFutureExt, ActorTryFutureExt, Context, ContextFutureSpawner,
-    Handler, io::WriteHandler, StreamHandler, SystemService, WrapFuture,
+    io::WriteHandler, ActorContext, ActorFutureExt, ActorTryFutureExt, Context,
+    ContextFutureSpawner, Handler, StreamHandler, SystemService, WrapFuture,
 };
 use bytes::BytesMut;
 use failure::Fail;
@@ -749,7 +749,6 @@ fn inventory_process_block(session: &mut Session, _ctx: &mut Context<Session>, b
             // that uses a newer version.
             session.blocks_timestamp = 0;
             session.requested_blocks.clear();
-
         }
     } else {
         // If this is not a requested block, assume it is a candidate

validations/src/eligibility/current.rs

@@ -176,21 +176,23 @@ where
         let validator: Address = validator.into();
 
         // Cap replication factor to 2/3rds of total stake entries count
-        let max_replication_factor = u16::try_from((((self.stakes_count() * 2) as f64) / 3.0) as u32).unwrap_or(u16::MAX);
+        let max_replication_factor =
+            u16::try_from((((self.stakes_count() * 2) as f64) / 3.0) as u32).unwrap_or(u16::MAX);
         let replication_factor = if replication_factor > max_replication_factor {
             max_replication_factor
         } else {
             replication_factor
         };
 
         Ok(
-            match self.by_rank(Capability::Mining, epoch)
+            match self
+                .by_rank(Capability::Mining, epoch)
                 .take(replication_factor as usize)
                 .find(|(key, _)| key.validator == validator)
             {
                 Some(_) => Eligible::Yes,
-                None => IneligibilityReason::InsufficientPower.into()
-            }
+                None => IneligibilityReason::InsufficientPower.into(),
+            },
         )
     }