validator: fixed stupid mistake

src/validator/consensus.rs

@@ -322,7 +322,7 @@ impl Consensus {
         let excess = prefix.len();
         let prefix_last_index = excess - 1;
         let prefix_last = prefix.last().unwrap();
-        let mut dropped_forks = vec![];
+        let mut keep = vec![true; forks.len()];
         for (index, fork) in forks.iter_mut().enumerate() {
             if &index == finalized_fork_index {
                 continue
@@ -332,7 +332,7 @@ impl Consensus {
                 prefix_last_index >= fork.proposals.len() ||
                 &fork.proposals[prefix_last_index] != prefix_last
             {
-                dropped_forks.push(index);
+                keep[index] = false;
                 continue
             }
 
@@ -347,9 +347,8 @@ impl Consensus {
         }
 
         // Drop invalid forks
-        for index in dropped_forks {
-            forks.remove(index);
-        }
+        let mut iter = keep.iter();
+        forks.retain(|_| *iter.next().unwrap());
 
         // Drop forks lock
         drop(forks);

src/validator/mod.rs

@@ -346,31 +346,34 @@ impl Validator {
         // Find the excess over finalization threshold
         let excess = (fork.proposals.len() - self.consensus.finalization_threshold) + 1;
 
-        // Apply finalized proposals diffs
+        // Grab finalized proposals and update fork's sequences
         let rest_proposals = fork.proposals.split_off(excess);
         let rest_diffs = fork.diffs.split_off(excess);
-        let finalized = fork.proposals.clone();
+        let finalized_proposals = fork.proposals.clone();
         let mut diffs = fork.diffs.clone();
         fork.proposals = rest_proposals;
         fork.diffs = rest_diffs;
+
+        // Grab finalized proposals blocks
+        let finalized_blocks =
+            fork.overlay.lock().unwrap().get_blocks_by_hash(&finalized_proposals)?;
+
+        // Apply finalized proposals diffs
         info!(target: "validator::finalization", "Finalizing proposals:");
-        for (index, proposal) in finalized.iter().enumerate() {
-            info!(target: "validator::finalization", "\t{}", proposal);
+        for (index, proposal) in finalized_proposals.iter().enumerate() {
+            info!(target: "validator::finalization", "\t{} - {}", proposal, finalized_blocks[index].header.height);
             fork.overlay.lock().unwrap().overlay.lock().unwrap().apply_diff(&mut diffs[index])?;
         }
         drop(forks);
 
         // Reset forks starting with the finalized blocks
-        self.consensus.reset_forks(&finalized, &finalized_fork).await;
+        self.consensus.reset_forks(&finalized_proposals, &finalized_fork).await;
         info!(target: "validator::finalization", "Finalization completed!");
 
         // Release append lock
         drop(append_lock);
 
-        // Grab finalized blocks
-        let finalized = self.blockchain.get_blocks_by_hash(&finalized)?;
-
-        Ok(finalized)
+        Ok(finalized_blocks)
     }
 
     // ==========================