more fixes

Author: QuantumExplorer

dash/src/bip152.rs

@@ -504,7 +504,7 @@ mod test {
     fn test_getblocktx_panic_when_encoding_u64_max() {
         serialize(&BlockTransactionsRequest {
             block_hash: Hash::all_zeros(),
-            indexes: vec![core::u64::MAX],
+            indexes: vec![u64::MAX],
         });
     }
 }

dash/src/blockdata/fee_rate.rs

@@ -138,7 +138,6 @@ crate::parse::impl_parse_str_from_int_infallible!(FeeRate, u64, from_sat_per_kwu
 
 #[cfg(test)]
 mod tests {
-    use std::u64;
 
     use super::*;
 

dash/src/consensus/encode.rs

@@ -1438,7 +1438,7 @@ mod tests {
             .is_err()
         );
 
-        let rand_io_err = Error::Io(io::Error::new(io::ErrorKind::Other, ""));
+        let rand_io_err = Error::Io(io::Error::other(""));
 
         // Check serialization that `if len > MAX_VEC_SIZE {return err}` isn't inclusive,
         // by making sure it fails with IO Error and not an `OversizedVectorAllocation` Error.
@@ -1466,7 +1466,7 @@ mod tests {
         Vec<T>: Decodable,
         T: fmt::Debug,
     {
-        let rand_io_err = Error::Io(io::Error::new(io::ErrorKind::Other, ""));
+        let rand_io_err = Error::Io(io::Error::other(""));
         let varint = VarInt((super::MAX_VEC_SIZE / mem::size_of::<T>()) as u64);
         let err = deserialize::<Vec<T>>(&serialize(&varint)).unwrap_err();
         assert_eq!(discriminant(&err), discriminant(&rand_io_err));
@@ -1617,7 +1617,7 @@ mod tests {
                 // Expect the write to succeed
                 let bytes_written = result.expect("Failed to write");
                 // Calculate expected bytes written
-                let expected_bytes = (size + 7) / 8;
+                let expected_bytes = size.div_ceil(8);
                 assert_eq!(
                     bytes_written, expected_bytes,
                     "Incorrect number of bytes written for bitset with size {}",

dash/src/crypto/sighash.rs

@@ -1563,7 +1563,6 @@ mod tests {
 
         #[derive(serde::Deserialize)]
         #[serde(rename_all = "camelCase")]
-
         struct KpsGiven {
             #[serde(with = "con_serde::With::<con_serde::Hex>")]
             raw_unsigned_tx: Transaction,
@@ -1572,7 +1571,6 @@ mod tests {
 
         #[derive(serde::Deserialize)]
         #[serde(rename_all = "camelCase")]
-
         struct KpsIntermediary {
             hash_prevouts: sha256::Hash,
             hash_outputs: sha256::Hash,
@@ -1583,7 +1581,6 @@ mod tests {
 
         #[derive(serde::Deserialize)]
         #[serde(rename_all = "camelCase")]
-
         struct KpsInputSpendingGiven {
             txin_index: usize,
             internal_privkey: SecretKey,
@@ -1594,7 +1591,6 @@ mod tests {
 
         #[derive(serde::Deserialize)]
         #[serde(rename_all = "camelCase")]
-
         struct KpsInputSpendingIntermediary {
             internal_pubkey: XOnlyPublicKey,
             tweak: TapTweakHash,
@@ -1606,14 +1602,12 @@ mod tests {
 
         #[derive(serde::Deserialize)]
         #[serde(rename_all = "camelCase")]
-
         struct KpsInputSpendingExpected {
             witness: Vec<String>,
         }
 
         #[derive(serde::Deserialize)]
         #[serde(rename_all = "camelCase")]
-
         struct KpsInputSpending {
             given: KpsInputSpendingGiven,
             intermediary: KpsInputSpendingIntermediary,
@@ -1623,7 +1617,6 @@ mod tests {
 
         #[derive(serde::Deserialize)]
         #[serde(rename_all = "camelCase")]
-
         struct KeyPathSpending {
             given: KpsGiven,
             intermediary: KpsIntermediary,
@@ -1632,7 +1625,6 @@ mod tests {
 
         #[derive(serde::Deserialize)]
         #[serde(rename_all = "camelCase")]
-
         struct TestData {
             version: u64,
             key_path_spending: Vec<KeyPathSpending>,

dash/src/merkle_tree/block.rs

@@ -601,7 +601,7 @@ mod tests {
         let mut height = 1;
         let mut ntx = tx_count;
         while ntx > 1 {
-            ntx = (ntx + 1) / 2;
+            ntx = ntx.div_ceil(2);
             height += 1;
         }
 
@@ -629,7 +629,7 @@ mod tests {
 
             // Verify PartialMerkleTree's size guarantees
             let n = min(tx_count, 1 + match_txid1.len() * height);
-            assert!(serialized.len() <= 10 + (258 * n + 7) / 8);
+            assert!(serialized.len() <= 10 + (258 * n).div_ceil(8));
 
             // Deserialize into a tester copy
             let pmt2: PartialMerkleTree =

dash/src/network/message.rs

@@ -994,7 +994,7 @@ mod test {
         // Verify
         match decoded.payload {
             NetworkMessage::SendDsq(wants_dsq) => {
-                assert_eq!(wants_dsq, true);
+                assert!(wants_dsq);
             }
             _ => panic!("Expected SendDsq message"),
         }
@@ -1015,7 +1015,7 @@ mod test {
         // Verify
         match decoded.payload {
             NetworkMessage::SendDsq(wants_dsq) => {
-                assert_eq!(wants_dsq, false);
+                assert!(!wants_dsq);
             }
             _ => panic!("Expected SendDsq message"),
         }

dash/src/pow.rs

@@ -1490,7 +1490,7 @@ mod tests {
 
             let config = bincode::config::standard();
 
-            let bin_encoded = bincode::encode_to_vec(&uint, config).unwrap();
+            let bin_encoded = bincode::encode_to_vec(uint, config).unwrap();
             let bin_decoded: U256 = bincode::decode_from_slice(&bin_encoded, config).unwrap().0;
             assert_eq!(bin_decoded, uint);
         };

dash/src/sml/masternode_list_engine/mod.rs

@@ -1278,19 +1278,19 @@ mod tests {
         let block_container_bytes: &[u8] =
             include_bytes!("../../../tests/data/test_DML_diffs/block_container_2240504.dat");
         let block_container: MasternodeListEngineBlockContainer =
-            bincode::decode_from_slice(&block_container_bytes, bincode::config::standard())
+            bincode::decode_from_slice(block_container_bytes, bincode::config::standard())
                 .expect("expected to decode")
                 .0;
         let mn_list_diffs_bytes: &[u8] =
             include_bytes!("../../../tests/data/test_DML_diffs/mnlistdiffs_2240504.dat");
         let mn_list_diffs: BTreeMap<(CoreBlockHeight, CoreBlockHeight), MnListDiff> =
-            bincode::decode_from_slice(&mn_list_diffs_bytes, bincode::config::standard())
+            bincode::decode_from_slice(mn_list_diffs_bytes, bincode::config::standard())
                 .expect("expected to decode")
                 .0;
         let qr_info_bytes: &[u8] =
             include_bytes!("../../../tests/data/test_DML_diffs/qrinfo_2240504.dat");
         let qr_info: QRInfo =
-            bincode::decode_from_slice(&qr_info_bytes, bincode::config::standard())
+            bincode::decode_from_slice(qr_info_bytes, bincode::config::standard())
                 .expect("expected to decode")
                 .0;
 
@@ -1403,10 +1403,9 @@ mod tests {
 
         for (cycle_hash, quorums) in mn_list_engine.rotated_quorums_per_cycle.iter() {
             for (i, quorum) in quorums.iter().enumerate() {
-                mn_list_engine.validate_quorum(quorum).expect(
-                    format!("expected to validate quorum {} in cycle hash {}", i, cycle_hash)
-                        .as_str(),
-                );
+                mn_list_engine.validate_quorum(quorum).unwrap_or_else(|_| {
+                    panic!("expected to validate quorum {} in cycle hash {}", i, cycle_hash)
+                });
             }
         }
     }

dash/src/sml/quorum_entry/validation.rs

@@ -134,7 +134,7 @@ mod tests {
         #[test]
         fn test_real_operator_key_compatibility() {
             // Real operator public keys from mainnet quorum at height 2300832
-            let real_keys = vec![
+            let real_keys = [
                 hex!(
                     "86e7ea34cc084da3ed0e90649ad444df0ca25d638164a596b4fbec9567bbcf3e635a8d8457107e7fe76326f3816e34d9"
                 ),
@@ -294,7 +294,7 @@ mod tests {
                     println!("Verification with modern sig format: {:?}", result);
 
                     // Try with reversed block hash (endianness)
-                    let mut reversed_hash = block_hash.clone();
+                    let mut reversed_hash = block_hash;
                     reversed_hash.reverse();
                     let result_reversed = sig.verify(&pk, &reversed_hash);
                     println!("Verification with reversed block hash: {:?}", result_reversed);
@@ -399,7 +399,7 @@ mod tests {
             for _ in 0..10 {
                 let _ = verify_secure_basic_with_mode::<Bls12381G2Impl, _>(
                     &operator_keys,
-                    inner_sig.clone(),
+                    inner_sig,
                     msg,
                     SerializationFormat::Modern,
                 );
@@ -412,7 +412,7 @@ mod tests {
             for _ in 0..iterations {
                 let _ = verify_secure_basic_with_mode::<Bls12381G2Impl, _>(
                     &operator_keys,
-                    inner_sig.clone(),
+                    inner_sig,
                     msg,
                     SerializationFormat::Modern,
                 );

key-wallet-ffi/include/key_wallet_ffi.h

@@ -1294,10 +1294,6 @@ FFIAccount *account_collection_get_identity_topup_not_bound(const FFIAccountColl
 FFIBLSAccount *account_collection_get_provider_operator_keys(const FFIAccountCollection *collection)
 ;
 
-/*
- Get the provider operator keys account if it exists (stub when BLS is disabled)
- */
- void *account_collection_get_provider_operator_keys(const FFIAccountCollection *_collection) ;
 
 /*
  Check if provider operator keys account exists
@@ -1321,10 +1317,6 @@ FFIBLSAccount *account_collection_get_provider_operator_keys(const FFIAccountCol
 FFIEdDSAAccount *account_collection_get_provider_platform_keys(const FFIAccountCollection *collection)
 ;
 
-/*
- Get the provider platform keys account if it exists (stub when EdDSA is disabled)
- */
- void *account_collection_get_provider_platform_keys(const FFIAccountCollection *_collection) ;
 
 /*
  Check if provider platform keys account exists