fix: multiple code improvements across rust-dashcore

- Fix unsafe CString usage in test_client.rs by using CStr::from_ptr
- Add error handling for missing masternode fields in fetch_terminal_blocks.py
- Remove unnecessary f-string prefixes in fetch_terminal_blocks.py
- Clarify error message in chain_tip.rs for single active tip
- Add MAX_PENDING_CHAINLOCKS limit to prevent unbounded queue growth
- Remove unnecessary header clone in orphan_pool.rs
- Fix incorrectly prefixed storage parameter in filters.rs

🤖 Generated with [Claude Code](https://claude.ai/code)

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

Author: 2 people

dash-spv-ffi/tests/test_client.rs

@@ -233,7 +233,7 @@ mod tests {
                 println!("Warning: Failed to start client, error code: {}", start_result);
                 let error = dash_spv_ffi_get_last_error();
                 if !error.is_null() {
-                    let error_str = CString::from_raw(error as *mut _);
+                    let error_str = std::ffi::CStr::from_ptr(error);
                     println!("Error message: {:?}", error_str);
                 }
             }

dash-spv/scripts/fetch_terminal_blocks.py

@@ -77,14 +77,26 @@ def fetch_terminal_block_data(network, height, genesis_hash):
     # Extract relevant data
     masternode_list = []
     for mn in diff_result.get("mnList", []):
-        masternode_list.append({
-            "pro_tx_hash": mn["proRegTxHash"],
-            "service": mn["service"],
-            "pub_key_operator": mn["pubKeyOperator"],
-            "voting_address": mn["votingAddress"],
-            "is_valid": mn["isValid"],
-            "n_type": mn.get("nType", 0),
-        })
+        try:
+            # Check for required fields and skip entry if any are missing
+            required_fields = ["proRegTxHash", "service", "pubKeyOperator", "votingAddress", "isValid"]
+            missing_fields = [field for field in required_fields if field not in mn]
+            
+            if missing_fields:
+                print(f"Warning: Masternode entry missing required fields: {missing_fields}. Skipping entry.")
+                continue
+            
+            masternode_list.append({
+                "pro_tx_hash": mn["proRegTxHash"],
+                "service": mn["service"],
+                "pub_key_operator": mn["pubKeyOperator"],
+                "voting_address": mn["votingAddress"],
+                "is_valid": mn["isValid"],
+                "n_type": mn.get("nType", 0),  # Default to 0 if not present
+            })
+        except Exception as e:
+            print(f"Error processing masternode entry: {e}. Skipping entry.")
+            continue
 
     return {
         "height": height,
@@ -150,12 +162,12 @@ def main():
                 json_file = output_dir / f"terminal_block_{height}.json"
                 if json_file.exists():
                     f.write(f'    // Terminal block {height}\n')
-                    f.write(f'    {{\n')
+                    f.write('    {\n')
                     f.write(f'        let data = include_str!("terminal_block_{height}.json");\n')
-                    f.write(f'        if let Ok(state) = serde_json::from_str::<TerminalBlockMasternodeState>(data) {{\n')
-                    f.write(f'            manager.add_state(state);\n')
-                    f.write(f'        }}\n')
-                    f.write(f'    }}\n\n')
+                    f.write('        if let Ok(state) = serde_json::from_str::<TerminalBlockMasternodeState>(data) {\n')
+                    f.write('            manager.add_state(state);\n')
+                    f.write('        }\n')
+                    f.write('    }\n\n')
 
             f.write("}\n")
 

dash-spv/src/chain/chain_tip.rs

@@ -181,7 +181,7 @@ impl ChainTipManager {
             self.tips.remove(&hash);
             Ok(())
         } else {
-            Err("Cannot evict: all tips are active")
+            Err("Cannot evict: the only tip present is active")
         }
     }
 

dash-spv/src/chain/chainlock_manager.rs

@@ -13,6 +13,9 @@ use crate::error::{StorageError, StorageResult, ValidationError, ValidationResul
 use crate::storage::StorageManager;
 use crate::types::ChainState;
 
+/// Maximum number of pending ChainLocks to queue
+const MAX_PENDING_CHAINLOCKS: usize = 100;
+
 /// ChainLock storage entry
 #[derive(Debug, Clone)]
 pub struct ChainLockEntry {
@@ -70,6 +73,16 @@ impl ChainLockManager {
     pub fn queue_pending_chainlock(&self, chain_lock: ChainLock) -> StorageResult<()> {
         let mut pending = self.pending_chainlocks.write()
             .map_err(|_| StorageError::LockPoisoned("pending_chainlocks".to_string()))?;
+        
+        // If at capacity, drop the oldest ChainLock
+        if pending.len() >= MAX_PENDING_CHAINLOCKS {
+            let dropped = pending.remove(0);
+            warn!(
+                "Pending ChainLocks queue at capacity ({}), dropping oldest ChainLock at height {}",
+                MAX_PENDING_CHAINLOCKS, dropped.block_height
+            );
+        }
+        
         pending.push(chain_lock);
         debug!("Queued ChainLock for pending validation, total pending: {}", pending.len());
         Ok(())

dash-spv/src/chain/orphan_pool.rs

@@ -71,19 +71,20 @@ impl OrphanPool {
 
         // Create orphan entry
         let orphan = OrphanBlock {
-            header: header.clone(),
+            header,
             received_at: Instant::now(),
             process_attempts: 0,
         };
 
         // Index by previous block
-        self.orphans_by_prev.entry(header.prev_blockhash).or_default().push(orphan.clone());
+        let prev_blockhash = orphan.header.prev_blockhash;
+        self.orphans_by_prev.entry(prev_blockhash).or_default().push(orphan.clone());
 
         // Index by hash
         self.orphans_by_hash.insert(block_hash, orphan);
         self.eviction_queue.push_back(block_hash);
 
-        debug!("Added orphan block {} (prev: {})", block_hash, header.prev_blockhash);
+        debug!("Added orphan block {} (prev: {})", block_hash, prev_blockhash);
 
         true
     }

dash-spv/src/sync/filters.rs

@@ -1459,7 +1459,7 @@ impl FilterSyncManager {
         &mut self,
         range: (u32, u32),
         _network: &mut dyn NetworkManager,
-        _storage: &dyn StorageManager,
+        storage: &dyn StorageManager,
     ) -> SyncResult<()> {
         let (start, end) = range;
         let retry_count = self.filter_retry_counts.get(&range).copied().unwrap_or(0);
@@ -1478,7 +1478,7 @@ impl FilterSyncManager {
         }
 
         // Calculate stop hash for retry
-        match _storage.get_header(end).await {
+        match storage.get_header(end).await {
             Ok(Some(header)) => {
                 let stop_hash = header.block_hash();