feat(slashing): lazyly slash reluctant block proposers

Author: guidiaz

data_structures/src/staking/stake.rs

@@ -158,8 +158,8 @@ where
     }
 
     /// Set the epoch for a certain capability. Most normally, the epoch is the current epoch.
-    pub fn reset_age(&mut self, capability: Capability, current_epoch: Epoch) {
-        self.epochs.update(capability, current_epoch);
+    pub fn reset_age(&mut self, capability: Capability, reset_epoch: Epoch) {
+        self.epochs.update(capability, reset_epoch);
     }
 }
 

data_structures/src/staking/stakes.rs

@@ -413,6 +413,50 @@ where
         }
     }
 
+    /// First, order stake entries by mining power rank, as to find first occurance for given validator.
+    /// Once found, update the entry's mining epoch on that stake entry and all others with a better mining rank.
+    /// The better the rank, the more in the future will the entry's next mining epoch be set to.
+    pub fn reset_mining_age<ISK>(
+        &mut self,
+        validator: ISK,
+        current_epoch: Epoch
+    ) -> StakesResult<(), Address, Coins, Epoch>
+    where
+        ISK: Into<Address>,
+    {
+        let validator = validator.into();
+
+        // order mining stake entries by rank, as for given current_epoch:
+        let mut by_rank = self.by_rank(Capability::Mining, current_epoch);
+        
+        // locate first entry whose validator matches the one searched for:
+        let winner_rank = by_rank.position(move |(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();
+            // 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| {
+                let stake_entry = self.by_key.get_mut(key);
+                if let Some(stake_entry) = stake_entry {
+                    let penalty_epochs = Epoch::from((1 + winner_rank - index) as u32);
+                    log::debug!("Delaying {} as block candidate during +{} epochs", key, penalty_epochs);
+                    stake_entry
+                        .value
+                        .write()
+                        .unwrap()
+                        .reset_age(Capability::Mining, current_epoch + penalty_epochs);
+                }
+                index += 1;
+            });
+        }
+
+        Ok(())
+    }
+
     /// Set the epoch for a certain address and capability. Most normally, the epoch is the current
     /// epoch.
     pub fn reset_age<ISK>(

node/src/actors/chain_manager/handlers.rs

@@ -10,14 +10,12 @@ use actix::{prelude::*, ActorFutureExt, WrapFuture};
 use futures::future::Either;
 
 use witnet_data_structures::{
-    capabilities::Capability,
     chain::{
         tapi::ActiveWips, Block, ChainInfo, ChainState, CheckpointBeacon, DataRequestInfo, Epoch,
         Hash, Hashable, NodeStats, PublicKeyHash, SuperBlockVote, SupplyInfo, ValueTransferOutput,
     },
     error::{ChainInfoError, TransactionError::DataRequestNotFound},
     get_protocol_version,
-    proto::versioning::ProtocolVersion,
     refresh_protocol_version,
     staking::{errors::StakesError, prelude::StakeKey},
     transaction::{
@@ -167,7 +165,6 @@ impl Handler<EpochNotification<EveryEpochPayload>> for ChainManager {
                 match self.chain_state {
                     ChainState {
                         reputation_engine: Some(_),
-                        ref mut stakes,
                         ..
                     } => {
                         if self.epoch_constants.is_none() || self.vrf_ctx.is_none() {
@@ -186,35 +183,6 @@ impl Handler<EpochNotification<EveryEpochPayload>> for ChainManager {
                         {
                             // Persist block and update ChainState
                             self.consolidate_block(ctx, block, utxo_diff, priorities, false);
-                        } else if msg.checkpoint > 0 {
-                            let previous_epoch = msg.checkpoint - 1;
-                            log::warn!(
-                                "There was no valid block candidate to consolidate for epoch {}",
-                                previous_epoch
-                            );
-                            if ProtocolVersion::from_epoch(previous_epoch) == ProtocolVersion::V2_0
-                            {
-                                let replication_factor = self
-                                    .consensus_constants_wit2
-                                    .get_replication_factor(previous_epoch);
-                                let rank_subset: Vec<_> = stakes
-                                    .rank(Capability::Mining, previous_epoch)
-                                    .take(replication_factor.into())
-                                    .collect();
-                                for (i, (validator, _)) in rank_subset.into_iter().enumerate() {
-                                    log::warn!(
-                                        "Slashed the power of {} as it did not propose a block",
-                                        validator
-                                    );
-                                    let _ = stakes.reset_age(
-                                        validator,
-                                        Capability::Mining,
-                                        msg.checkpoint,
-                                        // This should never fail
-                                        (i + 1).try_into().unwrap(),
-                                    );
-                                }
-                            }
                         }
 
                         // Send last beacon on block consolidation

node/src/actors/chain_manager/mod.rs

@@ -1231,13 +1231,8 @@ impl ChainManager {
 
                     // IMPORTANT: Always perform age resets after adding rewards
 
-                    // Reset mining power for miner
-                    log::debug!(
-                        "Resetting mining age for {} to {}",
-                        miner_pkh,
-                        block_epoch + 1,
-                    );
-                    let _ = stakes.reset_age(miner_pkh, Capability::Mining, block_epoch + 1, 1);
+                    // Reset mining power to block proposer, and higher ranked eligible candidates:
+                    let _ = stakes.reset_mining_age(miner_pkh, block_epoch);
 
                     // Reset witnessing power
                     for co_tx in &block.txns.commit_txns {