Single account wallet

sdk/examples/wallet/spammer.rs

@@ -14,8 +14,8 @@ use iota_sdk::{
         request_funds_from_faucet,
         secret::{mnemonic::MnemonicSecretManager, SecretManager},
     },
-    types::block::{address::Bech32Address, output::BasicOutput, payload::transaction::TransactionId},
-    wallet::{account::FilterOptions, Account, ClientOptions, Result, SendParams, Wallet},
+    types::block::{address::{Bech32Address, Address}, output::BasicOutput, payload::transaction::TransactionId},
+    wallet::{account::FilterOptions, Account, ClientOptions, Result, SendParams, Wallet}, crypto::keys::bip44::Bip44,
 };
 
 // The account alias used in this example.
@@ -39,12 +39,19 @@ async fn main() -> Result<()> {
     // Restore wallet from a mnemonic phrase.
     let client_options = ClientOptions::new().with_node(&std::env::var("NODE_URL").unwrap())?;
     let secret_manager = MnemonicSecretManager::try_from_mnemonic(std::env::var("MNEMONIC").unwrap())?;
+
+    todo!("generate and set address");
+
     let wallet = Wallet::builder()
+        .with_alias(ACCOUNT_ALIAS)
+        // .with_address(Address::Ed25519(...))
+        .with_bip44(Bip44::new(SHIMMER_COIN_TYPE))
         .with_secret_manager(SecretManager::Mnemonic(secret_manager))
         .with_client_options(client_options)
-        .with_coin_type(SHIMMER_COIN_TYPE)
         .finish()
         .await?;
+
+    todo!("remove this");
     let account = wallet.get_or_create_account(ACCOUNT_ALIAS).await?;
 
     let recv_address = *account.addresses().await?[0].address();

sdk/src/client/node_api/core/routes.rs

@@ -112,7 +112,7 @@ impl ClientInner {
     /// Returns the information of committee members at the given epoch index. If epoch index is not provided, the
     /// current committee members are returned.
     /// GET /api/core/v3/committee/?epochIndex
-    pub async fn get_committee(&self, epoch_index: impl Into<Option<EpochIndex>>) -> Result<CommitteeResponse> {
+    pub async fn get_committee(&self, epoch_index: impl Into<Option<EpochIndex>> + Send) -> Result<CommitteeResponse> {
         const PATH: &str = "api/core/v3/committee";
 
         let epoch_index = epoch_index.into().map(|i| format!("epochIndex={i}"));

sdk/src/lib.rs

@@ -4,7 +4,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 // TODO missing_docs
-#![deny(clippy::nursery, rust_2018_idioms, /* warnings, */ unreachable_pub)]
+#![deny(clippy::nursery, rust_2018_idioms, /* warnings, unreachable_pub */)]
 #![allow(
     clippy::redundant_pub_crate,
     clippy::missing_const_for_fn,

sdk/src/types/block/core/wrapper.rs

@@ -350,7 +350,7 @@ pub(crate) mod dto {
                 });
             }
 
-            Ok(BlockWrapper::new(
+            Ok(Self::new(
                 &protocol_params,
                 dto.issuing_time,
                 dto.slot_commitment_id,

sdk/src/types/block/slot/index.rs

@@ -60,7 +60,7 @@ impl SlotIndex {
 
     /// Gets the slot index of a unix timestamp.
     /// Slots are counted starting from `1` with `0` being reserved for times before the genesis.
-    pub fn from_timestamp(timestamp: u64, genesis_unix_timestamp: u64, slot_duration_in_seconds: u8) -> SlotIndex {
+    pub fn from_timestamp(timestamp: u64, genesis_unix_timestamp: u64, slot_duration_in_seconds: u8) -> Self {
         timestamp
             .checked_sub(genesis_unix_timestamp as u64)
             .map(|diff| (diff / slot_duration_in_seconds as u64) + 1)

sdk/src/wallet/account/builder.rs

@@ -59,87 +59,90 @@ where
     /// Also generates the first address of the account and if it's not the first account, the address for the first
     /// account will also be generated and compared, so no accounts get generated with different seeds
     pub async fn finish(&mut self) -> crate::wallet::Result<Account<S>> {
-        let mut accounts = self.wallet.accounts.write().await;
-        let account_index = accounts.len() as u32;
-        // If no alias is provided, the account index will be set as alias
-        let account_alias = self.alias.clone().unwrap_or_else(|| account_index.to_string());
-        log::debug!(
-            "[ACCOUNT BUILDER] creating new account {} with index {}",
-            account_alias,
-            account_index
-        );
-
-        // Check that the alias isn't already used for another account
-        for account in accounts.iter() {
-            let account = account.details().await;
-            if account.alias().to_lowercase() == account_alias.to_lowercase() {
-                return Err(Error::AccountAliasAlreadyExists(account_alias));
-            }
-        }
-
-        let coin_type = self.wallet.coin_type.load(core::sync::atomic::Ordering::Relaxed);
-
-        // If addresses are provided we will use them directly without the additional checks, because then we assume
-        // that it's for offline signing and the secretManager can't be used
-        let addresses = match &self.addresses {
-            Some(addresses) => addresses.clone(),
-            None => {
-                let mut bech32_hrp = self.bech32_hrp;
-                if let Some(first_account) = accounts.first() {
-                    let first_account_coin_type = *first_account.details().await.coin_type();
-                    // Generate the first address of the first account and compare it to the stored address from the
-                    // first account to prevent having multiple accounts created with different
-                    // seeds
-                    let first_account_public_address =
-                        get_first_public_address(&self.wallet.secret_manager, first_account_coin_type, 0).await?;
-                    let first_account_addresses = first_account.public_addresses().await;
-
-                    if Address::Ed25519(first_account_public_address)
-                        != first_account_addresses
-                            .first()
-                            .ok_or(Error::FailedToGetRemainder)?
-                            .address
-                            .inner
-                    {
-                        return Err(Error::InvalidMnemonic(
-                            "first account address used another seed".to_string(),
-                        ));
-                    }
-
-                    // Get bech32_hrp from address
-                    if let Some(address) = first_account_addresses.first() {
-                        if bech32_hrp.is_none() {
-                            bech32_hrp = Some(address.address.hrp);
-                        }
-                    }
-                }
-
-                // get bech32_hrp
-                let bech32_hrp = {
-                    match bech32_hrp {
-                        Some(bech32_hrp) => bech32_hrp,
-                        None => self.wallet.client().get_bech32_hrp().await?,
-                    }
-                };
-
-                let first_public_address =
-                    get_first_public_address(&self.wallet.secret_manager, coin_type, account_index).await?;
-
-                let first_public_account_address = Bip44Address {
-                    address: Bech32Address::new(bech32_hrp, first_public_address),
-                    key_index: 0,
-                    internal: false,
-                };
-
-                vec![first_public_account_address]
-            }
-        };
+        let mut wallet_data = self.wallet.data.write().await;
+
+        // let account_index = wallet_data.len() as u32;
+        // // If no alias is provided, the account index will be set as alias
+        // let account_alias = self.alias.clone().unwrap_or_else(|| account_index.to_string());
+        // log::debug!(
+        //     "[ACCOUNT BUILDER] creating new account {} with index {}",
+        //     account_alias,
+        //     account_index
+        // );
+
+        // // Check that the alias isn't already used for another account
+        // for account in wallet_data.iter() {
+        //     let account = account.details().await;
+        //     if account.alias().to_lowercase() == account_alias.to_lowercase() {
+        //         return Err(Error::AccountAliasAlreadyExists(account_alias));
+        //     }
+        // }
+
+        // let coin_type = self.wallet.coin_type.load(core::sync::atomic::Ordering::Relaxed);
+
+        // // If addresses are provided we will use them directly without the additional checks, because then we assume
+        // // that it's for offline signing and the secretManager can't be used
+        // let addresses = match &self.addresses {
+        //     Some(addresses) => addresses.clone(),
+        //     None => {
+        //         let mut bech32_hrp = self.bech32_hrp;
+        //         if let Some(first_account) = wallet_data.first() {
+        //             let first_account_coin_type = *first_account.details().await.coin_type();
+        //             // Generate the first address of the first account and compare it to the stored address from the
+        //             // first account to prevent having multiple accounts created with different
+        //             // seeds
+        //             let first_account_public_address =
+        //                 get_first_public_address(&self.wallet.secret_manager, first_account_coin_type, 0).await?;
+        //             let first_account_addresses = first_account.public_addresses().await;
+
+        //             if Address::Ed25519(first_account_public_address)
+        //                 != first_account_addresses
+        //                     .first()
+        //                     .ok_or(Error::FailedToGetRemainder)?
+        //                     .address
+        //                     .inner
+        //             {
+        //                 return Err(Error::InvalidMnemonic(
+        //                     "first account address used another seed".to_string(),
+        //                 ));
+        //             }
+
+        //             // Get bech32_hrp from address
+        //             if let Some(address) = first_account_addresses.first() {
+        //                 if bech32_hrp.is_none() {
+        //                     bech32_hrp = Some(address.address.hrp);
+        //                 }
+        //             }
+        //         }
+
+        //         // get bech32_hrp
+        //         let bech32_hrp = {
+        //             match bech32_hrp {
+        //                 Some(bech32_hrp) => bech32_hrp,
+        //                 None => self.wallet.client().get_bech32_hrp().await?,
+        //             }
+        //         };
+
+        //         let first_public_address =
+        //             get_first_public_address(&self.wallet.secret_manager, coin_type, account_index).await?;
+
+        //         let first_public_account_address = Bip44Address {
+        //             address: Bech32Address::new(bech32_hrp, first_public_address),
+        //             key_index: 0,
+        //             internal: false,
+        //         };
+
+        //         vec![first_public_account_address]
+        //     }
+        // };
+
+        todo!();
 
         let account = AccountDetails {
-            index: account_index,
-            coin_type,
-            alias: account_alias,
-            public_addresses: addresses,
+            index: 0,
+            coin_type: todo!("coin_type"),
+            alias: todo!("account alias"),
+            public_addresses: todo!("addresses"),
             internal_addresses: Vec::new(),
             addresses_with_unspent_outputs: Vec::new(),
             outputs: HashMap::new(),
@@ -155,7 +158,9 @@ where
         let account = Account::new(account, self.wallet.inner.clone()).await?;
         #[cfg(feature = "storage")]
         account.save(None).await?;
-        accounts.push(account.clone());
+
+        todo!("set instead of push");
+        // wallet_data.push(account.clone());
 
         Ok(account)
     }