feat: Parallelize header validation with rayon

Pre-calculate `CachedHeader` block hashes in parallel and split header validation into two steps:

1. Validate continuity
2. Parallelized PoW checks

### Timing on a Macbook with M2 Pro

  | Validation Mode | Before (avg) | After (avg) |
  |-----------------|--------------|-------------|
  | Basic           | 78.74 ms     | 0.067 ms    |
  | Full            | 154.33 ms    | 10.12 ms    |

Author: xdustinface

dash-spv/Cargo.toml

@@ -44,6 +44,9 @@ rand = "0.8"
 hex = "0.4"
 indexmap = "2.0"
 
+# Parallelization
+rayon = "1.11"
+
 # Terminal UI (optional)
 crossterm = { version = "0.27", optional = true }
 

dash-spv/src/sync/headers/manager.rs

@@ -16,6 +16,7 @@ use crate::sync::headers::validate_headers;
 use crate::sync::headers2::Headers2StateManager;
 use crate::types::{CachedHeader, ChainState};
 use std::sync::Arc;
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use tokio::sync::RwLock;
 
 /// Configuration for reorg handling
@@ -247,8 +248,15 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
 
         // Wrap headers in CachedHeader to avoid redundant X11 hashing
         // This prevents recomputing hashes during validation, logging, and storage
-        let cached_headers: Vec<CachedHeader> =
-            headers.iter().map(|h| CachedHeader::new(*h)).collect();
+        // Precalculate the block hashes in parallel
+        let cached_headers: Vec<CachedHeader> = headers
+            .par_iter()
+            .map(|h| {
+                let cached = CachedHeader::new(*h);
+                let _ = cached.block_hash();
+                cached
+            })
+            .collect();
 
         // Step 2: Validate Batch
         let first_cached = &cached_headers[0];

dash-spv/src/sync/headers/validation.rs

@@ -1,6 +1,7 @@
 //! Header validation functionality.
 
 use dashcore::{block::Header as BlockHeader, error::Error as DashError, BlockHash};
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use std::time::Instant;
 
 use crate::error::{ValidationError, ValidationResult};
@@ -58,7 +59,7 @@ impl ValidationHeader for CachedHeader {
 /// Validate a chain of headers considering the validation mode.
 pub fn validate_headers<H>(headers: &[H], mode: ValidationMode) -> ValidationResult<()>
 where
-    H: ValidationHeader,
+    H: ValidationHeader + Send + Sync,
 {
     if mode == ValidationMode::None {
         tracing::debug!("Skipping header validation: disabled");
@@ -82,15 +83,14 @@ where
                 ));
             }
         }
-
-        if mode == ValidationMode::Full {
-            // Validate proof of work with X11 hashing
-            header.validate_pow()?;
-        }
-
         prev_block_hash = Some(header.block_hash());
     }
 
+    if mode == ValidationMode::Full {
+        // Parallelized proof of work validation
+        headers.par_iter().try_for_each(|header| header.validate_pow())?;
+    }
+
     tracing::debug!(
         "Header chain validation passed for {} headers in mode: {:?}, duration: {:?}",
         headers.len(),