Remove ed25519 address generation from wallet

bindings/core/src/lib.rs

@@ -17,7 +17,6 @@ use fern_logger::{logger_init, LoggerConfig, LoggerOutputConfigBuilder};
 pub use iota_sdk;
 use iota_sdk::{
     client::secret::{SecretManager, SecretManagerDto},
-    types::block::address::Bech32Address,
     utils::serde::bip44::option_bip44,
     wallet::{ClientOptions, Wallet},
 };
@@ -44,7 +43,6 @@ pub fn init_logger(config: String) -> std::result::Result<(), fern_logger::Error
 #[derivative(Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct WalletOptions {
-    pub address: Option<Bech32Address>,
     pub alias: Option<String>,
     #[serde(with = "option_bip44", default)]
     pub bip_path: Option<Bip44>,
@@ -55,11 +53,6 @@ pub struct WalletOptions {
 }
 
 impl WalletOptions {
-    pub fn with_address(mut self, address: impl Into<Option<Bech32Address>>) -> Self {
-        self.address = address.into();
-        self
-    }
-
     pub fn with_alias(mut self, alias: impl Into<Option<String>>) -> Self {
         self.alias = alias.into();
         self
@@ -89,7 +82,6 @@ impl WalletOptions {
     pub async fn build(self) -> iota_sdk::wallet::Result<Wallet> {
         log::debug!("wallet options: {self:?}");
         let mut builder = Wallet::builder()
-            .with_address(self.address)
             .with_alias(self.alias)
             .with_bip_path(self.bip_path)
             .with_client_options(self.client_options);

bindings/core/src/method/wallet.rs

@@ -18,7 +18,6 @@ use iota_sdk::{
     client::{
         api::{input_selection::Burn, PreparedTransactionDataDto, SignedTransactionDataDto},
         node_manager::node::NodeAuth,
-        secret::GenerateAddressOptions,
     },
     types::block::{
         address::{Bech32Address, Hrp},
@@ -419,27 +418,11 @@ pub enum WalletMethod {
     /// Expected response: [`OutputsData`](crate::Response::OutputsData)
     #[serde(rename_all = "camelCase")]
     UnspentOutputs { filter_options: Option<FilterOptions> },
-
     /// Emits an event for testing if the event system is working
     /// Expected response: [`Ok`](crate::Response::Ok)
     #[cfg(feature = "events")]
     #[cfg_attr(docsrs, doc(cfg(feature = "events")))]
     EmitTestEvent { event: WalletEvent },
-
-    // TODO: reconsider whether to have the following methods on the wallet
-    /// Generate an address without storing it
-    /// Expected response: [`Bech32Address`](crate::Response::Bech32Address)
-    #[serde(rename_all = "camelCase")]
-    GenerateEd25519Address {
-        /// Account index
-        account_index: u32,
-        /// Account index
-        address_index: u32,
-        /// Options
-        options: Option<GenerateAddressOptions>,
-        /// Bech32 HRP
-        bech32_hrp: Option<Hrp>,
-    },
     /// Get the ledger nano status
     /// Expected response: [`LedgerNanoStatus`](crate::Response::LedgerNanoStatus)
     #[cfg(feature = "ledger_nano")]

bindings/core/src/method_handler/wallet.rs

@@ -8,10 +8,7 @@ use iota_sdk::{
     client::api::{
         PreparedTransactionData, PreparedTransactionDataDto, SignedTransactionData, SignedTransactionDataDto,
     },
-    types::{
-        block::{address::ToBech32Ext, output::feature::BlockIssuerKeySource},
-        TryFromDto,
-    },
+    types::{block::output::feature::BlockIssuerKeySource, TryFromDto},
     wallet::{types::TransactionWithMetadataDto, PreparedCreateNativeTokenTransactionDto, Wallet},
 };
 
@@ -72,23 +69,6 @@ pub(crate) async fn call_wallet_method_internal(wallet: &Wallet, method: WalletM
             let ledger_nano_status = wallet.get_ledger_nano_status().await?;
             Response::LedgerNanoStatus(ledger_nano_status)
         }
-        WalletMethod::GenerateEd25519Address {
-            account_index,
-            address_index,
-            options,
-            bech32_hrp,
-        } => {
-            let address = wallet
-                .generate_ed25519_address(account_index, address_index, options)
-                .await?;
-
-            let bech32_hrp = match bech32_hrp {
-                Some(bech32_hrp) => bech32_hrp,
-                None => *wallet.address().await.hrp(),
-            };
-
-            Response::Bech32Address(address.to_bech32(bech32_hrp))
-        }
         #[cfg(feature = "stronghold")]
         WalletMethod::SetStrongholdPassword { password } => {
             wallet.set_stronghold_password(password).await?;

bindings/nodejs/examples/how_tos/accounts_and_addresses/create-wallet.ts

@@ -44,18 +44,7 @@ async function run() {
         // The mnemonic can't be retrieved from the Stronghold file, so make a backup in a secure place!
         await secretManager.storeMnemonic(process.env.MNEMONIC as string);
 
-        const walletAddress = await secretManager.generateEd25519Addresses({
-            coinType: CoinType.IOTA,
-            accountIndex: 0,
-            range: {
-                start: 0,
-                end: 1,
-            },
-            bech32Hrp: 'tst',
-        });
-
         const walletOptions: WalletOptions = {
-            address: walletAddress[0],
             storagePath: process.env.WALLET_DB_PATH,
             clientOptions: {
                 nodes: [process.env.NODE_URL as string],

bindings/nodejs/examples/wallet/getting-started.ts

@@ -44,18 +44,7 @@ async function run() {
     // The mnemonic can't be retrieved from the Stronghold file, so make a backup in a secure place!
     await secretManager.storeMnemonic(mnemonic);
 
-    const wallet_address = await secretManager.generateEd25519Addresses({
-        coinType: CoinType.IOTA,
-        accountIndex: 0,
-        range: {
-            start: 0,
-            end: 1,
-        },
-        bech32Hrp: 'tst',
-    });
-
     const walletOptions: WalletOptions = {
-        address: wallet_address[0],
         storagePath: WALLET_DB_PATH,
         clientOptions: {
             nodes: [NODE_URL as string],

bindings/nodejs/lib/types/wallet/wallet.ts

@@ -11,12 +11,10 @@
 import { DecayedMana, u256, u64 } from '../utils';
 import { IClientOptions } from '../client';
 import { Bip44, SecretManagerType } from '../secret_manager/secret-manager';
 import { Bech32Address, OutputId } from '../block';
 
 /** Options for the Wallet builder. */
 export interface WalletOptions {
-    /** The wallet address. */
-    address?: Bech32Address;
     /** The alias of the wallet. */
     alias?: string;
     /** The the BIP44 path of the wallet. */

bindings/nodejs/src/wallet.rs

@@ -121,7 +121,7 @@ pub async fn get_client(wallet: External<WalletMethodHandler>) -> Result<Externa
 #[napi(js_name = "getSecretManager")]
 pub async fn get_secret_manager(wallet: External<WalletMethodHandler>) -> Result<External<SecretManagerMethodHandler>> {
     if let Some(wallet) = &**wallet.as_ref().read().await {
-        Ok(External::new(wallet.get_secret_manager().clone()))
+        Ok(External::new(wallet.secret_manager().clone()))
     } else {
         Err(destroyed_err("Wallet"))
     }

bindings/python/src/wallet.rs

@@ -120,7 +120,7 @@ pub fn get_secret_manager_from_wallet(wallet: &Wallet) -> Result<SecretManager>
             .read()
             .await
             .as_ref()
-            .map(|w| w.get_secret_manager().clone())
+            .map(|w| w.secret_manager().clone())
             .ok_or_else(|| {
                 Error::from(
                     serde_json::to_string(&Response::Panic("wallet was destroyed".into()))

bindings/wasm/src/wallet.rs

@@ -52,7 +52,7 @@ pub async fn get_client(method_handler: &WalletMethodHandler) -> Result<ClientMe
 #[wasm_bindgen(js_name = getSecretManager)]
 pub async fn get_secret_manager(method_handler: &WalletMethodHandler) -> Result<SecretManagerMethodHandler, JsError> {
     if let Some(wallet) = &*method_handler.0.read().await {
-        Ok(SecretManagerMethodHandler::new(wallet.get_secret_manager().clone()))
+        Ok(SecretManagerMethodHandler::new(wallet.secret_manager().clone()))
     } else {
         // Notify that the wallet was destroyed
         Err(destroyed_err("Wallet"))

cli/src/cli.rs

@@ -66,9 +66,6 @@ pub struct InitParameters {
     /// Set the BIP path, `4219/0/0/0` if not provided.
     #[arg(short, long, value_parser = parse_bip_path, default_value = "4219/0/0/0")]
     pub bip_path: Option<Bip44>,
-    /// Set the Bech32-encoded wallet address.
-    #[arg(short, long)]
-    pub address: Option<String>,
 }
 
 impl Default for InitParameters {
@@ -77,7 +74,6 @@ impl Default for InitParameters {
             mnemonic_file_path: None,
             node_url: DEFAULT_NODE_URL.to_string(),
             bip_path: Some(Bip44::new(SHIMMER_COIN_TYPE)),
-            address: None,
         }
     }
 }
@@ -280,17 +276,11 @@ pub async fn init_command(
         None
     };
 
-    let address = init_params
-        .address
-        .map(|addr| Bech32Address::from_str(&addr))
-        .transpose()?;
-
     Ok(Wallet::builder()
         .with_secret_manager(secret_manager)
         .with_client_options(ClientOptions::new().with_node(init_params.node_url.as_str())?)
         .with_storage_path(storage_path.to_str().expect("invalid unicode"))
         .with_bip_path(init_params.bip_path)
-        .with_address(address)
         .with_alias(alias)
         .finish()
         .await?)

sdk/examples/wallet/ledger_nano.rs

@@ -23,8 +23,6 @@ use iota_sdk::{
     wallet::{ClientOptions, Result, Wallet},
 };
 
-// The address to send coins to
-const RECV_ADDRESS: &str = "rms1qpszqzadsym6wpppd6z037dvlejmjuke7s24hm95s9fg9vpua7vluaw60xu";
 // The amount of base coins we'll send
 const SEND_AMOUNT: u64 = 1_000_000;
 
@@ -38,32 +36,28 @@ async fn main() -> Result<()> {
     }
 
     let client_options = ClientOptions::new().with_node(&std::env::var("NODE_URL").unwrap())?;
-    let secret_manager = LedgerSecretManager::new(true);
+    let secret_manager = SecretManager::LedgerNano(LedgerSecretManager::new(true));
+
     let wallet = Wallet::builder()
-        .with_secret_manager(SecretManager::LedgerNano(secret_manager))
+        .with_secret_manager(secret_manager)
         .with_storage_path(&std::env::var("WALLET_DB_PATH").unwrap())
         .with_client_options(client_options)
         .with_bip_path(Bip44::new(SHIMMER_COIN_TYPE))
         .finish()
         .await?;
 
+    let recv_address = wallet.address().await;
+    println!("receive address: {recv_address}");
     println!("{:?}", wallet.get_ledger_nano_status().await?);
 
-    println!("Generating address...");
-    let now = tokio::time::Instant::now();
-    let address = wallet.generate_ed25519_address(0, 0, None).await?;
-    println!("took: {:.2?}", now.elapsed());
-
-    println!("ADDRESS:\n{address:#?}");
-
     let now = tokio::time::Instant::now();
     let balance = wallet.sync(None).await?;
     println!("Wallet synced in: {:.2?}", now.elapsed());
 
     println!("Balance BEFORE:\n{:?}", balance.base_coin());
 
     println!("Sending the coin-transfer transaction...");
-    let transaction = wallet.send(SEND_AMOUNT, RECV_ADDRESS, None).await?;
+    let transaction = wallet.send(SEND_AMOUNT, recv_address, None).await?;
     println!("Transaction sent: {}", transaction.transaction_id);
 
     let block_id = wallet

sdk/examples/wallet/logger.rs

@@ -10,6 +10,7 @@
 
 use iota_sdk::{
     client::{
+        api::GetAddressesOptions,
         constants::SHIMMER_COIN_TYPE,
         secret::{mnemonic::MnemonicSecretManager, SecretManager},
     },
@@ -38,18 +39,17 @@ async fn main() -> Result<()> {
 
     // Restore a wallet
     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())?;
-    let wallet = Wallet::builder()
-        .with_secret_manager(SecretManager::Mnemonic(secret_manager))
+    let secret_manager = SecretManager::Mnemonic(MnemonicSecretManager::try_from_mnemonic(
+        std::env::var("MNEMONIC").unwrap(),
+    )?);
+
+    let wallet = Wallet::<MnemonicSecretManager>::builder()
         .with_storage_path(&std::env::var("WALLET_DB_PATH").unwrap())
         .with_client_options(client_options)
         .with_bip_path(Bip44::new(SHIMMER_COIN_TYPE))
         .finish()
         .await?;
 
-    println!("Generating address...");
-    let _ = wallet.generate_ed25519_address(0, 0, None).await?;
-
     println!("Syncing wallet");
     wallet.sync(None).await?;
 

sdk/examples/wallet/offline_signing/0_generate_address.rs

@@ -19,7 +19,6 @@ use iota_sdk::{
 
 const OFFLINE_WALLET_DB_PATH: &str = "./examples/wallet/offline_signing/example-offline-walletdb";
 const STRONGHOLD_SNAPSHOT_PATH: &str = "./examples/wallet/offline_signing/example.stronghold";
-const ADDRESS_FILE_PATH: &str = "./examples/wallet/offline_signing/example.address.json";
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -43,7 +42,7 @@ async fn main() -> Result<()> {
     secret_manager.store_mnemonic(mnemonic).await?;
 
     // Create the wallet with the secret_manager and client options
-    let wallet = Wallet::builder()
+    Wallet::builder()
         .with_secret_manager(SecretManager::Stronghold(secret_manager))
         .with_storage_path(OFFLINE_WALLET_DB_PATH)
         .with_client_options(offline_client)
@@ -53,17 +52,5 @@ async fn main() -> Result<()> {
 
     println!("Generated a new wallet");
 
-    write_wallet_address_to_file(&wallet).await
-}
-
-async fn write_wallet_address_to_file(wallet: &Wallet) -> Result<()> {
-    use tokio::io::AsyncWriteExt;
-
-    let wallet_address = wallet.address().await;
-    let json = serde_json::to_string_pretty(&wallet_address)?;
-    let mut file = tokio::io::BufWriter::new(tokio::fs::File::create(ADDRESS_FILE_PATH).await?);
-    println!("example.address.json:\n{json}");
-    file.write_all(json.as_bytes()).await?;
-    file.flush().await?;
     Ok(())
 }

sdk/examples/wallet/offline_signing/1_prepare_transaction.rs

@@ -11,11 +11,10 @@
 use iota_sdk::{
     client::{api::PreparedTransactionDataDto, constants::SHIMMER_COIN_TYPE, secret::SecretManager},
     crypto::keys::bip44::Bip44,
-    wallet::{types::Bip44Address, ClientOptions, Result, SendParams, Wallet},
+    wallet::{ClientOptions, Result, SendParams, Wallet},
 };
 
 const ONLINE_WALLET_DB_PATH: &str = "./examples/wallet/offline_signing/example-online-walletdb";
-const ADDRESS_FILE_PATH: &str = "./examples/wallet/offline_signing/example.address.json";
 const PREPARED_TRANSACTION_FILE_PATH: &str = "./examples/wallet/offline_signing/example.prepared_transaction.json";
 const PROTOCOL_PARAMETERS_FILE_PATH: &str = "./examples/wallet/offline_signing/example.protocol_parameters.json";
 // Address to which we want to send the amount.
@@ -35,9 +34,6 @@ async fn main() -> Result<()> {
 
     let params = [SendParams::new(SEND_AMOUNT, RECV_ADDRESS)?];
 
-    // Recovers addresses from example `0_address_generation`.
-    let address = read_address_from_file().await?.into_bech32();
-
     let client_options = ClientOptions::new().with_node(&std::env::var("NODE_URL").unwrap())?;
 
     // Create the wallet with the secret_manager and client options
@@ -46,7 +42,6 @@ async fn main() -> Result<()> {
         .with_storage_path(ONLINE_WALLET_DB_PATH)
         .with_client_options(client_options.clone())
         .with_bip_path(Bip44::new(SHIMMER_COIN_TYPE))
-        .with_address(address)
         .finish()
         .await?;
 
@@ -72,16 +67,6 @@ async fn main() -> Result<()> {
     Ok(())
 }
 
-async fn read_address_from_file() -> Result<Bip44Address> {
-    use tokio::io::AsyncReadExt;
-
-    let mut file = tokio::io::BufReader::new(tokio::fs::File::open(ADDRESS_FILE_PATH).await?);
-    let mut json = String::new();
-    file.read_to_string(&mut json).await?;
-
-    Ok(serde_json::from_str(&json)?)
-}
-
 async fn write_data_to_file(data: impl serde::Serialize, path: &str) -> Result<()> {
     use tokio::io::AsyncWriteExt;