debug

Author: eval-exec

chain/src/chain_service.rs

@@ -92,6 +92,10 @@ impl ChainService {
     fn asynchronous_process_block(&self, lonely_block: LonelyBlock) {
         let block_number = lonely_block.block().number();
         let block_hash = lonely_block.block().hash();
+        debug!(
+            "[ChainService] asynchronous_process_block {}-{}",
+            block_number, block_hash
+        );
         // Skip verifying a genesis block if its hash is equal to our genesis hash,
         // otherwise, return error and ban peer.
         if block_number < 1 {

ckb-bin/src/setup.rs

@@ -15,7 +15,7 @@ use std::{path::PathBuf, str::FromStr};
 use crate::cli;
 
 // 500_000 total difficulty
-const MIN_CHAIN_WORK_500K: U256 = u256!("0x3314412053c82802a7");
+const MIN_CHAIN_WORK_500K: U256 = u256!("0x0");
 
 /// A struct including all the information to start the ckb process.
 pub struct Setup {

shared/src/shared.rs

@@ -423,19 +423,21 @@ impl Shared {
         match self.block_status_map().get(block_hash) {
             Some(status_ref) => *status_ref.value(),
             None => {
-                if self.header_map().contains_key(block_hash) {
-                    BlockStatus::HEADER_VALID
-                } else {
-                    let verified = self
-                        .snapshot()
-                        .get_block_ext(block_hash)
-                        .map(|block_ext| block_ext.verified);
-                    match verified {
-                        None => BlockStatus::UNKNOWN,
-                        Some(None) => BlockStatus::BLOCK_STORED,
-                        Some(Some(true)) => BlockStatus::BLOCK_VALID,
-                        Some(Some(false)) => BlockStatus::BLOCK_INVALID,
+                let verified = self
+                    .snapshot()
+                    .get_block_ext(block_hash)
+                    .map(|block_ext| block_ext.verified);
+                match verified {
+                    None => {
+                        if self.header_map().contains_key(block_hash) {
+                            BlockStatus::HEADER_VALID
+                        } else {
+                            BlockStatus::UNKNOWN
+                        }
                     }
+                    Some(None) => BlockStatus::BLOCK_STORED,
+                    Some(Some(true)) => BlockStatus::BLOCK_VALID,
+                    Some(Some(false)) => BlockStatus::BLOCK_INVALID,
                 }
             }
         }

sync/src/synchronizer/headers_process.rs

@@ -253,7 +253,13 @@ impl<'a> HeadersProcess<'a> {
 
         // Batch insert all valid headers in ONE transaction
         if !headers_to_insert.is_empty() {
+            debug!(
+                "Calling insert_valid_headers_batch for {} headers",
+                headers_to_insert.len()
+            );
             shared.insert_valid_headers_batch(self.peer, &headers_to_insert);
+        } else {
+            debug!("No new headers to insert (all already valid)");
         }
 
         self.debug();

sync/src/synchronizer/mod.rs

@@ -453,12 +453,18 @@ impl Synchronizer {
     //TODO: process block which we don't request
     pub fn asynchronous_process_remote_block(&self, remote_block: RemoteBlock) {
         let block_hash = remote_block.block.hash();
+        let block_number = remote_block.block.number();
         let status = self.shared.active_chain().get_block_status(&block_hash);
+        debug!(
+            "asynchronous_process_remote_block {}-{}, status: {:?}",
+            block_number, block_hash, status
+        );
         // NOTE: Filtering `BLOCK_STORED` but not `BLOCK_RECEIVED`, is for avoiding
         // stopping synchronization even when orphan_pool maintains dirty items by bugs.
         if status.contains(BlockStatus::BLOCK_STORED) {
             error!("Block {} already stored", block_hash);
         } else if status.contains(BlockStatus::HEADER_VALID) {
+            debug!("Calling accept_remote_block for {}-{}", block_number, block_hash);
             self.shared.accept_remote_block(&self.chain, remote_block);
         } else {
             debug!(

sync/src/types/mod.rs

@@ -1083,16 +1083,28 @@ impl SyncShared {
     }
 
     pub(crate) fn accept_remote_block(&self, chain: &ChainController, remote_block: RemoteBlock) {
+        let block_number = remote_block.block.number();
+        let block_hash = remote_block.block.header().hash();
+        debug!(
+            "accept_remote_block {}-{}",
+            block_number,
+            block_hash
+        );
         {
             let entry = self
                 .shared()
                 .block_status_map()
-                .entry(remote_block.block.header().hash());
+                .entry(block_hash.clone());
             if let dashmap::mapref::entry::Entry::Vacant(entry) = entry {
                 entry.insert(BlockStatus::BLOCK_RECEIVED);
             }
         }
 
+        debug!(
+            "Calling chain.asynchronous_process_remote_block for {}-{}",
+            block_number,
+            block_hash
+        );
         chain.asynchronous_process_remote_block(remote_block)
     }
 
@@ -1211,6 +1223,15 @@ impl SyncShared {
         // Commit ONCE - single fsync for all headers
         db_txn.commit().expect("commit should be ok");
 
+        debug!(
+            "insert_valid_headers_batch committed {} headers, range: {}-{} to {}-{}",
+            headers.len(),
+            headers.first().map(|h| h.number()).unwrap_or(0),
+            headers.first().map(|h| h.hash()).unwrap_or_default(),
+            headers.last().map(|h| h.number()).unwrap_or(0),
+            headers.last().map(|h| h.hash()).unwrap_or_default()
+        );
+
         last_header_index
     }