Replace unstable byte-array API with stable slice/inner API

- Replace secp256k1::SecretKey::from_byte_array with from_slice
- Replace bitcoin_hashes::Hash::to_byte_array() with into_inner()
- Updates across 30+ files for MSRV compatibility
- Fixes deprecated API usage in preparation for future Rust versions

Author: PastaPastaPasta

dash-spv/src/mempool_filter.rs

@@ -277,10 +277,10 @@ mod tests {
             let mut data = seed.to_vec();
             data.extend_from_slice(&index.to_le_bytes());
 
-            let secret_bytes = sha256::Hash::hash(&data).to_byte_array();
+            let secret_bytes = sha256::Hash::hash(&data).into_inner();
 
             // Try to create secp256k1 SecretKey from the hash
-            match secp256k1::SecretKey::from_byte_array(&secret_bytes) {
+            match secp256k1::SecretKey::from_slice(&secret_bytes) {
                 Ok(secret_key) => {
                     // Create PrivateKey from SecretKey
                     let private_key = PrivateKey::new(secret_key, network);

dash-spv/src/sync/filters.rs

@@ -952,7 +952,7 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
             data[32..].copy_from_slice(prev_header.as_byte_array());
 
             let filter_header =
-                FilterHeader::from_byte_array(sha256d::Hash::hash(&data).to_byte_array());
+                FilterHeader::from_byte_array(sha256d::Hash::hash(&data).into_inner());
 
             if i < 1 || i >= cf_headers.filter_hashes.len() - 1 {
                 tracing::trace!(

dash-spv/tests/filter_header_verification_test.rs

@@ -199,7 +199,7 @@ fn calculate_expected_filter_header(
     let mut data = [0u8; 64];
     data[..32].copy_from_slice(filter_hash.as_byte_array());
     data[32..].copy_from_slice(prev_filter_header.as_byte_array());
-    FilterHeader::from_byte_array(sha256d::Hash::hash(&data).to_byte_array())
+    FilterHeader::from_byte_array(sha256d::Hash::hash(&data).into_inner())
 }
 
 #[ignore = "mock implementation incomplete"]
@@ -488,7 +488,7 @@ async fn test_overlapping_batches_from_different_peers() {
         .expect("Should have filter header at height 1499");
 
     // Simulate Peer B having computed this header differently - create a slightly different value
-    let mut peer_b_prev_bytes = peer_b_prev_filter_header_stored.to_byte_array();
+    let mut peer_b_prev_bytes = peer_b_prev_filter_header_stored.into_inner();
     peer_b_prev_bytes[0] ^= 0x01; // Flip one bit to make it different
     let peer_b_prev_filter_header = FilterHeader::from_byte_array(peer_b_prev_bytes);
 

dash/src/bip158.rs

@@ -177,7 +177,7 @@ pub struct BlockFilterWriter<'a, W> {
 impl<'a, W: io::Write> BlockFilterWriter<'a, W> {
     /// Creates a new [`BlockFilterWriter`] from `block`.
     pub fn new(writer: &'a mut W, block: &'a Block) -> BlockFilterWriter<'a, W> {
-        let block_hash_as_int = block.block_hash().to_byte_array();
+        let block_hash_as_int = block.block_hash().into_inner();
         let k0 = u64::from_le_bytes(block_hash_as_int[0..8].try_into().expect("8 byte slice"));
         let k1 = u64::from_le_bytes(block_hash_as_int[8..16].try_into().expect("8 byte slice"));
         let writer = GcsFilterWriter::new(writer, k0, k1, M, P);
@@ -239,7 +239,7 @@ pub struct BlockFilterReader {
 impl BlockFilterReader {
     /// Creates a new [`BlockFilterReader`] from `block_hash`.
     pub fn new(block_hash: &BlockHash) -> BlockFilterReader {
-        let block_hash_as_int = block_hash.to_byte_array();
+        let block_hash_as_int = block_hash.into_inner();
         let k0 = u64::from_le_bytes(block_hash_as_int[0..8].try_into().expect("8 byte slice"));
         let k1 = u64::from_le_bytes(block_hash_as_int[8..16].try_into().expect("8 byte slice"));
         BlockFilterReader {

dash/src/blockdata/constants.rs

@@ -228,7 +228,7 @@ impl ChainHash {
 
     /// Converts genesis block hash into `ChainHash`.
     pub fn from_genesis_block_hash(block_hash: crate::BlockHash) -> Self {
-        ChainHash(block_hash.to_byte_array())
+        ChainHash(block_hash.into_inner())
     }
 }
 

dash/src/crypto/key.rs

@@ -164,7 +164,7 @@ impl PublicKey {
     pub fn wpubkey_hash(&self) -> Option<WPubkeyHash> {
         if self.compressed {
             Some(WPubkeyHash::from_byte_array(
-                hash160::Hash::hash(&self.inner.serialize()).to_byte_array(),
+                hash160::Hash::hash(&self.inner.serialize()).into_inner(),
             ))
         } else {
             // We can't create witness pubkey hashes for an uncompressed
@@ -398,7 +398,7 @@ impl PrivateKey {
     }
 
     pub fn from_byte_array(data: &[u8; 32], network: Network) -> Result<PrivateKey, Error> {
-        Ok(PrivateKey::new(secp256k1::SecretKey::from_byte_array(data)?, network))
+        Ok(PrivateKey::new(secp256k1::SecretKey::from_slice(data)?, network))
     }
 
     /// Format the private key to WIF format.
@@ -450,7 +450,7 @@ impl PrivateKey {
         Ok(PrivateKey {
             compressed,
             network,
-            inner: secp256k1::SecretKey::from_byte_array(
+            inner: secp256k1::SecretKey::from_slice(
                 <&[u8; 32]>::try_from(&data[1..33]).expect("expected 32 bytes"),
             )?,
         })

dash/src/crypto/sighash.rs

@@ -1260,7 +1260,7 @@ mod tests {
         let mut enc = TapSighash::engine();
         enc.input(&bytes);
         let hash = TapSighash::from_engine(enc);
-        assert_eq!(expected, hash.to_byte_array());
+        assert_eq!(expected, hash.into_inner());
     }
 
     #[ignore]
@@ -1526,7 +1526,7 @@ mod tests {
             .taproot_signature_hash(input_index, &prevouts, annex, leaf_hash, sighash_type)
             .unwrap();
         let expected = hex!(expected_hash);
-        assert_eq!(expected, hash.to_byte_array());
+        assert_eq!(expected, hash.into_inner());
     }
 
     #[cfg(feature = "serde")]
@@ -1708,7 +1708,7 @@ mod tests {
                 .taproot_signature_hash(tx_ind, &Prevouts::All(&utxos), None, None, hash_ty)
                 .unwrap();
 
-            let msg = secp256k1::Message::from_digest(sighash.to_byte_array());
+            let msg = secp256k1::Message::from_digest(sighash.into_inner());
             let key_spend_sig =
                 secp.sign_schnorr_with_aux_rand(msg.as_ref(), &tweaked_keypair, &[0u8; 32]);
 

dash/src/hash_types.rs

@@ -160,8 +160,8 @@ mod newtypes {
 
     impl Ord for ScoreHash {
         fn cmp(&self, other: &Self) -> Ordering {
-            let mut self_bytes = self.0.to_byte_array();
-            let mut other_bytes = other.0.to_byte_array();
+            let mut self_bytes = self.0.into_inner();
+            let mut other_bytes = other.0.into_inner();
 
             self_bytes.reverse();
             other_bytes.reverse();
@@ -268,9 +268,9 @@ mod newtypes {
             if let Some(confirmed_hash_hashed_with_pro_reg_tx) =
                 confirmed_hash_hashed_with_pro_reg_tx
             {
-                bytes.append(&mut confirmed_hash_hashed_with_pro_reg_tx.to_byte_array().to_vec());
+                bytes.append(&mut confirmed_hash_hashed_with_pro_reg_tx.into_inner().to_vec());
             }
-            bytes.append(&mut modifier.to_byte_array().to_vec());
+            bytes.append(&mut modifier.into_inner().to_vec());
             Self::hash(bytes.as_slice())
         }
     }
@@ -333,15 +333,15 @@ mod newtypes {
 
         /// Hashes the members
         pub fn hash_members(pro_tx_hash: &ProTxHash, confirmed_hash: &ConfirmedHash) -> Self {
-            Self::hash(&[pro_tx_hash.to_byte_array(), confirmed_hash.to_byte_array()].concat())
+            Self::hash(&[pro_tx_hash.into_inner(), confirmed_hash.into_inner()].concat())
         }
         /// Hashes the members
         pub fn hash_members_confirmed_hash_optional(
             pro_tx_hash: &ProTxHash,
             confirmed_hash: Option<&ConfirmedHash>,
         ) -> Option<Self> {
             confirmed_hash.map(|confirmed_hash| {
-                Self::hash(&[pro_tx_hash.to_byte_array(), confirmed_hash.to_byte_array()].concat())
+                Self::hash(&[pro_tx_hash.into_inner(), confirmed_hash.into_inner()].concat())
             })
         }
     }

dash/src/merkle_tree/block.rs

@@ -317,7 +317,7 @@ impl PartialMerkleTree {
         if hash_used != self.hashes.len() as u32 {
             return Err(NotAllHashesConsumed);
         }
-        Ok(TxMerkleNode::from_byte_array(hash_merkle_root.to_byte_array()))
+        Ok(TxMerkleNode::from_byte_array(hash_merkle_root.into_inner()))
     }
 
     /// Helper function to efficiently calculate the number of nodes at given height
@@ -331,7 +331,7 @@ impl PartialMerkleTree {
     fn calc_hash(&self, height: u32, pos: u32, txids: &[Txid]) -> TxMerkleNode {
         if height == 0 {
             // Hash at height 0 is the txid itself
-            TxMerkleNode::from_byte_array(txids[pos as usize].to_byte_array())
+            TxMerkleNode::from_byte_array(txids[pos as usize].into_inner())
         } else {
             // Calculate left hash
             let left = self.calc_hash(height - 1, pos * 2, txids);
@@ -396,7 +396,7 @@ impl PartialMerkleTree {
             *hash_used += 1;
             if height == 0 && parent_of_match {
                 // in case of height 0, we have a matched txid
-                matches.push(Txid::from_byte_array(hash.to_byte_array()));
+                matches.push(Txid::from_byte_array(hash.into_inner()));
                 indexes.push(pos);
             }
             Ok(hash)
@@ -763,7 +763,7 @@ mod tests {
             let n = rng.gen_range(0..self.hashes.len());
             let bit = rng.r#gen::<u8>();
             let hashes = &mut self.hashes;
-            let mut hash = hashes[n].to_byte_array();
+            let mut hash = hashes[n].into_inner();
             hash[(bit >> 3) as usize] ^= 1 << (bit & 7);
             hashes[n] = TxMerkleNode::from_slice(&hash).unwrap();
         }

dash/src/pow.rs

@@ -210,7 +210,7 @@ impl Target {
     /// to the target.
     pub fn is_met_by(&self, hash: BlockHash) -> bool {
         use hashes::Hash;
-        let hash = U256::from_le_bytes(hash.to_byte_array());
+        let hash = U256::from_le_bytes(hash.into_inner());
         hash <= self.0
     }
 
@@ -1598,7 +1598,7 @@ mod tests {
         let hash =
             BlockHash::from_str("ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c")
                 .expect("failed to parse block hash");
-        let target = Target(U256::from_le_bytes(hash.to_byte_array()));
+        let target = Target(U256::from_le_bytes(hash.into_inner()));
         assert!(target.is_met_by(hash));
     }