diff --git a/.github/strict-checks.json b/.github/strict-checks.json
deleted file mode 100644
index 16ac99b7b..000000000
--- a/.github/strict-checks.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-  "strict_check_crates": [
-    "key-wallet",
-    "key-wallet-manager",
-    "key-wallet-ffi",
-    "dash",
-    "hashes"
-  ],
-  "excluded_crates": [
-    "dash-network",
-    "dash-network-ffi",
-    "internals",
-    "fuzz",
-    "rpc-client",
-    "rpc-json",
-    "rpc-integration-test",
-    "dash-spv",
-    "dash-spv-ffi",
-    "test-utils"
-  ],
-  "comment": "Crates in strict_check_crates will fail CI on any warnings or clippy issues. Add or remove crates as needed."
-}
\ No newline at end of file
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index a4720aa7e..159dfd5ea 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -81,7 +81,7 @@ jobs:
       - name: Run clippy (excluding strict-checked crates)
         run: |
           # Auto-discover all workspace crates and exclude strict-checked ones
-          STRICT_CRATES=("key-wallet" "key-wallet-manager" "key-wallet-ffi" "dashcore_hashes" "dashcore")
+          STRICT_CRATES=("key-wallet" "key-wallet-manager" "key-wallet-ffi" "dashcore_hashes" "dashcore" "dash-spv" "dash-spv-ffi")
           mapfile -t ALL_CRATES < <(cargo metadata --no-deps --format-version=1 | jq -r '.packages[].name' | sort -u)
           for crate in "${ALL_CRATES[@]}"; do
             if printf '%s\n' "${STRICT_CRATES[@]}" | grep -qx "$crate"; then
@@ -163,6 +163,30 @@ jobs:
       
       - name: Clippy dashcore_hashes (deny all warnings)
         run: cargo clippy -p dashcore_hashes --all-features --lib --bins --tests -- -D warnings
+
+      # Check dash-spv with strict warnings
+      - name: Check dash-spv (deny warnings)
+        env:
+          RUSTFLAGS: "-D warnings"
+        run: |
+          cargo check -p dash-spv --all-features --lib --bins --tests
+          cargo build -p dash-spv --all-features --lib --bins
+          cargo test -p dash-spv --all-features --lib --bins
+
+      - name: Clippy dash-spv (deny all warnings)
+        run: cargo clippy -p dash-spv --all-features --lib --bins --tests -- -D warnings
+
+      # Check dash-spv-ffi with strict warnings
+      - name: Check dash-spv-ffi (deny warnings)
+        env:
+          RUSTFLAGS: "-D warnings"
+        run: |
+          cargo check -p dash-spv-ffi --all-features --lib --bins --tests
+          cargo build -p dash-spv-ffi --all-features --lib --bins
+          cargo test -p dash-spv-ffi --all-features --lib --bins
+
+      - name: Clippy dash-spv-ffi (deny all warnings)
+        run: cargo clippy -p dash-spv-ffi --all-features --lib --bins --tests -- -D warnings
   
   fmt:
     name: Format
diff --git a/dash-spv/src/chain/chain_tip.rs b/dash-spv/src/chain/chain_tip.rs
index fe7a628df..2e95d786f 100644
--- a/dash-spv/src/chain/chain_tip.rs
+++ b/dash-spv/src/chain/chain_tip.rs
@@ -101,7 +101,7 @@ impl ChainTipManager {
             Err(e) => {
                 // Restore the old tip if adding the new one failed
                 if let Some(tip) = old_tip {
-                    self.tips.insert(tip_hash.clone(), tip);
+                    self.tips.insert(*tip_hash, tip);
                 }
                 Err(e)
             }
diff --git a/dash-spv/src/chain/chainlock_manager.rs b/dash-spv/src/chain/chainlock_manager.rs
index 789e0db03..049c5aeac 100644
--- a/dash-spv/src/chain/chainlock_manager.rs
+++ b/dash-spv/src/chain/chainlock_manager.rs
@@ -189,59 +189,60 @@ impl ChainLockManager {
         }
 
         // Full validation with masternode engine if available
-        let engine_guard = self
-            .masternode_engine
-            .read()
-            .map_err(|_| ValidationError::InvalidChainLock("Lock poisoned".to_string()))?;
-
         let mut validated = false;
+        {
+            let engine_guard = self
+                .masternode_engine
+                .read()
+                .map_err(|_| ValidationError::InvalidChainLock("Lock poisoned".to_string()))?;
 
-        if let Some(engine) = engine_guard.as_ref() {
-            // Use the masternode engine's verify_chain_lock method
-            match engine.verify_chain_lock(&chain_lock) {
-                Ok(()) => {
-                    info!(
-                        "✅ ChainLock validated with masternode engine for height {}",
-                        chain_lock.block_height
-                    );
-                    validated = true;
-                }
-                Err(e) => {
-                    // Check if the error is due to missing masternode lists
-                    let error_string = e.to_string();
-                    if error_string.contains("No masternode lists in engine") {
-                        // ChainLock validation requires masternode list at (block_height - CHAINLOCK_VALIDATION_MASTERNODE_OFFSET)
-                        let required_height = chain_lock
-                            .block_height
-                            .saturating_sub(CHAINLOCK_VALIDATION_MASTERNODE_OFFSET);
-                        warn!("⚠️ Masternode engine exists but lacks required masternode lists for height {} (needs list at height {} for ChainLock validation), queueing ChainLock for later validation", 
-                            chain_lock.block_height, required_height);
-                        drop(engine_guard); // Release the read lock before acquiring write lock
-                        self.queue_pending_chainlock(chain_lock.clone()).map_err(|e| {
-                            ValidationError::InvalidChainLock(format!(
-                                "Failed to queue pending ChainLock: {}",
+            if let Some(engine) = engine_guard.as_ref() {
+                // Use the masternode engine's verify_chain_lock method
+                match engine.verify_chain_lock(&chain_lock) {
+                    Ok(()) => {
+                        info!(
+                            "✅ ChainLock validated with masternode engine for height {}",
+                            chain_lock.block_height
+                        );
+                        validated = true;
+                    }
+                    Err(e) => {
+                        // Check if the error is due to missing masternode lists
+                        let error_string = e.to_string();
+                        if error_string.contains("No masternode lists in engine") {
+                            // ChainLock validation requires masternode list at (block_height - CHAINLOCK_VALIDATION_MASTERNODE_OFFSET)
+                            let required_height = chain_lock
+                                .block_height
+                                .saturating_sub(CHAINLOCK_VALIDATION_MASTERNODE_OFFSET);
+                            warn!("⚠️ Masternode engine exists but lacks required masternode lists for height {} (needs list at height {} for ChainLock validation), queueing ChainLock for later validation", 
+                                chain_lock.block_height, required_height);
+                            self.queue_pending_chainlock(chain_lock.clone()).map_err(|e| {
+                                ValidationError::InvalidChainLock(format!(
+                                    "Failed to queue pending ChainLock: {}",
+                                    e
+                                ))
+                            })?;
+                        } else {
+                            return Err(ValidationError::InvalidChainLock(format!(
+                                "MasternodeListEngine validation failed: {:?}",
                                 e
-                            ))
-                        })?;
-                    } else {
-                        return Err(ValidationError::InvalidChainLock(format!(
-                            "MasternodeListEngine validation failed: {:?}",
-                            e
-                        )));
+                            )));
+                        }
                     }
                 }
+            } else {
+                // Queue for later validation when engine becomes available
+                warn!(
+                    "⚠️ Masternode engine not available, queueing ChainLock for later validation"
+                );
+                self.queue_pending_chainlock(chain_lock.clone()).map_err(|e| {
+                    ValidationError::InvalidChainLock(format!(
+                        "Failed to queue pending ChainLock: {}",
+                        e
+                    ))
+                })?;
             }
-        } else {
-            // Queue for later validation when engine becomes available
-            warn!("⚠️ Masternode engine not available, queueing ChainLock for later validation");
-            drop(engine_guard); // Release the read lock before acquiring write lock
-            self.queue_pending_chainlock(chain_lock.clone()).map_err(|e| {
-                ValidationError::InvalidChainLock(format!(
-                    "Failed to queue pending ChainLock: {}",
-                    e
-                ))
-            })?;
-        }
+        } // engine_guard dropped before any await
 
         // Store the chain lock with appropriate validation status
         self.store_chain_lock_with_validation(chain_lock.clone(), storage, validated).await?;
diff --git a/dash-spv/src/chain/checkpoints.rs b/dash-spv/src/chain/checkpoints.rs
index 47ce287f7..df8b77737 100644
--- a/dash-spv/src/chain/checkpoints.rs
+++ b/dash-spv/src/chain/checkpoints.rs
@@ -60,7 +60,7 @@ impl Checkpoint {
 }
 
 /// Checkpoint override settings
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct CheckpointOverride {
     /// Override checkpoint height for sync chain
     pub sync_override_height: Option<u32>,
@@ -70,16 +70,6 @@ pub struct CheckpointOverride {
     pub sync_from_genesis: bool,
 }
 
-impl Default for CheckpointOverride {
-    fn default() -> Self {
-        Self {
-            sync_override_height: None,
-            terminal_override_height: None,
-            sync_from_genesis: false,
-        }
-    }
-}
-
 /// Manages checkpoints for a specific network
 pub struct CheckpointManager {
     /// Checkpoints indexed by height
@@ -147,7 +137,7 @@ impl CheckpointManager {
 
     /// Check if we're past the last checkpoint
     pub fn is_past_last_checkpoint(&self, height: u32) -> bool {
-        self.sorted_heights.last().map_or(true, |&last| height > last)
+        self.sorted_heights.last().is_none_or(|&last| height > last)
     }
 
     /// Get the last checkpoint before a given timestamp
diff --git a/dash-spv/src/chain/fork_detector.rs b/dash-spv/src/chain/fork_detector.rs
index 33cdf1c0b..f8dfa2822 100644
--- a/dash-spv/src/chain/fork_detector.rs
+++ b/dash-spv/src/chain/fork_detector.rs
@@ -108,15 +108,16 @@ impl ForkDetector {
         // Check if this connects to the main chain (creates new fork)
         if let Ok(Some(height)) = storage.get_header_height(&prev_hash) {
             // Check if this would create a fork from before our checkpoint
-            if chain_state.synced_from_checkpoint && chain_state.sync_base_height > 0 {
-                if height < chain_state.sync_base_height {
-                    tracing::warn!(
+            if chain_state.synced_from_checkpoint
+                && chain_state.sync_base_height > 0
+                && height < chain_state.sync_base_height
+            {
+                tracing::warn!(
                         "Rejecting header that would create fork from height {} (before checkpoint base {}). \
                         This likely indicates headers from genesis were received during checkpoint sync.",
                         height, chain_state.sync_base_height
                     );
-                    return ForkDetectionResult::Orphan;
-                }
+                return ForkDetectionResult::Orphan;
             }
 
             // Found connection point - this creates a new fork
diff --git a/dash-spv/src/chain/orphan_pool.rs b/dash-spv/src/chain/orphan_pool.rs
index 94de7086c..f3f81673a 100644
--- a/dash-spv/src/chain/orphan_pool.rs
+++ b/dash-spv/src/chain/orphan_pool.rs
@@ -101,7 +101,7 @@ impl OrphanPool {
                         if let Some(orphan) = self.orphans_by_hash.get_mut(&o.header.block_hash()) {
                             orphan.process_attempts += 1;
                         }
-                        o.header.clone()
+                        o.header
                     })
                     .collect()
             })
diff --git a/dash-spv/src/client/block_processor.rs b/dash-spv/src/client/block_processor.rs
index 1970ceb89..fe7129905 100644
--- a/dash-spv/src/client/block_processor.rs
+++ b/dash-spv/src/client/block_processor.rs
@@ -13,11 +13,11 @@ use key_wallet_manager::wallet_interface::WalletInterface;
 #[derive(Debug)]
 pub enum BlockProcessingTask {
     ProcessBlock {
-        block: dashcore::Block,
+        block: Box<dashcore::Block>,
         response_tx: oneshot::Sender<Result<()>>,
     },
     ProcessTransaction {
-        tx: dashcore::Transaction,
+        tx: Box<dashcore::Transaction>,
         response_tx: oneshot::Sender<Result<()>>,
     },
     ProcessCompactFilter {
@@ -126,7 +126,7 @@ impl<W: WalletInterface + Send + Sync + 'static, S: StorageManager + Send + Sync
                     }
 
                     // Process block and handle errors
-                    let result = self.process_block_internal(block).await;
+                    let result = self.process_block_internal(*block).await;
 
                     match &result {
                         Ok(()) => {
@@ -160,7 +160,7 @@ impl<W: WalletInterface + Send + Sync + 'static, S: StorageManager + Send + Sync
                     response_tx,
                 } => {
                     let txid = tx.txid();
-                    let result = self.process_transaction_internal(tx).await;
+                    let result = self.process_transaction_internal(*tx).await;
 
                     if let Err(e) = &result {
                         tracing::error!("❌ TRANSACTION PROCESSING FAILED for tx {}: {}", txid, e);
diff --git a/dash-spv/src/client/block_processor_test.rs b/dash-spv/src/client/block_processor_test.rs
index ef2eac760..3251b5811 100644
--- a/dash-spv/src/client/block_processor_test.rs
+++ b/dash-spv/src/client/block_processor_test.rs
@@ -108,7 +108,7 @@ mod tests {
         let (response_tx, _response_rx) = oneshot::channel();
         task_tx
             .send(BlockProcessingTask::ProcessBlock {
-                block: block.clone(),
+                block: Box::new(block.clone()),
                 response_tx,
             })
             .unwrap();
@@ -135,9 +135,6 @@ mod tests {
         // Verify wallet was called
         {
             let wallet = wallet.read().await;
-            // Since we're using key_wallet_manager::wallet_interface::WalletInterface,
-            // we need to use the trait to access as_any
-            use key_wallet_manager::wallet_interface::WalletInterface;
             let processed = wallet.processed_blocks.lock().await;
             assert_eq!(processed.len(), 1);
             assert_eq!(processed[0].0, block_hash);
@@ -300,7 +297,7 @@ mod tests {
         let (response_tx, _response_rx) = oneshot::channel();
         task_tx
             .send(BlockProcessingTask::ProcessTransaction {
-                tx: tx.clone(),
+                tx: Box::new(tx.clone()),
                 response_tx,
             })
             .unwrap();
@@ -354,7 +351,7 @@ mod tests {
         let (response_tx, _response_rx) = oneshot::channel();
         task_tx
             .send(BlockProcessingTask::ProcessBlock {
-                block: block.clone(),
+                block: Box::new(block.clone()),
                 response_tx,
             })
             .unwrap();
diff --git a/dash-spv/src/client/message_handler.rs b/dash-spv/src/client/message_handler.rs
index 96ea9ec5d..65120620e 100644
--- a/dash-spv/src/client/message_handler.rs
+++ b/dash-spv/src/client/message_handler.rs
@@ -236,7 +236,7 @@ impl<
                         // Emit event
                         let event = SpvEvent::MempoolTransactionAdded {
                             txid,
-                            transaction: tx,
+                            transaction: Box::new(tx),
                             amount,
                             addresses,
                             is_instant_send,
@@ -495,7 +495,7 @@ impl<
         // Send block to the background processor without waiting for completion
         let (response_tx, _response_rx) = tokio::sync::oneshot::channel();
         let task = crate::client::BlockProcessingTask::ProcessBlock {
-            block,
+            block: Box::new(block),
             response_tx,
         };
 
diff --git a/dash-spv/src/client/mod.rs b/dash-spv/src/client/mod.rs
index 4cabe073d..ebb6e07de 100644
--- a/dash-spv/src/client/mod.rs
+++ b/dash-spv/src/client/mod.rs
@@ -1136,7 +1136,7 @@ impl<
         // Send block to the background processor without waiting for completion
         let (response_tx, _response_rx) = tokio::sync::oneshot::channel();
         let task = BlockProcessingTask::ProcessBlock {
-            block,
+            block: Box::new(block),
             response_tx,
         };
 
diff --git a/dash-spv/src/mempool_filter.rs b/dash-spv/src/mempool_filter.rs
index 986cc7070..00191a8f2 100644
--- a/dash-spv/src/mempool_filter.rs
+++ b/dash-spv/src/mempool_filter.rs
@@ -206,8 +206,9 @@ mod tests {
     #[derive(Clone)]
     enum WatchItem {
         Address(Address),
-        Script(ScriptBuf),
-        Outpoint(OutPoint),
+        // Keep placeholders as unit to avoid dead_code warnings
+        Script(()),
+        Outpoint(()),
     }
 
     impl WatchItem {
@@ -219,27 +220,23 @@ mod tests {
             WatchItem::Address(addr)
         }
 
-        fn script(script: ScriptBuf) -> Self {
-            WatchItem::Script(script)
+        fn script(_script: ScriptBuf) -> Self {
+            WatchItem::Script(())
         }
 
-        fn outpoint(outpoint: OutPoint) -> Self {
-            WatchItem::Outpoint(outpoint)
+        fn outpoint(_outpoint: OutPoint) -> Self {
+            WatchItem::Outpoint(())
         }
     }
 
     struct MockWallet {
-        network: Network,
         watched_addresses: HashSet<Address>,
-        utxos: HashSet<OutPoint>,
     }
 
     impl MockWallet {
-        fn new(network: Network) -> Self {
+        fn new(_network: Network) -> Self {
             Self {
-                network,
                 watched_addresses: HashSet::new(),
-                utxos: HashSet::new(),
             }
         }
 
@@ -247,17 +244,7 @@ mod tests {
             self.watched_addresses.insert(address);
         }
 
-        fn network(&self) -> &Network {
-            &self.network
-        }
-
-        fn watched_addresses(&self) -> &HashSet<Address> {
-            &self.watched_addresses
-        }
-
-        fn utxos(&self) -> &HashSet<OutPoint> {
-            &self.utxos
-        }
+        // Accessor omitted; tests use add_watched_address directly
     }
 
     // Helper to create deterministically generated test addresses
diff --git a/dash-spv/src/network/connection.rs b/dash-spv/src/network/connection.rs
index cd4313f34..b5082be2f 100644
--- a/dash-spv/src/network/connection.rs
+++ b/dash-spv/src/network/connection.rs
@@ -513,12 +513,9 @@ impl TcpConnection {
         drop(state);
 
         // Handle disconnection if needed
-        match &result {
-            Err(NetworkError::PeerDisconnected) => {
-                self.state = None;
-                self.connected_at = None;
-            }
-            _ => {}
+        if let Err(NetworkError::PeerDisconnected) = &result {
+            self.state = None;
+            self.connected_at = None;
         }
 
         result
diff --git a/dash-spv/src/network/message_handler.rs b/dash-spv/src/network/message_handler.rs
index a02df67f9..a9fa3274a 100644
--- a/dash-spv/src/network/message_handler.rs
+++ b/dash-spv/src/network/message_handler.rs
@@ -10,6 +10,12 @@ pub struct MessageHandler {
     stats: MessageStats,
 }
 
+impl Default for MessageHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl MessageHandler {
     /// Create a new message handler.
     pub fn new() -> Self {
diff --git a/dash-spv/src/network/mod.rs b/dash-spv/src/network/mod.rs
index 3fd193a2f..c7cb9e795 100644
--- a/dash-spv/src/network/mod.rs
+++ b/dash-spv/src/network/mod.rs
@@ -238,7 +238,7 @@ impl NetworkManager for TcpNetworkManager {
     }
 
     fn is_connected(&self) -> bool {
-        self.connection.as_ref().map_or(false, |c| c.is_connected())
+        self.connection.as_ref().is_some_and(|c| c.is_connected())
     }
 
     fn peer_count(&self) -> usize {
@@ -285,7 +285,7 @@ impl NetworkManager for TcpNetworkManager {
     }
 
     fn should_ping(&self) -> bool {
-        self.connection.as_ref().map_or(false, |c| c.should_ping())
+        self.connection.as_ref().is_some_and(|c| c.should_ping())
     }
 
     fn cleanup_old_pings(&mut self) {
@@ -302,7 +302,7 @@ impl NetworkManager for TcpNetworkManager {
         if let Some(connection) = &self.connection {
             // For single peer connection, return the peer's best height
             match connection.peer_info().best_height {
-                Some(height) if height > 0 => Ok(Some(height as u32)),
+                Some(height) if height > 0 => Ok(Some(height)),
                 _ => Ok(None),
             }
         } else {
diff --git a/dash-spv/src/network/multi_peer.rs b/dash-spv/src/network/multi_peer.rs
index 0048a7fc3..bbbfe7f53 100644
--- a/dash-spv/src/network/multi_peer.rs
+++ b/dash-spv/src/network/multi_peer.rs
@@ -831,7 +831,7 @@ impl MultiPeerNetworkManager {
 
             let handle = tokio::spawn(async move {
                 let mut conn_guard = conn.write().await;
-                conn_guard.send_message(msg).await.map_err(|e| Error::Network(e))
+                conn_guard.send_message(msg).await.map_err(Error::Network)
             });
             handles.push(handle);
         }
@@ -884,7 +884,7 @@ impl MultiPeerNetworkManager {
             use std::hash::{Hash, Hasher};
             let mut hasher = std::collections::hash_map::DefaultHasher::new();
             addr.hash(&mut hasher);
-            crate::types::PeerId(hasher.finish() as u64)
+            crate::types::PeerId(hasher.finish())
         } else {
             // Default to PeerId(0) if no peer available
             crate::types::PeerId(0)
@@ -1176,7 +1176,7 @@ impl NetworkManager for MultiPeerNetworkManager {
 
             if let Some(peer_height) = peer_info.best_height {
                 if peer_height > 0 {
-                    best_height = best_height.max(peer_height as u32);
+                    best_height = best_height.max(peer_height);
                     log::debug!(
                         "get_peer_best_height: Updated best_height to {} from peer {}",
                         best_height,
diff --git a/dash-spv/src/network/reputation.rs b/dash-spv/src/network/reputation.rs
index 1ca180159..705042291 100644
--- a/dash-spv/src/network/reputation.rs
+++ b/dash-spv/src/network/reputation.rs
@@ -139,7 +139,7 @@ impl Default for PeerReputation {
 impl PeerReputation {
     /// Check if the peer is currently banned
     pub fn is_banned(&self) -> bool {
-        self.banned_until.map_or(false, |until| Instant::now() < until)
+        self.banned_until.is_some_and(|until| Instant::now() < until)
     }
 
     /// Get remaining ban time
@@ -198,6 +198,12 @@ pub struct PeerReputationManager {
     max_events: usize,
 }
 
+impl Default for PeerReputationManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl PeerReputationManager {
     /// Create a new reputation manager
     pub fn new() -> Self {
@@ -224,7 +230,7 @@ impl PeerReputationManager {
         // Update score
         let old_score = reputation.score;
         reputation.score =
-            (reputation.score + score_change).max(MIN_SCORE).min(MAX_MISBEHAVIOR_SCORE);
+            (reputation.score + score_change).clamp(MIN_SCORE, MAX_MISBEHAVIOR_SCORE);
 
         // Track positive/negative actions
         if score_change > 0 {
diff --git a/dash-spv/src/storage/sync_storage.rs b/dash-spv/src/storage/sync_storage.rs
index 8a56d6eb0..102114ca7 100644
--- a/dash-spv/src/storage/sync_storage.rs
+++ b/dash-spv/src/storage/sync_storage.rs
@@ -14,6 +14,12 @@ pub struct MemoryStorage {
     block_txs: RwLock<HashMap<BlockHash, Vec<Txid>>>,
 }
 
+impl Default for MemoryStorage {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl MemoryStorage {
     pub fn new() -> Self {
         Self {
diff --git a/dash-spv/src/sync/filters.rs b/dash-spv/src/sync/filters.rs
index cfe43ecf0..dc5e92128 100644
--- a/dash-spv/src/sync/filters.rs
+++ b/dash-spv/src/sync/filters.rs
@@ -1459,7 +1459,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
         // Check which active requests are now complete
         let mut completed_requests = Vec::new();
 
-        for ((start, end), _active_req) in &self.active_filter_requests {
+        for (start, end) in self.active_filter_requests.keys() {
             if self.is_request_complete(*start, *end).await? {
                 completed_requests.push((*start, *end));
             }
@@ -2794,7 +2794,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
         };
 
         // For each requested range
-        for ((start, end), _) in &self.requested_filter_ranges {
+        for (start, end) in self.requested_filter_ranges.keys() {
             let mut current = *start;
 
             // Find gaps within this range
@@ -2905,11 +2905,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
             .map_err(|e| SyncError::Storage(format!("Failed to get filter tip: {}", e)))?
             .unwrap_or(0);
 
-        let gap_size = if block_height > filter_height {
-            block_height - filter_height
-        } else {
-            0
-        };
+        let gap_size = block_height.saturating_sub(filter_height);
 
         // Consider within 1 block as "no gap" to handle edge cases at the tip
         let has_gap = gap_size > 1;
diff --git a/dash-spv/src/sync/headers2_state.rs b/dash-spv/src/sync/headers2_state.rs
index a10ab1fb4..32eb1ec19 100644
--- a/dash-spv/src/sync/headers2_state.rs
+++ b/dash-spv/src/sync/headers2_state.rs
@@ -76,15 +76,15 @@ impl Headers2StateManager {
 
     /// Get or create compression state for a peer
     pub fn get_state(&mut self, peer_id: PeerId) -> &mut CompressionState {
-        self.peer_states.entry(peer_id).or_insert_with(CompressionState::new)
+        self.peer_states.entry(peer_id).or_default()
     }
 
     /// Initialize compression state for a peer with a known header
     /// This is useful when starting sync from a specific point
     pub fn init_peer_state(&mut self, peer_id: PeerId, last_header: Header) {
-        let state = self.peer_states.entry(peer_id).or_insert_with(CompressionState::new);
+        let state = self.peer_states.entry(peer_id).or_default();
         // Set the previous header in the compression state
-        state.prev_header = Some(last_header.clone());
+        state.prev_header = Some(last_header);
         tracing::debug!(
             "Initialized compression state for peer {} with header at height implied by hash {}",
             peer_id,
diff --git a/dash-spv/src/sync/headers_with_reorg.rs b/dash-spv/src/sync/headers_with_reorg.rs
index f14aa32ef..18670860a 100644
--- a/dash-spv/src/sync/headers_with_reorg.rs
+++ b/dash-spv/src/sync/headers_with_reorg.rs
@@ -309,14 +309,13 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
         for (index, header) in headers.iter().enumerate() {
             let prospective_height = current_height + (index as u32) + 1;
 
-            if self.reorg_config.enforce_checkpoints {
-                if !self.checkpoint_manager.validate_block(prospective_height, &header.block_hash())
-                {
-                    return Err(SyncError::Validation(format!(
-                        "Block at height {} does not match checkpoint",
-                        prospective_height
-                    )));
-                }
+            if self.reorg_config.enforce_checkpoints
+                && !self.checkpoint_manager.validate_block(prospective_height, &header.block_hash())
+            {
+                return Err(SyncError::Validation(format!(
+                    "Block at height {} does not match checkpoint",
+                    prospective_height
+                )));
             }
         }
 
@@ -542,7 +541,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
                             "Initializing headers2 compression state for peer {} with genesis header",
                             peer_id
                         );
-                            self.headers2_state.init_peer_state(peer_id, genesis_header.clone());
+                            self.headers2_state.init_peer_state(peer_id, *genesis_header);
                         }
                     } else if self.chain_state.tip_height() > 0 {
                         // Get our current tip to use as the base for compression
@@ -635,18 +634,19 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
             .map_err(|e| SyncError::Storage(format!("Failed to get tip height: {}", e)))?;
 
         // If we're syncing from a checkpoint, we need to account for sync_base_height
-        let effective_tip_height = if self.chain_state.synced_from_checkpoint
-            && current_tip_height.is_some()
-        {
-            let stored_headers = current_tip_height.unwrap();
-            let actual_height = self.chain_state.sync_base_height + stored_headers;
-            tracing::info!(
-                "Syncing from checkpoint: sync_base_height={}, stored_headers={}, effective_height={}",
-                self.chain_state.sync_base_height,
-                stored_headers,
-                actual_height
-            );
-            Some(actual_height)
+        let effective_tip_height = if self.chain_state.synced_from_checkpoint {
+            if let Some(stored_headers) = current_tip_height {
+                let actual_height = self.chain_state.sync_base_height + stored_headers;
+                tracing::info!(
+                    "Syncing from checkpoint: sync_base_height={}, stored_headers={}, effective_height={}",
+                    self.chain_state.sync_base_height,
+                    stored_headers,
+                    actual_height
+                );
+                Some(actual_height)
+            } else {
+                None
+            }
         } else {
             tracing::info!(
                 "Not syncing from checkpoint or no tip height. synced_from_checkpoint={}, current_tip_height={:?}",
@@ -847,11 +847,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
                 }
                 Some(height) => {
                     // When syncing from checkpoint, adjust the storage height
-                    let storage_height = if self.chain_state.synced_from_checkpoint {
-                        height // height is already the storage index
-                    } else {
-                        height
-                    };
+                    let storage_height = height;
 
                     // Get the current tip hash
                     storage
diff --git a/dash-spv/src/sync/masternodes.rs b/dash-spv/src/sync/masternodes.rs
index 36d08730d..4fe2be388 100644
--- a/dash-spv/src/sync/masternodes.rs
+++ b/dash-spv/src/sync/masternodes.rs
@@ -265,12 +265,13 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
             tracing::debug!("🔗 Feeding QRInfo block heights to masternode engine");
 
             // Collect all block hashes from QRInfo MnListDiffs
-            let mut block_hashes = Vec::new();
-            block_hashes.push(qr_info.mn_list_diff_tip.block_hash);
-            block_hashes.push(qr_info.mn_list_diff_h.block_hash);
-            block_hashes.push(qr_info.mn_list_diff_at_h_minus_c.block_hash);
-            block_hashes.push(qr_info.mn_list_diff_at_h_minus_2c.block_hash);
-            block_hashes.push(qr_info.mn_list_diff_at_h_minus_3c.block_hash);
+            let mut block_hashes = vec![
+                qr_info.mn_list_diff_tip.block_hash,
+                qr_info.mn_list_diff_h.block_hash,
+                qr_info.mn_list_diff_at_h_minus_c.block_hash,
+                qr_info.mn_list_diff_at_h_minus_2c.block_hash,
+                qr_info.mn_list_diff_at_h_minus_3c.block_hash,
+            ];
 
             if let Some((_, diff)) = &qr_info.quorum_snapshot_and_mn_list_diff_at_h_minus_4c {
                 block_hashes.push(diff.block_hash);
diff --git a/dash-spv/src/sync/sequential/request_control.rs b/dash-spv/src/sync/sequential/request_control.rs
index f7ad14263..f1f5ecc60 100644
--- a/dash-spv/src/sync/sequential/request_control.rs
+++ b/dash-spv/src/sync/sequential/request_control.rs
@@ -124,39 +124,14 @@ impl RequestController {
 
     /// Check if a request type is allowed in the current phase
     pub fn is_request_allowed(&self, phase: &SyncPhase, request_type: &RequestType) -> bool {
-        match (phase, request_type) {
-            (
-                SyncPhase::DownloadingHeaders {
-                    ..
-                },
-                RequestType::GetHeaders(_),
-            ) => true,
-            (
-                SyncPhase::DownloadingMnList {
-                    ..
-                },
-                RequestType::GetMnListDiff(_),
-            ) => true,
-            (
-                SyncPhase::DownloadingCFHeaders {
-                    ..
-                },
-                RequestType::GetCFHeaders(_, _),
-            ) => true,
-            (
-                SyncPhase::DownloadingFilters {
-                    ..
-                },
-                RequestType::GetCFilters(_, _),
-            ) => true,
-            (
-                SyncPhase::DownloadingBlocks {
-                    ..
-                },
-                RequestType::GetBlock(_),
-            ) => true,
-            _ => false,
-        }
+        matches!(
+            (phase, request_type),
+            (SyncPhase::DownloadingHeaders { .. }, RequestType::GetHeaders(_))
+                | (SyncPhase::DownloadingMnList { .. }, RequestType::GetMnListDiff(_))
+                | (SyncPhase::DownloadingCFHeaders { .. }, RequestType::GetCFHeaders(_, _))
+                | (SyncPhase::DownloadingFilters { .. }, RequestType::GetCFilters(_, _))
+                | (SyncPhase::DownloadingBlocks { .. }, RequestType::GetBlock(_))
+        )
     }
 
     /// Queue a request for sending
@@ -307,8 +282,7 @@ impl RequestController {
 
             RequestType::GetBlock(hash) => {
                 let inv = dashcore::network::message_blockdata::Inventory::Block(*hash);
-                let getdata = dashcore::network::message::NetworkMessage::GetData(vec![inv]);
-                getdata
+                dashcore::network::message::NetworkMessage::GetData(vec![inv])
             }
         };
 
@@ -365,9 +339,11 @@ impl RequestController {
 
     /// Get statistics about pending and active requests
     pub fn get_stats(&self) -> RequestStats {
-        let mut stats = RequestStats::default();
-        stats.pending_count = self.pending_requests.len();
-        stats.active_count = self.active_requests.len();
+        let mut stats = RequestStats {
+            pending_count: self.pending_requests.len(),
+            active_count: self.active_requests.len(),
+            ..Default::default()
+        };
 
         // Count by type
         for request in &self.pending_requests {
@@ -380,7 +356,7 @@ impl RequestController {
             }
         }
 
-        for (_, active) in &self.active_requests {
+        for active in self.active_requests.values() {
             match &active.request.request_type {
                 RequestType::GetHeaders(_) => stats.active_headers += 1,
                 RequestType::GetMnListDiff(_) => stats.active_mnlist += 1,
diff --git a/dash-spv/src/sync/state.rs b/dash-spv/src/sync/state.rs
index 902da0914..b973ee028 100644
--- a/dash-spv/src/sync/state.rs
+++ b/dash-spv/src/sync/state.rs
@@ -17,6 +17,12 @@ pub struct SyncState {
     sync_start: Option<SystemTime>,
 }
 
+impl Default for SyncState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl SyncState {
     /// Create a new sync state.
     pub fn new() -> Self {
diff --git a/dash-spv/src/sync/validation_state.rs b/dash-spv/src/sync/validation_state.rs
index 8932a1037..f37d177bb 100644
--- a/dash-spv/src/sync/validation_state.rs
+++ b/dash-spv/src/sync/validation_state.rs
@@ -10,6 +10,8 @@ use std::collections::{HashMap, VecDeque};
 use std::time::{Duration, Instant};
 use tracing;
 
+type ValidationStateListener = Box<dyn Fn(&ValidationState) + Send>;
+
 /// Maximum number of state snapshots to maintain
 const MAX_SNAPSHOTS: usize = 10;
 
@@ -113,7 +115,7 @@ pub struct ValidationStateManager {
     /// Maximum age for snapshots
     snapshot_ttl: Duration,
     /// State change listeners
-    change_listeners: Vec<Box<dyn Fn(&ValidationState) + Send>>,
+    change_listeners: Vec<ValidationStateListener>,
 }
 
 /// State snapshot for rollback
@@ -144,6 +146,12 @@ impl Default for ValidationState {
     }
 }
 
+impl Default for ValidationStateManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ValidationStateManager {
     /// Create a new validation state manager
     pub fn new() -> Self {
@@ -267,7 +275,7 @@ impl ValidationStateManager {
             recoverable,
         };
 
-        self.current_state.validation_failures.entry(height).or_insert_with(Vec::new).push(failure);
+        self.current_state.validation_failures.entry(height).or_default().push(failure);
 
         self.current_state.version += 1;
         self.notify_listeners();
@@ -323,7 +331,7 @@ impl ValidationStateManager {
         }
 
         // Check that pending validations are within reasonable range
-        for (height, _) in &self.current_state.pending_validations {
+        for height in self.current_state.pending_validations.keys() {
             if *height > self.current_state.current_height + 1000 {
                 return Err(SyncError::InvalidState(format!(
                     "Pending validation at height {} is too far ahead of current height {}",
diff --git a/dash-spv/src/terminal.rs b/dash-spv/src/terminal.rs
index d481a78ac..1e26eabb8 100644
--- a/dash-spv/src/terminal.rs
+++ b/dash-spv/src/terminal.rs
@@ -170,14 +170,12 @@ impl TerminalUI {
 fn format_number(n: u32) -> String {
     let s = n.to_string();
     let mut result = String::new();
-    let mut count = 0;
 
-    for ch in s.chars().rev() {
+    for (count, ch) in s.chars().rev().enumerate() {
         if count > 0 && count % 3 == 0 {
             result.push(',');
         }
         result.push(ch);
-        count += 1;
     }
 
     result.chars().rev().collect()
diff --git a/dash-spv/src/types.rs b/dash-spv/src/types.rs
index 5b3040fa0..27d0f9401 100644
--- a/dash-spv/src/types.rs
+++ b/dash-spv/src/types.rs
@@ -146,7 +146,7 @@ impl DetailedSyncProgress {
 }
 
 /// Chain state maintained by the SPV client.
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct ChainState {
     /// Block headers indexed by height.
     pub headers: Vec<BlockHeader>,
@@ -176,22 +176,6 @@ pub struct ChainState {
     pub synced_from_checkpoint: bool,
 }
 
-impl Default for ChainState {
-    fn default() -> Self {
-        Self {
-            headers: Vec::new(),
-            filter_headers: Vec::new(),
-            last_chainlock_height: None,
-            last_chainlock_hash: None,
-            current_filter_tip: None,
-            masternode_engine: None,
-            last_masternode_diff_height: None,
-            sync_base_height: 0,
-            synced_from_checkpoint: false,
-        }
-    }
-}
-
 impl ChainState {
     /// Create a new empty chain state
     pub fn new() -> Self {
@@ -309,7 +293,7 @@ impl ChainState {
     /// Update chain lock status
     pub fn update_chain_lock(&mut self, height: u32, hash: BlockHash) {
         // Only update if this is a newer chain lock
-        if self.last_chainlock_height.map_or(true, |h| height > h) {
+        if self.last_chainlock_height.is_none_or(|h| height > h) {
             self.last_chainlock_height = Some(height);
             self.last_chainlock_hash = Some(hash);
         }
@@ -317,7 +301,7 @@ impl ChainState {
 
     /// Check if a block at given height is chain-locked
     pub fn is_height_chain_locked(&self, height: u32) -> bool {
-        self.last_chainlock_height.map_or(false, |locked_height| height <= locked_height)
+        self.last_chainlock_height.is_some_and(|locked_height| height <= locked_height)
     }
 
     /// Check if we have a chain lock
@@ -814,7 +798,7 @@ pub enum SpvEvent {
         /// Transaction ID.
         txid: Txid,
         /// Raw transaction data.
-        transaction: Transaction,
+        transaction: Box<Transaction>,
         /// Net amount change (positive for received, negative for sent).
         amount: i64,
         /// Addresses affected by this transaction.
diff --git a/dash-spv/src/validation/instantlock.rs b/dash-spv/src/validation/instantlock.rs
index 350c68a01..6919408d2 100644
--- a/dash-spv/src/validation/instantlock.rs
+++ b/dash-spv/src/validation/instantlock.rs
@@ -9,6 +9,12 @@ pub struct InstantLockValidator {
     // TODO: Add masternode list for signature verification
 }
 
+impl Default for InstantLockValidator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl InstantLockValidator {
     /// Create a new InstantLock validator.
     pub fn new() -> Self {
diff --git a/dash-spv/src/validation/quorum.rs b/dash-spv/src/validation/quorum.rs
index 348e8a0a5..5f63d1bdc 100644
--- a/dash-spv/src/validation/quorum.rs
+++ b/dash-spv/src/validation/quorum.rs
@@ -67,6 +67,12 @@ pub struct QuorumManager {
     max_cached_quorums: usize,
 }
 
+impl Default for QuorumManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl QuorumManager {
     /// Create a new quorum manager
     pub fn new() -> Self {
@@ -205,7 +211,7 @@ impl QuorumManager {
         let mut min_height = u32::MAX;
         let mut max_height = 0;
 
-        for ((quorum_type, height), _) in &self.quorums {
+        for (quorum_type, height) in self.quorums.keys() {
             match quorum_type {
                 QuorumType::ChainLock => chainlock_count += 1,
                 QuorumType::InstantSend => instantsend_count += 1,
diff --git a/dash-spv/tests/block_download_test.rs b/dash-spv/tests/block_download_test.rs
index 6a3d4d92c..ab908b271 100644
--- a/dash-spv/tests/block_download_test.rs
+++ b/dash-spv/tests/block_download_test.rs
@@ -16,18 +16,15 @@ use dashcore::{
     network::message::NetworkMessage,
     network::message_blockdata::Inventory,
     pow::CompactTarget,
-    Address, BlockHash, Network,
+    BlockHash,
 };
 use dashcore_hashes::Hash;
 
 use dash_spv::{
-    client::ClientConfig,
-    network::NetworkManager,
-    storage::MemoryStorageManager,
-    sync::{sequential::SequentialSyncManager, FilterSyncManager},
-    types::FilterMatch,
+    client::ClientConfig, network::NetworkManager, storage::MemoryStorageManager,
+    sync::FilterSyncManager, types::FilterMatch,
 };
-use key_wallet::wallet::ManagedWalletInfo;
+// use key_wallet::wallet::ManagedWalletInfo;
 
 /// Mock network manager for testing
 struct MockNetworkManager {
@@ -45,17 +42,9 @@ impl MockNetworkManager {
         }
     }
 
-    async fn add_response(&self, message: NetworkMessage) {
-        self.received_messages.write().await.push(message);
-    }
-
     async fn get_sent_messages(&self) -> Vec<NetworkMessage> {
         self.sent_messages.read().await.clone()
     }
-
-    async fn clear_sent_messages(&self) {
-        self.sent_messages.write().await.clear();
-    }
 }
 
 #[async_trait::async_trait]
@@ -167,13 +156,13 @@ fn create_test_config() -> ClientConfig {
         .with_connection_timeout(std::time::Duration::from_secs(10))
 }
 
-fn create_test_address() -> Address {
-    use dashcore::{Address, PubkeyHash, ScriptBuf};
-    use dashcore_hashes::Hash;
-    let pubkey_hash = PubkeyHash::from_slice(&[1u8; 20]).unwrap();
-    let script = ScriptBuf::new_p2pkh(&pubkey_hash);
-    Address::from_script(&script, Network::Testnet).unwrap()
-}
+// fn create_test_address() -> Address {
+//     use dashcore::{Address, PubkeyHash, ScriptBuf};
+//     use dashcore_hashes::Hash;
+//     let pubkey_hash = PubkeyHash::from_slice(&[1u8; 20]).unwrap();
+//     let script = ScriptBuf::new_p2pkh(&pubkey_hash);
+//     Address::from_script(&script, Network::Testnet).unwrap()
+// }
 
 fn create_test_block() -> Block {
     let header = BlockHeader {
@@ -374,29 +363,7 @@ async fn test_process_multiple_filter_matches() {
 
 #[ignore = "mock implementation incomplete"]
 #[tokio::test]
-async fn test_sync_manager_integration() {
-    let config = create_test_config();
-    let received_heights = Arc::new(Mutex::new(HashSet::new()));
-    let wallet = Arc::new(RwLock::new(key_wallet_manager::wallet_manager::WalletManager::<
-        ManagedWalletInfo,
-    >::new()));
-    let mut sync_manager: SequentialSyncManager<MemoryStorageManager, MockNetworkManager, _> =
-        SequentialSyncManager::new(&config, received_heights, wallet)
-            .expect("Failed to create SequentialSyncManager for integration test");
-    let mut network = MockNetworkManager::new();
-
-    let block_hash = BlockHash::from_slice(&[1u8; 32]).unwrap();
-    let filter_matches = vec![create_test_filter_match(block_hash, 100)];
-
-    // Request block downloads through sync manager
-    // Note: request_block_downloads method doesn't exist in the current SequentialSyncManager API
-    // let result = sync_manager.request_block_downloads(filter_matches, &mut network).await;
-    // assert!(result.is_ok());
-
-    // Check state through sync manager
-    // Note: Methods for checking pending downloads and handling blocks
-    // may not exist in current API. This test may need significant refactoring.
-}
+async fn test_sync_manager_integration() {}
 
 #[ignore = "mock implementation incomplete"]
 #[tokio::test]
@@ -409,7 +376,7 @@ async fn test_filter_match_and_download_workflow() {
     let mut network = MockNetworkManager::new();
 
     // Create test address (WatchItem replaced with wallet-based tracking)
-    let address = create_test_address();
+    // let address = create_test_address();
 
     // This is a simplified test - in real usage, we'd need to:
     // 1. Store filter headers and filters
diff --git a/dash-spv/tests/cfheader_gap_test.rs b/dash-spv/tests/cfheader_gap_test.rs
index bed8ee0c9..a24677401 100644
--- a/dash-spv/tests/cfheader_gap_test.rs
+++ b/dash-spv/tests/cfheader_gap_test.rs
@@ -10,15 +10,11 @@ use std::sync::{Arc, Mutex};
 
 use dash_spv::{
     client::ClientConfig,
-    error::{NetworkError, NetworkResult},
-    network::{MultiPeerNetworkManager, NetworkManager},
+    network::MultiPeerNetworkManager,
     storage::{MemoryStorageManager, StorageManager},
     sync::filters::FilterSyncManager,
 };
-use dashcore::{
-    block::Header as BlockHeader, hash_types::FilterHeader, network::message::NetworkMessage,
-    BlockHash, Network,
-};
+use dashcore::{block::Header as BlockHeader, hash_types::FilterHeader, BlockHash, Network};
 use dashcore_hashes::Hash;
 
 /// Create a mock block header
@@ -155,9 +151,7 @@ async fn test_cfheader_restart_cooldown() {
     let mut config = ClientConfig::new(Network::Dash);
     config.cfheader_gap_restart_cooldown_secs = 1; // 1 second cooldown for testing
 
-    let received_heights = Arc::new(Mutex::new(HashSet::new()));
-    let mut filter_sync: FilterSyncManager<MemoryStorageManager, MultiPeerNetworkManager> =
-        FilterSyncManager::new(&config, received_heights);
+    // FilterSyncManager instantiation omitted until restart logic is implemented
 
     let mut storage = MemoryStorageManager::new().await.unwrap();
 
@@ -176,9 +170,9 @@ async fn test_cfheader_restart_cooldown() {
     storage.store_headers(&headers).await.unwrap();
     storage.store_filter_headers(&filter_headers).await.unwrap();
 
-    // Create a mock network manager (will fail when trying to restart)
-    struct MockNetworkManager;
+    // Network manager mock omitted until restart logic exists
 
+    /*
     #[async_trait::async_trait]
     impl NetworkManager for MockNetworkManager {
         fn as_any(&self) -> &dyn std::any::Any {
@@ -262,8 +256,9 @@ async fn test_cfheader_restart_cooldown() {
             Ok(())
         }
     }
+    */
 
-    let mut network = MockNetworkManager;
+    // Network manager omitted until restart logic is implemented
 
     // Note: The following tests are skipped because MockNetworkManager doesn't implement
     // the full MultiPeerNetworkManager interface required by maybe_restart_cfheader_sync_for_gap
diff --git a/dash-spv/tests/chainlock_validation_test.rs b/dash-spv/tests/chainlock_validation_test.rs
index e74d40c99..a4b2ec085 100644
--- a/dash-spv/tests/chainlock_validation_test.rs
+++ b/dash-spv/tests/chainlock_validation_test.rs
@@ -8,19 +8,16 @@
 //! Integration tests for ChainLock validation flow with masternode engine
 
 use dash_spv::client::{ClientConfig, DashSpvClient};
-use dash_spv::error::Result;
 use dash_spv::network::NetworkManager;
-use dash_spv::storage::{DiskStorageManager, StorageManager};
-use dash_spv::types::{ChainState, ValidationMode};
-use dashcore::block::Header;
+use dash_spv::storage::DiskStorageManager;
+use dash_spv::types::ValidationMode;
 use dashcore::blockdata::constants::genesis_block;
-use dashcore::sml::masternode_list_engine::MasternodeListEngine;
+// use dashcore::sml::masternode_list_engine::MasternodeListEngine;
 use dashcore::Network;
 use dashcore::{BlockHash, ChainLock};
 use key_wallet::wallet::managed_wallet_info::ManagedWalletInfo;
 use key_wallet_manager::wallet_manager::WalletManager;
 use std::sync::Arc;
-use std::time::Duration;
 use tempfile::TempDir;
 use tokio::sync::RwLock;
 use tracing::{info, Level};
@@ -179,45 +176,7 @@ fn create_test_chainlock(height: u32, block_hash: BlockHash) -> ChainLock {
 async fn test_chainlock_validation_without_masternode_engine() {
     init_logging();
 
-    // Create temp directory for storage
-    let temp_dir = TempDir::new().unwrap();
-    let storage_path = temp_dir.path().to_path_buf();
-
-    // Create storage and network managers
-    let mut storage = DiskStorageManager::new(storage_path).await.unwrap();
-    let network = MockNetworkManager::new();
-
-    // Create wallet manager
-    let wallet = Arc::new(RwLock::new(WalletManager::<ManagedWalletInfo>::new()));
-
-    // Create client config
-    let config = ClientConfig {
-        network: Network::Dash,
-        enable_filters: false,
-        enable_masternodes: false,
-        validation_mode: ValidationMode::Basic,
-        ..Default::default()
-    };
-
-    // Create the SPV client
-    let mut client = DashSpvClient::new(config, network, storage, wallet).await.unwrap();
-
-    // Add a test header to storage
-    let genesis = genesis_block(Network::Dash).header;
-    // Note: storage_mut() is not available in current API
-    // let storage = client.storage_mut();
-    // storage.store_header(&genesis, 0).await.unwrap();
-
-    // Create a test ChainLock for genesis block
-    let chain_lock = create_test_chainlock(0, genesis.block_hash());
-
-    // Process the ChainLock (should queue it since no masternode engine)
-    let chainlock_manager = client.chainlock_manager();
-    let chain_state = ChainState::new();
-    // Note: In the current API, we need to access storage differently
-    // For now, skip this test as it needs to be rewritten for the new client API
-
-    // Skip the rest of this test for now
+    // Placeholder: test requires API updates; skip for now
     return;
 
     // Verify it was queued
@@ -237,7 +196,7 @@ async fn test_chainlock_validation_with_masternode_engine() {
     let storage_path = temp_dir.path().to_path_buf();
 
     // Create storage and network managers
-    let mut storage = DiskStorageManager::new(storage_path).await.unwrap();
+    let storage = DiskStorageManager::new(storage_path).await.unwrap();
     let mut network = MockNetworkManager::new();
 
     // Add a test ChainLock to be received
@@ -258,7 +217,7 @@ async fn test_chainlock_validation_with_masternode_engine() {
     };
 
     // Create the SPV client
-    let mut client = DashSpvClient::new(config, network, storage, wallet).await.unwrap();
+    let client = DashSpvClient::new(config, network, storage, wallet).await.unwrap();
 
     // Add genesis header
     // Note: storage_mut() is not available in current API
@@ -267,18 +226,18 @@ async fn test_chainlock_validation_with_masternode_engine() {
 
     // Simulate masternode sync completion by creating a mock engine
     // In a real scenario, this would be populated by the masternode sync
-    let mock_engine = MasternodeListEngine::default_for_network(Network::Dash);
+    // let mock_engine = MasternodeListEngine::default_for_network(Network::Dash);
 
     // Update the ChainLock manager with the engine
     let updated = client.update_chainlock_validation().unwrap();
     assert!(!updated); // Should be false since we don't have a real engine
 
     // For testing, directly set a mock engine
-    let engine_arc = Arc::new(mock_engine);
-    client.chainlock_manager().set_masternode_engine(engine_arc);
+    // let engine_arc = Arc::new(mock_engine);
+    // client.chainlock_manager().set_masternode_engine(engine_arc);
 
-    // Process pending ChainLocks
-    let chain_state = ChainState::new();
+    // Process pending ChainLocks (skipped for now due to API changes)
+    // let chain_state = ChainState::new();
     // Note: storage_mut() is not available in current API
     // let storage = client.storage_mut();
     // Skip this test section as it needs to be rewritten for the new client API
@@ -295,7 +254,7 @@ async fn test_chainlock_queue_and_process_flow() {
     let storage_path = temp_dir.path().to_path_buf();
 
     // Create storage
-    let mut storage = DiskStorageManager::new(storage_path).await.unwrap();
+    let storage = DiskStorageManager::new(storage_path).await.unwrap();
     let network = MockNetworkManager::new();
 
     // Create wallet manager
@@ -333,8 +292,7 @@ async fn test_chainlock_queue_and_process_flow() {
         // assert_eq!(pending[2].block_height, 300);
     }
 
-    // Process pending (will fail validation but clear the queue)
-    let chain_state = ChainState::new();
+    // Process pending (skipped for now due to API changes)
     // Skip this test as it needs to be rewritten for the new client API
     return;
 }
@@ -349,7 +307,7 @@ async fn test_chainlock_manager_cache_operations() {
     let storage_path = temp_dir.path().to_path_buf();
 
     // Create storage
-    let mut storage = DiskStorageManager::new(storage_path).await.unwrap();
+    let storage = DiskStorageManager::new(storage_path).await.unwrap();
     let network = MockNetworkManager::new();
 
     // Create wallet manager
@@ -370,12 +328,12 @@ async fn test_chainlock_manager_cache_operations() {
 
     // Add test headers
     let genesis = genesis_block(Network::Dash).header;
-    let storage = client.storage();
+    // let storage = client.storage();
     // storage.store_header(&genesis, 0).await.unwrap();
 
     // Create and process a ChainLock - skip for now as storage access pattern changed
-    let chain_lock = create_test_chainlock(0, genesis.block_hash());
-    let chain_state = ChainState::new();
+    // let chain_lock = create_test_chainlock(0, genesis.block_hash());
+    // let chain_state = ChainState::new();
     // Note: storage access pattern has changed in the new client API
     // let _ = chainlock_manager.process_chain_lock(chain_lock.clone(), &chain_state, storage).await;
 
@@ -407,7 +365,7 @@ async fn test_client_chainlock_update_flow() {
     let storage_path = temp_dir.path().to_path_buf();
 
     // Create storage and network
-    let mut storage = DiskStorageManager::new(storage_path).await.unwrap();
+    let storage = DiskStorageManager::new(storage_path).await.unwrap();
     let network = MockNetworkManager::new();
 
     // Create wallet manager
@@ -423,7 +381,7 @@ async fn test_client_chainlock_update_flow() {
     };
 
     // Create the SPV client
-    let mut client = DashSpvClient::new(config, network, storage, wallet).await.unwrap();
+    let client = DashSpvClient::new(config, network, storage, wallet).await.unwrap();
 
     // Initially, update should fail (no masternode engine)
     let updated = client.update_chainlock_validation().unwrap();
@@ -441,7 +399,7 @@ async fn test_client_chainlock_update_flow() {
     // });
 
     // Create a mock masternode list engine
-    let mock_engine = MasternodeListEngine::default_for_network(Network::Dash);
+    // let mock_engine = MasternodeListEngine::default_for_network(Network::Dash);
 
     // Manually inject the engine (in real usage, this would come from masternode sync)
     // Note: sync_manager is private, can't access directly
diff --git a/dash-spv/tests/error_handling_test.rs b/dash-spv/tests/error_handling_test.rs
index 6e04f887a..12d9fb65b 100644
--- a/dash-spv/tests/error_handling_test.rs
+++ b/dash-spv/tests/error_handling_test.rs
@@ -14,31 +14,26 @@
 //! - Recovery mechanisms (automatic retries, graceful degradation)
 //! - Error propagation through layers
 
-use std::any::Any;
 use std::collections::HashMap;
-use std::io;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
-use std::path::PathBuf;
 use std::sync::Arc;
-use std::time::{Duration, SystemTime};
+use std::time::Duration;
 
 use dashcore::{
     block::{Header as BlockHeader, Version},
-    consensus::Encodable,
     hash_types::FilterHeader,
     pow::CompactTarget,
-    Address, BlockHash, Network, OutPoint, Script, Txid,
+    BlockHash, Network, OutPoint, Txid,
 };
 use dashcore_hashes::Hash;
 use tokio::sync::{mpsc, RwLock};
 
 use dash_spv::error::*;
 use dash_spv::network::{NetworkManager, TcpConnection};
-use dash_spv::storage::{DiskStorageManager, MemoryStorageManager, StorageManager};
+use dash_spv::storage::{DiskStorageManager, StorageManager};
 use dash_spv::sync::sequential::phases::SyncPhase;
 use dash_spv::sync::sequential::recovery::{RecoveryManager, RecoveryStrategy};
 use dash_spv::types::{ChainState, MempoolState, PeerInfo, UnconfirmedTransaction};
-use key_wallet_manager::Utxo;
 
 /// Mock network manager for testing error scenarios
 struct MockNetworkManager {
@@ -60,9 +55,7 @@ impl MockNetworkManager {
         }
     }
 
-    fn set_fail_on_connect(&mut self) {
-        self.fail_on_connect = true;
-    }
+    // Removed unused set_fail_on_connect; use flags directly where needed
 
     fn set_timeout_on_message(&mut self) {
         self.timeout_on_message = true;
@@ -200,7 +193,6 @@ struct MockStorageManager {
     disk_full: bool,
     permission_denied: bool,
     lock_poisoned: bool,
-    data: HashMap<String, Vec<u8>>,
 }
 
 impl MockStorageManager {
@@ -212,7 +204,6 @@ impl MockStorageManager {
             disk_full: false,
             permission_denied: false,
             lock_poisoned: false,
-            data: HashMap::new(),
         }
     }
 
diff --git a/dash-spv/tests/error_recovery_integration_test.rs b/dash-spv/tests/error_recovery_integration_test.rs
index 2ca4d8b8a..189d3bb58 100644
--- a/dash-spv/tests/error_recovery_integration_test.rs
+++ b/dash-spv/tests/error_recovery_integration_test.rs
@@ -11,22 +11,15 @@
 //! including network interruptions, storage failures during sync,
 //! and validation errors with real data.
 
-use std::net::SocketAddr;
-use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
 
-use dashcore::{block::Header as BlockHeader, hash_types::FilterHeader, BlockHash, Network, Txid};
+use dashcore::{block::Header as BlockHeader, hash_types::FilterHeader, BlockHash, Txid};
 use tokio::sync::{Mutex, RwLock};
-use tokio::time::timeout;
 
-use dash_spv::client::{ClientConfig, DashSpvClient};
-use dash_spv::error::{NetworkError, SpvError, StorageError, SyncError, ValidationError};
-use dash_spv::storage::{
-    sync_state::SyncCheckpoint, DiskStorageManager, MemoryStorage, StorageManager,
-};
+use dash_spv::error::{StorageError, SyncError, ValidationError};
+use dash_spv::storage::{sync_state::SyncCheckpoint, DiskStorageManager, StorageManager};
 use dash_spv::sync::sequential::recovery::RecoveryManager;
-use key_wallet_manager::Utxo;
 
 /// Test helper to simulate network interruptions
 struct NetworkInterruptor {
@@ -76,9 +69,6 @@ struct StorageFailureSimulator {
 #[derive(Clone)]
 enum FailureType {
     None,
-    WriteFailure,
-    ReadFailure,
-    Corruption,
     DiskFull,
 }
 
@@ -99,18 +89,6 @@ impl StorageFailureSimulator {
         if let Some(fail_height) = *self.fail_at_height.read().await {
             if height >= fail_height {
                 return match &*self.failure_type.read().await {
-                    FailureType::WriteFailure => Some(StorageError::WriteFailed(format!(
-                        "Simulated write failure at height {}",
-                        height
-                    ))),
-                    FailureType::ReadFailure => Some(StorageError::ReadFailed(format!(
-                        "Simulated read failure at height {}",
-                        height
-                    ))),
-                    FailureType::Corruption => Some(StorageError::Corruption(format!(
-                        "Simulated corruption at height {}",
-                        height
-                    ))),
                     FailureType::DiskFull => {
                         Some(StorageError::WriteFailed("No space left on device".to_string()))
                     }
@@ -128,11 +106,10 @@ async fn test_recovery_from_network_interruption_during_header_sync() {
     // This test simulates a network interruption during header synchronization
     // and verifies that the client can recover and continue from where it left off
 
-    let temp_dir = tempfile::tempdir().unwrap();
-    let storage_path = temp_dir.path().to_path_buf();
-
     // Create storage manager
-    let storage = Arc::new(RwLock::new(DiskStorageManager::new(storage_path).await.unwrap()));
+    let storage = Arc::new(RwLock::new(
+        DiskStorageManager::new(tempfile::tempdir().unwrap().path().to_path_buf()).await.unwrap(),
+    ));
 
     // Create network interruptor
     let interruptor = Arc::new(NetworkInterruptor::new());
@@ -230,8 +207,7 @@ async fn test_recovery_from_storage_failure_during_sync() {
     // This test simulates storage failures during synchronization
     // and verifies appropriate error handling and recovery
 
-    let temp_dir = tempfile::tempdir().unwrap();
-    let storage_path = temp_dir.path().to_path_buf();
+    // No temp directory needed in this simulated test
 
     // Create storage with failure simulator
     let failure_sim = Arc::new(StorageFailureSimulator::new());
@@ -245,8 +221,6 @@ async fn test_recovery_from_storage_failure_during_sync() {
 
     // Simulate sync with storage failures
     for height in 0..target_height {
-        let header = create_test_header(height);
-
         // Check if we should simulate a failure
         if let Some(error) = failure_sim.should_fail(height).await {
             eprintln!("Storage failure at height {}: {:?}", height, error);
diff --git a/dash-spv/tests/instantsend_integration_test.rs b/dash-spv/tests/instantsend_integration_test.rs
index fda99e5df..b060b4a10 100644
--- a/dash-spv/tests/instantsend_integration_test.rs
+++ b/dash-spv/tests/instantsend_integration_test.rs
@@ -16,28 +16,21 @@
 //
 // These tests are currently ignored until they can be properly updated.
 
-use std::sync::Arc;
-use tokio::sync::RwLock;
+// use std::sync::Arc;
+// use tokio::sync::RwLock;
 
 use blsful::{Bls12381G2Impl, SecretKey};
-use dash_spv::{
-    client::{ClientConfig, DashSpvClient},
-    network::MultiPeerNetworkManager,
-    storage::MemoryStorageManager,
-};
+use dash_spv; // keep module path available for validator usage
 use dashcore::{
-    Address, Amount, InstantLock, Network, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid,
-    Witness,
+    Address, InstantLock, Network, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid, Witness,
 };
-use dashcore_hashes::{sha256d, Hash};
-use key_wallet::wallet::managed_wallet_info::ManagedWalletInfo;
-use key_wallet_manager::{wallet_manager::WalletManager, Utxo};
+use dashcore_hashes::Hash;
+// use key_wallet::wallet::managed_wallet_info::ManagedWalletInfo;
+// use key_wallet_manager::wallet_manager::WalletManager;
 use rand::thread_rng;
 
 /// Helper to create a test wallet manager.
-fn create_test_wallet() -> Arc<RwLock<WalletManager<ManagedWalletInfo>>> {
-    Arc::new(RwLock::new(WalletManager::<ManagedWalletInfo>::new()))
-}
+// Removed unused helper create_test_wallet (test scaffolding simplified)
 
 /// Create a deterministic test address.
 fn create_test_address() -> Address {
@@ -102,46 +95,14 @@ fn create_signed_instantlock(tx: &Transaction, _sk: &SecretKey<Bls12381G2Impl>)
 #[tokio::test]
 #[ignore = "instantsend tests not yet updated"]
 async fn test_instantsend_end_to_end() {
-    let wallet = create_test_wallet();
-    let address = create_test_address();
-
-    // 1. Setup: Add a UTXO to the wallet to be spent.
-    let initial_amount = 100_000_000; // 1 DASH
-    let initial_outpoint = OutPoint {
-        txid: Txid::from_byte_array([1; 32]),
-        vout: 0,
-    };
-    let mut initial_utxo = Utxo::new(
-        initial_outpoint,
-        TxOut {
-            value: initial_amount,
-            script_pubkey: address.script_pubkey(),
-        },
-        address.clone(),
-        100,   // block height
-        false, // is_coinbase
-    );
-    initial_utxo.is_confirmed = true;
-
-    // TODO: The WalletManager<ManagedWalletInfo> API has changed. These methods no longer exist:
-    // - add_utxo() - need to use WalletInterface methods or direct base access
-    // - add_watched_address() - need to use different approach for monitoring
-    // wallet.write().await.add_utxo(initial_utxo).await.unwrap();
-    // wallet.write().await.add_watched_address(address).await.unwrap();
-
-    // 2. Create a transaction that spends the UTXO.
-    let spend_amount = 80_000_000;
-    let spend_tx = create_regular_transaction(
-        vec![initial_outpoint],
-        vec![(spend_amount, ScriptBuf::new())], // Send to an external address
-    );
+    // 1. Create a dummy spending transaction (skipped wallet operations due to API changes)
+    let spend_tx = create_regular_transaction(vec![], vec![(80_000_000, ScriptBuf::new())]);
 
     // At this point, the transaction is in the mempool (conceptually).
     // The wallet balance would show the initial_amount as confirmed.
 
     // 3. Create a valid InstantLock for the spending transaction.
     let sk = SecretKey::<Bls12381G2Impl>::random(&mut thread_rng());
-    let pk = sk.public_key();
     let instant_lock = create_signed_instantlock(&spend_tx, &sk);
 
     // 4. Simulate the client receiving and processing the InstantLock.
@@ -176,7 +137,6 @@ async fn test_instantsend_end_to_end() {
     // Let's simplify and focus on the direct impact of the InstantLock on a UTXO.
 
     // Let's create a new UTXO that represents a payment *to* us, and then InstantLock it.
-    let wallet = create_test_wallet();
     let address = create_test_address();
     // TODO: add_watched_address() method no longer exists
     // wallet.write().await.add_watched_address(address.clone()).await.unwrap();
@@ -191,20 +151,7 @@ async fn test_instantsend_end_to_end() {
         vec![dummy_input],
         vec![(incoming_amount, address.script_pubkey())],
     );
-    let incoming_outpoint = OutPoint {
-        txid: incoming_tx.txid(),
-        vout: 0,
-    };
-    let incoming_utxo = Utxo::new(
-        incoming_outpoint,
-        TxOut {
-            value: incoming_amount,
-            script_pubkey: address.script_pubkey(),
-        },
-        address.clone(),
-        0,     // In mempool
-        false, // is_coinbase
-    );
+    // Create an outpoint for the received UTXO (skipped due to API changes)
     // TODO: add_utxo() method no longer exists
     // wallet.write().await.add_utxo(incoming_utxo).await.unwrap();
 
@@ -216,7 +163,6 @@ async fn test_instantsend_end_to_end() {
 
     // Create and process the InstantLock.
     let sk = SecretKey::<Bls12381G2Impl>::random(&mut thread_rng());
-    let pk = sk.public_key();
     let instant_lock = create_signed_instantlock(&incoming_tx, &sk);
 
     let validator = dash_spv::validation::InstantLockValidator::new();
diff --git a/dash-spv/tests/rollback_test.rs b/dash-spv/tests/rollback_test.rs
index b515dc2d7..d2424f972 100644
--- a/dash-spv/tests/rollback_test.rs
+++ b/dash-spv/tests/rollback_test.rs
@@ -14,9 +14,8 @@ use dashcore::{
 use dashcore_hashes::Hash;
 use tempfile::TempDir;
 
-#[ignore = "mock implementation incomplete"]
 #[tokio::test]
-#[ignore = "rollback_to_height not implemented in StorageManager trait"]
+#[ignore = "mock implementation incomplete"]
 async fn test_disk_storage_rollback() -> Result<(), Box<dyn std::error::Error>> {
     // Create a temporary directory for testing
     let temp_dir = TempDir::new()?;
@@ -55,28 +54,27 @@ async fn test_disk_storage_rollback() -> Result<(), Box<dyn std::error::Error>>
 
     // TODO: Test assertions commented out because rollback_to_height is not implemented
     // Verify tip height is now 5
-    let tip_height_after_rollback = storage.get_tip_height().await?;
+    let _ = storage.get_tip_height().await?;
     // assert_eq!(tip_height_after_rollback, Some(5));
 
     // Verify we can only load headers up to height 5
-    let headers_after_rollback = storage.load_headers(0..10).await?;
+    let _ = storage.load_headers(0..10).await?;
     // assert_eq!(headers_after_rollback.len(), 6); // heights 0-5
 
     // Verify header at height 6 is not accessible
-    let header_at_6 = storage.get_header(6).await?;
+    let _ = storage.get_header(6).await?;
     // assert!(header_at_6.is_none());
 
     // Verify header hash index doesn't contain removed headers
     let hash_of_removed_header = headers[7].block_hash();
-    let height_of_removed = storage.get_header_height_by_hash(&hash_of_removed_header).await?;
+    let _ = storage.get_header_height_by_hash(&hash_of_removed_header).await?;
     // assert!(height_of_removed.is_none());
 
     Ok(())
 }
 
-#[ignore = "mock implementation incomplete"]
 #[tokio::test]
-#[ignore = "rollback_to_height not implemented in StorageManager trait"]
+#[ignore = "mock implementation incomplete"]
 async fn test_disk_storage_rollback_filter_headers() -> Result<(), Box<dyn std::error::Error>> {
     use dashcore::hash_types::FilterHeader;
 
@@ -100,15 +98,15 @@ async fn test_disk_storage_rollback_filter_headers() -> Result<(), Box<dyn std::
 
     // TODO: Test assertions commented out because rollback_to_height is not implemented
     // Verify filter tip height is now 3
-    let filter_tip_after_rollback = storage.get_filter_tip_height().await?;
+    let _ = storage.get_filter_tip_height().await?;
     // assert_eq!(filter_tip_after_rollback, Some(3));
 
     // Verify we can only load filter headers up to height 3
-    let filter_headers_after_rollback = storage.load_filter_headers(0..10).await?;
+    let _ = storage.load_filter_headers(0..10).await?;
     // assert_eq!(filter_headers_after_rollback.len(), 4); // heights 0-3
 
     // Verify filter header at height 4 is not accessible
-    let filter_header_at_4 = storage.get_filter_header(4).await?;
+    let _ = storage.get_filter_header(4).await?;
     // assert!(filter_header_at_4.is_none());
 
     Ok(())
diff --git a/rpc-integration-test/src/main.rs b/rpc-integration-test/src/main.rs
index 707aad2c0..eb86b7fbd 100644
--- a/rpc-integration-test/src/main.rs
+++ b/rpc-integration-test/src/main.rs
@@ -12,7 +12,7 @@
 extern crate lazy_static;
 extern crate log;
 
-use log::{Log, trace};
+use log::trace;
 use std::collections::{HashMap, HashSet};
 use std::str::FromStr;
 
@@ -33,12 +33,16 @@ use dashcore_rpc::{
 use dashcore_rpc::dashcore::address::NetworkUnchecked;
 use dashcore_rpc::dashcore::{BlockHash, ProTxHash, QuorumHash, ScriptBuf};
 use dashcore_rpc::dashcore_rpc_json::{
-    GetBlockTemplateModes, GetBlockTemplateRules, ProTxInfo, ProTxRevokeReason, QuorumType,
-    ScanTxOutRequest,
+    GetBlockTemplateModes, GetBlockTemplateRules, ProTxInfo, ProTxRevokeReason, ScanTxOutRequest,
 };
 use dashcore_rpc::json::ProTxListType;
 use dashcore_rpc::json::QuorumType::LlmqTest;
 
+const FAUCET_WALLET_NAME: &str = "main";
+const TEST_WALLET_NAME: &str = "testwallet";
+const DEFAULT_WALLET_NODE_RPC_URL: &str = "http://127.0.0.1:20002";
+const DEFAULT_EVO_NODE_RPC_URL: &str = "http://127.0.0.1:20302";
+
 lazy_static! {
     static ref SECP: secp256k1::Secp256k1<secp256k1::All> = secp256k1::Secp256k1::new();
     static ref NET: Network = Network::Regtest;
@@ -49,14 +53,6 @@ lazy_static! {
             .unwrap();
     /// The default fee amount to use when needed.
     static ref FEE: Amount = Amount::from_btc(0.001).unwrap();
-    // Default name for faucet wallet
-    static ref FAUCET_WALLET_NAME: &'static str = "main";
-    // Default name for test wallet
-    static ref TEST_WALLET_NAME: &'static str = "testwallet";
-    // Default RPC url for wallet node
-    static ref DEFAULT_WALLET_NODE_RPC_URL: &'static str = "http://127.0.0.1:20002";
-    // Default RPC url for evo node
-    static ref DEFAULT_EVO_NODE_RPC_URL: &'static str = "http://127.0.0.1:20302";
 }
 
 struct StdLogger;
@@ -79,16 +75,6 @@ impl log::Log for StdLogger {
 
 static LOGGER: StdLogger = StdLogger;
 
-/// Assert that the call returns a "deprecated" error.
-macro_rules! assert_deprecated {
-    ($call:expr) => {
-        match $call.unwrap_err() {
-            Error::JsonRpc(JsonRpcError::Rpc(ref e)) if e.code == -32 => {}
-            e => panic!("expected deprecated error for {}, got: {}", stringify!($call), e),
-        }
-    };
-}
-
 /// Assert that the call returns a "method not found" error.
 macro_rules! assert_not_found {
     ($call:expr) => {
@@ -220,10 +206,10 @@ fn main() {
     evo_client.get_blockchain_info().unwrap();
 
     // Create/Load test wallet to perform operations on RPC
-    match wallet_client.load_wallet(&TEST_WALLET_NAME) {
+    match wallet_client.load_wallet(TEST_WALLET_NAME) {
         Err(e) => match e {
             dashcore_rpc::Error::JsonRpc(JsonRpcError::Rpc(ref e)) if e.code == -18 => {
-                wallet_client.create_wallet(&TEST_WALLET_NAME, None, None, None, None).unwrap();
+                wallet_client.create_wallet(TEST_WALLET_NAME, None, None, None, None).unwrap();
                 trace!(target: "integration_test", "Wallet \"{}\" created", TEST_WALLET_NAME);
             }
             dashcore_rpc::Error::JsonRpc(JsonRpcError::Rpc(ref e)) if e.code == -35 => {
@@ -1243,8 +1229,8 @@ fn test_create_wallet(cl: &Client) {
     wallet_list.sort();
 
     // Main wallet created for tests
-    assert!(wallet_list.iter().any(|w| w == &TEST_WALLET_NAME || w == &FAUCET_WALLET_NAME));
-    wallet_list.retain(|w| w != &TEST_WALLET_NAME && !w.is_empty() && w != &FAUCET_WALLET_NAME);
+    assert!(wallet_list.iter().any(|w| w == TEST_WALLET_NAME || w == FAUCET_WALLET_NAME));
+    wallet_list.retain(|w| w != TEST_WALLET_NAME && !w.is_empty() && w != FAUCET_WALLET_NAME);
 
     // Created wallets
     assert!(wallet_list.iter().zip(wallet_names).all(|(a, b)| a == b));
@@ -1424,7 +1410,7 @@ fn test_get_quorum_dkgstatus(cl: &Client) {
     // assert!(quorum_dkgstatus.minable_commitments.len() >= 0);
 }
 
-fn test_get_quorum_sign(cl: &Client, wallet_client: &Client) {
+fn test_get_quorum_sign(cl: &Client, _wallet_client: &Client) {
     let list = cl.get_quorum_list(Some(1)).unwrap();
     let quorum_type = list.quorums_by_type.keys().next().unwrap().to_owned();
 
@@ -1536,9 +1522,9 @@ fn test_get_protx_info(cl: &Client) {
     let ProTxInfo {
         pro_tx_hash: _,
         collateral_hash: _,
-        collateral_index,
+        collateral_index: _,
         collateral_address: _,
-        operator_reward,
+        operator_reward: _,
         state: _,
         confirmations: _,
         wallet: _,