feat(wallet): implement HD multi-address support for message signing

mm2src/coins/eth.rs

@@ -2378,10 +2378,26 @@ impl MarketCoinOps for EthCoin {
         Some(keccak256(&stream.out()).take())
     }
 
-    fn sign_message(&self, message: &str) -> SignatureResult<String> {
+    fn sign_message(&self, message: &str, account: Option<HDAddressSelector>) -> SignatureResult<String> {
         let message_hash = self.sign_message_hash(message).ok_or(SignatureError::PrefixNotFound)?;
-        let privkey = &self.priv_key_policy.activated_key_or_err()?.secret();
-        let signature = sign(privkey, &H256::from(message_hash))?;
+
+        let signature = if let Some(account) = account {
+            let path_to_coin = self.priv_key_policy.path_to_coin_or_err()?;
+            let derivation_path = account
+                .valid_derivation_path(path_to_coin)
+                .mm_err(|err| SignatureError::InvalidRequest(err.to_string()))?;
+            let privkey = self
+                .priv_key_policy
+                .hd_wallet_derived_priv_key_or_err(&derivation_path)?;
+            let secret = ethkey::Secret::from_slice(privkey.as_slice()).ok_or(MmError::new(
+                SignatureError::InternalError("failed to derive ethkey::Secret".to_string()),
+            ))?;
+            sign(&secret, &H256::from(message_hash))?
+        } else {
+            let secret = self.priv_key_policy.activated_key_or_err()?.secret();
+            sign(secret, &H256::from(message_hash))?
+        };
+
         Ok(format!("0x{}", signature))
     }
 

mm2src/coins/eth/eth_tests.rs

@@ -868,7 +868,7 @@ fn test_sign_verify_message() {
     );
 
     let message = "test";
-    let signature = coin.sign_message(message).unwrap();
+    let signature = coin.sign_message(message, None).unwrap();
     assert_eq!(signature, "0xcdf11a9c4591fb7334daa4b21494a2590d3f7de41c7d2b333a5b61ca59da9b311b492374cc0ba4fbae53933260fa4b1c18f15d95b694629a7b0620eec77a938600");
 
     let is_valid = coin

mm2src/coins/eth/eth_withdraw.rs

@@ -3,7 +3,7 @@ use super::{checksum_address, u256_to_big_decimal, wei_from_big_decimal, ChainSp
 use crate::eth::{calc_total_fee, get_eth_gas_details_from_withdraw_fee, tx_builder_with_pay_for_gas_option,
                  tx_type_from_pay_for_gas_option, Action, Address, EthTxFeeDetails, KeyPair, PayForGasOption,
                  SignedEthTx, TransactionWrapper, UnSignedEthTxBuilder};
-use crate::hd_wallet::{HDCoinWithdrawOps, HDWalletOps, WithdrawFrom, WithdrawSenderAddress};
+use crate::hd_wallet::{HDAddressSelector, HDCoinWithdrawOps, HDWalletOps, WithdrawSenderAddress};
 use crate::rpc_command::init_withdraw::{WithdrawInProgressStatus, WithdrawTaskHandleShared};
 use crate::{BytesJson, CoinWithDerivationMethod, EthCoin, GetWithdrawSenderAddress, PrivKeyPolicy, TransactionData,
             TransactionDetails};
@@ -89,10 +89,12 @@ where
 
     /// Gets the derivation path for the address from which the withdrawal is made using the `from` parameter.
     #[allow(clippy::result_large_err)]
-    fn get_from_derivation_path(&self, from: &WithdrawFrom) -> Result<DerivationPath, MmError<WithdrawError>> {
+    fn get_from_derivation_path(&self, from: &HDAddressSelector) -> Result<DerivationPath, MmError<WithdrawError>> {
         let coin = self.coin();
         let path_to_coin = &coin.deref().derivation_method.hd_wallet_or_err()?.derivation_path;
-        let path_to_address = from.to_address_path(path_to_coin.coin_type())?;
+        let path_to_address = from
+            .to_address_path(path_to_coin.coin_type())
+            .mm_err(|err| WithdrawError::UnexpectedFromAddress(err.to_string()))?;
         let derivation_path = path_to_address.to_derivation_path(path_to_coin)?;
         Ok(derivation_path)
     }

mm2src/coins/hd_wallet/mod.rs

@@ -47,7 +47,7 @@ mod wallet_ops;
 pub use wallet_ops::HDWalletOps;
 
 mod withdraw_ops;
-pub use withdraw_ops::{HDCoinWithdrawOps, WithdrawFrom, WithdrawSenderAddress};
+pub use withdraw_ops::{HDCoinWithdrawOps, WithdrawSenderAddress};
 
 pub(crate) type HDAccountsMap<HDAccount> = BTreeMap<u32, HDAccount>;
 pub(crate) type HDAccountsMutex<HDAccount> = AsyncMutex<HDAccountsMap<HDAccount>>;
@@ -485,6 +485,63 @@ impl HDPathAccountToAddressId {
         Ok(account_der_path)
     }
 }
+/// Represents how a hierarchical deterministic (HD) address is selected.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum HDAddressSelector {
+    /// Specifies the HD address using its structured account, chain, and address ID.
+    AddressId(HDPathAccountToAddressId),
+    /// Specifies the HD address directly using a BIP-44 compliant derivation path.
+    ///
+    /// IMPORTANT: Don't use `Bip44DerivationPath` or `RpcDerivationPath` because if there is an error in the path,
+    /// `serde::Deserialize` returns "data did not match any variant of untagged enum HDAddressSelector".
+    /// It's better to show the user an informative error.
+    DerivationPath { derivation_path: String },
+}
+
+impl HDAddressSelector {
+    pub fn to_address_path(&self, expected_coin_type: u32) -> MmResult<HDPathAccountToAddressId, StandardHDPathError> {
+        match self {
+            HDAddressSelector::AddressId(address_id) => Ok(*address_id),
+            HDAddressSelector::DerivationPath { derivation_path } => {
+                let derivation_path = StandardHDPath::from_str(derivation_path).map_to_mm(StandardHDPathError::from)?;
+                let coin_type = derivation_path.coin_type();
+
+                if coin_type != expected_coin_type {
+                    return MmError::err(StandardHDPathError::InvalidCoinType {
+                        expected: expected_coin_type,
+                        found: coin_type,
+                    });
+                }
+
+                Ok(HDPathAccountToAddressId::from(derivation_path))
+            },
+        }
+    }
+
+    pub fn valid_derivation_path(self, path_to_coin: &HDPathToCoin) -> MmResult<DerivationPath, StandardHDPathError> {
+        match self {
+            HDAddressSelector::AddressId(id) => id
+                .to_derivation_path(path_to_coin)
+                .mm_err(StandardHDPathError::Bip32Error),
+            HDAddressSelector::DerivationPath { derivation_path } => {
+                let standard_hd_path = StandardHDPath::from_str(&derivation_path)
+                    .map_to_mm(|_| StandardHDPathError::Bip32Error(Bip32Error::Decode))?;
+                let rpc_path_to_coin = standard_hd_path.path_to_coin();
+
+                // validate rpc path_to_coin against activated coin.
+                if &rpc_path_to_coin != path_to_coin {
+                    return MmError::err(StandardHDPathError::InvalidPathToCoin {
+                        expected: rpc_path_to_coin.to_string(),
+                        found: path_to_coin.to_string(),
+                    });
+                };
+
+                Ok(standard_hd_path.to_derivation_path())
+            },
+        }
+    }
+}
 
 pub(crate) mod inner_impl {
     use super::*;

mm2src/coins/hd_wallet/withdraw_ops.rs

@@ -1,51 +1,12 @@
 use super::{DisplayAddress, HDPathAccountToAddressId, HDWalletOps, HDWithdrawError};
-use crate::hd_wallet::{HDAccountOps, HDAddressOps, HDCoinAddress, HDWalletCoinOps};
+use crate::hd_wallet::{HDAccountOps, HDAddressOps, HDAddressSelector, HDCoinAddress, HDWalletCoinOps};
 use async_trait::async_trait;
 use bip32::DerivationPath;
-use crypto::{StandardHDPath, StandardHDPathError};
 use mm2_err_handle::prelude::*;
-use std::str::FromStr;
 
 type HDCoinPubKey<T> =
     <<<<T as HDWalletCoinOps>::HDWallet as HDWalletOps>::HDAccount as HDAccountOps>::HDAddress as HDAddressOps>::Pubkey;
 
-/// Represents the source of the funds for a withdrawal operation.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum WithdrawFrom {
-    /// The address id of the sender address which is specified by the account id, chain, and address id.
-    AddressId(HDPathAccountToAddressId),
-    /// The derivation path of the sender address in the BIP-44 format.
-    ///
-    /// IMPORTANT: Don't use `Bip44DerivationPath` or `RpcDerivationPath` because if there is an error in the path,
-    /// `serde::Deserialize` returns "data did not match any variant of untagged enum WithdrawFrom".
-    /// It's better to show the user an informative error.
-    DerivationPath { derivation_path: String },
-}
-
-impl WithdrawFrom {
-    #[allow(clippy::result_large_err)]
-    pub fn to_address_path(&self, expected_coin_type: u32) -> MmResult<HDPathAccountToAddressId, HDWithdrawError> {
-        match self {
-            WithdrawFrom::AddressId(address_id) => Ok(*address_id),
-            WithdrawFrom::DerivationPath { derivation_path } => {
-                let derivation_path = StandardHDPath::from_str(derivation_path)
-                    .map_to_mm(StandardHDPathError::from)
-                    .mm_err(|e| HDWithdrawError::UnexpectedFromAddress(e.to_string()))?;
-                let coin_type = derivation_path.coin_type();
-                if coin_type != expected_coin_type {
-                    let error = format!(
-                        "Derivation path '{}' must have '{}' coin type",
-                        derivation_path, expected_coin_type
-                    );
-                    return MmError::err(HDWithdrawError::UnexpectedFromAddress(error));
-                }
-                Ok(HDPathAccountToAddressId::from(derivation_path))
-            },
-        }
-    }
-}
-
 /// Contains the details of the sender address for a withdraw operation.
 pub struct WithdrawSenderAddress<Address, Pubkey> {
     pub(crate) address: Address,
@@ -61,13 +22,15 @@ pub trait HDCoinWithdrawOps: HDWalletCoinOps {
     async fn get_withdraw_hd_sender(
         &self,
         hd_wallet: &Self::HDWallet,
-        from: &WithdrawFrom,
+        from: &HDAddressSelector,
     ) -> MmResult<WithdrawSenderAddress<HDCoinAddress<Self>, HDCoinPubKey<Self>>, HDWithdrawError> {
         let HDPathAccountToAddressId {
             account_id,
             chain,
             address_id,
-        } = from.to_address_path(hd_wallet.coin_type())?;
+        } = from
+            .to_address_path(hd_wallet.coin_type())
+            .mm_err(|err| HDWithdrawError::UnexpectedFromAddress(err.to_string()))?;
 
         let hd_account = hd_wallet
             .get_account(account_id)

mm2src/coins/lightning.rs

@@ -11,6 +11,7 @@ pub mod ln_storage;
 pub mod ln_utils;
 
 use crate::coin_errors::{AddressFromPubkeyError, MyAddressError, ValidatePaymentResult};
+use crate::hd_wallet::HDAddressSelector;
 use crate::lightning::ln_utils::{filter_channels, pay_invoice_with_max_total_cltv_expiry_delta, PaymentError};
 use crate::utxo::rpc_clients::UtxoRpcClientEnum;
 use crate::utxo::utxo_common::{big_decimal_from_sat, big_decimal_from_sat_unsigned};
@@ -956,7 +957,12 @@ impl MarketCoinOps for LightningCoin {
         Some(dhash256(prefixed_message.as_bytes()).take())
     }
 
-    fn sign_message(&self, message: &str) -> SignatureResult<String> {
+    fn sign_message(&self, message: &str, account: Option<HDAddressSelector>) -> SignatureResult<String> {
+        if account.is_some() {
+            return MmError::err(SignatureError::InvalidRequest(
+                "functionality not supported for Lightning yet.".into(),
+            ));
+        }
         let message_hash = self.sign_message_hash(message).ok_or(SignatureError::PrefixNotFound)?;
         let secret_key = self
             .keys_manager

mm2src/coins/lp_coins.rs

@@ -225,9 +225,9 @@ use eth::{eth_coin_from_conf_and_request, get_eth_address, EthCoin, EthGasDetail
           GetEthAddressError, GetValidEthWithdrawAddError, SignedEthTx};
 
 pub mod hd_wallet;
-use hd_wallet::{AccountUpdatingError, AddressDerivingError, HDAccountOps, HDAddressId, HDAddressOps, HDCoinAddress,
-                HDCoinHDAccount, HDExtractPubkeyError, HDPathAccountToAddressId, HDWalletAddress, HDWalletCoinOps,
-                HDWalletOps, HDWithdrawError, HDXPubExtractor, WithdrawFrom, WithdrawSenderAddress};
+use hd_wallet::{AccountUpdatingError, AddressDerivingError, HDAccountOps, HDAddressId, HDAddressOps,
+                HDAddressSelector, HDCoinAddress, HDCoinHDAccount, HDExtractPubkeyError, HDPathAccountToAddressId,
+                HDWalletAddress, HDWalletCoinOps, HDWalletOps, HDWithdrawError, HDXPubExtractor, WithdrawSenderAddress};
 
 #[cfg(not(target_arch = "wasm32"))] pub mod lightning;
 #[cfg_attr(target_arch = "wasm32", allow(dead_code, unused_imports))]
@@ -2083,7 +2083,7 @@ pub trait MarketCoinOps {
 
     fn sign_message_hash(&self, _message: &str) -> Option<[u8; 32]>;
 
-    fn sign_message(&self, _message: &str) -> SignatureResult<String>;
+    fn sign_message(&self, _message: &str, _account: Option<HDAddressSelector>) -> SignatureResult<String>;
 
     fn verify_message(&self, _signature: &str, _message: &str, _address: &str) -> VerificationResult<bool>;
 
@@ -2210,7 +2210,7 @@ pub trait GetWithdrawSenderAddress {
 #[derive(Clone, Default, Deserialize)]
 pub struct WithdrawRequest {
     coin: String,
-    from: Option<WithdrawFrom>,
+    from: Option<HDAddressSelector>,
     to: String,
     #[serde(default)]
     amount: BigDecimal,
@@ -2294,10 +2294,11 @@ pub enum ValidatorsInfoDetails {
     Cosmos(rpc_command::tendermint::staking::ValidatorsQuery),
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Deserialize)]
 pub struct SignatureRequest {
     coin: String,
     message: String,
+    account: Option<HDAddressSelector>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -5116,8 +5117,14 @@ pub async fn get_raw_transaction(ctx: MmArc, req: RawTransactionRequest) -> RawT
 }
 
 pub async fn sign_message(ctx: MmArc, req: SignatureRequest) -> SignatureResult<SignatureResponse> {
+    if req.account.is_some() && !ctx.enable_hd() {
+        return MmError::err(SignatureError::InvalidRequest(
+            "You need to enable kdf with enable_hd to sign messages with a specific account/address".to_string(),
+        ));
+    };
     let coin = lp_coinfind_or_err(&ctx, &req.coin).await?;
-    let signature = coin.sign_message(&req.message)?;
+    let signature = coin.sign_message(&req.message, req.account)?;
+
     Ok(SignatureResponse { signature })
 }
 
@@ -6151,7 +6158,7 @@ mod tests {
 pub mod for_tests {
     use crate::rpc_command::init_withdraw::WithdrawStatusRequest;
     use crate::rpc_command::init_withdraw::{init_withdraw, withdraw_status};
-    use crate::{TransactionDetails, WithdrawError, WithdrawFee, WithdrawFrom, WithdrawRequest};
+    use crate::{HDAddressSelector, TransactionDetails, WithdrawError, WithdrawFee, WithdrawRequest};
     use common::executor::Timer;
     use common::{now_ms, wait_until_ms};
     use mm2_core::mm_ctx::MmArc;
@@ -6173,7 +6180,7 @@ pub mod for_tests {
             client_id: 0,
             inner: WithdrawRequest {
                 amount: BigDecimal::from_str(amount).unwrap(),
-                from: from_derivation_path.map(|from_derivation_path| WithdrawFrom::DerivationPath {
+                from: from_derivation_path.map(|from_derivation_path| HDAddressSelector::DerivationPath {
                     derivation_path: from_derivation_path.to_owned(),
                 }),
                 to: to.to_owned(),

mm2src/coins/qrc20.rs

@@ -1,5 +1,6 @@
 use crate::coin_errors::{AddressFromPubkeyError, MyAddressError, ValidatePaymentError, ValidatePaymentResult};
 use crate::eth::{self, u256_to_big_decimal, wei_from_big_decimal, TryToAddress};
+use crate::hd_wallet::HDAddressSelector;
 use crate::qrc20::rpc_clients::{LogEntry, Qrc20ElectrumOps, Qrc20NativeOps, Qrc20RpcOps, TopicFilter, TxReceipt,
                                 ViewContractCallType};
 use crate::utxo::qtum::QtumBasedCoin;
@@ -1039,8 +1040,8 @@ impl MarketCoinOps for Qrc20Coin {
         utxo_common::sign_message_hash(self.as_ref(), message)
     }
 
-    fn sign_message(&self, message: &str) -> SignatureResult<String> {
-        utxo_common::sign_message(self.as_ref(), message)
+    fn sign_message(&self, message: &str, account: Option<HDAddressSelector>) -> SignatureResult<String> {
+        utxo_common::sign_message(self.as_ref(), message, account)
     }
 
     fn verify_message(&self, signature_base64: &str, message: &str, address: &str) -> VerificationResult<bool> {

mm2src/coins/rpc_command/tendermint/staking.rs

@@ -3,7 +3,8 @@ use cosmrs::staking::{Commission, Description, Validator};
 use mm2_err_handle::prelude::MmError;
 use mm2_number::BigDecimal;
 
-use crate::{hd_wallet::WithdrawFrom, tendermint::TendermintCoinRpcError, MmCoinEnum, StakingInfoError, WithdrawFee};
+use crate::{hd_wallet::HDAddressSelector, tendermint::TendermintCoinRpcError, MmCoinEnum, StakingInfoError,
+            WithdrawFee};
 
 /// Represents current status of the validator.
 #[derive(Debug, Default, Deserialize)]
@@ -131,7 +132,7 @@ pub async fn validators_rpc(
 pub struct DelegationPayload {
     pub validator_address: String,
     pub fee: Option<WithdrawFee>,
-    pub withdraw_from: Option<WithdrawFrom>,
+    pub withdraw_from: Option<HDAddressSelector>,
     #[serde(default)]
     pub memo: String,
     #[serde(default)]

mm2src/coins/siacoin.rs

@@ -1,5 +1,6 @@
 use super::{BalanceError, CoinBalance, HistorySyncState, MarketCoinOps, MmCoin, RawTransactionFut,
             RawTransactionRequest, SwapOps, TradeFee, TransactionEnum};
+use crate::hd_wallet::HDAddressSelector;
 use crate::{coin_errors::MyAddressError, AddressFromPubkeyError, BalanceFut, CanRefundHtlc, CheckIfMyPaymentSentArgs,
             ConfirmPaymentInput, DexFee, FeeApproxStage, FoundSwapTxSpend, NegotiateSwapContractAddrErr,
             PrivKeyBuildPolicy, PrivKeyPolicy, RawTransactionResult, RefundPaymentArgs, SearchForSwapTxSpendInput,
@@ -8,6 +9,7 @@ use crate::{coin_errors::MyAddressError, AddressFromPubkeyError, BalanceFut, Can
             ValidateAddressResult, ValidateFeeArgs, ValidateOtherPubKeyErr, ValidatePaymentInput,
             ValidatePaymentResult, VerificationResult, WaitForHTLCTxSpendArgs, WatcherOps, WeakSpawner, WithdrawFut,
             WithdrawRequest};
+use crate::{SignatureError, VerificationError};
 use async_trait::async_trait;
 use common::executor::AbortedError;
 pub use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature};
@@ -321,14 +323,18 @@ impl MarketCoinOps for SiaCoin {
         Ok(address.to_string())
     }
 
-    async fn get_public_key(&self) -> Result<String, MmError<UnexpectedDerivationMethod>> { unimplemented!() }
+    async fn get_public_key(&self) -> Result<String, MmError<UnexpectedDerivationMethod>> {
+        MmError::err(UnexpectedDerivationMethod::InternalError("Not implemented".into()))
+    }
 
-    fn sign_message_hash(&self, _message: &str) -> Option<[u8; 32]> { unimplemented!() }
+    fn sign_message_hash(&self, _message: &str) -> Option<[u8; 32]> { None }
 
-    fn sign_message(&self, _message: &str) -> SignatureResult<String> { unimplemented!() }
+    fn sign_message(&self, _message: &str, _account: Option<HDAddressSelector>) -> SignatureResult<String> {
+        MmError::err(SignatureError::InternalError("Not implemented".into()))
+    }
 
     fn verify_message(&self, _signature: &str, _message: &str, _address: &str) -> VerificationResult<bool> {
-        unimplemented!()
+        MmError::err(VerificationError::InternalError("Not implemented".into()))
     }
 
     fn my_balance(&self) -> BalanceFut<CoinBalance> {