Fix bug: no store the sync dag block

flexidag/src/blockdag.rs

@@ -223,10 +223,12 @@ impl BlockDAG {
         );
         let reachability_store = self.storage.reachability_store.clone();
 
-        let mut merge_set = ghostdata
-            .unordered_mergeset_without_selected_parent()
-            .filter(|hash| self.storage.reachability_store.read().has(*hash).unwrap())
-            .collect::<Vec<_>>()
+        let mut merge_set = self
+            .ghost_dag_manager()
+            .unordered_mergeset_without_selected_parent(
+                ghostdata.selected_parent,
+                &header.parents(),
+            )
             .into_iter();
         let add_block_result = {
             let mut reachability_writer = reachability_store.write();
@@ -482,8 +484,8 @@ impl BlockDAG {
         let dag_state = self.get_dag_state(previous_pruning_point)?;
         let next_ghostdata = self.ghostdata(&dag_state.tips)?;
         info!(
-            "start to calculate the mergeset and tips for tips: {:?}, and last pruning point: {:?} and next ghostdata: {:?}",
-            dag_state.tips, previous_pruning_point, next_ghostdata,
+            "start to calculate the mergeset and tips for tips: {:?}, and last pruning point: {:?} and next ghostdata's selected parents: {:?} and blues set are {:?}",
+            dag_state.tips, previous_pruning_point, next_ghostdata.selected_parent, next_ghostdata.mergeset_blues,
         );
         let next_pruning_point = self.pruning_point_manager().next_pruning_point(
             previous_pruning_point,

flexidag/src/ghostdag/protocol.rs

@@ -210,22 +210,29 @@ impl<
             }
         }
 
+        let remote_blue_set = blue_blocks
+            .iter()
+            .map(|header| header.id())
+            .collect::<HashSet<_>>();
         if new_block_data
             .mergeset_blues
             .iter()
             .skip(1)
             .cloned()
             .collect::<HashSet<_>>()
-            != blue_blocks
+            != remote_blue_set
+        {
+            warn!("The data of blue set is not equal when executing the block: {:?}, for {:?}, checking data: {:?}", header.id(), blue_blocks.iter().map(|header| header.id()).collect::<Vec<_>>(), new_block_data.mergeset_blues);
+            let ghostdata = self.ghostdag(&header.parents_hash())?;
+            if ghostdata
+                .mergeset_blues
                 .iter()
-                .map(|header| header.id())
+                .skip(1)
+                .cloned()
                 .collect::<HashSet<_>>()
-        {
-            if header.number() < 10000000 {
-                // no bail before 10000000
-                warn!("The data of blue set is not equal when executing the block: {:?}, for {:?}, checking data: {:?}", header.id(), blue_blocks.iter().map(|header| header.id()).collect::<Vec<_>>(), new_block_data.mergeset_blues);
-            } else {
-                bail!("The data of blue set is not equal when executing the block: {:?}, for {:?}, checking data: {:?}", header.id(), blue_blocks.iter().map(|header| header.id()).collect::<Vec<_>>(), new_block_data.mergeset_blues);
+                != remote_blue_set
+            {
+                bail!("The ghost data of blue set is not equal when executing the block: {:?}, for {:?}, checking data: {:?}", header.id(), blue_blocks.iter().map(|header| header.id()).collect::<Vec<_>>(), ghostdata.mergeset_blues);
             }
         }
 
@@ -377,12 +384,20 @@ impl<
             *candidate_blue_anticone_size = (*candidate_blue_anticone_size).checked_add(1).unwrap();
             if *candidate_blue_anticone_size > self.k {
                 // k-cluster violation: The candidate's blue anticone exceeded k
+                info!(
+                    "Checking blue candidate: {} failed, blue anticone exceeded k",
+                    blue_candidate
+                );
                 return Ok(ColoringState::Red);
             }
 
             if *candidate_blues_anticone_sizes.get(&block).unwrap() == self.k {
                 // k-cluster violation: A block in candidate's blue anticone already
                 // has k blue blocks in its own anticone
+                info!(
+                    "Checking blue candidate: {} failed, block {} has k blue blocks in its anticone",
+                    blue_candidate, block
+                );
                 return Ok(ColoringState::Red);
             }
 
@@ -431,6 +446,10 @@ impl<
         // The maximum length of new_block_data.mergeset_blues can be K+1 because
         // it contains the selected parent.
         if new_block_data.mergeset_blues.len() as KType == self.k.checked_add(1).unwrap() {
+            info!(
+                "Checking blue candidate: {} failed, mergeset blues size is K+1",
+                blue_candidate
+            );
             return Ok(ColoringOutput::Red);
         }
 

flexidag/src/prune/pruning_point_manager.rs

@@ -75,6 +75,11 @@ impl<T: ReachabilityStoreReader + Clone> PruningPointManagerT<T> {
             min_required_blue_score_for_next_pruning_point
         );
 
+        debug!("previous_pruning_point: {:?}, previous_ghostdata: {:?}, next_ghostdata: {:?}, pruning_depth: {:?}, pruning_finality: {:?}", 
+            previous_pruning_point, previous_ghostdata, next_ghostdata,
+            pruning_depth, pruning_finality,
+        );
+
         let mut latest_pruning_ghost_data = previous_ghostdata.to_compact();
         if min_required_blue_score_for_next_pruning_point + pruning_depth
             <= next_ghostdata.blue_score