refactor: key wallet clippy warnings

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};

key-wallet-ffi/src/bip38.rs

@@ -1,18 +1,25 @@
 //! BIP38 encryption support
 
-use std::ffi::{CStr, CString};
+use std::ffi::CStr;
 use std::os::raw::c_char;
 use std::ptr;
 
 use crate::error::{FFIError, FFIErrorCode};
 use crate::types::FFINetwork;
 
 /// 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
 #[no_mangle]
-pub extern "C" fn bip38_encrypt_private_key(
+pub unsafe extern "C" fn bip38_encrypt_private_key(
     private_key: *const c_char,
     passphrase: *const c_char,
-    network: FFINetwork,
+    _network: FFINetwork,
     error: *mut FFIError,
 ) -> *mut c_char {
     #[cfg(feature = "bip38")]
@@ -26,31 +33,27 @@ pub extern "C" fn bip38_encrypt_private_key(
             return ptr::null_mut();
         }
 
-        let privkey_str = unsafe {
-            match CStr::from_ptr(private_key).to_str() {
-                Ok(s) => s,
-                Err(_) => {
-                    FFIError::set_error(
-                        error,
-                        FFIErrorCode::InvalidInput,
-                        "Invalid UTF-8 in private key".to_string(),
-                    );
-                    return ptr::null_mut();
-                }
+        let _privkey_str = match CStr::from_ptr(private_key).to_str() {
+            Ok(s) => s,
+            Err(_) => {
+                FFIError::set_error(
+                    error,
+                    FFIErrorCode::InvalidInput,
+                    "Invalid UTF-8 in private key".to_string(),
+                );
+                return ptr::null_mut();
             }
         };
 
-        let passphrase_str = unsafe {
-            match CStr::from_ptr(passphrase).to_str() {
-                Ok(s) => s,
-                Err(_) => {
-                    FFIError::set_error(
-                        error,
-                        FFIErrorCode::InvalidInput,
-                        "Invalid UTF-8 in passphrase".to_string(),
-                    );
-                    return ptr::null_mut();
-                }
+        let _passphrase_str = match CStr::from_ptr(passphrase).to_str() {
+            Ok(s) => s,
+            Err(_) => {
+                FFIError::set_error(
+                    error,
+                    FFIErrorCode::InvalidInput,
+                    "Invalid UTF-8 in passphrase".to_string(),
+                );
+                return ptr::null_mut();
             }
         };
 
@@ -75,8 +78,15 @@ pub extern "C" fn bip38_encrypt_private_key(
 }
 
 /// 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
 #[no_mangle]
-pub extern "C" fn bip38_decrypt_private_key(
+pub unsafe extern "C" fn bip38_decrypt_private_key(
     encrypted_key: *const c_char,
     passphrase: *const c_char,
     error: *mut FFIError,
@@ -92,31 +102,27 @@ pub extern "C" fn bip38_decrypt_private_key(
             return ptr::null_mut();
         }
 
-        let encrypted_str = unsafe {
-            match CStr::from_ptr(encrypted_key).to_str() {
-                Ok(s) => s,
-                Err(_) => {
-                    FFIError::set_error(
-                        error,
-                        FFIErrorCode::InvalidInput,
-                        "Invalid UTF-8 in encrypted key".to_string(),
-                    );
-                    return ptr::null_mut();
-                }
+        let _encrypted_str = match CStr::from_ptr(encrypted_key).to_str() {
+            Ok(s) => s,
+            Err(_) => {
+                FFIError::set_error(
+                    error,
+                    FFIErrorCode::InvalidInput,
+                    "Invalid UTF-8 in encrypted key".to_string(),
+                );
+                return ptr::null_mut();
             }
         };
 
-        let passphrase_str = unsafe {
-            match CStr::from_ptr(passphrase).to_str() {
-                Ok(s) => s,
-                Err(_) => {
-                    FFIError::set_error(
-                        error,
-                        FFIErrorCode::InvalidInput,
-                        "Invalid UTF-8 in passphrase".to_string(),
-                    );
-                    return ptr::null_mut();
-                }
+        let _passphrase_str = match CStr::from_ptr(passphrase).to_str() {
+            Ok(s) => s,
+            Err(_) => {
+                FFIError::set_error(
+                    error,
+                    FFIErrorCode::InvalidInput,
+                    "Invalid UTF-8 in passphrase".to_string(),
+                );
+                return ptr::null_mut();
             }
         };
 

key-wallet-ffi/src/derivation_tests.rs

@@ -1,6 +1,7 @@
 //! Tests for derivation path FFI functions
 
 #[cfg(test)]
+#[allow(clippy::module_inception)]
 mod tests {
     use crate::derivation::*;
     use crate::error::{FFIError, FFIErrorCode};

key-wallet-ffi/src/keys_tests.rs

@@ -1,6 +1,7 @@
 //! Tests for key derivation FFI functions
 
 #[cfg(test)]
+#[allow(clippy::module_inception)]
 mod tests {
     use crate::error::{FFIError, FFIErrorCode};
     use crate::keys::*;

key-wallet-ffi/src/managed_account.rs

@@ -856,7 +856,7 @@ mod tests {
 
             let mut options = FFIWalletAccountCreationOptions::default_options();
             options.option_type = FFIAccountCreationOptionType::BIP44AccountsOnly;
-            let bip44_indices = vec![0];
+            let bip44_indices = [0];
             options.bip44_indices = bip44_indices.as_ptr();
             options.bip44_count = bip44_indices.len();
 
@@ -929,9 +929,9 @@ mod tests {
             let mut options = FFIWalletAccountCreationOptions::default_options();
             options.option_type = FFIAccountCreationOptionType::AllAccounts;
 
-            let bip44_indices = vec![0, 1, 2];
-            let bip32_indices = vec![0];
-            let coinjoin_indices = vec![0];
+            let bip44_indices = [0, 1, 2];
+            let bip32_indices = [0];
+            let coinjoin_indices = [0];
 
             options.bip44_indices = bip44_indices.as_ptr();
             options.bip44_count = bip44_indices.len();
@@ -1046,7 +1046,7 @@ mod tests {
 
             // Test get_is_watch_only
             let is_watch_only = managed_account_get_is_watch_only(account);
-            assert_eq!(is_watch_only, false);
+            assert!(!is_watch_only);
 
             // Test get_balance
             let mut balance_out = crate::types::FFIBalance {
@@ -1094,7 +1094,7 @@ mod tests {
             assert_eq!(account_type, FFIAccountType::StandardBIP44); // Default type
 
             let is_watch_only = managed_account_get_is_watch_only(ptr::null());
-            assert_eq!(is_watch_only, false);
+            assert!(!is_watch_only);
 
             let tx_count = managed_account_get_transaction_count(ptr::null());
             assert_eq!(tx_count, 0);
@@ -1261,7 +1261,7 @@ mod tests {
             // Create wallet with CoinJoin account
             let mut options = FFIWalletAccountCreationOptions::default_options();
             options.option_type = FFIAccountCreationOptionType::SpecificAccounts;
-            let coinjoin_indices = vec![0];
+            let coinjoin_indices = [0];
             options.coinjoin_indices = coinjoin_indices.as_ptr();
             options.coinjoin_count = coinjoin_indices.len();
 

key-wallet-ffi/src/managed_wallet.rs

@@ -906,7 +906,7 @@ mod tests {
 
         // Create managed wallet info from the wallet
         let wallet_rust = unsafe { &(*wallet).wallet };
-        let managed_info = ManagedWalletInfo::from_wallet(&wallet_rust);
+        let managed_info = ManagedWalletInfo::from_wallet(wallet_rust);
         let mut ffi_managed = FFIManagedWalletInfo::new(managed_info);
 
         // Test get_next_receive_address with valid pointers
@@ -995,7 +995,7 @@ mod tests {
 
         // We need to work with the existing wallet structure
         // Create managed wallet info from the existing wallet
-        let mut managed_info = ManagedWalletInfo::from_wallet(&wallet_arc);
+        let mut managed_info = ManagedWalletInfo::from_wallet(wallet_arc);
 
         let network = key_wallet::Network::Testnet;
 
@@ -1177,7 +1177,7 @@ mod tests {
 
         // Create managed wallet info
         let wallet_arc = unsafe { &(*wallet_ptr).wallet };
-        let mut managed_info = ManagedWalletInfo::from_wallet(&wallet_arc);
+        let mut managed_info = ManagedWalletInfo::from_wallet(wallet_arc);
 
         // Set some test balance values
         managed_info.balance = WalletBalance {

key-wallet-ffi/src/managed_wallet_tests.rs

@@ -360,7 +360,7 @@ mod tests {
         };
 
         // Create invalid UTF-8 string
-        let invalid_utf8 = vec![0xFF, 0xFE, 0xFD, 0x00]; // Invalid UTF-8 bytes with null terminator
+        let invalid_utf8 = [0xFF, 0xFE, 0xFD, 0x00]; // Invalid UTF-8 bytes with null terminator
         let success = unsafe {
             managed_wallet_mark_address_used(
                 managed_wallet,

key-wallet-ffi/src/mnemonic_tests.rs

@@ -1,6 +1,7 @@
 //! Unit tests for mnemonic FFI module
 
 #[cfg(test)]
+#[allow(clippy::module_inception)]
 mod tests {
     use crate::error::{FFIError, FFIErrorCode};
     use crate::mnemonic;
@@ -380,7 +381,7 @@ mod tests {
         let mut error = FFIError::success();
 
         // Create invalid UTF-8 string
-        let invalid_utf8 = vec![0xFF, 0xFE, 0xFD, 0x00];
+        let invalid_utf8 = [0xFF, 0xFE, 0xFD, 0x00];
         let count = unsafe {
             mnemonic::mnemonic_word_count(
                 invalid_utf8.as_ptr() as *const std::os::raw::c_char,
@@ -467,7 +468,7 @@ mod tests {
         let mut seed_len = 0usize;
 
         // Test invalid UTF-8 in mnemonic
-        let invalid_utf8 = vec![0xFF, 0xFE, 0xFD, 0x00];
+        let invalid_utf8 = [0xFF, 0xFE, 0xFD, 0x00];
         let success = unsafe {
             mnemonic::mnemonic_to_seed(
                 invalid_utf8.as_ptr() as *const std::os::raw::c_char,
@@ -500,7 +501,7 @@ mod tests {
         let mut error = FFIError::success();
 
         // Create invalid UTF-8 string
-        let invalid_utf8 = vec![0xFF, 0xFE, 0xFD, 0x00];
+        let invalid_utf8 = [0xFF, 0xFE, 0xFD, 0x00];
         let is_valid = unsafe {
             mnemonic::mnemonic_validate(
                 invalid_utf8.as_ptr() as *const std::os::raw::c_char,