Fix rustfmt/clippy issues

Author: Ash-L2L

lib/authorization.rs

@@ -12,8 +12,6 @@ use crate::types::{
     get_address,
 };
 
-use hex;
-
 fn borsh_serialize_verifying_key<W>(
     vk: &VerifyingKey,
     writer: &mut W,
@@ -148,7 +146,7 @@ impl utoipa::ToSchema for Authorization {
 
 impl utoipa::PartialSchema for Authorization {
     fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
-        use utoipa::openapi::*;
+        use utoipa::openapi::{Object, RefOr, Schema, schema};
         let obj = Object::builder()
             .property(
                 "verifying_key",

lib/bench.rs

@@ -3,6 +3,8 @@
 
 use criterion::{Criterion, criterion_group, criterion_main};
 
+#[allow(dead_code, unused_imports)]
+mod authorization;
 #[allow(dead_code)]
 mod state;
 #[allow(dead_code)]

lib/state/bench.rs

@@ -12,10 +12,11 @@ use sneed::{Env, EnvError};
 #[cfg(feature = "utreexo")]
 use crate::types::{Accumulator, AccumulatorDiff};
 use crate::{
+    authorization::Authorization,
     state::State,
     types::{
-        Address, Authorization, Block, Body, FilledTransaction, GetValue as _,
-        Header, MerkleRoot, OutPoint, Output, OutputContent, PointedOutputRef,
+        Address, Block, Body, FilledTransaction, GetValue as _, Header,
+        MerkleRoot, OutPoint, Output, OutputContent, PointedOutputRef,
         Transaction, hash,
         proto::mainchain::{self, TwoWayPegData},
     },

lib/state/block.rs

@@ -434,6 +434,7 @@ pub fn connect_prevalidated(
     }
 
     // Parallel collection of transaction operations
+    #[allow(clippy::type_complexity)]
     let tx_results: Vec<(
         Vec<OutPoint>,
         Vec<(OutPoint, SpentOutput)>,
@@ -484,6 +485,7 @@ pub fn connect_prevalidated(
         .collect();
 
     // Separate the three vectors
+    #[allow(clippy::type_complexity)]
     let (tx_deletes, tx_stxo_puts, tx_utxo_puts): (
         Vec<Vec<OutPoint>>,
         Vec<Vec<(OutPoint, SpentOutput)>>,

lib/state/mod.rs

@@ -71,12 +71,12 @@ impl MemoryPools {
 
     /// Get a pre-allocated vector or create a new one
     fn get_outpoint_key_vec(&self, capacity: usize) -> Vec<OutPointKey> {
-        if let Ok(mut pool) = self.outpoint_key_pool.lock() {
-            if let Some(mut vec) = pool.pop() {
-                vec.clear();
-                vec.reserve(capacity);
-                return vec;
-            }
+        if let Ok(mut pool) = self.outpoint_key_pool.lock()
+            && let Some(mut vec) = pool.pop()
+        {
+            vec.clear();
+            vec.reserve(capacity);
+            return vec;
         }
         Vec::with_capacity(capacity)
     }
@@ -87,11 +87,11 @@ impl MemoryPools {
             // Prevent excessive memory usage
             vec.shrink_to(1024);
         }
-        if let Ok(mut pool) = self.outpoint_key_pool.lock() {
-            if pool.len() < 8 {
-                // Limit pool size
-                pool.push(vec);
-            }
+        if let Ok(mut pool) = self.outpoint_key_pool.lock()
+            && pool.len() < 8
+        {
+            // Limit pool size
+            pool.push(vec);
         }
     }
 }
@@ -697,7 +697,7 @@ impl State {
         let results = Arc::new(Mutex::new(vec![None; blocks.len()]));
         let error_occurred = Arc::new(Mutex::new(None));
 
-        let chunk_size = (blocks.len() + num_workers - 1) / num_workers;
+        let chunk_size = blocks.len().div_ceil(num_workers);
         let mut handles = Vec::new();
 
         for worker_id in 0..num_workers {
@@ -768,8 +768,7 @@ impl State {
         let results = Arc::try_unwrap(results).unwrap().into_inner().unwrap();
         let results: Result<Vec<_>, _> = results
             .into_iter()
-            .enumerate()
-            .map(|(_i, opt)| opt.ok_or(Error::Authorization))
+            .map(|opt| opt.ok_or(Error::Authorization))
             .collect();
 
         results

lib/state/parallel.rs

@@ -170,7 +170,7 @@ impl ValidationWorker {
                 };
                 let key = OutPointKey::from(&outpoint);
                 let serialized = borsh::to_vec(output)
-                    .map_err(|e| crate::state::Error::BorshSerialize(e))?;
+                    .map_err(crate::state::Error::BorshSerialize)?;
                 Ok::<(OutPointKey, Vec<u8>), crate::state::Error>((
                     key, serialized,
                 ))
@@ -283,7 +283,7 @@ impl ValidationWorker {
             };
 
             // Send result to Stage B coordinator
-            if let Err(_) = self.result_sender.send(validation_result) {
+            if self.result_sender.send(validation_result).is_err() {
                 tracing::warn!(
                     "Worker {} failed to send result - coordinator may have shut down",
                     self.worker_id
@@ -512,7 +512,7 @@ impl WriterCoordinator {
             // Deserialize the SpentOutput to use with the typed database
             let spent_output: SpentOutput =
                 borsh::from_slice(serialized_spent_output)
-                    .map_err(|e| Error::BorshDeserialize(e))?;
+                    .map_err(Error::BorshDeserialize)?;
             self.state.stxos.put(rwtxn, key, &spent_output)?;
         }
 
@@ -521,7 +521,7 @@ impl WriterCoordinator {
             // Deserialize the Output to use with the typed database
             let output: crate::types::Output =
                 borsh::from_slice(serialized_output)
-                    .map_err(|e| Error::BorshDeserialize(e))?;
+                    .map_err(Error::BorshDeserialize)?;
             self.state.utxos.put(rwtxn, key, &output)?;
         }
 
@@ -554,7 +554,7 @@ impl ParallelBlockProcessor {
         env: Arc<Env>,
         num_workers: usize,
     ) -> Result<Self, Error> {
-        let num_workers = num_workers.min(MAX_PARALLEL_BLOCKS).max(1);
+        let num_workers = num_workers.clamp(1, MAX_PARALLEL_BLOCKS);
 
         // Create channels for Stage A (parallel workers)
         let mut work_senders = Vec::with_capacity(num_workers);
@@ -713,13 +713,10 @@ impl Drop for ParallelBlockProcessor {
             self.work_senders.clear();
 
             // Wait for coordinator if still running
-            if let Some(coordinator_handle) = self.coordinator_handle.take() {
-                if let Err(e) = coordinator_handle.join() {
-                    tracing::error!(
-                        "Coordinator panicked during drop: {:?}",
-                        e
-                    );
-                }
+            if let Some(coordinator_handle) = self.coordinator_handle.take()
+                && let Err(e) = coordinator_handle.join()
+            {
+                tracing::error!("Coordinator panicked during drop: {:?}", e);
             }
         }
     }
@@ -832,17 +829,17 @@ mod tests {
         };
 
         // Test coordination logic
-        if let Some(work) = pending_work.remove(&result.block_id) {
-            if result.result.is_ok() {
-                let pending = PendingBlock {
-                    block_id: work.block_id,
-                    header: work.header,
-                    body: work.body,
-                    prevalidated: result.result.unwrap(),
-                    serialized_data: result.serialized_data,
-                };
-                pending_blocks.insert(work.block_id, pending);
-            }
+        if let Some(work) = pending_work.remove(&result.block_id)
+            && result.result.is_ok()
+        {
+            let pending = PendingBlock {
+                block_id: work.block_id,
+                header: work.header,
+                body: work.body,
+                prevalidated: result.result.unwrap(),
+                serialized_data: result.serialized_data,
+            };
+            pending_blocks.insert(work.block_id, pending);
         }
 
         assert_eq!(pending_blocks.len(), 1);
@@ -900,6 +897,7 @@ mod tests {
 
     /// Integration test demonstrating Phase 1, 2, and 3 optimization compatibility
     #[test]
+    #[allow(clippy::assertions_on_constants)]
     fn test_phase_integration() {
         // This test validates that Phase 3 parallel processing integrates
         // correctly with Phase 1 (sorted operations) and Phase 2 (memory pools)
@@ -916,7 +914,7 @@ mod tests {
         assert_eq!(memory_pool.capacity(), 100);
 
         // Phase 3: Parallel processing maintains data integrity
-        let block_ids = vec![0, 1, 2, 3, 4];
+        let block_ids = [0, 1, 2, 3, 4];
         let processed_in_parallel =
             block_ids.iter().map(|&id| id * 2).collect::<Vec<_>>();
         assert_eq!(processed_in_parallel, vec![0, 2, 4, 6, 8]);

lib/wallet.rs

@@ -9,7 +9,6 @@ use ed25519_dalek_bip32::{ChildIndex, DerivationPath, ExtendedSigningKey};
 use fallible_iterator::FallibleIterator as _;
 use futures::{Stream, StreamExt};
 
-use crate::types::get_address;
 use heed::types::{Bytes, SerdeBincode, U8};
 #[cfg(feature = "utreexo")]
 use rustreexo::accumulator::node_hash::BitcoinNodeHash;
@@ -21,10 +20,10 @@ use sneed::{
 use tokio_stream::{StreamMap, wrappers::WatchStream};
 
 #[cfg(feature = "utreexo")]
-use crate::types::{Accumulator, UtreexoError, get_address};
+use crate::types::{Accumulator, UtreexoError};
 pub use crate::types::{
     Address, Authorization, AuthorizedTransaction, GetValue, InPoint, OutPoint,
-    OutPointKey, Output, OutputContent, SpentOutput, Transaction,
+    OutPointKey, Output, OutputContent, SpentOutput, Transaction, get_address,
 };
 use crate::{
     types::{