Remove ed25519 address generation from wallet

bindings/core/src/method/secret_manager.rs

@@ -5,7 +5,7 @@ use crypto::keys::bip44::Bip44;
 use derivative::Derivative;
 use iota_sdk::{
     client::api::{GetAddressesOptions, PreparedTransactionDataDto},
-    types::block::{protocol::ProtocolParameters, UnsignedBlockDto},
+    types::block::{address::Hrp, protocol::ProtocolParameters, UnsignedBlockDto},
     utils::serde::bip44::Bip44Def,
 };
 use serde::{Deserialize, Serialize};
@@ -19,7 +19,22 @@ use crate::OmittedDebug;
 #[serde(tag = "name", content = "data", rename_all = "camelCase")]
 #[non_exhaustive]
 pub enum SecretManagerMethod {
-    /// Generate Ed25519 addresses.
+    // TODO: Should we refactor `GetAddressesOptions` so we can use it for this method as well?
+    /// Generate a single Ed25519 address.
+    #[serde(rename_all = "camelCase")]
+    GenerateEd25519Address {
+        coin_type: u32,
+        bech32_hrp: Hrp,
+        #[serde(default)]
+        account_index: u32,
+        #[serde(default)]
+        address_index: u32,
+        #[serde(default)]
+        internal: bool,
+        #[serde(default)]
+        ledger_nano_prompt: bool,
+    },
+    /// Generate multiple Ed25519 addresses at once.
     GenerateEd25519Addresses {
         /// Addresses generation options
         options: GetAddressesOptions,

bindings/core/src/method/wallet.rs

@@ -6,9 +6,9 @@ use std::path::PathBuf;
 
 use crypto::keys::bip44::Bip44;
 use derivative::Derivative;
+use iota_sdk::client::api::options::TransactionOptions;
 #[cfg(feature = "events")]
 use iota_sdk::wallet::events::types::{WalletEvent, WalletEventType};
-use iota_sdk::{client::api::options::TransactionOptions, utils::serde::string};
 // #[cfg(feature = "participation")]
 // use iota_sdk::{
 //     client::node_manager::node::Node,
@@ -19,10 +19,9 @@ use iota_sdk::{
     client::{
         api::{transaction_builder::Burn, PreparedTransactionDataDto, SignedTransactionDataDto},
         node_manager::node::NodeAuth,
-        secret::GenerateAddressOptions,
     },
     types::block::{
-        address::{Bech32Address, Hrp},
+        address::Hrp,
         output::{AccountId, DelegationId, Output, OutputId, TokenId},
         payload::signed_transaction::TransactionId,
     },
@@ -456,27 +455,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/secret_manager.rs

@@ -8,7 +8,7 @@ use iota_sdk::client::secret::{stronghold::StrongholdSecretManager, SecretManage
 use iota_sdk::{
     client::{
         api::{GetAddressesOptions, PreparedTransactionData},
-        secret::{DowncastSecretManager, SecretManage, SignBlock},
+        secret::{DowncastSecretManager, GenerateAddressOptions, SecretManage, SignBlock},
         ClientError,
     },
     types::{
@@ -28,6 +28,34 @@ where
     ClientError: From<S::Error>,
 {
     let response = match method {
+        SecretManagerMethod::GenerateEd25519Address {
+            coin_type,
+            account_index,
+            address_index,
+            internal,
+            ledger_nano_prompt,
+            bech32_hrp,
+        } => {
+            let address = secret_manager
+                .generate_ed25519_addresses(
+                    coin_type,
+                    account_index,
+                    address_index..address_index + 1,
+                    GenerateAddressOptions {
+                        internal,
+                        ledger_nano_prompt,
+                    },
+                )
+                .await
+                .map_err(ClientError::from)?
+                .into_iter()
+                .map(|a| a.to_bech32(bech32_hrp))
+                .collect::<Vec<_>>()
+                .pop()
+                // Panic: if the secret manager method didn't fail then there must be at least one address
+                .unwrap();
+            Response::Bech32Address(address)
+        }
         SecretManagerMethod::GenerateEd25519Addresses {
             options:
                 GetAddressesOptions {

bindings/core/src/method_handler/wallet.rs

@@ -6,10 +6,7 @@ use std::time::Duration;
 use crypto::signatures::ed25519::PublicKey;
 use iota_sdk::{
     client::api::{PreparedTransactionData, SignedTransactionData, SignedTransactionDataDto},
-    types::{
-        block::{address::ToBech32Ext, output::feature::BlockIssuerKeySource},
-        TryFromDto,
-    },
+    types::{block::output::feature::BlockIssuerKeySource, TryFromDto},
     wallet::{types::TransactionWithMetadataDto, Wallet},
 };
 
@@ -73,23 +70,6 @@ pub(crate) async fn call_wallet_method_internal(
             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/wallet/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/secret_manager/secret-manager.ts

@@ -6,6 +6,8 @@ import type {
     GenerateAddressesOptions,
     PreparedTransactionData,
     LedgerNanoStatus,
+    CoinType,
+    GenerateAddressOptions,
 } from '../types/client';
 import {
     Bip44,
@@ -21,6 +23,7 @@ import {
     UnsignedBlock,
     Block,
     parseBlock,
+    Bech32Address,
 } from '../types';
 
 import { plainToInstance } from 'class-transformer';
@@ -44,14 +47,41 @@ export class SecretManager {
     }
 
     /**
-     * Generate Ed25519 addresses.
+     * Generate a single Ed25519 address.
+     *
+     * @returns The generated Bech32 address.
+     */
+    async generateEd25519Address(
+        coinType: CoinType,
+        bech32Hrp: string,
+        accountIndex?: number,
+        addressIndex?: number,
+        options?: GenerateAddressOptions,
+    ): Promise<Bech32Address> {
+        const response = await this.methodHandler.callMethod({
+            name: 'generateEd25519Address',
+            data: {
+                coinType,
+                bech32Hrp,
+                accountIndex,
+                addressIndex,
+                internal: options?.internal,
+                ledgerNanoPrompt: options?.ledgerNanoPrompt,
+            },
+        });
+
+        return JSON.parse(response).payload;
+    }
+
+    /**
+     * Generate multiple Ed25519 addresses at once.
      *
      * @param generateAddressesOptions Options to generate addresses.
      * @returns An array of generated addresses.
      */
     async generateEd25519Addresses(
         generateAddressesOptions: GenerateAddressesOptions,
-    ): Promise<string[]> {
+    ): Promise<Bech32Address[]> {
         const response = await this.methodHandler.callMethod({
             name: 'generateEd25519Addresses',
             data: {

bindings/nodejs/lib/types/client/generate-addresses-options.ts

@@ -3,6 +3,8 @@
 import type { CoinType } from './constants';
 import type { Range } from './range';
 
+// TODO: Rename (to GetAddressOptions) and refactor (move out range field),
+// so we can use it for the single address generation method as well?
 /**
  * Input options for GenerateAddresses
  */

bindings/nodejs/lib/types/secret_manager/bridge/index.ts

@@ -1,4 +1,5 @@
 import type {
+    __GenerateEd25519AddressMethod__,
     __GenerateEd25519AddressesMethod__,
     __GenerateEvmAddressesMethod__,
     __GetLedgerNanoStatusMethod__,
@@ -14,6 +15,7 @@ import type {
 } from './secret-manager';
 
 export type __SecretManagerMethods__ =
+    | __GenerateEd25519AddressMethod__
     | __GenerateEd25519AddressesMethod__
     | __GenerateEvmAddressesMethod__
     | __GetLedgerNanoStatusMethod__

bindings/nodejs/lib/types/secret_manager/bridge/secret-manager.ts

@@ -2,11 +2,24 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { UnsignedBlock } from '../../block';
+import { CoinType } from '../../client';
 import type { GenerateAddressesOptions } from '../../client/generate-addresses-options';
 import type { PreparedTransactionData } from '../../client/prepared-transaction-data';
 import { HexEncodedString } from '../../utils';
 import { Bip44 } from '../secret-manager';
 
+export interface __GenerateEd25519AddressMethod__ {
+    name: 'generateEd25519Address';
+    data: {
+        coinType: CoinType;
+        bech32Hrp: string;
+        accountIndex?: number;
+        addressIndex?: number;
+        internal?: boolean;
+        ledgerNanoPrompt?: boolean;
+    };
+}
+
 export interface __GenerateEd25519AddressesMethod__ {
     name: 'generateEd25519Addresses';
     data: {

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/nodejs/tests/secret_manager/secret_manager.spec.ts

@@ -0,0 +1,41 @@
+// Copyright 2023 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import 'reflect-metadata';
+
+import { describe, it, expect } from '@jest/globals';
+import {
+    CoinType,
+    SecretManager,
+    Utils,
+} from '../../lib/';
+
+describe('SecretManager', () => {
+    it('generate IOTA Ed25519 address', async () => {
+        const mnemonicSecretManager = {
+            mnemonic: "acoustic trophy damage hint search taste love bicycle foster cradle brown govern endless depend situate athlete pudding blame question genius transfer van random vast"
+        };
+
+        let bech32_hrp = Utils.iotaMainnetProtocolParameters().bech32Hrp;
+
+        const secretManager = SecretManager.create(mnemonicSecretManager);
+        const address = await secretManager.generateEd25519Address(CoinType.IOTA, bech32_hrp);
+
+        expect(address).toEqual('iota1qpg2xkj66wwgn8p2ggnp7p582gj8g6p79us5hve2tsudzpsr2ap4skprwjg');
+
+    }, 20000);
+
+    it('generate Shimmer Ed25519 address', async () => {
+        const mnemonicSecretManager = {
+            mnemonic: "acoustic trophy damage hint search taste love bicycle foster cradle brown govern endless depend situate athlete pudding blame question genius transfer van random vast"
+        };
+
+        let bech32_hrp = Utils.shimmerMainnetProtocolParameters().bech32Hrp;
+
+        const secretManager = SecretManager.create(mnemonicSecretManager);
+        const address = await secretManager.generateEd25519Address(CoinType.Shimmer, bech32_hrp);
+
+        expect(address).toEqual('smr1qzev36lk0gzld0k28fd2fauz26qqzh4hd4cwymlqlv96x7phjxcw6ckj80y');
+
+    }, 20000);
+});