[DK::shortcut] Further shortcut with singular strong group

Author: coderofstuff

consensus/src/processes/dagknight/protocol.rs

@@ -114,6 +114,12 @@ pub struct DagknightData {
     pub conflict_ordered_parents: Vec<Hash>, // The rest of the parents, ordered by conflict hierarchy (parents from latest/topmost conflicts first)
 }
 
+#[derive(Default)]
+struct ShortcutResult {
+    strong_groups: Vec<Hash>,
+    weak_groups: BlockHashSet,
+}
+
 impl<
     C: DagknightStore + DagknightStoreReader,
     O: HeaderStoreReader + 'static,
@@ -199,23 +205,31 @@ impl<
             // Check shortcut to identify weak groups at k=0
             // This doesn't change conflict hierarchy - it just marks groups as weak
             // for later processes to decide what to do with such weak groups
-            let weak_groups: BlockHashSet =
-                if use_shortcut { self.check_weak_block_shortcut(&agreement_grouping, conflict_genesis) } else { BlockHashSet::new() };
+            let ShortcutResult { strong_groups, weak_groups } =
+                if use_shortcut { self.check_weak_block_shortcut(&agreement_grouping, conflict_genesis) } else { Default::default() };
 
             // Pick a "winner" among these subgroups
             let (winning_conflict_genesis, winning_subgroup) = {
-                let best_groups = self.rank(conflict_genesis, &agreement_grouping, &curr_subgroup, &weak_groups);
+                if use_shortcut && strong_groups.len() == 1 {
+                    // If there is a singular strong group, win with it immediately
+                    let key = strong_groups[0];
+                    let value = agreement_grouping[&key].clone();
 
-                #[allow(clippy::style)]
-                let final_winner = if best_groups.len() > 1 {
-                    self.tie_breaking(conflict_genesis, &curr_subgroup, &best_groups)
+                    (key, value)
                 } else {
-                    let single_winner = best_groups.into_iter().next().expect("best_groups should be non-empty after filtering");
-                    (single_winner.conflict_genesis, single_winner.subgroup)
-                };
+                    let best_groups = self.rank(conflict_genesis, &agreement_grouping, &curr_subgroup, &weak_groups);
+
+                    #[allow(clippy::style)]
+                    let final_winner = if best_groups.len() > 1 {
+                        self.tie_breaking(conflict_genesis, &curr_subgroup, &best_groups)
+                    } else {
+                        let single_winner = best_groups.into_iter().next().expect("best_groups should be non-empty after filtering");
+                        (single_winner.conflict_genesis, single_winner.subgroup)
+                    };
 
-                // This will always be Some since curr_subgroup.len() > 1 and thus there is at least one subgroup
-                final_winner
+                    // This will always be Some since curr_subgroup.len() > 1 and thus there is at least one subgroup
+                    final_winner
+                }
             };
 
             // Add the non-winners to the ordered parents
@@ -370,7 +384,7 @@ impl<
         best_groups_cell.take()
     }
 
-    fn check_weak_block_shortcut(&self, agreement_grouping: &HashMap<Hash, Arc<Vec<Hash>>>, conflict_genesis: Hash) -> BlockHashSet {
+    fn check_weak_block_shortcut(&self, agreement_grouping: &HashMap<Hash, Arc<Vec<Hash>>>, conflict_genesis: Hash) -> ShortcutResult {
         // First pass: compute k=0 blue_work for each subgroup
         let subgroup_work: Vec<(Hash, Uint192)> = agreement_grouping
             .iter()
@@ -403,6 +417,8 @@ impl<
 
         // Collect weak subgroups (subgroups whose blue_work < threshold)
         let mut weak_groups = BlockHashSet::new();
+        let mut strong_groups = Vec::new();
+
         for (cg, blue_work) in &subgroup_work {
             if *blue_work < threshold {
                 debug!(
@@ -413,12 +429,14 @@ impl<
                     threshold.as_u64()
                 );
                 weak_groups.insert(*cg);
+            } else {
+                strong_groups.push(*cg);
             }
         }
 
         debug!("SHORTCUT cg: {} | {} weak groups out of {} total", conflict_genesis, weak_groups.len(), subgroup_work.len());
 
-        weak_groups
+        ShortcutResult { strong_groups, weak_groups }
     }
 
     /// Applies a coloring to the conflict zone, and determines if the