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

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

Author: VictorLux

crates/zipherx-core/src/async_block_fetch.rs

@@ -78,7 +78,7 @@ pub async fn fetch_blocks_by_hashes(
 
     let blocks_per_round = (peer_count as u64) * MAX_BLOCKS_PER_PEER;
     let total = blocks_to_fetch.len();
-    let num_rounds = (total + blocks_per_round as usize - 1) / blocks_per_round as usize;
+    let num_rounds = total.div_ceil(blocks_per_round as usize);
 
     let mut all_blocks: Vec<CompactBlock> = Vec::new();
     let mut received_heights: HashSet<u64> = HashSet::new();

crates/zipherx-core/src/async_prover.rs

@@ -115,6 +115,7 @@ pub async fn ensure_prover_initialized(
 ///    expected hashes (SPEND_PARAMS_SHA256, OUTPUT_PARAMS_SHA256) ensures
 ///    content integrity — even if the TLS connection were compromised,
 ///    the hash mismatch would reject tampered data.
+///
 /// The hardcoded hashes are the same as those published by the Zcash team.
 async fn download_param_if_needed(
     path: &str,

crates/zipherx-core/src/async_send.rs

@@ -151,7 +151,7 @@ pub async fn send_transaction(
         if found {
             eprintln!("[ZipherX] Anchor OK for note {} (id={})", i, note.id);
         } else {
-            let anchor_hex = hex::encode(&anchor);
+            let anchor_hex = hex::encode(anchor);
             eprintln!(
                 "[ZipherX] ANCHOR INVALID for note {} (id={}): {} — not in any block header",
                 i, note.id, anchor_hex
@@ -374,10 +374,7 @@ async fn select_notes_with_witness_check(
         .map_err(|e| CoreError::RuntimeError(e.to_string()))?
         .map_err(|e| CoreError::Storage(e.to_string()))?;
 
-    let spendable: Vec<SpendableNote> = notes
-        .iter()
-        .filter_map(|n| send::note_to_spendable(n))
-        .collect();
+    let spendable: Vec<SpendableNote> = notes.iter().filter_map(send::note_to_spendable).collect();
 
     let (selected, total_value) =
         send::select_notes(&spendable, request.total_needed()).map_err(|_| {

crates/zipherx-core/src/async_sync.rs

@@ -508,7 +508,7 @@ pub async fn sync_to_tip(
     let headers_synced = header_sync
         .sync_headers(peer_manager, start_height, None, Some(progress_tx))
         .await
-        .map_err(|e| CoreError::Network(e))?;
+        .map_err(CoreError::Network)?;
 
     let _ = progress_forwarder.await;
 
@@ -580,7 +580,7 @@ pub async fn sync_to_tip(
 
         if total_output_blocks > 0 {
             let pacing = PacingConfig::default();
-            let num_chunks = (total_output_blocks + DELTA_CHUNK_SIZE - 1) / DELTA_CHUNK_SIZE;
+            let num_chunks = total_output_blocks.div_ceil(DELTA_CHUNK_SIZE);
             let mut grand_total_cmus: u64 = 0;
             let mut grand_total_nullifiers: u64 = 0;
             let mut chunks_completed: usize = 0;
@@ -921,8 +921,7 @@ pub async fn sync_to_tip(
                                 .parent()
                                 .map(|p| p.join("BoostCache").join("zipherx_boost_manifest.json"))
                                 .unwrap_or_default()
-                                .to_string_lossy()
-                                .to_string(),
+                                .to_string_lossy(),
                         ) {
                             let manifest_root_hex = &manifest.tree_root;
                             let blockchain_root_hex = hex::encode(&blockchain_root);
@@ -1645,7 +1644,7 @@ pub async fn sync_to_tip(
 
             let mut scan_offset = tree_height as usize;
             let mut current_tree_position = tree_height;
-            let num_scan_chunks = ((unscanned as usize) + SCAN_CHUNK_SIZE - 1) / SCAN_CHUNK_SIZE;
+            let num_scan_chunks = (unscanned as usize).div_ceil(SCAN_CHUNK_SIZE);
 
             eprintln!(
                 "[ZipherX] Scanning in {} chunks of up to {} outputs",
@@ -1687,8 +1686,11 @@ pub async fn sync_to_tip(
                 let chunk_nullifiers = delta_store
                     .load_nullifiers_for_height_range(first_height, last_height)
                     .map_err(|e| CoreError::Storage(e.to_string()))?;
-                let mut nullifier_map: std::collections::BTreeMap<u64, Vec<(Vec<u8>, Vec<u8>)>> =
-                    std::collections::BTreeMap::new();
+                #[allow(clippy::type_complexity)]
+                let mut nullifier_map: std::collections::BTreeMap<
+                    u64,
+                    Vec<(Vec<u8>, Vec<u8>)>,
+                > = std::collections::BTreeMap::new();
                 for nf in &chunk_nullifiers {
                     nullifier_map
                         .entry(nf.height as u64)
@@ -2138,7 +2140,7 @@ pub async fn sync_to_tip(
                 .map(|n| {
                     (
                         n.value,
-                        n.height as u64,
+                        n.height,
                         n.received_txid
                             .as_deref()
                             .unwrap_or("?")
@@ -2155,7 +2157,7 @@ pub async fn sync_to_tip(
                 .map(|n| {
                     (
                         n.value,
-                        n.height as u64,
+                        n.height,
                         n.received_txid
                             .as_deref()
                             .unwrap_or("?")
@@ -2305,6 +2307,7 @@ pub async fn sync_to_tip(
             let db_c = db.clone();
 
             // Collect data needed for nullifier recomputation
+            #[allow(clippy::type_complexity)]
             let notes_data: Vec<(
                 Vec<u8>,
                 Option<Vec<u8>>,
@@ -2517,10 +2520,10 @@ pub async fn sync_to_tip(
                 );
                 // Re-read balance after recovery
                 let db_bal = db.clone();
-                if let Ok(bal) = tokio::task::spawn_blocking(move || db_bal.get_balance(0)).await {
-                    if let Ok(spendable) = bal {
-                        eprintln!("[ZipherX] Post-recovery spendable balance: {}", spendable);
-                    }
+                if let Ok(Ok(spendable)) =
+                    tokio::task::spawn_blocking(move || db_bal.get_balance(0)).await
+                {
+                    eprintln!("[ZipherX] Post-recovery spendable balance: {}", spendable);
                 }
             }
             Ok(Err(e)) => {
@@ -2943,7 +2946,7 @@ pub async fn rebuild_witnesses_if_needed(
             commitment_tree::root().map_err(|e| CoreError::Crypto(format!("Tree root: {e}")))?;
         let rebuilt_size =
             commitment_tree::size().map_err(|e| CoreError::Crypto(format!("Tree size: {e}")))?;
-        let root_hex = hex::encode(&rebuilt_root);
+        let root_hex = hex::encode(rebuilt_root);
         let root_rev_hex = hex::encode(rebuilt_root.iter().rev().copied().collect::<Vec<u8>>());
         eprintln!(
             "[ZipherX] DIAG witness rebuild: tree_size={}, root={}",
@@ -2964,37 +2967,35 @@ pub async fn rebuild_witnesses_if_needed(
         );
 
         // Try to get the actual blockchain root at chain tip for comparison
-        if let Ok(tip) = _header_store.get_latest_height() {
-            if let Some(tip_height) = tip {
-                if let Ok(Some(blockchain_root)) = _header_store.get_sapling_root(tip_height) {
-                    let blockchain_hex = hex::encode(&blockchain_root);
-                    let blockchain_rev_hex =
-                        hex::encode(blockchain_root.iter().rev().copied().collect::<Vec<u8>>());
-                    eprintln!(
-                        "[ZipherX] DIAG: blockchain root at tip {}: {}",
-                        tip_height, blockchain_hex,
-                    );
-                    eprintln!(
-                        "[ZipherX] DIAG: blockchain root reversed: {}",
-                        blockchain_rev_hex,
-                    );
-                    if root_hex == blockchain_hex
-                        || root_hex == blockchain_rev_hex
-                        || root_rev_hex == blockchain_hex
-                        || root_rev_hex == blockchain_rev_hex
-                    {
-                        eprintln!("[ZipherX] DIAG: *** ROOT MATCHES (byte order issue in contains_sapling_root) ***");
-                    } else {
-                        eprintln!(
-                            "[ZipherX] DIAG: *** ROOT MISMATCH — delta CMUs incomplete or boost file corrupted ***",
-                        );
-                    }
+        if let Ok(Some(tip_height)) = _header_store.get_latest_height() {
+            if let Ok(Some(blockchain_root)) = _header_store.get_sapling_root(tip_height) {
+                let blockchain_hex = hex::encode(&blockchain_root);
+                let blockchain_rev_hex =
+                    hex::encode(blockchain_root.iter().rev().copied().collect::<Vec<u8>>());
+                eprintln!(
+                    "[ZipherX] DIAG: blockchain root at tip {}: {}",
+                    tip_height, blockchain_hex,
+                );
+                eprintln!(
+                    "[ZipherX] DIAG: blockchain root reversed: {}",
+                    blockchain_rev_hex,
+                );
+                if root_hex == blockchain_hex
+                    || root_hex == blockchain_rev_hex
+                    || root_rev_hex == blockchain_hex
+                    || root_rev_hex == blockchain_rev_hex
+                {
+                    eprintln!("[ZipherX] DIAG: *** ROOT MATCHES (byte order issue in contains_sapling_root) ***");
                 } else {
                     eprintln!(
-                        "[ZipherX] DIAG: no sapling root in header store at tip {}",
-                        tip_height
+                        "[ZipherX] DIAG: *** ROOT MISMATCH — delta CMUs incomplete or boost file corrupted ***",
                     );
                 }
+            } else {
+                eprintln!(
+                    "[ZipherX] DIAG: no sapling root in header store at tip {}",
+                    tip_height
+                );
             }
         }
     }
@@ -3613,7 +3614,7 @@ async fn boost_scan_if_needed(
             .unwrap_or(&tree_data_for_validation);
         match commitment_tree::root_from_serialized(tree_stripped) {
             Ok(root_bytes) => {
-                let root_hex = hex::encode(&root_bytes);
+                let root_hex = hex::encode(root_bytes);
                 eprintln!(
                     "[ZipherX] DIAG tree root validation: boost tree root = {}",
                     root_hex,
@@ -3721,6 +3722,7 @@ async fn post_boost_delta_scan(
         .map_err(|e| CoreError::Storage(e.to_string()))?;
 
     // Build height → nullifiers map for CompactBlock reconstruction
+    #[allow(clippy::type_complexity)]
     let mut nullifier_map: std::collections::BTreeMap<u64, Vec<(Vec<u8>, Vec<u8>)>> =
         std::collections::BTreeMap::new();
     for nf in &post_boost_nullifiers {
@@ -4207,19 +4209,25 @@ async fn post_boost_full_block_scan(
                 // RC-2: Spending key clone — zeroized after nullifier recompute.
                 let sk = sk_bytes.to_vec();
                 let db_clone = db.clone();
-                let notes_data: Vec<(Vec<u8>, Option<Vec<u8>>, u64, Option<Vec<u8>>, Option<u64>)> =
-                    post_boost_notes
-                        .iter()
-                        .map(|n| {
-                            (
-                                n.cmu.clone(),
-                                n.diversifier.clone(),
-                                n.value,
-                                n.rcm.clone(),
-                                n.position,
-                            )
-                        })
-                        .collect();
+                #[allow(clippy::type_complexity)]
+                let notes_data: Vec<(
+                    Vec<u8>,
+                    Option<Vec<u8>>,
+                    u64,
+                    Option<Vec<u8>>,
+                    Option<u64>,
+                )> = post_boost_notes
+                    .iter()
+                    .map(|n| {
+                        (
+                            n.cmu.clone(),
+                            n.diversifier.clone(),
+                            n.value,
+                            n.rcm.clone(),
+                            n.position,
+                        )
+                    })
+                    .collect();
                 let cmu_map = cmu_position_map;
 
                 let fixed_count = tokio::task::spawn_blocking(move || -> Result<u32, CoreError> {
@@ -4584,7 +4592,7 @@ async fn post_boost_full_block_scan(
                     }
 
                     for (txid_hex, (total_value, height)) in &spends_by_tx {
-                        let block_ts = ts_map2.get(&(*height as u64)).map(|&t| t as u64);
+                        let block_ts = ts_map2.get(height).map(|&t| t as u64);
                         let _ = db_clone.insert_transaction(
                             txid_hex,
                             *height,
@@ -4787,7 +4795,7 @@ async fn post_boost_full_block_scan(
             // Get combined root
             let combined_root = commitment_tree::root()
                 .map_err(|e| CoreError::Crypto(format!("Tree root: {e}")))?;
-            let combined_root_hex = hex::encode(&combined_root);
+            let combined_root_hex = hex::encode(combined_root);
 
             eprintln!(
                 "[ZipherX] Combined tree: size={}, root={}",
@@ -5026,19 +5034,25 @@ async fn post_boost_full_block_scan(
                 // RC-2: Spending key clone — zeroized after nullifier recompute.
                 let sk = sk_bytes.to_vec();
                 let db_clone = db.clone();
-                let notes_data: Vec<(Vec<u8>, Option<Vec<u8>>, u64, Option<Vec<u8>>, Option<u64>)> =
-                    post_boost_unspent
-                        .iter()
-                        .map(|n| {
-                            (
-                                n.cmu.clone(),
-                                n.diversifier.clone(),
-                                n.value,
-                                n.rcm.clone(),
-                                n.position,
-                            )
-                        })
-                        .collect();
+                #[allow(clippy::type_complexity)]
+                let notes_data: Vec<(
+                    Vec<u8>,
+                    Option<Vec<u8>>,
+                    u64,
+                    Option<Vec<u8>>,
+                    Option<u64>,
+                )> = post_boost_unspent
+                    .iter()
+                    .map(|n| {
+                        (
+                            n.cmu.clone(),
+                            n.diversifier.clone(),
+                            n.value,
+                            n.rcm.clone(),
+                            n.position,
+                        )
+                    })
+                    .collect();
                 let cmu_map = cmu_position_map;
 
                 let fixed_count = tokio::task::spawn_blocking(move || -> Result<u32, CoreError> {
@@ -5473,6 +5487,7 @@ async fn scan_blocks_for_pending_txs(
 /// Groups DeltaOutput records by block height and includes nullifier spends
 /// from the height-indexed map. Used by the catch-up scan to feed delta
 /// store data into the block scanner.
+#[allow(clippy::type_complexity)]
 fn reconstruct_compact_blocks(
     outputs: &[DeltaOutput],
     nullifier_map: &std::collections::BTreeMap<u64, Vec<(Vec<u8>, Vec<u8>)>>,

crates/zipherx-core/src/async_wallet.rs

@@ -116,7 +116,7 @@ impl AsyncWallet {
         let mut pm = self.peer_manager.lock().await;
         pm.connect_with_counter(Some(&self.connected_peer_count))
             .await
-            .map_err(|e| CoreError::Network(e))?;
+            .map_err(CoreError::Network)?;
         // Final update in case connect_with_counter missed any edge case
         self.connected_peer_count
             .store(pm.connected_count() as u32, Ordering::Relaxed);

crates/zipherx-core/src/mempool_monitor.rs

@@ -4,6 +4,7 @@
 //! - Peer receives "inv" MSG_TX → sends getdata → receives "tx" response
 //! - Block listener fires `on_mempool_tx_data` callback with raw TX bytes
 //! - This module trial-decrypts Sapling outputs and notifies the UI
+//!
 //! No separate task, no channel, no extra TCP connection.
 
 use std::collections::HashSet;