Pass the final result of LastVotedForkSlots aggregation to next stage and find the heaviest fork we will Gossip to others.

wen-restart/proto/wen_restart.proto

@@ -20,10 +20,23 @@ message LastVotedForkSlotsRecord {
 
 message LastVotedForkSlotsAggregateRecord {
     map<string, LastVotedForkSlotsRecord> received = 1;
+    optional LastVotedForkSlotsAggregateFinal final_result = 2;
+}
+
+message LastVotedForkSlotsAggregateFinal {
+    map<uint64, uint64> slots_stake_map = 1;
+    uint64 total_active_stake = 2;
+}
+
+message HeaviestFork {
+    uint64 slot = 1;
+    string bankhash = 2;
+    uint64 total_active_stake = 3;
 }
 
 message WenRestartProgress {
     State state = 1;
     optional LastVotedForkSlotsRecord my_last_voted_fork_slots = 2;
     optional LastVotedForkSlotsAggregateRecord last_voted_fork_slots_aggregate = 3;
+    optional HeaviestFork my_heaviest_fork = 4;
 }

wen-restart/src/last_voted_fork_slots_aggregate.rs

@@ -27,6 +27,12 @@ pub struct LastVotedForkSlotsAggregateResult {
     pub active_percent: f64, /* 0 ~ 100.0 */
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub struct LastVotedForkSlotsFinalResult {
+    pub slots_stake_map: HashMap<Slot, u64>,
+    pub total_active_stake: u64,
+}
+
 impl LastVotedForkSlotsAggregate {
     pub(crate) fn new(
         root_slot: Slot,
@@ -131,15 +137,25 @@ impl LastVotedForkSlotsAggregate {
         Some(record)
     }
 
-    pub(crate) fn get_aggregate_result(&self) -> LastVotedForkSlotsAggregateResult {
-        let total_stake = self.epoch_stakes.total_stake();
-        let total_active_stake = self.active_peers.iter().fold(0, |sum: u64, pubkey| {
+    fn total_active_stake(&self) -> u64 {
+        self.active_peers.iter().fold(0, |sum: u64, pubkey| {
             sum.saturating_add(Self::validator_stake(&self.epoch_stakes, pubkey))
-        });
-        let active_percent = total_active_stake as f64 / total_stake as f64 * 100.0;
+        })
+    }
+
+    pub(crate) fn get_aggregate_result(&self) -> LastVotedForkSlotsAggregateResult {
         LastVotedForkSlotsAggregateResult {
             slots_to_repair: self.slots_to_repair.iter().cloned().collect(),
-            active_percent,
+            active_percent: self.total_active_stake() as f64
+                / self.epoch_stakes.total_stake() as f64
+                * 100.0,
+        }
+    }
+
+    pub(crate) fn get_final_result(&self) -> LastVotedForkSlotsFinalResult {
+        LastVotedForkSlotsFinalResult {
+            slots_stake_map: self.slots_stake_map.clone(),
+            total_active_stake: self.total_active_stake(),
         }
     }
 }