fix: Resolve 29 Rust 1.93.0 Clippy lints in zipherx-network

- Add type aliases for complex callback types (MempoolTxCallback, etc.)
- Group listener callbacks into ListenerCallbacks struct (too-many-args)
- Replace manual div_ceil, abs_diff, is_multiple_of patterns
- Use RangeInclusive::contains instead of manual range checks
- Replace map_or(false, ...) with is_some_and(...)
- Remove redundant closures and unnecessary borrows
- Use &mut [T] instead of &mut Vec<T> in function signatures
- Derive Default for PeerScore instead of manual impl
- Fix doc list item indentation

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: VictorLux

crates/zipherx-network/src/block_fetcher.rs

@@ -12,6 +12,9 @@ use crate::constants::MAX_BLOCKS_PER_REQUEST;
 use crate::messages::{self, BlockHeader};
 use crate::types::NetworkError;
 
+/// Parsed transaction result: (bytes_consumed, txid, outputs, spends).
+type ParsedTransaction = (usize, [u8; 32], Vec<ShieldedOutput>, Vec<ShieldedSpend>);
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -190,7 +193,7 @@ pub fn parse_raw_block(
 /// - binding_sig (64) — only if shielded data present
 pub fn parse_transaction(
     data: &[u8],
-) -> Option<(usize, [u8; 32], Vec<ShieldedOutput>, Vec<ShieldedSpend>)> {
+) -> Option<ParsedTransaction> {
     if data.len() < 12 {
         return None;
     }
@@ -371,7 +374,7 @@ pub fn parse_transaction(
 fn compute_txid(tx_data: &[u8]) -> [u8; 32] {
     use sha2::{Digest, Sha256};
     let first_pass = Sha256::digest(tx_data);
-    let second_pass = Sha256::digest(&first_pass);
+    let second_pass = Sha256::digest(first_pass);
     let mut txid = [0u8; 32];
     txid.copy_from_slice(&second_pass);
     txid
@@ -381,15 +384,15 @@ fn compute_txid(tx_data: &[u8]) -> [u8; 32] {
 pub fn compute_block_hash(header: &BlockHeader) -> [u8; 32] {
     use sha2::{Digest, Sha256};
     let base = header.serialize();
-    let first = Sha256::digest(&base);
-    let second = Sha256::digest(&first);
+    let first = Sha256::digest(base);
+    let second = Sha256::digest(first);
     let mut hash = [0u8; 32];
     hash.copy_from_slice(&second);
     hash
 }
 
 /// Sort blocks by height (FIX #1199).
-pub fn sort_blocks_by_height(blocks: &mut Vec<CompactBlock>) {
+pub fn sort_blocks_by_height(blocks: &mut [CompactBlock]) {
     blocks.sort_by_key(|b| b.height);
 }
 
@@ -400,7 +403,7 @@ pub fn calculate_rounds(start: u64, end: u64, peer_count: usize) -> usize {
     }
     let total_blocks = (end - start + 1) as usize;
     let blocks_per_round = peer_count * MAX_BLOCKS_PER_REQUEST;
-    (total_blocks + blocks_per_round - 1) / blocks_per_round
+    total_blocks.div_ceil(blocks_per_round)
 }
 
 /// Check if a fetch result meets the 50% threshold (FIX #1218).

crates/zipherx-network/src/dispatcher.rs

@@ -12,6 +12,8 @@ use std::collections::{HashMap, VecDeque};
 
 use tokio::sync::oneshot;
 
+use crate::types::MessagePayload;
+
 /// A batch collector that accumulates multiple messages of the same type.
 struct BatchCollector {
     #[allow(dead_code)]
@@ -27,7 +29,7 @@ struct BatchCollector {
 /// synchronous (no awaits while holding the lock).
 pub struct Dispatcher {
     /// Single-message handlers keyed by command name, FIFO queue per command.
-    pending: HashMap<String, VecDeque<oneshot::Sender<(String, Vec<u8>)>>>,
+    pending: HashMap<String, VecDeque<oneshot::Sender<MessagePayload>>>,
 
     /// Batch collectors keyed by monotonic ID.
     batch_collectors: HashMap<u64, BatchCollector>,
@@ -36,7 +38,7 @@ pub struct Dispatcher {
     command_to_batch: HashMap<String, Vec<u64>>,
 
     /// Broadcast handlers keyed by "broadcast_{txid}".
-    broadcast_handlers: HashMap<String, oneshot::Sender<(String, Vec<u8>)>>,
+    broadcast_handlers: HashMap<String, oneshot::Sender<MessagePayload>>,
 
     /// Next batch collector ID.
     next_batch_id: u64,
@@ -62,7 +64,7 @@ impl Dispatcher {
     ///
     /// Returns a `oneshot::Receiver` that resolves when a matching message arrives.
     /// The caller should wrap this with `tokio::time::timeout()`.
-    pub fn register_handler(&mut self, command: &str) -> oneshot::Receiver<(String, Vec<u8>)> {
+    pub fn register_handler(&mut self, command: &str) -> oneshot::Receiver<MessagePayload> {
         let (tx, rx) = oneshot::channel();
         self.pending
             .entry(command.to_string())
@@ -87,7 +89,7 @@ impl Dispatcher {
     pub fn register_any_handler(
         &mut self,
         commands: &[&str],
-    ) -> oneshot::Receiver<(String, Vec<u8>)> {
+    ) -> oneshot::Receiver<MessagePayload> {
         let (tx, rx) = oneshot::channel();
 
         // We clone the sender for all but the last command.
@@ -168,7 +170,7 @@ impl Dispatcher {
     ///
     /// The handler fires when a "reject" message arrives for this txid,
     /// or resolves to None (via timeout) if no reject = success.
-    pub fn register_broadcast(&mut self, txid: &str) -> oneshot::Receiver<(String, Vec<u8>)> {
+    pub fn register_broadcast(&mut self, txid: &str) -> oneshot::Receiver<MessagePayload> {
         let (tx, rx) = oneshot::channel();
         let key = format!("broadcast_{txid}");
         self.broadcast_handlers.insert(key, tx);

crates/zipherx-network/src/header_sync.rs

@@ -292,10 +292,8 @@ impl<S: HeaderStore> HeaderSync<S> {
             let locator_hash = if let Some(hash) = last_known_hash {
                 hash
             } else if current_height > 0 {
-                match self.store.get_header_hash(current_height - 1)? {
-                    Some(hash) => hash,
-                    None => [0u8; 32],
-                }
+                self.store.get_header_hash(current_height - 1)?
+                    .unwrap_or([0u8; 32])
             } else {
                 [0u8; 32]
             };
@@ -449,7 +447,7 @@ impl<S: HeaderStore> HeaderSync<S> {
                 // RN-1: Verify every 10th header (10% coverage) instead of every
                 // 100th (1%). This provides much better PoW verification coverage
                 // with only a modest performance cost during bulk sync.
-                let should_verify = remaining < 1000 || height % 10 == 0 || is_last_in_batch;
+                let should_verify = remaining < 1000 || height.is_multiple_of(10) || is_last_in_batch;
 
                 if should_verify {
                     match zipherx_crypto::equihash::verify(&header_base, &header.solution) {

crates/zipherx-network/src/peer.rs

@@ -24,6 +24,17 @@ use crate::protocol;
 use crate::socks5;
 use crate::types::*;
 
+/// Grouped listener callbacks passed to `block_listener_loop` and
+/// `handle_background_message` to avoid exceeding the argument limit.
+pub struct ListenerCallbacks {
+    /// Callback fired when an unsolicited "tx" message arrives (mempool detection).
+    pub on_mempool_tx_data: MempoolTxCallback,
+    /// Callback fired when an inv MSG_BLOCK arrives (new block mined).
+    pub on_new_block: NewBlockCallback,
+    /// Callback fired when addr/addrv2 messages arrive with peer addresses.
+    pub on_addr: AddrCallback,
+}
+
 /// Maximum magic byte resyncs before declaring stream desync.
 const MAX_RESYNCS: usize = 5;
 /// Maximum bytes to scan for magic bytes during resync.
@@ -101,17 +112,17 @@ pub struct Peer {
     /// Wrapped in Arc<Mutex<>> so running block listeners share the same slot.
     /// When `set_on_mempool_tx_data` updates this, all running listeners see the change
     /// immediately — no need to restart listeners.
-    pub on_mempool_tx_data: Arc<Mutex<Option<Arc<dyn Fn(Vec<u8>) + Send + Sync>>>>,
+    pub on_mempool_tx_data: MempoolTxCallback,
 
     /// Callback fired when an inv MSG_BLOCK arrives (new block mined).
     /// Signals the background sync loop to trigger an immediate sync instead
     /// of waiting for the 30s timer. Shared via Arc<Mutex<>> like on_mempool_tx_data.
-    pub on_new_block: Arc<Mutex<Option<Arc<dyn Fn() + Send + Sync>>>>,
+    pub on_new_block: NewBlockCallback,
 
     /// Callback fired when addr/addrv2 messages arrive with peer addresses.
     /// Used for peer discovery — harvested addresses feed into PeerManager's
     /// known_addresses pool for future connections.
-    pub on_addr: Arc<Mutex<Option<Arc<dyn Fn(Vec<(String, u16)>) + Send + Sync>>>>,
+    pub on_addr: AddrCallback,
 }
 
 impl Peer {
@@ -224,9 +235,11 @@ impl Peer {
         let cancel = CancellationToken::new();
         let cancel_clone = cancel.clone();
         let peer_id = self.id.clone();
-        let on_mempool_tx_data = self.on_mempool_tx_data.clone(); // shares the same Mutex slot
-        let on_new_block = self.on_new_block.clone();
-        let on_addr = self.on_addr.clone();
+        let callbacks = ListenerCallbacks {
+            on_mempool_tx_data: self.on_mempool_tx_data.clone(), // shares the same Mutex slot
+            on_new_block: self.on_new_block.clone(),
+            on_addr: self.on_addr.clone(),
+        };
 
         let handle = tokio::spawn(async move {
             block_listener_loop(
@@ -235,9 +248,7 @@ impl Peer {
                 dispatcher,
                 cancel_clone,
                 peer_id,
-                on_mempool_tx_data,
-                on_new_block,
-                on_addr,
+                callbacks,
             )
             .await;
         });
@@ -547,8 +558,8 @@ async fn do_handshake(
 
 /// Check if a protocol version is valid Zclassic (not Zcash).
 fn is_valid_zclassic_version(version: u32) -> bool {
-    (version >= MIN_PEER_PROTOCOL_VERSION && version <= MAX_ZCLASSIC_PROTOCOL_VERSION)
-        || (version >= ZCLASSIC_V2_MIN_VERSION && version <= ZCLASSIC_V2_MAX_VERSION)
+    (MIN_PEER_PROTOCOL_VERSION..=MAX_ZCLASSIC_PROTOCOL_VERSION).contains(&version)
+        || (ZCLASSIC_V2_MIN_VERSION..=ZCLASSIC_V2_MAX_VERSION).contains(&version)
 }
 
 /// Configure TCP keepalive and no-delay on a stream.
@@ -613,7 +624,7 @@ pub async fn receive_message_timeout(
                     tokio::time::timeout(timeout, reader.read_exact(&mut payload))
                         .await
                         .map_err(|_| NetworkError::ResponseTimeout)?
-                        .map_err(|e| NetworkError::Io(e))?;
+                        .map_err(NetworkError::Io)?;
                 }
 
                 // Verify checksum
@@ -682,9 +693,7 @@ async fn block_listener_loop(
     dispatcher: Arc<Mutex<Dispatcher>>,
     cancel: CancellationToken,
     peer_id: String,
-    on_mempool_tx_data: Arc<Mutex<Option<Arc<dyn Fn(Vec<u8>) + Send + Sync>>>>,
-    on_new_block: Arc<Mutex<Option<Arc<dyn Fn() + Send + Sync>>>>,
-    on_addr: Arc<Mutex<Option<Arc<dyn Fn(Vec<(String, u16)>) + Send + Sync>>>>,
+    callbacks: ListenerCallbacks,
 ) {
     dispatcher.lock().unwrap().set_active(true);
 
@@ -717,7 +726,7 @@ async fn block_listener_loop(
                                 eprintln!("[ZipherX] Peer {} exceeded rate limit ({} unsolicited msgs/min), disconnecting", peer_id, rl_count);
                                 break;
                             }
-                            handle_background_message(&cmd, &payload, &writer, &peer_id, &on_mempool_tx_data, &on_new_block, &on_addr).await;
+                            handle_background_message(&cmd, &payload, &writer, &peer_id, &callbacks).await;
                         }
                     }
                     Err(e) => {
@@ -739,15 +748,14 @@ async fn block_listener_loop(
 /// Event-driven mempool detection:
 /// - "inv" MSG_TX → immediately send getdata back to the peer
 /// - "tx" → fire `on_mempool_tx_data` callback with raw TX bytes
+///
 /// No separate task, no channel, no extra TCP connection.
 async fn handle_background_message(
     command: &str,
     payload: &[u8],
     writer: &Arc<Mutex<Option<OwnedWriteHalf>>>,
     _peer_id: &str,
-    on_mempool_tx_data: &Arc<Mutex<Option<Arc<dyn Fn(Vec<u8>) + Send + Sync>>>>,
-    on_new_block: &Arc<Mutex<Option<Arc<dyn Fn() + Send + Sync>>>>,
-    on_addr: &Arc<Mutex<Option<Arc<dyn Fn(Vec<(String, u16)>) + Send + Sync>>>>,
+    callbacks: &ListenerCallbacks,
 ) {
     match command {
         // ── Keepalive ──
@@ -770,7 +778,7 @@ async fn handle_background_message(
                         "[ZipherX] {}: inv MSG_BLOCK received — new block!",
                         _peer_id
                     );
-                    let cb = on_new_block.lock().unwrap().clone();
+                    let cb = callbacks.on_new_block.lock().unwrap().clone();
                     if let Some(cb) = cb {
                         cb();
                     } else {
@@ -782,7 +790,7 @@ async fn handle_background_message(
                 }
 
                 // MSG_TX: mempool detection — fetch TX for trial decryption
-                if on_mempool_tx_data.lock().unwrap().is_some() {
+                if callbacks.on_mempool_tx_data.lock().unwrap().is_some() {
                     let tx_items: Vec<crate::types::InvVector> = items
                         .into_iter()
                         .filter(|item| item.inv_type == crate::types::InvType::Tx)
@@ -797,15 +805,15 @@ async fn handle_background_message(
 
         // ── Transaction data (mempool detection) ──
         "tx" => {
-            let cb = on_mempool_tx_data.lock().unwrap().clone();
+            let cb = callbacks.on_mempool_tx_data.lock().unwrap().clone();
             if let Some(cb) = cb {
                 cb(payload.to_vec());
             }
         }
 
         // ── Peer address discovery ──
         "addr" => {
-            let cb = on_addr.lock().unwrap().clone();
+            let cb = callbacks.on_addr.lock().unwrap().clone();
             if let Some(cb) = cb {
                 if let Some(addrs) = crate::messages::deserialize_addr(payload) {
                     let peers: Vec<(String, u16)> = addrs
@@ -828,7 +836,7 @@ async fn handle_background_message(
             }
         }
         "addrv2" => {
-            let cb = on_addr.lock().unwrap().clone();
+            let cb = callbacks.on_addr.lock().unwrap().clone();
             if let Some(cb) = cb {
                 if let Some(addrs) = crate::messages::deserialize_addrv2(payload) {
                     let peers: Vec<(String, u16)> = addrs
@@ -953,7 +961,7 @@ mod tests {
         reader
             .read_exact(&mut header_buf)
             .await
-            .map_err(|e| NetworkError::Io(e))?;
+            .map_err(NetworkError::Io)?;
 
         let (command, payload_len, checksum) = protocol::parse_header(&header_buf)?;
         let len = payload_len as usize;
@@ -962,7 +970,7 @@ mod tests {
             reader
                 .read_exact(&mut payload)
                 .await
-                .map_err(|e| NetworkError::Io(e))?;
+                .map_err(NetworkError::Io)?;
         }
         assert!(protocol::verify_checksum(&payload, &checksum));
         Ok((command, payload))

crates/zipherx-network/src/peer_manager.rs

@@ -194,7 +194,7 @@ pub struct PeerManager {
     on_new_block: Option<Arc<dyn Fn() + Send + Sync>>,
 
     /// Callback fired when addr/addrv2 messages arrive with peer addresses.
-    on_addr: Option<Arc<dyn Fn(Vec<(String, u16)>) + Send + Sync>>,
+    on_addr: Option<AddrCallbackFn>,
 
     /// Live chain tip updated by block listener inv notifications.
     /// Tracks the minimum known chain height from inv MSG_BLOCK events.
@@ -265,7 +265,7 @@ impl PeerManager {
     }
 
     /// Set the addr/addrv2 callback for peer discovery. Distributes to all existing peers.
-    pub fn set_on_addr(&mut self, cb: Arc<dyn Fn(Vec<(String, u16)>) + Send + Sync>) {
+    pub fn set_on_addr(&mut self, cb: AddrCallbackFn) {
         self.on_addr = Some(cb.clone());
         for peer in self.peers.values() {
             *peer.on_addr.lock().unwrap() = Some(cb.clone());
@@ -655,14 +655,7 @@ impl PeerManager {
         // Count peers within 10 blocks of median
         let consensus_count = heights
             .iter()
-            .filter(|(_, h)| {
-                let diff = if *h > median_height {
-                    *h - median_height
-                } else {
-                    median_height - *h
-                };
-                diff <= 10
-            })
+            .filter(|(_, h)| (*h).abs_diff(median_height) <= 10)
             .count();
 
         if consensus_count < 2 {
@@ -977,7 +970,7 @@ impl PeerManager {
         use tokio::sync::oneshot;
 
         // Collect (peer_id, receiver) for all ready peers
-        let mut receivers: Vec<(String, oneshot::Receiver<(String, Vec<u8>)>)> = Vec::new();
+        let mut receivers: Vec<(String, oneshot::Receiver<MessagePayload>)> = Vec::new();
 
         let ready_ids: Vec<String> = self
             .get_ready_peers()
@@ -1185,13 +1178,13 @@ fn is_reserved_ip(ip: &str) -> bool {
                 .split('.')
                 .nth(1)
                 .and_then(|s| s.parse::<u8>().ok())
-                .map_or(false, |n| (16..=31).contains(&n)))
+                .is_some_and(|n| (16..=31).contains(&n)))
         || (ip.starts_with("100.")
             && ip
                 .split('.')
                 .nth(1)
                 .and_then(|s| s.parse::<u8>().ok())
-                .map_or(false, |n| (64..=127).contains(&n)))
+                .is_some_and(|n| (64..=127).contains(&n)))
 }
 
 #[cfg(test)]