diff --git a/dash-spv/src/client/lifecycle.rs b/dash-spv/src/client/lifecycle.rs
index 3c27c0c0c..6d76fb1be 100644
--- a/dash-spv/src/client/lifecycle.rs
+++ b/dash-spv/src/client/lifecycle.rs
@@ -62,7 +62,7 @@ impl<
         .map_err(SpvError::Sync)?;
 
         // Create validation manager
-        let validation = ValidationManager::new(config.validation_mode);
+        let validation = ValidationManager::new(config.validation_mode, config.network);
 
         // Create ChainLock manager
         let chainlock_manager = Arc::new(ChainLockManager::new(true));
diff --git a/dash-spv/src/client/sync_coordinator.rs b/dash-spv/src/client/sync_coordinator.rs
index edd043c1a..ebd81a037 100644
--- a/dash-spv/src/client/sync_coordinator.rs
+++ b/dash-spv/src/client/sync_coordinator.rs
@@ -931,7 +931,7 @@ impl<
             // Validate headers before adding to chain state
             {
                 // Validate the batch of headers
-                if let Err(e) = self.validation.validate_header_chain(&headers, false) {
+                if let Err(e) = self.validation.validate_headers(&headers) {
                     tracing::error!(
                         "Header validation failed for range {}..{}: {:?}",
                         current_height,
diff --git a/dash-spv/src/validation/headers.rs b/dash-spv/src/validation/headers.rs
index 8baa281a9..2c4dbfa61 100644
--- a/dash-spv/src/validation/headers.rs
+++ b/dash-spv/src/validation/headers.rs
@@ -16,10 +16,10 @@ pub struct HeaderValidator {
 
 impl HeaderValidator {
     /// Create a new header validator.
-    pub fn new(mode: ValidationMode) -> Self {
+    pub fn new(mode: ValidationMode, network: Network) -> Self {
         Self {
             mode,
-            network: Network::Dash, // Default to mainnet
+            network,
         }
     }
 
@@ -28,11 +28,6 @@ impl HeaderValidator {
         self.mode = mode;
     }
 
-    /// Set network.
-    pub fn set_network(&mut self, network: Network) {
-        self.network = network;
-    }
-
     /// Validate a single header.
     pub fn validate(
         &self,
@@ -76,55 +71,23 @@ impl HeaderValidator {
         // Validate proof of work with X11 hashing (now enabled with core-block-hash-use-x11 feature)
         let target = header.target();
         if let Err(e) = header.validate_pow(target) {
-            match e {
-                DashError::BlockBadProofOfWork => {
-                    return Err(ValidationError::InvalidProofOfWork);
-                }
+            return match e {
+                DashError::BlockBadProofOfWork => Err(ValidationError::InvalidProofOfWork),
                 DashError::BlockBadTarget => {
-                    return Err(ValidationError::InvalidHeaderChain("Invalid target".to_string()));
+                    Err(ValidationError::InvalidHeaderChain("Invalid target".to_string()))
                 }
-                _ => {
-                    return Err(ValidationError::InvalidHeaderChain(format!(
-                        "PoW validation error: {:?}",
-                        e
-                    )));
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Validate a chain of headers with basic validation.
-    pub fn validate_chain_basic(&self, headers: &[BlockHeader]) -> ValidationResult<()> {
-        // Respect ValidationMode::None
-        if self.mode == ValidationMode::None {
-            return Ok(());
-        }
-
-        if headers.is_empty() {
-            return Ok(());
-        }
-
-        // Validate chain continuity
-        for i in 1..headers.len() {
-            let header = &headers[i];
-            let prev_header = &headers[i - 1];
-
-            self.validate_basic(header, Some(prev_header))?;
+                _ => Err(ValidationError::InvalidHeaderChain(format!(
+                    "PoW validation error: {:?}",
+                    e
+                ))),
+            };
         }
 
-        tracing::debug!("Basic header chain validation passed for {} headers", headers.len());
         Ok(())
     }
 
-    /// Validate a chain of headers with full validation.
-    pub fn validate_chain_full(
-        &self,
-        headers: &[BlockHeader],
-        validate_pow: bool,
-    ) -> ValidationResult<()> {
-        // Respect ValidationMode::None
+    /// Validate a chain of headers considering the validation mode.
+    pub fn validate_headers(&self, headers: &[BlockHeader]) -> ValidationResult<()> {
         if self.mode == ValidationMode::None {
             return Ok(());
         }
@@ -145,14 +108,14 @@ impl HeaderValidator {
                 None
             };
 
-            if validate_pow {
-                self.validate_full(header, prev_header)?;
-            } else {
-                self.validate_basic(header, prev_header)?;
-            }
+            self.validate(header, prev_header)?;
         }
 
-        tracing::debug!("Full header chain validation passed for {} headers", headers.len());
+        tracing::debug!(
+            "Header chain validation passed for {} headers in mode: {:?}",
+            headers.len(),
+            self.mode
+        );
         Ok(())
     }
 
@@ -174,23 +137,6 @@ impl HeaderValidator {
 
         Ok(())
     }
-
-    /// Validate difficulty adjustment (simplified for SPV).
-    pub fn validate_difficulty_adjustment(
-        &self,
-        header: &BlockHeader,
-        prev_header: &BlockHeader,
-    ) -> ValidationResult<()> {
-        // For SPV client, we trust that the network has validated difficulty properly
-        // We only check basic constraints
-
-        // For SPV we trust the network for difficulty validation
-        // TODO: Implement proper difficulty validation if needed
-        let _prev_target = prev_header.target();
-        let _current_target = header.target();
-
-        Ok(())
-    }
 }
 
 #[cfg(test)]
diff --git a/dash-spv/src/validation/headers_edge_test.rs b/dash-spv/src/validation/headers_edge_test.rs
index 7ebd12393..8662b1fc4 100644
--- a/dash-spv/src/validation/headers_edge_test.rs
+++ b/dash-spv/src/validation/headers_edge_test.rs
@@ -33,10 +33,9 @@ mod tests {
 
     #[test]
     fn test_genesis_block_validation() {
-        let mut validator = HeaderValidator::new(ValidationMode::Full);
-
         for network in [Network::Dash, Network::Testnet, Network::Regtest] {
-            validator.set_network(network);
+            let validator = HeaderValidator::new(ValidationMode::Full, network);
+
             let genesis = genesis_block(network).header;
 
             // Genesis block should validate with no previous header
@@ -50,7 +49,7 @@ mod tests {
 
     #[test]
     fn test_maximum_target_validation() {
-        let validator = HeaderValidator::new(ValidationMode::Full);
+        let validator = HeaderValidator::new(ValidationMode::Full, Network::Dash);
 
         // Create header with maximum allowed target (easiest difficulty)
         let max_target_bits = 0x1e0fffff; // Maximum target for testing
@@ -71,7 +70,7 @@ mod tests {
 
     #[test]
     fn test_minimum_target_validation() {
-        let validator = HeaderValidator::new(ValidationMode::Full);
+        let validator = HeaderValidator::new(ValidationMode::Full, Network::Dash);
 
         // Create header with very low target (hardest difficulty)
         let min_target_bits = 0x17000000; // Very difficult target
@@ -93,7 +92,7 @@ mod tests {
 
     #[test]
     fn test_zero_prev_blockhash() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // First header with zero prev_blockhash (like genesis)
         let header1 = create_test_header_with_params(
@@ -126,7 +125,7 @@ mod tests {
 
     #[test]
     fn test_all_ff_prev_blockhash() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // Header with all 0xFF prev_blockhash
         let header = create_test_header_with_params(
@@ -162,7 +161,7 @@ mod tests {
 
     #[test]
     fn test_timestamp_boundaries() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // Test with minimum timestamp (0)
         let header_min_time = create_test_header_with_params(
@@ -193,7 +192,7 @@ mod tests {
 
     #[test]
     fn test_version_edge_cases() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // Test various version values
         let versions = [0, 1, 0x20000000, 0x20000001, u32::MAX];
@@ -217,7 +216,7 @@ mod tests {
 
     #[test]
     fn test_large_chain_validation() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // Create a large chain
         let chain_size = 1000;
@@ -240,7 +239,7 @@ mod tests {
         }
 
         // Should validate entire chain
-        assert!(validator.validate_chain_basic(&headers).is_ok());
+        assert!(validator.validate_headers(&headers).is_ok());
 
         // Break the chain in the middle
         let broken_index = chain_size / 2;
@@ -256,14 +255,12 @@ mod tests {
         );
 
         // Should fail validation
-        let result = validator.validate_chain_basic(&headers);
+        let result = validator.validate_headers(&headers);
         assert!(matches!(result, Err(ValidationError::InvalidHeaderChain(_))));
     }
 
     #[test]
     fn test_single_header_chain_validation() {
-        let validator = HeaderValidator::new(ValidationMode::Full);
-
         let header = create_test_header_with_params(
             0x20000000,
             dashcore::BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::from_byte_array(
@@ -277,14 +274,15 @@ mod tests {
 
         let headers = vec![header];
 
-        // Single header chain should validate in both basic and full modes
-        assert!(validator.validate_chain_basic(&headers).is_ok());
-        assert!(validator.validate_chain_full(&headers, false).is_ok());
+        // Single header chain should validate
+        assert!(HeaderValidator::new(ValidationMode::Basic, Network::Dash)
+            .validate_headers(&headers)
+            .is_ok());
     }
 
     #[test]
     fn test_duplicate_headers_in_chain() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         let header = create_test_header_with_params(
             0x20000000,
@@ -301,13 +299,13 @@ mod tests {
         let headers = vec![header, header];
 
         // Should fail because second header's prev_blockhash won't match first header's hash
-        let result = validator.validate_chain_basic(&headers);
+        let result = validator.validate_headers(&headers);
         assert!(matches!(result, Err(ValidationError::InvalidHeaderChain(_))));
     }
 
     #[test]
     fn test_merkle_root_variations() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // Test various merkle root patterns
         let merkle_patterns = [
@@ -340,7 +338,7 @@ mod tests {
 
     #[test]
     fn test_mode_switching_during_chain_validation() {
-        let mut validator = HeaderValidator::new(ValidationMode::None);
+        let mut validator = HeaderValidator::new(ValidationMode::None, Network::Dash);
 
         // Create headers with invalid PoW
         let mut headers = vec![];
@@ -361,18 +359,16 @@ mod tests {
             headers.push(header);
         }
 
-        // Should pass with None mode (ValidationMode::None always passes)
-        let result = validator.validate_chain_full(&headers, true);
+        let result = validator.validate_headers(&headers);
         assert!(result.is_ok(), "ValidationMode::None should always pass, but got: {:?}", result);
 
-        // Switch to Full mode
         validator.set_mode(ValidationMode::Full);
-
         // Should now fail due to invalid PoW
-        let result = validator.validate_chain_full(&headers, true);
+        let result = validator.validate_headers(&headers);
         assert!(matches!(result, Err(ValidationError::InvalidProofOfWork)));
 
-        // But should pass without PoW check
-        assert!(validator.validate_chain_full(&headers, false).is_ok());
+        validator.set_mode(ValidationMode::None);
+        let result = validator.validate_headers(&headers);
+        assert!(result.is_ok(), "ValidationMode::None should always pass, but got: {:?}", result);
     }
 }
diff --git a/dash-spv/src/validation/headers_test.rs b/dash-spv/src/validation/headers_test.rs
index 7c53bf636..b7bede8d3 100644
--- a/dash-spv/src/validation/headers_test.rs
+++ b/dash-spv/src/validation/headers_test.rs
@@ -31,7 +31,7 @@ mod tests {
 
     #[test]
     fn test_validation_mode_none_always_passes() {
-        let validator = HeaderValidator::new(ValidationMode::None);
+        let validator = HeaderValidator::new(ValidationMode::None, Network::Dash);
         let header = create_test_header(
             dashcore::BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::from_byte_array(
                 [0; 32],
@@ -58,7 +58,7 @@ mod tests {
 
     #[test]
     fn test_basic_validation_chain_continuity() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // Create two headers that connect properly
         let header1 = create_test_header(
@@ -89,7 +89,7 @@ mod tests {
 
     #[test]
     fn test_basic_validation_no_pow_check() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // Create header with invalid PoW (would fail full validation)
         let header = create_test_header(
@@ -107,7 +107,7 @@ mod tests {
 
     #[test]
     fn test_full_validation_includes_pow() {
-        let validator = HeaderValidator::new(ValidationMode::Full);
+        let validator = HeaderValidator::new(ValidationMode::Full, Network::Dash);
 
         // Create header with invalid PoW
         let header = create_test_header(
@@ -126,7 +126,7 @@ mod tests {
 
     #[test]
     fn test_full_validation_chain_continuity_and_pow() {
-        let validator = HeaderValidator::new(ValidationMode::Full);
+        let validator = HeaderValidator::new(ValidationMode::Full, Network::Dash);
 
         // Create headers that don't connect
         let header1 = create_test_header(
@@ -152,17 +152,18 @@ mod tests {
     }
 
     #[test]
-    fn test_validate_chain_basic_empty() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
-        let headers: Vec<BlockHeader> = vec![];
-
-        // Empty chain should pass
-        assert!(validator.validate_chain_basic(&headers).is_ok());
+    fn test_validate_headers_empty() {
+        for mode in [ValidationMode::None, ValidationMode::Basic, ValidationMode::Full] {
+            let validator = HeaderValidator::new(mode, Network::Dash);
+            let headers: Vec<BlockHeader> = vec![];
+            // Empty chain should pass
+            assert!(validator.validate_headers(&headers).is_ok());
+        }
     }
 
     #[test]
-    fn test_validate_chain_basic_single_header() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+    fn test_validate_headers_basic_single_header() {
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
         let header = create_test_header(
             dashcore::BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::from_byte_array(
                 [0; 32],
@@ -174,12 +175,12 @@ mod tests {
         let headers = vec![header];
 
         // Single header should pass (no chain validation needed)
-        assert!(validator.validate_chain_basic(&headers).is_ok());
+        assert!(validator.validate_headers(&headers).is_ok());
     }
 
     #[test]
-    fn test_validate_chain_basic_valid_chain() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+    fn test_validate_headers_basic_valid_chain() {
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // Create a valid chain of headers
         let mut headers = vec![];
@@ -194,12 +195,12 @@ mod tests {
         }
 
         // Valid chain should pass
-        assert!(validator.validate_chain_basic(&headers).is_ok());
+        assert!(validator.validate_headers(&headers).is_ok());
     }
 
     #[test]
-    fn test_validate_chain_basic_broken_chain() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+    fn test_validate_headers_basic_broken_chain() {
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         // Create a chain with a break in the middle
         let header1 = create_test_header(
@@ -223,13 +224,13 @@ mod tests {
         let headers = vec![header1, header2, header3];
 
         // Should fail due to broken chain
-        let result = validator.validate_chain_basic(&headers);
+        let result = validator.validate_headers(&headers);
         assert!(matches!(result, Err(ValidationError::InvalidHeaderChain(_))));
     }
 
     #[test]
-    fn test_validate_chain_full_with_pow() {
-        let validator = HeaderValidator::new(ValidationMode::Full);
+    fn test_validate_headers_full_with_pow() {
+        let validator = HeaderValidator::new(ValidationMode::Full, Network::Dash);
 
         // Create headers with invalid PoW
         let header1 = create_test_header(
@@ -243,17 +244,13 @@ mod tests {
         let headers = vec![header1];
 
         // Should fail when PoW validation is enabled
-        let result = validator.validate_chain_full(&headers, true);
+        let result = validator.validate_headers(&headers);
         assert!(matches!(result, Err(ValidationError::InvalidProofOfWork)));
-
-        // Should pass when PoW validation is disabled
-        assert!(validator.validate_chain_full(&headers, false).is_ok());
     }
 
     #[test]
     fn test_validate_connects_to_genesis_mainnet() {
-        let mut validator = HeaderValidator::new(ValidationMode::Basic);
-        validator.set_network(Network::Dash);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
 
         let genesis = genesis_block(Network::Dash).header;
         let valid_header =
@@ -281,8 +278,7 @@ mod tests {
 
     #[test]
     fn test_validate_connects_to_genesis_testnet() {
-        let mut validator = HeaderValidator::new(ValidationMode::Basic);
-        validator.set_network(Network::Testnet);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Testnet);
 
         let genesis = genesis_block(Network::Testnet).header;
         let valid_header =
@@ -296,7 +292,7 @@ mod tests {
 
     #[test]
     fn test_validate_connects_to_genesis_empty() {
-        let validator = HeaderValidator::new(ValidationMode::Basic);
+        let validator = HeaderValidator::new(ValidationMode::Basic, Network::Dash);
         let headers: Vec<BlockHeader> = vec![];
 
         // Empty chain should pass
@@ -305,7 +301,7 @@ mod tests {
 
     #[test]
     fn test_set_validation_mode() {
-        let mut validator = HeaderValidator::new(ValidationMode::None);
+        let mut validator = HeaderValidator::new(ValidationMode::None, Network::Dash);
 
         // Create header with broken chain continuity
         let header1 = create_test_header(
@@ -341,47 +337,4 @@ mod tests {
         // Should pass again
         assert!(validator.validate(&disconnected_header, Some(&header1)).is_ok());
     }
-
-    #[test]
-    fn test_network_setting() {
-        let mut validator = HeaderValidator::new(ValidationMode::Basic);
-
-        // Test with different networks (skip Regtest as it may not have a known genesis hash)
-        for network in [Network::Dash, Network::Testnet] {
-            validator.set_network(network);
-
-            let genesis = genesis_block(network).header;
-            let valid_header =
-                create_test_header(genesis.block_hash(), 1, 0x1e0fffff, genesis.time + 600);
-
-            let headers = vec![valid_header];
-            assert!(validator.validate_connects_to_genesis(&headers).is_ok());
-        }
-
-        // For Regtest, just verify we can set the network
-        validator.set_network(Network::Regtest);
-    }
-
-    #[test]
-    fn test_validate_difficulty_adjustment() {
-        let validator = HeaderValidator::new(ValidationMode::Full);
-
-        let header1 = create_test_header(
-            dashcore::BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::from_byte_array(
-                [0; 32],
-            )),
-            1,
-            0x1e0fffff,
-            1234567890,
-        );
-        let header2 = create_test_header(
-            header1.block_hash(),
-            2,
-            0x1e0ffff0, // Slightly different difficulty
-            1234567900,
-        );
-
-        // Currently just passes - SPV trusts network for difficulty
-        assert!(validator.validate_difficulty_adjustment(&header2, &header1).is_ok());
-    }
 }
diff --git a/dash-spv/src/validation/manager_test.rs b/dash-spv/src/validation/manager_test.rs
index bb8c98a8e..2ed6a28f0 100644
--- a/dash-spv/src/validation/manager_test.rs
+++ b/dash-spv/src/validation/manager_test.rs
@@ -59,19 +59,19 @@ mod tests {
 
     #[test]
     fn test_validation_manager_creation() {
-        let manager = ValidationManager::new(ValidationMode::Basic);
+        let manager = ValidationManager::new(ValidationMode::Basic, Network::Dash);
         assert_eq!(manager.mode(), ValidationMode::Basic);
 
-        let manager = ValidationManager::new(ValidationMode::Full);
+        let manager = ValidationManager::new(ValidationMode::Full, Network::Dash);
         assert_eq!(manager.mode(), ValidationMode::Full);
 
-        let manager = ValidationManager::new(ValidationMode::None);
+        let manager = ValidationManager::new(ValidationMode::None, Network::Dash);
         assert_eq!(manager.mode(), ValidationMode::None);
     }
 
     #[test]
     fn test_validation_manager_mode_change() {
-        let mut manager = ValidationManager::new(ValidationMode::None);
+        let mut manager = ValidationManager::new(ValidationMode::None, Network::Dash);
         assert_eq!(manager.mode(), ValidationMode::None);
 
         manager.set_mode(ValidationMode::Basic);
@@ -83,7 +83,7 @@ mod tests {
 
     #[test]
     fn test_header_validation_with_mode_none() {
-        let manager = ValidationManager::new(ValidationMode::None);
+        let manager = ValidationManager::new(ValidationMode::None, Network::Dash);
 
         let header = create_test_header(
             dashcore::BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::from_byte_array(
@@ -109,7 +109,7 @@ mod tests {
 
     #[test]
     fn test_header_validation_with_mode_basic() {
-        let manager = ValidationManager::new(ValidationMode::Basic);
+        let manager = ValidationManager::new(ValidationMode::Basic, Network::Dash);
 
         // Valid chain continuity
         let header1 = create_test_header(
@@ -138,7 +138,7 @@ mod tests {
 
     #[test]
     fn test_header_validation_with_mode_full() {
-        let manager = ValidationManager::new(ValidationMode::Full);
+        let manager = ValidationManager::new(ValidationMode::Full, Network::Dash);
 
         // Header with invalid PoW
         let header = create_test_header(
@@ -155,11 +155,10 @@ mod tests {
 
     #[test]
     fn test_header_chain_validation_none() {
-        let manager = ValidationManager::new(ValidationMode::None);
+        let manager = ValidationManager::new(ValidationMode::None, Network::Dash);
 
         // Even an empty chain should pass
-        assert!(manager.validate_header_chain(&[], false).is_ok());
-        assert!(manager.validate_header_chain(&[], true).is_ok());
+        assert!(manager.validate_headers(&[]).is_ok());
 
         // Even broken chains should pass
         let headers = vec![
@@ -167,13 +166,12 @@ mod tests {
             create_test_header(dashcore::BlockHash::from_byte_array([99; 32]), 2, 0x1e0fffff),
         ];
 
-        assert!(manager.validate_header_chain(&headers, false).is_ok());
-        assert!(manager.validate_header_chain(&headers, true).is_ok());
+        assert!(manager.validate_headers(&headers).is_ok());
     }
 
     #[test]
     fn test_header_chain_validation_basic() {
-        let manager = ValidationManager::new(ValidationMode::Basic);
+        let manager = ValidationManager::new(ValidationMode::Basic, Network::Dash);
 
         // Valid chain
         let mut headers = vec![];
@@ -187,7 +185,7 @@ mod tests {
             headers.push(header);
         }
 
-        assert!(manager.validate_header_chain(&headers, false).is_ok());
+        assert!(manager.validate_headers(&headers).is_ok());
 
         // Broken chain
         headers[2] = create_test_header(
@@ -198,13 +196,13 @@ mod tests {
             0x1e0fffff,
         );
 
-        let result = manager.validate_header_chain(&headers, false);
+        let result = manager.validate_headers(&headers);
         assert!(matches!(result, Err(ValidationError::InvalidHeaderChain(_))));
     }
 
     #[test]
     fn test_header_chain_validation_full() {
-        let manager = ValidationManager::new(ValidationMode::Full);
+        let manager = ValidationManager::new(ValidationMode::Full, Network::Dash);
 
         // Headers with invalid PoW
         let headers = vec![create_test_header(
@@ -215,17 +213,14 @@ mod tests {
             0x1d00ffff,
         )];
 
-        // Should pass when validate_pow is false
-        assert!(manager.validate_header_chain(&headers, false).is_ok());
-
-        // Should fail when validate_pow is true
-        let result = manager.validate_header_chain(&headers, true);
+        // Should fail because of the POW validation
+        let result = manager.validate_headers(&headers);
         assert!(matches!(result, Err(ValidationError::InvalidProofOfWork)));
     }
 
     #[test]
     fn test_instantlock_validation_none() {
-        let manager = ValidationManager::new(ValidationMode::None);
+        let manager = ValidationManager::new(ValidationMode::None, Network::Dash);
         let instantlock = create_test_instantlock();
 
         // Should always pass
@@ -234,7 +229,7 @@ mod tests {
 
     #[test]
     fn test_instantlock_validation_basic() {
-        let manager = ValidationManager::new(ValidationMode::Basic);
+        let manager = ValidationManager::new(ValidationMode::Basic, Network::Dash);
         let instantlock = create_test_instantlock();
 
         // Basic validation should check structure
@@ -246,7 +241,7 @@ mod tests {
 
     #[test]
     fn test_instantlock_validation_full() {
-        let manager = ValidationManager::new(ValidationMode::Full);
+        let manager = ValidationManager::new(ValidationMode::Full, Network::Dash);
         let instantlock = create_test_instantlock();
 
         // Full validation should check structure and signatures
@@ -257,7 +252,7 @@ mod tests {
 
     #[test]
     fn test_mode_switching_affects_validation() {
-        let mut manager = ValidationManager::new(ValidationMode::None);
+        let mut manager = ValidationManager::new(ValidationMode::None, Network::Dash);
 
         // Create headers with broken chain
         let header1 = create_test_header(
@@ -294,13 +289,14 @@ mod tests {
 
     #[test]
     fn test_empty_header_chain_validation() {
-        for mode in [ValidationMode::None, ValidationMode::Basic, ValidationMode::Full] {
-            let manager = ValidationManager::new(mode);
-            let empty_chain: Vec<BlockHeader> = vec![];
-
-            // Empty chains should always pass
-            assert!(manager.validate_header_chain(&empty_chain, false).is_ok());
-            assert!(manager.validate_header_chain(&empty_chain, true).is_ok());
+        for network in [Network::Dash, Network::Testnet, Network::Devnet, Network::Regtest] {
+            for mode in [ValidationMode::None, ValidationMode::Basic, ValidationMode::Full] {
+                let manager = ValidationManager::new(mode, network);
+                let empty_chain: Vec<BlockHeader> = vec![];
+
+                // Empty chains should always pass
+                assert!(manager.validate_headers(&empty_chain).is_ok());
+            }
         }
     }
 }
diff --git a/dash-spv/src/validation/mod.rs b/dash-spv/src/validation/mod.rs
index 57feab2a6..d6723305f 100644
--- a/dash-spv/src/validation/mod.rs
+++ b/dash-spv/src/validation/mod.rs
@@ -4,7 +4,7 @@ pub mod headers;
 pub mod instantlock;
 pub mod quorum;
 
-use dashcore::{block::Header as BlockHeader, InstantLock};
+use dashcore::{block::Header as BlockHeader, InstantLock, Network};
 
 use crate::error::ValidationResult;
 use crate::types::ValidationMode;
@@ -22,10 +22,10 @@ pub struct ValidationManager {
 
 impl ValidationManager {
     /// Create a new validation manager.
-    pub fn new(mode: ValidationMode) -> Self {
+    pub fn new(mode: ValidationMode, network: Network) -> Self {
         Self {
             mode,
-            header_validator: HeaderValidator::new(mode),
+            header_validator: HeaderValidator::new(mode, network),
             instantlock_validator: InstantLockValidator::new(),
         }
     }
@@ -36,27 +36,12 @@ impl ValidationManager {
         header: &BlockHeader,
         prev_header: Option<&BlockHeader>,
     ) -> ValidationResult<()> {
-        match self.mode {
-            ValidationMode::None => Ok(()),
-            ValidationMode::Basic | ValidationMode::Full => {
-                self.header_validator.validate(header, prev_header)
-            }
-        }
+        self.header_validator.validate(header, prev_header)
     }
 
     /// Validate a chain of headers.
-    pub fn validate_header_chain(
-        &self,
-        headers: &[BlockHeader],
-        validate_pow: bool,
-    ) -> ValidationResult<()> {
-        match self.mode {
-            ValidationMode::None => Ok(()),
-            ValidationMode::Basic => self.header_validator.validate_chain_basic(headers),
-            ValidationMode::Full => {
-                self.header_validator.validate_chain_full(headers, validate_pow)
-            }
-        }
+    pub fn validate_headers(&self, headers: &[BlockHeader]) -> ValidationResult<()> {
+        self.header_validator.validate_headers(headers)
     }
 
     /// Validate an InstantLock (structural validation only).