feat(types)!: use Mnemonic type from crypto.rs

bindings/core/src/lib.rs

@@ -80,6 +80,7 @@ pub(crate) trait OmittedDebug {
         f.write_str("<omitted>")
     }
 }
+impl OmittedDebug for crypto::keys::bip39::Mnemonic {}
 impl OmittedDebug for String {}
 impl OmittedDebug for SecretManagerDto {}
 impl<T: OmittedDebug> OmittedDebug for Option<T> {

bindings/core/tests/secrets_debug.rs

@@ -27,20 +27,22 @@ fn method_interface_secrets_debug() {
         );
     }
 
+    let mnemonic = "giant dynamic museum toddler six deny defense ostrich bomb access mercy blood explain muscle shoot shallow glad autumn author calm heavy hawk abuse rally";
+
     let client_method = UtilsMethod::MnemonicToHexSeed {
-        mnemonic: "mnemonic".to_string(),
+        mnemonic: mnemonic.to_string(),
     };
     assert_eq!(
         format!("{:?}", client_method),
         "MnemonicToHexSeed { mnemonic: <omitted> }"
     );
 
     let wallet_method = UtilsMethod::VerifyMnemonic {
-        mnemonic: "mnemonic".to_string(),
+        mnemonic: mnemonic.to_string(),
     };
     assert_eq!(format!("{:?}", wallet_method), "VerifyMnemonic { mnemonic: <omitted> }");
 
-    let response = Response::GeneratedMnemonic("mnemonic".to_string());
+    let response = Response::GeneratedMnemonic(mnemonic.to_owned());
     assert_eq!(format!("{:?}", response), "GeneratedMnemonic(<omitted>)");
 
     let wallet_options = WalletOptions {

cli/src/helper.rs

@@ -201,15 +201,15 @@ pub async fn import_mnemonic(path: &str) -> Result<Mnemonic, Error> {
     }
 }
 
-async fn write_mnemonic_to_file(path: &str, mnemonic: &str) -> Result<(), Error> {
+async fn write_mnemonic_to_file(path: &str, mnemonic: &Mnemonic) -> Result<(), Error> {
     let mut open_options = OpenOptions::new();
     open_options.create(true).append(true);
 
     #[cfg(unix)]
     open_options.mode(0o600);
 
     let mut file = open_options.open(path).await?;
-    file.write_all(format!("{mnemonic}\n").as_bytes()).await?;
+    file.write_all(format!("{}\n", mnemonic.as_ref()).as_bytes()).await?;
 
     Ok(())
 }

sdk/src/client/secret/mnemonic.rs

@@ -154,6 +154,76 @@ impl MnemonicSecretManager {
     }
 }
 
+// impl From<Mnemonic> for MnemonicSecretManager {
+//     fn from(m: Mnemonic) -> Self {
+//         Self(Client::mnemonic_to_seed(&m))
+//     }
+// }
+
+// /// A mnemonic (space separated list of words) that allows to create a seed from.
+// #[derive(Clone, Eq, PartialEq, Serialize, Deserialize, Zeroize, ZeroizeOnDrop)]
+// pub struct Mnemonic(String);
+
+// impl Mnemonic {
+//     pub fn as_str(&self) -> &str {
+//         self.0.as_str()
+//     }
+// }
+
+// impl TryFrom<String> for Mnemonic {
+//     type Error = Error;
+
+//     fn try_from(value: String) -> Result<Self, Self::Error> {
+//         let value: Zeroizing<String> = Zeroizing::new(value);
+//         // trim because empty spaces could create a different seed https://github.com/iotaledger/crypto.rs/issues/125
+//         let trimmed = value.as_str().trim();
+//         // first we check if the mnemonic is valid to give meaningful errors
+//         if let Err(err) = crypto::keys::bip39::wordlist::verify(trimmed, &crypto::keys::bip39::wordlist::ENGLISH) {
+//             Err(crate::client::Error::InvalidMnemonic(format!("{err:?}")))
+//         } else {
+//             Ok(Self(trimmed.to_string()))
+//         }
+//     }
+// }
+
+// pub trait MnemonicLike: Send {
+//     fn to_mnemonic(self) -> Result<Mnemonic, Error>;
+// }
+
+// impl MnemonicLike for Mnemonic {
+//     fn to_mnemonic(self) -> Result<Mnemonic, Error> {
+//         Ok(self)
+//     }
+// }
+
+// impl MnemonicLike for String {
+//     fn to_mnemonic(self) -> Result<Mnemonic, Error> {
+//         Mnemonic::try_from(self)
+//     }
+// }
+
+// impl MnemonicLike for Vec<String> {
+//     fn to_mnemonic(mut self) -> Result<Mnemonic, Error> {
+//         let m = self.join(" ");
+//         self.zeroize();
+//         Mnemonic::try_from(m)
+//     }
+// }
+
+// impl MnemonicLike for [&'static str; 24] {
+//     fn to_mnemonic(self) -> Result<Mnemonic, Error> {
+//         let m = self.join(" ");
+//         Mnemonic::try_from(m)
+//     }
+// }
+
+// // that's only necessary to use it in `assert!` macros
+// impl core::fmt::Debug for Mnemonic {
+//     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+//         write!(f, "<mnemonic>")
+//     }
+// }
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -194,4 +264,65 @@ mod tests {
             "atoi1qzt0nhsf38nh6rs4p6zs5knqp6psgha9wsv74uajqgjmwc75ugupx3y7x0r"
         );
     }
+
+    // #[test]
+    // fn mnemonic_like() {
+    //     // Mnemonic from a space-separated word list stored in a `String`
+    //     let mnemonic1 = "giant dynamic museum toddler six deny defense ostrich bomb access mercy blood explain muscle
+    // shoot shallow glad autumn author calm heavy hawk abuse rally".to_owned().to_mnemonic().unwrap();     // Mnemonic
+    // from a word list stored in a `Vec<String>`     let mnemonic2 = [
+    //         "giant", "dynamic", "museum", "toddler", "six", "deny", "defense", "ostrich", "bomb", "access", "mercy",
+    //         "blood", "explain", "muscle", "shoot", "shallow", "glad", "autumn", "author", "calm", "heavy", "hawk",
+    //         "abuse", "rally",
+    //     ]
+    //     .into_iter()
+    //     .map(|s| s.to_owned())
+    //     .collect::<Vec<_>>()
+    //     .to_mnemonic()
+    //     .unwrap();
+    //     // Mnemonic from a word list stored in a `[&'static str; 24]`
+    //     let mnemonic3 = [
+    //         "giant", "dynamic", "museum", "toddler", "six", "deny", "defense", "ostrich", "bomb", "access", "mercy",
+    //         "blood", "explain", "muscle", "shoot", "shallow", "glad", "autumn", "author", "calm", "heavy", "hawk",
+    //         "abuse", "rally",
+    //     ]
+    //     .to_mnemonic()
+    //     .unwrap();
+
+    //     assert_eq!(mnemonic1, mnemonic2);
+    //     assert_eq!(mnemonic1, mnemonic3);
+    //     assert_eq!(mnemonic2, mnemonic3);
+
+    //     // Different mnemonic
+    //     let mnemonic4 = [
+    //         "endorse", "answer", "radar", "about", "source", "reunion", "marriage", "tag", "sausage", "weekend",
+    //         "frost", "daring", "base", "attack", "because", "joke", "dream", "slender", "leisure", "group", "reason",
+    //         "prepare", "broken", "river",
+    //     ]
+    //     .to_mnemonic()
+    //     .unwrap();
+
+    //     assert_ne!(mnemonic1, mnemonic4);
+    //     assert_ne!(mnemonic2, mnemonic4);
+    //     assert_ne!(mnemonic3, mnemonic4);
+
+    //     // Incorrect mnemonic
+    //     assert!(
+    //         [
+    //             "dynamic", "giant", "museum", "toddler", "six", "deny", "defense", "ostrich", "bomb", "access",
+    //             "mercy", "blood", "explain", "muscle", "shoot", "shallow", "glad", "autumn", "author", "calm",
+    // "heavy",             "hawk", "abuse", "rally"
+    //         ]
+    //         .to_mnemonic()
+    //         .is_err()
+    //     );
+    // }
+
+    // #[test]
+    // fn zeroize_mnemonic() {
+    //     let mut mnemonic1 = "giant dynamic museum toddler six deny defense ostrich bomb access mercy blood explain
+    // muscle shoot shallow glad autumn author calm heavy hawk abuse rally".to_owned().to_mnemonic().unwrap();
+    //     mnemonic1.zeroize();
+    //     assert!(mnemonic1.as_str().is_empty());
+    // }
 }

sdk/src/client/secret/mod.rs

@@ -194,17 +194,22 @@ impl TryFrom<SecretManagerDto> for SecretManager {
         Ok(match value {
             #[cfg(feature = "stronghold")]
             SecretManagerDto::Stronghold(stronghold_dto) => {
+                let StrongholdDto {
+                    password,
+                    snapshot_path,
+                    timeout,
+                } = stronghold_dto;
                 let mut builder = StrongholdSecretManager::builder();
 
-                if let Some(password) = stronghold_dto.password {
+                if let Some(password) = password {
                     builder = builder.password(password);
                 }
 
-                if let Some(timeout) = stronghold_dto.timeout {
+                if let Some(timeout) = timeout {
                     builder = builder.timeout(Duration::from_secs(timeout));
                 }
 
-                Self::Stronghold(builder.build(&stronghold_dto.snapshot_path)?)
+                Self::Stronghold(builder.build(snapshot_path)?)
             }
 
             #[cfg(feature = "ledger_nano")]

sdk/src/client/secret/types.rs

@@ -18,7 +18,7 @@ use crate::{
     utils::serde::bip44::option_bip44,
 };
 
-/// Stronghold DTO to allow the creation of a Stronghold secret manager from bindings
+/// Stronghold DTO to allow the creation of a Stronghold secret manager from bindings.
 #[cfg(feature = "stronghold")]
 #[cfg_attr(docsrs, doc(cfg(feature = "stronghold")))]
 #[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]

sdk/tests/client/common/mod.rs

@@ -29,7 +29,12 @@ pub async fn create_client_and_secret_manager_with_funds(
 ) -> Result<(Client, SecretManager)> {
     let client = Client::builder().with_node(NODE_LOCAL)?.finish().await?;
 
-    let secret_manager = SecretManager::try_from_mnemonic(mnemonic.unwrap_or(Client::generate_mnemonic().unwrap()))?;
+    let mnemonic = if let Some(mnemonic) = mnemonic {
+        mnemonic
+    } else {
+        Client::generate_mnemonic()?
+    };
+    let secret_manager = SecretManager::try_from_mnemonic(mnemonic)?;
 
     let address = secret_manager
         .generate_ed25519_addresses(

sdk/tests/wallet/account_recovery.rs

@@ -6,12 +6,7 @@
 use std::time::Duration;
 
 use iota_sdk::{
-    client::{
-        api::GetAddressesOptions,
-        constants::SHIMMER_COIN_TYPE,
-        secret::{mnemonic::MnemonicSecretManager, SecretManager},
-        Client,
-    },
+    client::{api::GetAddressesOptions, constants::SHIMMER_COIN_TYPE, secret::SecretManager, Client},
     wallet::Result,
 };
 
@@ -66,7 +61,7 @@ async fn account_recovery_with_balance_and_empty_addresses() -> Result<()> {
         .finish()
         .await?;
 
-    let secret_manager = SecretManager::Mnemonic(MnemonicSecretManager::try_from_mnemonic(mnemonic.clone())?);
+    let secret_manager = SecretManager::try_from_mnemonic(mnemonic.clone())?;
 
     let addresses = secret_manager
         .generate_ed25519_addresses(

sdk/tests/wallet/common/mod.rs

@@ -31,8 +31,7 @@ pub use self::constants::*;
 #[allow(dead_code, unused_variables)]
 pub(crate) async fn make_wallet(storage_path: &str, mnemonic: Option<Mnemonic>, node: Option<&str>) -> Result<Wallet> {
     let client_options = ClientOptions::new().with_node(node.unwrap_or(NODE_LOCAL))?;
-    let secret_manager =
-        MnemonicSecretManager::try_from_mnemonic(mnemonic.unwrap_or(Client::generate_mnemonic().unwrap()))?;
+    let secret_manager = MnemonicSecretManager::try_from_mnemonic(mnemonic.unwrap_or(Client::generate_mnemonic()?))?;
 
     #[allow(unused_mut)]
     let mut wallet_builder = Wallet::builder()

sdk/tests/wallet/core.rs

@@ -81,6 +81,8 @@ async fn different_seed() -> Result<()> {
 #[cfg(feature = "storage")]
 #[tokio::test]
 async fn changed_coin_type() -> Result<()> {
+    use crypto::keys::bip39::Mnemonic;
+
     let storage_path = "test-storage/changed_coin_type";
     setup(storage_path)?;
 
@@ -92,10 +94,9 @@ async fn changed_coin_type() -> Result<()> {
     drop(_account);
     drop(wallet);
 
+    // Recreate Wallet with same mnemonic
     let err = Wallet::builder()
-        .with_secret_manager(SecretManager::Mnemonic(MnemonicSecretManager::try_from_mnemonic(
-            mnemonic.clone(),
-        )?))
+        .with_secret_manager(SecretManager::try_from_mnemonic(mnemonic.clone())?)
         .with_coin_type(IOTA_COIN_TYPE)
         .with_storage_path(storage_path)
         .finish()
@@ -113,9 +114,7 @@ async fn changed_coin_type() -> Result<()> {
 
     // Building the wallet with the same coin type still works
     let wallet = Wallet::builder()
-        .with_secret_manager(SecretManager::Mnemonic(MnemonicSecretManager::try_from_mnemonic(
-            mnemonic,
-        )?))
+        .with_secret_manager(SecretManager::try_from_mnemonic(mnemonic.clone())?)
         .with_storage_path(storage_path)
         .finish()
         .await?;