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

mm2src/coins/eth.rs

@@ -2328,10 +2328,26 @@ impl MarketCoinOps for EthCoin {
         Some(keccak256(&stream.out()).take())
     }
 
-    fn sign_message(&self, message: &str) -> SignatureResult<String> {
+    fn sign_message(&self, message: &str, derivation_path: Option<DerivationPath>) -> 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 = match derivation_path {
+            Some(derivation_path) => {
+                let privkey = self
+                    .priv_key_policy
+                    .hd_wallet_derived_priv_key_or_err(&derivation_path)
+                    .mm_err(|err| SignatureError::InvalidRequest(err.to_string()))?;
+                let eth_secret = ethkey::Secret::from_slice(privkey.as_slice()).ok_or(MmError::new(
+                    SignatureError::InvalidRequest("failed to derive ethkey::Secret".to_string()),
+                ))?;
+                sign(&eth_secret, &H256::from(message_hash))?
+            },
+            None => {
+                let privkey = &self.priv_key_policy.activated_key_or_err()?.secret();
+                sign(privkey, &H256::from(message_hash))?
+            },
+        };
+
         Ok(format!("0x{}", signature))
     }
 

mm2src/coins/eth/eth_tests.rs

@@ -863,7 +863,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/lightning.rs

@@ -27,6 +27,7 @@ use crate::{BalanceFut, CheckIfMyPaymentSentArgs, CoinBalance, ConfirmPaymentInp
             ValidatePaymentInput, VerificationError, VerificationResult, WaitForHTLCTxSpendArgs, WatcherOps,
             WeakSpawner, WithdrawError, WithdrawFut, WithdrawRequest};
 use async_trait::async_trait;
+use bip32::DerivationPath;
 use bitcoin::bech32::ToBase32;
 use bitcoin::hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
@@ -950,7 +951,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, derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
+        if derivation_path.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

@@ -2084,7 +2084,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, _derivation_path: Option<DerivationPath>) -> SignatureResult<String>;
 
     fn verify_message(&self, _signature: &str, _message: &str, _address: &str) -> VerificationResult<bool>;
 
@@ -2296,9 +2296,17 @@ pub enum ValidatorsInfoDetails {
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct SignatureRequest {
-    coin: String,
-    message: String,
+#[serde(tag = "derivation_method", rename_all = "snake_case")]
+pub enum SignatureRequest {
+    Iguana {
+        coin: String,
+        message: String,
+    },
+    HdWallet {
+        coin: String,
+        message: String,
+        derivation_path: RpcDerivationPath,
+    },
 }
 
 #[derive(Serialize, Deserialize)]
@@ -5112,8 +5120,17 @@ pub async fn get_raw_transaction(ctx: MmArc, req: RawTransactionRequest) -> RawT
 }
 
 pub async fn sign_message(ctx: MmArc, req: SignatureRequest) -> SignatureResult<SignatureResponse> {
-    let coin = lp_coinfind_or_err(&ctx, &req.coin).await?;
-    let signature = coin.sign_message(&req.message)?;
+    let (coin, message, derivation_path) = match &req {
+        SignatureRequest::Iguana { coin, message } => (coin, message, None),
+        SignatureRequest::HdWallet {
+            coin,
+            message,
+            derivation_path,
+        } => (coin, message, Some(derivation_path.0.clone())),
+    };
+    let coin = lp_coinfind_or_err(&ctx, coin).await?;
+    let signature = coin.sign_message(message, derivation_path)?;
+
     Ok(SignatureResponse { signature })
 }
 

mm2src/coins/qrc20.rs

@@ -27,6 +27,7 @@ use crate::{BalanceError, BalanceFut, CheckIfMyPaymentSentArgs, CoinBalance, Con
             ValidatePaymentInput, VerificationResult, WaitForHTLCTxSpendArgs, WatcherOps, WeakSpawner, WithdrawError,
             WithdrawFee, WithdrawFut, WithdrawRequest, WithdrawResult};
 use async_trait::async_trait;
+use bip32::DerivationPath;
 use bitcrypto::{dhash160, sha256};
 use chain::TransactionOutput;
 use common::executor::{AbortableSystem, AbortedError, Timer};
@@ -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, derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
+        utxo_common::sign_message(self.as_ref(), message, derivation_path)
     }
 
     fn verify_message(&self, signature_base64: &str, message: &str, address: &str) -> VerificationResult<bool> {

mm2src/coins/siacoin.rs

@@ -8,6 +8,7 @@ use crate::{coin_errors::MyAddressError, BalanceFut, CanRefundHtlc, CheckIfMyPay
             ValidateFeeArgs, ValidateOtherPubKeyErr, ValidatePaymentInput, ValidatePaymentResult, VerificationResult,
             WaitForHTLCTxSpendArgs, WatcherOps, WeakSpawner, WithdrawFut, WithdrawRequest};
 use async_trait::async_trait;
+use bip32::DerivationPath;
 use common::executor::AbortedError;
 pub use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature};
 use futures::{FutureExt, TryFutureExt};
@@ -316,7 +317,9 @@ impl MarketCoinOps for SiaCoin {
 
     fn sign_message_hash(&self, _message: &str) -> Option<[u8; 32]> { unimplemented!() }
 
-    fn sign_message(&self, _message: &str) -> SignatureResult<String> { unimplemented!() }
+    fn sign_message(&self, _message: &str, _derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
+        unimplemented!()
+    }
 
     fn verify_message(&self, _signature: &str, _message: &str, _address: &str) -> VerificationResult<bool> {
         unimplemented!()

mm2src/coins/tendermint/tendermint_coin.rs

@@ -3336,7 +3336,7 @@ impl MarketCoinOps for TendermintCoin {
         None
     }
 
-    fn sign_message(&self, _message: &str) -> SignatureResult<String> {
+    fn sign_message(&self, _message: &str, _derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
         // TODO
         MmError::err(SignatureError::InternalError("Not implemented".into()))
     }

mm2src/coins/tendermint/tendermint_token.rs

@@ -16,6 +16,7 @@ use crate::{big_decimal_from_sat_unsigned, utxo::sat_from_big_decimal, BalanceFu
             ValidatePaymentInput, VerificationResult, WaitForHTLCTxSpendArgs, WatcherOps, WeakSpawner, WithdrawError,
             WithdrawFut, WithdrawRequest};
 use async_trait::async_trait;
+use bip32::DerivationPath;
 use bitcrypto::sha256;
 use common::executor::abortable_queue::AbortableQueue;
 use common::executor::{AbortableSystem, AbortedError};
@@ -275,7 +276,9 @@ impl MarketCoinOps for TendermintToken {
 
     fn sign_message_hash(&self, message: &str) -> Option<[u8; 32]> { self.platform_coin.sign_message_hash(message) }
 
-    fn sign_message(&self, message: &str) -> SignatureResult<String> { self.platform_coin.sign_message(message) }
+    fn sign_message(&self, message: &str, derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
+        self.platform_coin.sign_message(message, derivation_path)
+    }
 
     fn verify_message(&self, signature: &str, message: &str, address: &str) -> VerificationResult<bool> {
         self.platform_coin.verify_message(signature, message, address)

mm2src/coins/test_coin.rs

@@ -20,6 +20,7 @@ use crate::{coin_errors::MyAddressError, BalanceFut, CanRefundHtlc, CheckIfMyPay
             WatcherValidatePaymentInput, WatcherValidateTakerFeeInput, WeakSpawner, WithdrawFut, WithdrawRequest};
 use crate::{DexFee, ToBytes, ValidateWatcherSpendInput};
 use async_trait::async_trait;
+use bip32::DerivationPath;
 use common::executor::AbortedError;
 use futures01::Future;
 use keys::KeyPair;
@@ -69,7 +70,9 @@ impl MarketCoinOps for TestCoin {
 
     fn sign_message_hash(&self, _message: &str) -> Option<[u8; 32]> { unimplemented!() }
 
-    fn sign_message(&self, _message: &str) -> SignatureResult<String> { unimplemented!() }
+    fn sign_message(&self, _message: &str, _derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
+        unimplemented!()
+    }
 
     fn verify_message(&self, _signature: &str, _message: &str, _address: &str) -> VerificationResult<bool> {
         unimplemented!()

mm2src/coins/utxo/bch.rs

@@ -1147,8 +1147,8 @@ impl MarketCoinOps for BchCoin {
         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, derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
+        utxo_common::sign_message(self.as_ref(), message, derivation_path)
     }
 
     fn verify_message(&self, signature_base64: &str, message: &str, address: &str) -> VerificationResult<bool> {
@@ -1703,7 +1703,7 @@ mod bch_tests {
     #[test]
     fn test_sign_message() {
         let (_ctx, coin) = tbch_coin_for_test();
-        let signature = coin.sign_message("test").unwrap();
+        let signature = coin.sign_message("test", None).unwrap();
         assert_eq!(
             signature,
             "ILuePKMsycXwJiNDOT7Zb7TfIlUW7Iq+5ylKd15AK72vGVYXbnf7Gj9Lk9MFV+6Ub955j7MiAkp0wQjvuIoRPPA="

mm2src/coins/utxo/qtum.rs

@@ -770,8 +770,8 @@ impl MarketCoinOps for QtumCoin {
         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, _derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
+        utxo_common::sign_message(self.as_ref(), message, None)
     }
 
     fn verify_message(&self, signature_base64: &str, message: &str, address: &str) -> VerificationResult<bool> {

mm2src/coins/utxo/slp.rs

@@ -26,6 +26,7 @@ use crate::{BalanceFut, CheckIfMyPaymentSentArgs, CoinBalance, ConfirmPaymentInp
 use async_trait::async_trait;
 use base64::engine::general_purpose::STANDARD;
 use base64::Engine;
+use bip32::DerivationPath;
 use bitcrypto::dhash160;
 use chain::constants::SEQUENCE_FINAL;
 use chain::{OutPoint, TransactionOutput};
@@ -1117,8 +1118,8 @@ impl MarketCoinOps for SlpToken {
         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, derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
+        utxo_common::sign_message(self.as_ref(), message, derivation_path)
     }
 
     fn verify_message(&self, signature: &str, message: &str, address: &str) -> VerificationResult<bool> {
@@ -2167,7 +2168,7 @@ mod slp_tests {
         let (_ctx, bch) = tbch_coin_for_test();
         let token_id = H256::from("bb309e48930671582bea508f9a1d9b491e49b69be3d6f372dc08da2ac6e90eb7");
         let fusd = SlpToken::new(4, "FUSD".into(), token_id, bch, 0).unwrap();
-        let signature = fusd.sign_message("test").unwrap();
+        let signature = fusd.sign_message("test", None).unwrap();
         assert_eq!(
             signature,
             "ILuePKMsycXwJiNDOT7Zb7TfIlUW7Iq+5ylKd15AK72vGVYXbnf7Gj9Lk9MFV+6Ub955j7MiAkp0wQjvuIoRPPA="

mm2src/coins/utxo/utxo_common.rs

@@ -2755,10 +2755,32 @@ pub fn sign_message_hash(coin: &UtxoCoinFields, message: &str) -> Option<[u8; 32
     Some(dhash256(&stream.out()).take())
 }
 
-pub fn sign_message(coin: &UtxoCoinFields, message: &str) -> SignatureResult<String> {
+pub fn sign_message(
+    coin: &UtxoCoinFields,
+    message: &str,
+    derivation_path: Option<DerivationPath>,
+) -> SignatureResult<String> {
     let message_hash = sign_message_hash(coin, message).ok_or(SignatureError::PrefixNotFound)?;
-    let private_key = coin.priv_key_policy.activated_key_or_err()?.private();
-    let signature = private_key.sign_compact(&H256::from(message_hash))?;
+    let signature = match derivation_path {
+        Some(derivation_path) => {
+            let privkey = coin
+                .priv_key_policy
+                .hd_wallet_derived_priv_key_or_err(&derivation_path)
+                .mm_err(|err| SignatureError::InvalidRequest(err.to_string()))?;
+            let private_key = Private {
+                prefix: coin.conf.wif_prefix,
+                secret: privkey,
+                compressed: true,
+                checksum_type: coin.conf.checksum_type,
+            };
+            private_key.sign_compact(&H256::from(message_hash))?
+        },
+        None => {
+            let private_key = coin.priv_key_policy.activated_key_or_err()?.private();
+            private_key.sign_compact(&H256::from(message_hash))?
+        },
+    };
+
     Ok(STANDARD.encode(&*signature))
 }
 

mm2src/coins/utxo/utxo_standard.rs

@@ -856,8 +856,8 @@ impl MarketCoinOps for UtxoStandardCoin {
         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, derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
+        utxo_common::sign_message(self.as_ref(), message, derivation_path)
     }
 
     fn verify_message(&self, signature_base64: &str, message: &str, address: &str) -> VerificationResult<bool> {

mm2src/coins/utxo/utxo_tests.rs

@@ -4539,7 +4539,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,
         "HzetbqVj9gnUOznon9bvE61qRlmjH5R+rNgkxu8uyce3UBbOu+2aGh7r/GGSVFGZjRnaYC60hdwtdirTKLb7bE4="
@@ -4560,7 +4560,7 @@ fn test_sign_verify_message_segwit() {
     );
 
     let message = "test";
-    let signature = coin.sign_message(message).unwrap();
+    let signature = coin.sign_message(message, None).unwrap();
     assert_eq!(
         signature,
         "HzetbqVj9gnUOznon9bvE61qRlmjH5R+rNgkxu8uyce3UBbOu+2aGh7r/GGSVFGZjRnaYC60hdwtdirTKLb7bE4="

mm2src/coins/z_coin.rs

@@ -39,6 +39,7 @@ use crate::{BalanceError, BalanceFut, CheckIfMyPaymentSentArgs, CoinBalance, Con
             WatcherOps, WeakSpawner, WithdrawError, WithdrawFut, WithdrawRequest};
 
 use async_trait::async_trait;
+use bip32::DerivationPath;
 use bitcrypto::dhash256;
 use chain::constants::SEQUENCE_FINAL;
 use chain::{Transaction as UtxoTx, TransactionOutput};
@@ -1143,7 +1144,7 @@ impl MarketCoinOps for ZCoin {
 
     fn sign_message_hash(&self, _message: &str) -> Option<[u8; 32]> { None }
 
-    fn sign_message(&self, _message: &str) -> SignatureResult<String> {
+    fn sign_message(&self, _message: &str, _derivation_path: Option<DerivationPath>) -> SignatureResult<String> {
         MmError::err(SignatureError::InvalidRequest(
             "Message signing is not supported by the given coin type".to_string(),
         ))

mm2src/mm2_main/Cargo.toml

@@ -25,7 +25,7 @@ enable-sia = ["coins/enable-sia", "coins_activation/enable-sia"]
 sepolia-maker-swap-v2-tests = []
 sepolia-taker-swap-v2-tests = []
 test-ext-api = ["trading_api/test-ext-api"]
-new-db-arch = [] # A temporary feature to integrate the new db architecture incrementally
+new-db-arch = ["mm2_core/new-db-arch"] # A temporary feature to integrate the new db architecture incrementally
 
 [dependencies]
 async-std = { version = "1.5", features = ["unstable"] }

mm2src/mm2_main/tests/mm2_tests/bch_and_slp_tests.rs

@@ -529,7 +529,7 @@ fn test_sign_verify_message_bch() {
     let electrum: Json = json::from_str(&electrum.1).unwrap();
     log!("{:?}", electrum);
 
-    let response = block_on(sign_message(&mm, "BCH"));
+    let response = block_on(sign_message(&mm, "BCH", None));
     let response: RpcV2Response<SignatureResponse> = json::from_value(response).unwrap();
     let response = response.result;
 
@@ -586,7 +586,7 @@ fn test_sign_verify_message_slp() {
     let enable_usdf = block_on(enable_slp(&mm, "USDF"));
     log!("enable_usdf: {:?}", enable_usdf);
 
-    let response = block_on(sign_message(&mm, "USDF"));
+    let response = block_on(sign_message(&mm, "USDF", None));
     let response: RpcV2Response<SignatureResponse> = json::from_value(response).unwrap();
     let response = response.result;
 

mm2src/mm2_main/tests/mm2_tests/lightning_tests.rs

@@ -1066,7 +1066,7 @@ fn test_sign_verify_message_lightning() {
     block_on(enable_electrum(&mm, "tBTC-TEST-segwit", false, T_BTC_ELECTRUMS));
     block_on(enable_lightning(&mm, "tBTC-TEST-lightning", 600));
 
-    let response = block_on(sign_message(&mm, "tBTC-TEST-lightning"));
+    let response = block_on(sign_message(&mm, "tBTC-TEST-lightning", None));
     let response: RpcV2Response<SignatureResponse> = json::from_value(response).unwrap();
     let response = response.result;