use simple impl

Author: Hecate2

crates/cfxcore/core/src/sync/message/new_block_hashes.rs

@@ -29,76 +29,14 @@ impl Decodable for NewBlockHashes {
 
 impl Handleable for NewBlockHashes {
     fn handle(self, ctx: &Context) -> Result<(), Error> {
-        debug!("on_new_block_hashes, msg={:?}", self);
-
-        // Determine which block hashes are unknown to us, but only when at
-        // least one consumer actually needs the result.
-        //
-        // Two consumers exist:
-        //   1. The `log_block_source` logging path, which uses the unknown
-        //      hashes for approximate first-seen deduplication so that only the
-        //      first peer to propagate a block hash (before we download its
-        //      header) generates a [BLOCK_SOURCE] log entry.
-        //   2. The header-request path (active only outside catch-up mode),
-        //      which filters out hashes whose headers we already have to avoid
-        //      redundant requests.
-        //
-        // When neither consumer is active — i.e. we are in catch-up mode with
-        // logging disabled — the `block_header_by_hash` lookups are skipped
-        // entirely and `unknown_hashes` stays empty (no allocation). This
-        // restores the pre-logging performance characteristics: zero overhead
-        // in catch-up mode.
-        //
-        // The result is computed once and shared by both consumers, avoiding
-        // duplicate lookups. A `Vec<&H256>` is used instead of a `HashSet`
-        // because the typical NewBlockHashes message contains only 1–2 hashes,
-        // making linear iteration cheaper than HashSet allocation and hashing.
-        //
-        // Trade-off: this uses the existing block_header_by_hash lookup
-        // (in-memory HashMap + DB fallback) for approximate first-seen
-        // deduplication. It is not a strict first-seen guarantee: multiple
-        // peers propagating the same hash within the header-download window
-        // (typically milliseconds to a few seconds) each generate a log
-        // entry. After the header is cached, all subsequent NewBlockHashes
-        // for the same block are silently suppressed, which is the desired
-        // behavior for tracking block propagation sources.
-        let in_catch_up_mode = ctx.manager.catch_up_mode();
-
-        let unknown_hashes: Vec<&H256> = if ctx
-            .manager
-            .protocol_config
-            .log_block_source
-            || !in_catch_up_mode
-        {
-            self.block_hashes
-                .iter()
-                .filter(|hash| {
-                    ctx.manager
-                        .graph
-                        .data_man
-                        .block_header_by_hash(hash)
-                        .is_none()
-                })
-                .collect()
-        } else {
-            Vec::new()
-        };
-
-        if ctx.manager.protocol_config.log_block_source {
-            let peer_addr = ctx
-                .peer_addr
-                .as_ref()
-                .map(|s| s.as_str())
-                .unwrap_or("unknown");
-            for hash in &unknown_hashes {
-                info!(
-                    "[BLOCK_SOURCE] hash={:#x} from_node={} from_addr={}",
-                    hash, ctx.node_id, peer_addr
-                );
-            }
-        }
+        debug!(
+            "on_new_block_hashes, msg={:?} from_node={} from_addr={}",
+            self,
+            ctx.node_id,
+            ctx.peer_addr.as_deref().unwrap_or("unknown")
+        );
 
-        if in_catch_up_mode {
+        if ctx.manager.catch_up_mode() {
             // If a node is in catch-up mode and we are not in test-mode, we
             // just simple ignore new block hashes.
             if ctx.manager.protocol_config.test_mode {
@@ -112,8 +50,18 @@ impl Handleable for NewBlockHashes {
             return Ok(());
         }
 
-        let headers_to_request: Vec<H256> =
-            unknown_hashes.into_iter().cloned().collect();
+        let headers_to_request = self
+            .block_hashes
+            .iter()
+            .filter(|hash| {
+                ctx.manager
+                    .graph
+                    .data_man
+                    .block_header_by_hash(&hash)
+                    .is_none()
+            })
+            .cloned()
+            .collect::<Vec<_>>();
 
         ctx.manager.request_block_headers(
             ctx.io,
@@ -126,52 +74,3 @@ impl Handleable for NewBlockHashes {
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn rlp_round_trip_empty() {
-        let original = NewBlockHashes {
-            block_hashes: vec![],
-        };
-        let encoded = rlp::encode(&original);
-        let decoded: NewBlockHashes = rlp::decode(&encoded).unwrap();
-        assert_eq!(original, decoded);
-    }
-
-    #[test]
-    fn rlp_round_trip_single_hash() {
-        let original = NewBlockHashes {
-            block_hashes: vec![H256::from_low_u64_be(42)],
-        };
-        let encoded = rlp::encode(&original);
-        let decoded: NewBlockHashes = rlp::decode(&encoded).unwrap();
-        assert_eq!(original, decoded);
-    }
-
-    #[test]
-    fn rlp_round_trip_multiple_hashes() {
-        let original = NewBlockHashes {
-            block_hashes: vec![
-                H256::from_low_u64_be(1),
-                H256::from_low_u64_be(2),
-                H256::from_low_u64_be(3),
-                H256::random(),
-            ],
-        };
-        let encoded = rlp::encode(&original);
-        let decoded: NewBlockHashes = rlp::decode(&encoded).unwrap();
-        assert_eq!(original, decoded);
-    }
-
-    #[test]
-    fn rlp_decode_rejects_short_element() {
-        // 0xc1 0x01 is an RLP list with one 1-byte element.
-        // H256 requires 32 bytes, so this should fail to decode.
-        let short_element: &[u8] = &[0xc1, 0x01];
-        let result: Result<NewBlockHashes, _> = rlp::decode(short_element);
-        assert!(result.is_err());
-    }
-}

crates/cfxcore/core/src/sync/synchronization_protocol_handler.rs

@@ -427,11 +427,6 @@ pub struct ProtocolConfiguration {
     pub check_status_genesis: bool,
 
     pub pos_started_as_voter: bool,
-
-    /// Enable logging of NewBlockHashes source peer information (IP and
-    /// NodeId). Designed for bootnode deployment to track block propagation.
-    /// Default: false. Set to true in production via config to enable.
-    pub log_block_source: bool,
 }
 
 impl SynchronizationProtocolHandler {

crates/config/src/configuration.rs

@@ -405,9 +405,6 @@ build_config! {
         (pos_fix_cip156_transition_view, (u64), u64::MAX)
         (dev_pos_private_key_encryption_password, (Option<String>), None)
         (pos_started_as_voter, (bool), true)
-        // Enable logging of NewBlockHashes source peer (IP and NodeId) for
-        // bootnode deployment to track block propagation. Default: false.
-        (log_block_source, (bool), false)
 
         // Light node section
         (ln_epoch_request_batch_size, (Option<usize>), None)
@@ -960,7 +957,6 @@ impl Configuration {
                 .expect("set to genesis if none"),
             check_status_genesis: self.raw_conf.check_status_genesis,
             pos_started_as_voter: self.raw_conf.pos_started_as_voter,
-            log_block_source: self.raw_conf.log_block_source,
         }
     }