refactor(key-wallet)!: unify mnemonic parsing on one auto-detecting path

dash-spv/tests/dashd_sync/tests_transaction.rs

@@ -17,7 +17,7 @@ use dashcore::PublicKey;
 use key_wallet::account::ManagedAccountTrait;
 use key_wallet::bip32::{ChildNumber, ExtendedPrivKey};
 use key_wallet::gap_limit::DEFAULT_EXTERNAL_GAP_LIMIT;
-use key_wallet::mnemonic::{Language, Mnemonic};
+use key_wallet::mnemonic::Mnemonic;
 use key_wallet::wallet::initialization::WalletAccountCreationOptions;
 use key_wallet::wallet::managed_wallet_info::coin_selection::SelectionStrategy;
 use key_wallet::wallet::managed_wallet_info::fee::FeeRate;
@@ -263,7 +263,7 @@ const MEMPOOL_TIMEOUT: Duration = Duration::from_secs(30);
 /// independently of any wallet state, so a test can pay addresses far beyond
 /// the pre-generated pool window.
 fn derive_external_addresses(mnemonic: &str, count: u32) -> Vec<Address> {
-    let mnemonic = Mnemonic::from_phrase(mnemonic, Language::English).expect("mnemonic");
+    let mnemonic = Mnemonic::from_phrase(mnemonic).expect("mnemonic");
     let seed = mnemonic.to_seed("");
     let secp = Secp256k1::new();
     let master = ExtendedPrivKey::new_master(Network::Regtest, &seed).expect("master key");

key-wallet-ffi/src/account_derivation.rs

@@ -10,7 +10,6 @@ use crate::keys::{FFIExtendedPrivKey, FFIPrivateKey};
 use crate::{check_ptr, deref_ptr, unwrap_or_return};
 use key_wallet::account::derivation::AccountDerivation;
 use key_wallet::account::AccountTrait;
-use key_wallet::Mnemonic;
 use std::ffi::CString;
 use std::os::raw::{c_char, c_uint};
 use std::ptr;
@@ -124,15 +123,8 @@ pub unsafe extern "C" fn bls_account_derive_private_key_from_mnemonic(
     } else {
         Some(unwrap_or_return!(std::ffi::CStr::from_ptr(passphrase).to_str(), error))
     };
-    let mnemonic_lang =
-        unwrap_or_return!(Mnemonic::from_phrase_in_any_language(mnemonic_str), error).language();
     let sk = unwrap_or_return!(
-        account.inner().derive_from_mnemonic_private_key_at(
-            mnemonic_str,
-            passphrase_str,
-            mnemonic_lang,
-            index,
-        ),
+        account.inner().derive_from_mnemonic_private_key_at(mnemonic_str, passphrase_str, index,),
         error
     );
     unwrap_or_return!(CString::new(hex::encode(sk.to_be_bytes())), error).into_raw()
@@ -203,15 +195,8 @@ pub unsafe extern "C" fn eddsa_account_derive_private_key_from_mnemonic(
     } else {
         Some(unwrap_or_return!(std::ffi::CStr::from_ptr(passphrase).to_str(), error))
     };
-    let mnemonic_lang =
-        unwrap_or_return!(Mnemonic::from_phrase_in_any_language(mnemonic_str), error).language();
     let sk = unwrap_or_return!(
-        account.inner().derive_from_mnemonic_private_key_at(
-            mnemonic_str,
-            passphrase_str,
-            mnemonic_lang,
-            index,
-        ),
+        account.inner().derive_from_mnemonic_private_key_at(mnemonic_str, passphrase_str, index,),
         error
     );
     unwrap_or_return!(CString::new(hex::encode(sk.to_bytes())), error).into_raw()
@@ -360,15 +345,10 @@ pub unsafe extern "C" fn account_derive_extended_private_key_from_mnemonic(
     } else {
         Some(unwrap_or_return!(std::ffi::CStr::from_ptr(passphrase).to_str(), error))
     };
-    let mnemonic_lang =
-        unwrap_or_return!(Mnemonic::from_phrase_in_any_language(mnemonic_str), error).language();
     let derived = unwrap_or_return!(
-        account.inner().derive_from_mnemonic_extended_xpriv_at(
-            mnemonic_str,
-            passphrase_str,
-            mnemonic_lang,
-            index,
-        ),
+        account
+            .inner()
+            .derive_from_mnemonic_extended_xpriv_at(mnemonic_str, passphrase_str, index,),
         error
     );
     Box::into_raw(Box::new(FFIExtendedPrivKey::from_inner(derived)))
@@ -400,15 +380,10 @@ pub unsafe extern "C" fn account_derive_private_key_from_mnemonic(
     } else {
         Some(unwrap_or_return!(std::ffi::CStr::from_ptr(passphrase).to_str(), error))
     };
-    let mnemonic_lang =
-        unwrap_or_return!(Mnemonic::from_phrase_in_any_language(mnemonic_str), error).language();
     let derived = unwrap_or_return!(
-        account.inner().derive_from_mnemonic_extended_xpriv_at(
-            mnemonic_str,
-            passphrase_str,
-            mnemonic_lang,
-            index,
-        ),
+        account
+            .inner()
+            .derive_from_mnemonic_extended_xpriv_at(mnemonic_str, passphrase_str, index,),
         error
     );
     Box::into_raw(Box::new(FFIPrivateKey::from_secret(derived.private_key)))

key-wallet-ffi/src/mnemonic.rs

@@ -164,7 +164,7 @@ pub unsafe extern "C" fn mnemonic_validate(mnemonic: *const c_char, error: *mut
     let mnemonic = deref_ptr!(mnemonic, error);
     let mnemonic_str = unwrap_or_return!(CStr::from_ptr(mnemonic).to_str(), error);
 
-    if Mnemonic::from_phrase_in_any_language(mnemonic_str).is_err() {
+    if Mnemonic::from_phrase(mnemonic_str).is_err() {
         (*error).set(
             FFIErrorCode::InvalidMnemonic,
             "Invalid mnemonic: does not match any supported language",
@@ -205,7 +205,7 @@ pub unsafe extern "C" fn mnemonic_to_seed(
         unwrap_or_return!(CStr::from_ptr(passphrase).to_str(), error)
     };
 
-    let m = unwrap_or_return!(Mnemonic::from_phrase_in_any_language(mnemonic_str), error);
+    let m = unwrap_or_return!(Mnemonic::from_phrase(mnemonic_str), error);
     let seed = m.to_seed(passphrase_str);
     let seed_bytes: &[u8] = seed.as_ref();
 

key-wallet-ffi/src/wallet.rs

@@ -40,7 +40,7 @@ pub unsafe extern "C" fn wallet_create_from_mnemonic_with_options(
     let mnemonic = deref_ptr!(mnemonic, error);
     let mnemonic_str = unwrap_or_return!(CStr::from_ptr(mnemonic).to_str(), error);
 
-    let mnemonic = unwrap_or_return!(Mnemonic::from_phrase_in_any_language(mnemonic_str), error);
+    let mnemonic = unwrap_or_return!(Mnemonic::from_phrase(mnemonic_str), error);
 
     let network_rust: Network = network.into();
     let creation_options = if account_options.is_null() {

key-wallet-ffi/tests/test_valid_addr.rs

@@ -7,8 +7,7 @@ fn test_valid_testnet_address() {
     use key_wallet::{Mnemonic, Network, Wallet};
 
     let mnemonic_str = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
-    let mnemonic =
-        Mnemonic::from_phrase(mnemonic_str, key_wallet::mnemonic::Language::English).unwrap();
+    let mnemonic = Mnemonic::from_phrase(mnemonic_str).unwrap();
 
     let wallet =
         Wallet::from_mnemonic(mnemonic, Network::Testnet, WalletAccountCreationOptions::Default)

key-wallet-manager/src/accessors.rs

@@ -272,12 +272,12 @@ impl<T: WalletInfoInterface + Send + Sync + 'static> WalletManager<T> {
 mod tests {
     use super::*;
     use crate::test_helpers::TEST_MNEMONIC;
-    use key_wallet::mnemonic::{Language, Mnemonic};
+    use key_wallet::mnemonic::Mnemonic;
     use key_wallet::wallet::initialization::WalletAccountCreationOptions;
     use key_wallet::wallet::managed_wallet_info::ManagedWalletInfo;
 
     fn build_wallet() -> Wallet {
-        let mnemonic = Mnemonic::from_phrase(TEST_MNEMONIC, Language::English).unwrap();
+        let mnemonic = Mnemonic::from_phrase(TEST_MNEMONIC).unwrap();
         Wallet::from_mnemonic(mnemonic, Network::Testnet, WalletAccountCreationOptions::Default)
             .expect("wallet from mnemonic")
     }

key-wallet-manager/src/lib.rs

@@ -277,7 +277,7 @@ impl<T: WalletInfoInterface + Send + Sync + 'static> WalletManager<T> {
         birth_height: CoreBlockHeight,
         account_creation_options: key_wallet::wallet::initialization::WalletAccountCreationOptions,
     ) -> Result<WalletId, WalletError> {
-        let mnemonic_obj = Mnemonic::from_phrase_in_any_language(mnemonic)
+        let mnemonic_obj = Mnemonic::from_phrase(mnemonic)
             .map_err(|e| WalletError::InvalidMnemonic(e.to_string()))?;
 
         let wallet = Wallet::from_mnemonic(mnemonic_obj, self.network, account_creation_options)
@@ -339,7 +339,7 @@ impl<T: WalletInfoInterface + Send + Sync + 'static> WalletManager<T> {
     ) -> Result<(Vec<u8>, WalletId), WalletError> {
         use zeroize::Zeroize;
 
-        let mnemonic_obj = Mnemonic::from_phrase_in_any_language(mnemonic)
+        let mnemonic_obj = Mnemonic::from_phrase(mnemonic)
             .map_err(|e| WalletError::InvalidMnemonic(e.to_string()))?;
 
         let mut wallet =

key-wallet/examples/account_types.rs

@@ -7,7 +7,7 @@ use key_wallet::account::{
 };
 use key_wallet::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey};
 use key_wallet::managed_account::address_pool::AddressPoolType;
-use key_wallet::mnemonic::{Language, Mnemonic};
+use key_wallet::mnemonic::Mnemonic;
 use key_wallet::Network;
 use secp256k1::Secp256k1;
 
@@ -18,10 +18,7 @@ use key_wallet::derivation_slip10::ExtendedEd25519PrivKey;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Generate a mnemonic for testing
-    let mnemonic = Mnemonic::from_phrase(
-        "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-        Language::English,
-    )?;
+    let mnemonic = Mnemonic::from_phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about")?;
     let seed = mnemonic.to_seed("");
 
     // Create master key

key-wallet/examples/basic_usage.rs

@@ -3,7 +3,6 @@
 use core::str::FromStr;
 use dashcore::{Address, Network as DashNetwork};
 use key_wallet::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey};
-use key_wallet::mnemonic::Language;
 use key_wallet::prelude::*;
 use key_wallet::Network;
 
@@ -12,10 +11,7 @@ fn main() -> core::result::Result<(), Box<dyn std::error::Error>> {
 
     // 1. Create a mnemonic
     println!("1. Creating mnemonic...");
-    let mnemonic = Mnemonic::from_phrase(
-        "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-        Language::English
-    )?;
+    let mnemonic = Mnemonic::from_phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about")?;
     println!("   Mnemonic: {}", mnemonic.phrase());
     println!("   Word count: {}", mnemonic.word_count());
 

key-wallet/src/account/account_collection_test.rs

@@ -7,7 +7,7 @@ mod tests {
         Account, AccountCollection, AccountType, BLSAccount, EdDSAAccount, StandardAccountType,
     };
     use crate::bip32::{ExtendedPrivKey, ExtendedPubKey};
-    use crate::mnemonic::{Language, Mnemonic};
+    use crate::mnemonic::Mnemonic;
     use crate::Network;
     use secp256k1::Secp256k1;
 
@@ -16,10 +16,7 @@ mod tests {
         let mut collection = AccountCollection::new();
 
         // Create test keys
-        let mnemonic = Mnemonic::from_phrase(
-            "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-            Language::English,
-        ).unwrap();
+        let mnemonic = Mnemonic::from_phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about").unwrap();
         let seed = mnemonic.to_seed("");
         let master = ExtendedPrivKey::new_master(Network::Testnet, &seed).unwrap();
         let secp = Secp256k1::new();

key-wallet/src/account/derivation.rs

@@ -1,5 +1,4 @@
 use crate::managed_account::address_pool::AddressPoolType;
-use crate::mnemonic::Language;
 use crate::{ChildNumber, DerivationPath, Error, Mnemonic};
 use dashcore::Address;
 
@@ -199,27 +198,27 @@ pub trait AccountDerivation<EPrivKeyType, EPubKeyType, PubKeyType, PrivKeyType>
     ) -> Result<PrivKeyType, Error>;
 
     /// Derive an extended private key from a BIP39 mnemonic and optional passphrase at the given index.
+    /// The mnemonic's wordlist is auto-detected ([`Mnemonic::from_phrase`]).
     fn derive_from_mnemonic_extended_xpriv_at(
         &self,
         mnemonic: &str,
         passphrase: Option<&str>,
-        language: Language,
         index: u32,
     ) -> Result<EPrivKeyType, Error> {
-        let m = Mnemonic::from_phrase(mnemonic, language)?;
+        let m = Mnemonic::from_phrase(mnemonic)?;
         let seed = m.to_seed(passphrase.unwrap_or(""));
         self.derive_from_seed_extended_xpriv_at(&seed, index)
     }
 
     /// Derive a private key from a BIP39 mnemonic and optional passphrase at the given index.
+    /// The mnemonic's wordlist is auto-detected ([`Mnemonic::from_phrase`]).
     fn derive_from_mnemonic_private_key_at(
         &self,
         mnemonic: &str,
         passphrase: Option<&str>,
-        language: Language,
         index: u32,
     ) -> Result<PrivKeyType, Error> {
-        let m = Mnemonic::from_phrase(mnemonic, language)?;
+        let m = Mnemonic::from_phrase(mnemonic)?;
         let seed = m.to_seed(passphrase.unwrap_or(""));
         self.derive_from_seed_private_key_at(&seed, index)
     }

key-wallet/src/account/mod.rs

@@ -400,13 +400,10 @@ impl fmt::Display for Account {
 mod tests {
     use super::*;
     use crate::bip32::ChildNumber;
-    use crate::mnemonic::{Language, Mnemonic};
+    use crate::mnemonic::Mnemonic;
 
     pub(crate) fn test_account() -> Account {
-        let mnemonic = Mnemonic::from_phrase(
-            "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-            Language::English,
-        ).unwrap();
+        let mnemonic = Mnemonic::from_phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about").unwrap();
         let seed = mnemonic.to_seed("");
         let master = ExtendedPrivKey::new_master(Network::Testnet, &seed).unwrap();
 

key-wallet/src/derivation.rs

@@ -429,10 +429,7 @@ mod tests {
     // ✓ Test special derivation paths (from DashSync special purpose paths)
     #[test]
     fn test_special_derivation_paths() {
-        let mnemonic = Mnemonic::from_phrase(
-            "upper renew that grow pelican pave subway relief describe enforce suit hedgehog blossom dose swallow",
-            crate::mnemonic::Language::English
-        ).unwrap();
+        let mnemonic = Mnemonic::from_phrase("upper renew that grow pelican pave subway relief describe enforce suit hedgehog blossom dose swallow").unwrap();
 
         let seed = mnemonic.to_seed("");
         let master_key = ExtendedPrivKey::new_master(crate::Network::Mainnet, &seed).unwrap();
@@ -537,10 +534,7 @@ mod tests {
     // ✓ Test derivation path builder pattern
     #[test]
     fn test_derivation_path_builder() {
-        let mnemonic = Mnemonic::from_phrase(
-            "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-            crate::mnemonic::Language::English
-        ).unwrap();
+        let mnemonic = Mnemonic::from_phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about").unwrap();
 
         let seed = mnemonic.to_seed("");
         let master_key = ExtendedPrivKey::new_master(crate::Network::Testnet, &seed).unwrap();
@@ -584,10 +578,7 @@ mod tests {
     // ✓ Test key signing and verification
     #[test]
     fn test_key_signing_deterministic() {
-        let mnemonic = Mnemonic::from_phrase(
-            "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-            crate::mnemonic::Language::English
-        ).unwrap();
+        let mnemonic = Mnemonic::from_phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about").unwrap();
 
         let seed = mnemonic.to_seed("");
         let master_key = ExtendedPrivKey::new_master(crate::Network::Testnet, &seed).unwrap();
@@ -629,10 +620,7 @@ mod tests {
     // ✓ Test key recovery from signature
     #[test]
     fn test_key_recovery_from_signature() {
-        let mnemonic = Mnemonic::from_phrase(
-            "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-            crate::mnemonic::Language::English
-        ).unwrap();
+        let mnemonic = Mnemonic::from_phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about").unwrap();
 
         let seed = mnemonic.to_seed("");
         let master_key = ExtendedPrivKey::new_master(crate::Network::Testnet, &seed).unwrap();
@@ -676,7 +664,6 @@ mod tests {
 
         let mnemonic = Mnemonic::from_phrase(
             "birth kingdom trash renew flavor utility donkey gasp regular alert pave layer",
-            crate::mnemonic::Language::English,
         )
         .unwrap();
 

key-wallet/src/managed_account/address_pool.rs

@@ -1329,13 +1329,10 @@ impl Default for AddressPoolBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::mnemonic::{Language, Mnemonic};
+    use crate::mnemonic::Mnemonic;
 
     fn test_key_source() -> KeySource {
-        let mnemonic = Mnemonic::from_phrase(
-            "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
-            Language::English,
-        ).unwrap();
+        let mnemonic = Mnemonic::from_phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about").unwrap();
         let seed = mnemonic.to_seed("");
         let master = ExtendedPrivKey::new_master(Network::Testnet, &seed).unwrap();