fix some bugs

flexidag/src/ghostdag/protocol.rs

@@ -196,7 +196,7 @@ impl<
             }
         }
 
-        *BlockHashes::make_mut(&mut new_block_data.mergeset_blues) = self.sort_blocks(new_block_data.mergeset_blues.iter().cloned())?;
+        *BlockHashes::make_mut(&mut new_block_data.mergeset_blues) = self.sort_blocks_for_work_type(new_block_data.mergeset_blues.iter().cloned())?;
 
         if new_block_data.mergeset_blues.iter().skip(1).cloned().collect::<HashSet<_>>() != blue_blocks.into_iter().map(|header| header.id()).collect::<HashSet<_>>() {
             if  header.number() < 10000000 {
@@ -517,7 +517,24 @@ impl<
         Ok(sorted_blocks)
     }
 
+    pub fn sort_blocks_for_work_type(&self, blocks: impl IntoIterator<Item = Hash>) -> Result<Vec<Hash>> {
+        let mut sorted_blocks: Vec<Hash> = blocks.into_iter().collect();
 
+        sorted_blocks.sort_by_cached_key(|block| {
+            let blue_work = self
+                .ghostdag_store
+                .get_blue_work(*block)
+                .unwrap_or_else(|err| {
+                    error!("Failed to get blue work of block: {}, {}", *block, err);
+                    0.into()
+                });
+            SortableBlockWithWorkType {
+                hash: *block,
+                blue_work,
+            }
+        });
+        Ok(sorted_blocks)
+    }
 }
 
 /// Chain block with attached ghostdag data

flexidag/src/types/ordering.rs

@@ -34,3 +34,35 @@ impl Ord for SortableBlock {
             .then_with(|| self.hash.cmp(&other.hash))
     }
 }
+
+#[derive(Eq, Clone, Debug, Serialize, Deserialize)]
+pub struct SortableBlockWithWorkType {
+    pub hash: Hash,
+    pub blue_work: BlueWorkType,
+}
+
+impl SortableBlockWithWorkType {
+    pub fn new(hash: Hash, blue_work: BlueWorkType) -> Self {
+        Self { hash, blue_work }
+    }
+}
+
+impl PartialEq for SortableBlockWithWorkType {
+    fn eq(&self, other: &Self) -> bool {
+        self.hash == other.hash
+    }
+}
+
+impl PartialOrd for SortableBlockWithWorkType {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for SortableBlockWithWorkType {
+    fn cmp(&self, other: &Self) -> Ordering {
+        other.blue_work
+            .cmp(&self.blue_work)
+            .then_with(|| self.hash.cmp(&other.hash))
+    }
+}

sync/src/parallel/sender.rs

@@ -127,6 +127,7 @@ impl<'a> DagBlockSender<'a> {
         }
 
         self.wait_for_finish().await?;
+        sync_dag_store.delete_all_dag_sync_block()?;
 
         Ok(())
     }
@@ -137,7 +138,6 @@ impl<'a> DagBlockSender<'a> {
                 Ok(state) => {
                     match state {
                         ExecuteState::Executed(executed_block) => {
-                            self.sync_dag_store.delete_dag_sync_block(executed_block.block().header().number(), executed_block.header().id())?;
                             info!("finish to execute block {:?}", executed_block.header());
                             self.notifier.notify(executed_block.clone())?;
                             worker.state = ExecuteState::Executed(executed_block);