refactor: key wallet clippy warnings

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/blockdata/transaction/mod.rs

@@ -468,7 +468,7 @@ impl Transaction {
         S: FnMut(&OutPoint) -> Option<TxOut>,
         F: Into<u32>,
     {
-        let tx = encode::serialize(&*self);
+        let tx = encode::serialize(self);
         let flags: u32 = flags.into();
         for (idx, input) in self.input.iter().enumerate() {
             if let Some(output) = spent(&input.previous_output) {
@@ -479,7 +479,7 @@ impl Transaction {
                     flags,
                 )?;
             } else {
-                return Err(script::Error::UnknownSpentOutput(input.previous_output.clone()));
+                return Err(script::Error::UnknownSpentOutput(input.previous_output));
             }
         }
         Ok(())

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,
                 );

hashes/Cargo.toml

@@ -16,7 +16,7 @@ exclude = ["tests", "contrib"]
 default = ["std"]
 std = ["alloc", "internals/std"]
 alloc = ["internals/alloc"]
-schemars = ["actual-schemars", "dyn-clone"]
+schemars = ["actual-schemars"]
 serde-std = ["serde/std"]
 x11 = ["rs-x11-hash"]
 
@@ -31,10 +31,7 @@ core2 = { version = "0.4.0", default-features = false, optional = true }
 # Only enable this if you explicitly do not want to use "std", otherwise enable "serde-std".
 serde = { version = "1.0.219", default-features = false, optional = true }
 # Do NOT use this as a feature! Use the `schemars` feature instead. Can only be used with "std" enabled.
-actual-schemars = { package = "schemars", version = "<=0.8.3", optional = true }
-# Do NOT enable this dependency, this is just to pin dyn-clone (transitive dep from schemars)
-# because 1.0.8 does not build with Rust 1.41.1 (because of useage of `Arc::as_ptr`).
-dyn-clone = { version = "<=1.0.7", default-features = false, optional = true }
+actual-schemars = { package = "schemars", version = "1.0", optional = true }
 secp256k1 = { default-features = false, features = ["hashes"], version= "0.30.0" }
 
 rs-x11-hash = { version = "0.1.8", optional = true }

hashes/src/util.rs

@@ -583,19 +583,19 @@ macro_rules! hash_newtype_known_attrs {
 
 #[cfg(feature = "schemars")]
 pub mod json_hex_string {
-    use schemars::JsonSchema;
-    use schemars::r#gen::SchemaGenerator;
-    use schemars::schema::{Schema, SchemaObject};
+    use schemars::SchemaGenerator;
+    use schemars::{Schema, json_schema};
+
     macro_rules! define_custom_hex {
         ($name:ident, $len:expr) => {
-            pub fn $name(generator: &mut SchemaGenerator) -> Schema {
-                let mut schema: SchemaObject = <String>::json_schema(generator).into();
-                schema.string = Some(Box::new(schemars::schema::StringValidation {
-                    max_length: Some($len * 2),
-                    min_length: Some($len * 2),
-                    pattern: Some("[0-9a-fA-F]+".to_owned()),
-                }));
-                schema.into()
+            pub fn $name(_generator: &mut SchemaGenerator) -> Schema {
+                // In schemars 1.0, we can use the json_schema! macro to create schemas
+                json_schema!({
+                    "type": "string",
+                    "minLength": $len * 2,
+                    "maxLength": $len * 2,
+                    "pattern": "^[0-9a-fA-F]+$"
+                })
             }
         };
     }

key-wallet-ffi/include/key_wallet_ffi.h

@@ -3789,16 +3789,30 @@ void wallet_manager_free_addresses(char **addresses,
 
 /*
  Encrypt a private key with BIP38
+
+ # Safety
+
+ This function is unsafe because it dereferences raw pointers:
+ - `private_key` must be a valid, null-terminated C string
+ - `passphrase` must be a valid, null-terminated C string
+ - `error` must be a valid pointer to an FFIError or null
  */
 
 char *bip38_encrypt_private_key(const char *private_key,
                                 const char *passphrase,
-                                FFINetwork network,
+                                FFINetwork _network,
                                 FFIError *error)
 ;
 
 /*
  Decrypt a BIP38 encrypted private key
+
+ # Safety
+
+ This function is unsafe because it dereferences raw pointers:
+ - `encrypted_key` must be a valid, null-terminated C string
+ - `passphrase` must be a valid, null-terminated C string
+ - `error` must be a valid pointer to an FFIError or null
  */
 
 char *bip38_decrypt_private_key(const char *encrypted_key,

key-wallet-ffi/src/account_collection.rs

@@ -1151,7 +1151,7 @@ mod tests {
             options.option_type = crate::types::FFIAccountCreationOptionType::AllAccounts;
 
             // Add provider operator keys account type
-            let special_types = vec![crate::types::FFIAccountType::ProviderOperatorKeys];
+            let special_types = [crate::types::FFIAccountType::ProviderOperatorKeys];
             options.special_account_types = special_types.as_ptr();
             options.special_account_types_count = special_types.len();
 
@@ -1199,7 +1199,7 @@ mod tests {
             options.option_type = crate::types::FFIAccountCreationOptionType::AllAccounts;
 
             // Add provider platform keys account type
-            let special_types = vec![crate::types::FFIAccountType::ProviderPlatformKeys];
+            let special_types = [crate::types::FFIAccountType::ProviderPlatformKeys];
             options.special_account_types = special_types.as_ptr();
             options.special_account_types_count = special_types.len();
 
@@ -1248,7 +1248,7 @@ mod tests {
             options.option_type = crate::types::FFIAccountCreationOptionType::AllAccounts;
 
             // Add various special accounts
-            let special_types = vec![
+            let special_types = [
                 crate::types::FFIAccountType::ProviderVotingKeys,
                 crate::types::FFIAccountType::ProviderOwnerKeys,
                 crate::types::FFIAccountType::IdentityRegistration,
@@ -1258,10 +1258,10 @@ mod tests {
             options.special_account_types_count = special_types.len();
 
             // Configure standard accounts - store vectors in variables to keep them alive
-            let bip44_indices = vec![0, 4, 5, 8];
-            let bip32_indices = vec![0];
-            let coinjoin_indices = vec![0, 1];
-            let topup_indices = vec![0, 1, 2];
+            let bip44_indices = [0, 4, 5, 8];
+            let bip32_indices = [0];
+            let coinjoin_indices = [0, 1];
+            let topup_indices = [0, 1, 2];
 
             options.bip44_indices = bip44_indices.as_ptr();
             options.bip44_count = bip44_indices.len();
@@ -1392,7 +1392,7 @@ mod tests {
             options.option_type = crate::types::FFIAccountCreationOptionType::AllAccounts;
 
             // Add various special accounts
-            let special_types = vec![
+            let special_types = [
                 crate::types::FFIAccountType::ProviderVotingKeys,
                 crate::types::FFIAccountType::ProviderOwnerKeys,
                 crate::types::FFIAccountType::IdentityRegistration,
@@ -1402,10 +1402,10 @@ mod tests {
             options.special_account_types_count = special_types.len();
 
             // Configure standard accounts
-            let bip44_indices = vec![0, 4, 5, 8];
-            let bip32_indices = vec![0];
-            let coinjoin_indices = vec![0, 1];
-            let topup_indices = vec![0, 1, 2];
+            let bip44_indices = [0, 4, 5, 8];
+            let bip32_indices = [0];
+            let coinjoin_indices = [0, 1];
+            let topup_indices = [0, 1, 2];
 
             options.bip44_indices = bip44_indices.as_ptr();
             options.bip44_count = bip44_indices.len();

key-wallet-ffi/src/account_tests.rs

@@ -1,4 +1,5 @@
 #[cfg(test)]
+#[allow(clippy::module_inception)]
 mod tests {
     use super::super::*;
     use crate::error::{FFIError, FFIErrorCode};