fix: avoid X11 hash with wrong input size in tests

X11 hash requires exactly 80 bytes (block header size). Tests were
incorrectly passing arbitrary small data. Use BlockHash::from_byte_array
with padded test data instead.

Author: xdustinface

dash-spv/src/chain/chainlock_test.rs

@@ -5,6 +5,13 @@ mod tests {
     use dashcore::{BlockHash, ChainLock, Network};
     use dashcore_hashes::Hash;
 
+    /// Create a test block hash from a single byte (for distinct test hashes)
+    fn test_block_hash(id: u8) -> BlockHash {
+        let mut bytes = [0u8; 32];
+        bytes[0] = id;
+        BlockHash::from_byte_array(bytes)
+    }
+
     #[tokio::test]
     async fn test_chainlock_processing() {
         // Create storage and ChainLock manager
@@ -16,7 +23,7 @@ mod tests {
         // Create a test ChainLock
         let chainlock = ChainLock {
             block_height: 1000,
-            block_hash: BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::hash(&[1, 2, 3])),
+            block_hash: test_block_hash(1),
             signature: dashcore::bls_sig_utils::BLSSignature::from([0; 96]),
         };
 
@@ -49,7 +56,7 @@ mod tests {
         // Process first ChainLock at height 1000
         let chainlock1 = ChainLock {
             block_height: 1000,
-            block_hash: BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::hash(&[1, 2, 3])),
+            block_hash: test_block_hash(1),
             signature: dashcore::bls_sig_utils::BLSSignature::from([0; 96]),
         };
         chainlock_manager
@@ -60,7 +67,7 @@ mod tests {
         // Process second ChainLock at height 2000
         let chainlock2 = ChainLock {
             block_height: 2000,
-            block_hash: BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::hash(&[4, 5, 6])),
+            block_hash: test_block_hash(2),
             signature: dashcore::bls_sig_utils::BLSSignature::from([1; 96]),
         };
         chainlock_manager
@@ -85,12 +92,10 @@ mod tests {
             DiskStorageManager::with_temp_dir().await.expect("Failed to create tmp storage");
 
         // Add ChainLocks at heights 1000, 2000, 3000
-        for height in [1000, 2000, 3000] {
+        for (i, height) in [1000u32, 2000, 3000].iter().enumerate() {
             let chainlock = ChainLock {
-                block_height: height,
-                block_hash: BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::hash(
-                    &height.to_le_bytes(),
-                )),
+                block_height: *height,
+                block_hash: test_block_hash((i + 10) as u8),
                 signature: dashcore::bls_sig_utils::BLSSignature::from([0; 96]),
             };
             chainlock_manager

dash-spv/src/chain/checkpoint_test.rs

@@ -6,21 +6,28 @@ mod tests {
     use dashcore::{BlockHash, CompactTarget, Target};
     use dashcore_hashes::Hash;
 
+    /// Create a test block hash from a height (for distinct test hashes)
+    fn test_block_hash(height: u32) -> BlockHash {
+        let mut bytes = [0u8; 32];
+        bytes[..4].copy_from_slice(&height.to_le_bytes());
+        BlockHash::from_byte_array(bytes)
+    }
+
     fn create_test_checkpoint(height: u32, timestamp: u32) -> Checkpoint {
-        let hash_bytes = dashcore_hashes::hash_x11::Hash::hash(&height.to_le_bytes());
-        let prev_bytes = if height > 0 {
-            dashcore_hashes::hash_x11::Hash::hash(&(height - 1).to_le_bytes())
+        let block_hash = test_block_hash(height);
+        let prev_blockhash = if height > 0 {
+            test_block_hash(height - 1)
         } else {
-            dashcore_hashes::hash_x11::Hash::all_zeros()
+            BlockHash::from_byte_array([0u8; 32])
         };
 
         Checkpoint {
             height,
-            block_hash: BlockHash::from_raw_hash(hash_bytes),
-            prev_blockhash: BlockHash::from_raw_hash(prev_bytes),
+            block_hash,
+            prev_blockhash,
             timestamp,
             target: Target::from_compact(CompactTarget::from_consensus(0x1d00ffff)),
-            merkle_root: Some(BlockHash::from_raw_hash(hash_bytes)),
+            merkle_root: Some(block_hash),
             chain_work: format!("0x{:064x}", height * 1000),
             masternode_list_name: if height.is_multiple_of(100000) && height > 0 {
                 Some(format!("ML{}__70230", height))