feat(wallet-connect): impl BTC (UTxO) activation via WalletConnect

mm2src/coins/eth.rs

@@ -120,7 +120,6 @@ use web3::{self, Web3};
 
 cfg_wasm32! {
     use crypto::MetamaskArc;
-    use ethereum_types::H520;
     use mm2_metamask::MetamaskError;
     use web3::types::TransactionRequest;
 }
@@ -866,9 +865,7 @@ pub enum EthPrivKeyBuildPolicy {
     Metamask(MetamaskArc),
     Trezor,
     WalletConnect {
-        address: Address,
-        public_key_uncompressed: H520,
-        session_topic: String,
+        session_topic: kdf_walletconnect::WcTopic,
     },
 }
 
@@ -889,11 +886,14 @@ impl EthPrivKeyBuildPolicy {
 }
 
 impl From<PrivKeyBuildPolicy> for EthPrivKeyBuildPolicy {
-    fn from(policy: PrivKeyBuildPolicy) -> Self {
+    fn from(policy: PrivKeyBuildPolicy) -> EthPrivKeyBuildPolicy {
         match policy {
             PrivKeyBuildPolicy::IguanaPrivKey(iguana) => EthPrivKeyBuildPolicy::IguanaPrivKey(iguana),
             PrivKeyBuildPolicy::GlobalHDAccount(global_hd) => EthPrivKeyBuildPolicy::GlobalHDAccount(global_hd),
             PrivKeyBuildPolicy::Trezor => EthPrivKeyBuildPolicy::Trezor,
+            PrivKeyBuildPolicy::WalletConnect { session_topic } => {
+                EthPrivKeyBuildPolicy::WalletConnect { session_topic }
+            },
         }
     }
 }
@@ -2992,8 +2992,7 @@ async fn sign_raw_eth_tx(coin: &EthCoin, args: &SignEthTransactionParams) -> Raw
             .map_to_mm(|err| RawTransactionError::TransactionError(err.get_plain_text_format()))
         },
         EthPrivKeyPolicy::WalletConnect { .. } => {
-            // NOTE: doesn't work with wallets that doesn't support `eth_signTransaction`.
-            // e.g Metamask
+            // NOTE: doesn't work with wallets that doesn't support `eth_signTransaction`. e.g TrustWallet
             let wc = {
                 let ctx = MmArc::from_weak(&coin.ctx).expect("No context");
                 WalletConnectCtx::from_ctx(&ctx)
@@ -6565,8 +6564,15 @@ pub async fn eth_coin_from_conf_and_request(
         }
     }
 
-    // Convert `PrivKeyBuildPolicy` to `EthPrivKeyBuildPolicy` if it's possible.
-    let priv_key_policy = From::from(priv_key_policy);
+    // Convert `PrivKeyBuildPolicy` to `EthPrivKeyBuildPolicy`.
+    let priv_key_policy = match priv_key_policy {
+        PrivKeyBuildPolicy::IguanaPrivKey(iguana) => EthPrivKeyBuildPolicy::IguanaPrivKey(iguana),
+        PrivKeyBuildPolicy::GlobalHDAccount(global_hd) => EthPrivKeyBuildPolicy::GlobalHDAccount(global_hd),
+        PrivKeyBuildPolicy::Trezor => EthPrivKeyBuildPolicy::Trezor,
+        PrivKeyBuildPolicy::WalletConnect { .. } => {
+            return ERR!("WalletConnect private key policy is not supported for legacy ETH coin activation");
+        },
+    };
 
     let mut urls: Vec<String> = try_s!(json::from_value(req["urls"].clone()));
     if urls.is_empty() {
@@ -6591,8 +6597,9 @@ pub async fn eth_coin_from_conf_and_request(
         req["path_to_address"].clone()
     ))
     .unwrap_or_default();
-    let (key_pair, derivation_method) =
-        try_s!(build_address_and_priv_key_policy(ctx, ticker, conf, priv_key_policy, &path_to_address, None).await);
+    let (key_pair, derivation_method) = try_s!(
+        build_address_and_priv_key_policy(ctx, ticker, conf, priv_key_policy, &path_to_address, None, None).await
+    );
 
     let mut web3_instances = vec![];
     let event_handlers = rpc_event_handlers_for_eth_transport(ctx, ticker.to_string());
@@ -6870,7 +6877,7 @@ pub async fn get_eth_address(
     .into();
 
     let (_, derivation_method) =
-        build_address_and_priv_key_policy(ctx, ticker, conf, priv_key_policy, path_to_address, None)
+        build_address_and_priv_key_policy(ctx, ticker, conf, priv_key_policy, path_to_address, None, None)
             .await
             .map_mm_err()?;
     let my_address = derivation_method.single_addr_or_err().await.map_mm_err()?;

mm2src/coins/eth/v2_activation.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::eth::erc20::{get_enabled_erc20_by_platform_and_contract, get_token_decimals};
+use crate::eth::wallet_connect::eth_request_wc_personal_sign;
 use crate::eth::web3_transport::http_transport::HttpTransport;
 use crate::hd_wallet::{
     load_hd_accounts_from_storage, HDAccountsMutex, HDPathAccountToAddressId, HDWalletCoinStorage,
@@ -17,6 +18,7 @@ use crypto::{trezor::TrezorError, Bip32Error, CryptoCtxError, HwError};
 use enum_derives::EnumFromTrait;
 use ethereum_types::H264;
 use kdf_walletconnect::error::WalletConnectError;
+use kdf_walletconnect::WcTopic;
 use mm2_err_handle::common_errors::WithInternal;
 #[cfg(target_arch = "wasm32")]
 use mm2_metamask::{from_metamask_error, MetamaskError, MetamaskRpcError, WithMetamaskRpcError};
@@ -201,7 +203,7 @@ pub enum EthPrivKeyActivationPolicy {
     #[cfg(target_arch = "wasm32")]
     Metamask,
     WalletConnect {
-        session_topic: String,
+        session_topic: WcTopic,
     },
 }
 
@@ -681,6 +683,7 @@ pub async fn eth_coin_from_conf_and_request_v2(
         priv_key_build_policy,
         &req.path_to_address,
         req.gap_limit,
+        Some(&chain_spec),
     )
     .await?;
 
@@ -781,6 +784,7 @@ pub(crate) async fn build_address_and_priv_key_policy(
     priv_key_build_policy: EthPrivKeyBuildPolicy,
     path_to_address: &HDPathAccountToAddressId,
     gap_limit: Option<u32>,
+    chain_spec: Option<&ChainSpec>,
 ) -> MmResult<(EthPrivKeyPolicy, EthDerivationMethod), EthActivationV2Error> {
     match priv_key_build_policy {
         EthPrivKeyBuildPolicy::IguanaPrivKey(iguana) => {
@@ -875,11 +879,18 @@ pub(crate) async fn build_address_and_priv_key_policy(
                 DerivationMethod::SingleAddress(address),
             ))
         },
-        EthPrivKeyBuildPolicy::WalletConnect {
-            address,
-            public_key_uncompressed,
-            session_topic,
-        } => {
+        EthPrivKeyBuildPolicy::WalletConnect { session_topic } => {
+            let wc = WalletConnectCtx::from_ctx(ctx).map_err(|e| {
+                EthActivationV2Error::WalletConnectError(format!("Failed to get WalletConnect context: {e}"))
+            })?;
+            let chain_spec = chain_spec.ok_or(EthActivationV2Error::ChainIdNotSet)?;
+            let chain_id = chain_spec.chain_id().ok_or(EthActivationV2Error::UnsupportedChain {
+                chain: chain_spec.kind().to_string(),
+                feature: "WalletConnect".to_string(),
+            })?;
+            let (public_key_uncompressed, address) = eth_request_wc_personal_sign(&wc, &session_topic, chain_id)
+                .await
+                .mm_err(|err| EthActivationV2Error::WalletConnectError(err.to_string()))?;
             let public_key = compress_public_key(public_key_uncompressed)?;
             Ok((
                 EthPrivKeyPolicy::WalletConnect {

mm2src/coins/eth/wallet_connect.rs

@@ -16,7 +16,7 @@ use ethereum_types::{Address, Public, H160, H520, U256};
 use ethkey::{public_to_address, Message, Signature};
 use kdf_walletconnect::chain::{WcChainId, WcRequestMethods};
 use kdf_walletconnect::error::WalletConnectError;
-use kdf_walletconnect::{WalletConnectCtx, WalletConnectOps};
+use kdf_walletconnect::{WalletConnectCtx, WalletConnectOps, WcTopic};
 use mm2_err_handle::prelude::*;
 use secp256k1::recovery::{RecoverableSignature, RecoveryId};
 use secp256k1::{PublicKey, Secp256k1};
@@ -180,7 +180,7 @@ impl WalletConnectOps for EthCoin {
         Ok((signed_tx, tx_hex))
     }
 
-    fn session_topic(&self) -> Result<&str, Self::Error> {
+    fn session_topic(&self) -> Result<&WcTopic, Self::Error> {
         if let EthPrivKeyPolicy::WalletConnect { ref session_topic, .. } = &self.priv_key_policy {
             return Ok(session_topic);
         }
@@ -194,7 +194,7 @@ impl WalletConnectOps for EthCoin {
 
 pub async fn eth_request_wc_personal_sign(
     wc: &WalletConnectCtx,
-    session_topic: &str,
+    session_topic: &WcTopic,
     chain_id: u64,
 ) -> MmResult<(H520, Address), EthWalletConnectError> {
     let chain_id = WcChainId::new_eip155(chain_id.to_string());
@@ -211,7 +211,7 @@ pub async fn eth_request_wc_personal_sign(
         json!(&[&message_hex, &account_str])
     };
     let data = wc
-        .send_session_request_and_wait::<String>(session_topic, &chain_id, WcRequestMethods::PersonalSign, params)
+        .send_session_request_and_wait::<String>(session_topic, &chain_id, WcRequestMethods::EthPersonalSign, params)
         .await
         .map_mm_err()?;
 

mm2src/coins/hd_wallet/pubkey.rs

@@ -136,7 +136,7 @@ where
             .or_mm_err(|| HDExtractPubkeyError::HwContextNotInitialized)?;
 
         let trezor_message_type = match coin_protocol {
-            CoinProtocol::UTXO => TrezorMessageType::Bitcoin,
+            CoinProtocol::UTXO { .. } => TrezorMessageType::Bitcoin,
             CoinProtocol::QTUM => TrezorMessageType::Bitcoin,
             CoinProtocol::ETH { .. } | CoinProtocol::ERC20 { .. } => TrezorMessageType::Ethereum,
             _ => return Err(MmError::new(HDExtractPubkeyError::CoinDoesntSupportTrezor)),

mm2src/coins/lp_coins.rs

@@ -4294,11 +4294,14 @@ impl CoinsContext {
 }
 
 /// This enum is used in coin activation requests.
-#[derive(Copy, Clone, Debug, Deserialize, Serialize, Default)]
+#[derive(Clone, Debug, Deserialize, Serialize, Default)]
 pub enum PrivKeyActivationPolicy {
     #[default]
     ContextPrivKey,
     Trezor,
+    WalletConnect {
+        session_topic: kdf_walletconnect::WcTopic,
+    },
 }
 
 impl PrivKeyActivationPolicy {
@@ -4356,10 +4359,16 @@ pub enum PrivKeyPolicy<T> {
     /// - `public_key`: Compressed public key, represented as [H264].
     /// - `public_key_uncompressed`: Uncompressed public key, represented as [H520].
     /// - `session_topic`: WalletConnect session that was used to activate this coin.
+    // TODO: We want to have different variants of WalletConnect policy for different coin types:
+    //       - ETH uses the structure found here.
+    //       - Tendermint doesn't use this variant all together. Tendermint generalizes one level on top of PrivKeyPolicy by having a different activation policy
+    //         structure that is either Priv(PrivKeyPolicy) or Pubkey(PublicKey) and when activated via wallet connect it uses the Pubkey(PublicKey) variant.
+    //       - UTXO coins on the otherhand need to keep a list of all the addresses activated in the wallet and not just a single account.
+    //            - Note: We need to have a way to select which account and address are the active ones (WalletConnect just spams us with all the addresses in every account).
     WalletConnect {
         public_key: H264,
         public_key_uncompressed: H520,
-        session_topic: String,
+        session_topic: kdf_walletconnect::WcTopic,
     },
 }
 
@@ -4502,6 +4511,7 @@ pub enum PrivKeyBuildPolicy {
     IguanaPrivKey(IguanaPrivKey),
     GlobalHDAccount(GlobalHDAccountArc),
     Trezor,
+    WalletConnect { session_topic: kdf_walletconnect::WcTopic },
 }
 
 impl PrivKeyBuildPolicy {
@@ -4677,11 +4687,21 @@ pub trait IguanaBalanceOps {
     async fn iguana_balances(&self) -> BalanceResult<Self::BalanceObject>;
 }
 
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+/// Information about the UTXO protocol used by a coin.
+pub struct UtxoProtocolInfo {
+    /// A CAIP-2 compliant chain ID. Starts with `b122:`
+    /// This is used to identify the blockchain when using WalletConnect.
+    /// https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-4.md
+    chain_id: String,
+}
+
 #[allow(clippy::upper_case_acronyms)]
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(tag = "type", content = "protocol_data")]
 pub enum CoinProtocol {
-    UTXO,
+    // TODO: Nest this option deep into the innert struct fields when more fields are added to the UTXO protocol info.
+    UTXO(Option<UtxoProtocolInfo>),
     QTUM,
     QRC20 {
         platform: String,
@@ -4758,7 +4778,7 @@ impl CoinProtocol {
             CoinProtocol::TENDERMINTTOKEN(info) => Some(&info.platform),
             #[cfg(not(target_arch = "wasm32"))]
             CoinProtocol::LIGHTNING { platform, .. } => Some(platform),
-            CoinProtocol::UTXO
+            CoinProtocol::UTXO { .. }
             | CoinProtocol::QTUM
             | CoinProtocol::ETH { .. }
             | CoinProtocol::TRX { .. }
@@ -4777,7 +4797,7 @@ impl CoinProtocol {
                 Some(contract_address)
             },
             CoinProtocol::SLPTOKEN { .. }
-            | CoinProtocol::UTXO
+            | CoinProtocol::UTXO { .. }
             | CoinProtocol::QTUM
             | CoinProtocol::ETH { .. }
             | CoinProtocol::TRX { .. }
@@ -5069,7 +5089,7 @@ pub async fn lp_coininit(ctx: &MmArc, ticker: &str, req: &Json) -> Result<MmCoin
     let protocol: CoinProtocol = try_s!(json::from_value(coins_en["protocol"].clone()));
 
     let coin: MmCoinEnum = match &protocol {
-        CoinProtocol::UTXO => {
+        CoinProtocol::UTXO { .. } => {
             let params = try_s!(UtxoActivationParams::from_legacy_req(req));
             try_s!(utxo_standard_coin_with_policy(ctx, ticker, &coins_en, &params, priv_key_policy).await).into()
         },
@@ -5742,7 +5762,7 @@ pub fn address_by_coin_conf_and_pubkey_str(
         },
         // Todo: implement TRX address generation
         CoinProtocol::TRX { .. } => ERR!("TRX address generation is not implemented yet"),
-        CoinProtocol::UTXO | CoinProtocol::QTUM | CoinProtocol::QRC20 { .. } | CoinProtocol::BCH { .. } => {
+        CoinProtocol::UTXO { .. } | CoinProtocol::QTUM | CoinProtocol::QRC20 { .. } | CoinProtocol::BCH { .. } => {
             utxo::address_by_conf_and_pubkey_str(coin, conf, pubkey, addr_format)
         },
         CoinProtocol::SLPTOKEN { platform, .. } => {

mm2src/coins/qrc20.rs

@@ -12,8 +12,8 @@ use crate::utxo::rpc_clients::{
 #[cfg(not(target_arch = "wasm32"))]
 use crate::utxo::tx_cache::{UtxoVerboseCacheOps, UtxoVerboseCacheShared};
 use crate::utxo::utxo_builder::{
-    UtxoCoinBuildError, UtxoCoinBuildResult, UtxoCoinBuilder, UtxoCoinBuilderCommonOps, UtxoFieldsWithGlobalHDBuilder,
-    UtxoFieldsWithHardwareWalletBuilder, UtxoFieldsWithIguanaSecretBuilder,
+    build_utxo_fields_with_global_hd, build_utxo_fields_with_iguana_priv_key, UtxoCoinBuildError, UtxoCoinBuildResult,
+    UtxoCoinBuilder, UtxoCoinBuilderCommonOps,
 };
 use crate::utxo::utxo_common::{self, big_decimal_from_sat, check_all_utxo_inputs_signed_by_pub, UtxoTxBuilder};
 use crate::utxo::{
@@ -35,7 +35,7 @@ use crate::{
     WithdrawResult,
 };
 use async_trait::async_trait;
-use bitcrypto::{dhash160, sha256};
+use bitcrypto::{dhash160, sha256, sign_message_hash};
 use chain::TransactionOutput;
 use common::executor::{AbortableSystem, AbortedError, Timer};
 use common::jsonrpc_client::{JsonRpcClient, JsonRpcRequest, RpcRes};
@@ -299,14 +299,6 @@ impl UtxoCoinBuilderCommonOps for Qrc20CoinBuilder<'_> {
     }
 }
 
-impl UtxoFieldsWithIguanaSecretBuilder for Qrc20CoinBuilder<'_> {}
-
-impl UtxoFieldsWithGlobalHDBuilder for Qrc20CoinBuilder<'_> {}
-
-/// Although, `Qrc20Coin` doesn't support [`PrivKeyBuildPolicy::Trezor`] yet,
-/// `UtxoCoinBuilder` trait requires `UtxoFieldsWithHardwareWalletBuilder` to be implemented.
-impl UtxoFieldsWithHardwareWalletBuilder for Qrc20CoinBuilder<'_> {}
-
 #[async_trait]
 impl UtxoCoinBuilder for Qrc20CoinBuilder<'_> {
     type ResultCoin = Qrc20Coin;
@@ -316,17 +308,27 @@ impl UtxoCoinBuilder for Qrc20CoinBuilder<'_> {
         self.priv_key_policy.clone()
     }
 
-    async fn build(self) -> MmResult<Self::ResultCoin, Self::Error> {
-        let utxo = match self.priv_key_policy() {
-            PrivKeyBuildPolicy::IguanaPrivKey(priv_key) => self.build_utxo_fields_with_iguana_secret(priv_key).await?,
+    async fn build_utxo_fields(&self) -> UtxoCoinBuildResult<UtxoCoinFields> {
+        match self.priv_key_policy() {
+            PrivKeyBuildPolicy::IguanaPrivKey(priv_key) => build_utxo_fields_with_iguana_priv_key(self, priv_key).await,
             PrivKeyBuildPolicy::GlobalHDAccount(global_hd_ctx) => {
-                self.build_utxo_fields_with_global_hd(global_hd_ctx).await?
+                build_utxo_fields_with_global_hd(self, global_hd_ctx).await
             },
             PrivKeyBuildPolicy::Trezor => {
                 let priv_key_err = PrivKeyPolicyNotAllowed::HardwareWalletNotSupported;
-                return MmError::err(UtxoCoinBuildError::PrivKeyPolicyNotAllowed(priv_key_err));
+                MmError::err(UtxoCoinBuildError::PrivKeyPolicyNotAllowed(priv_key_err))
             },
-        };
+            PrivKeyBuildPolicy::WalletConnect { .. } => {
+                let priv_key_err = PrivKeyPolicyNotAllowed::UnsupportedMethod(
+                    "WalletConnect is not available for QRC20 coin".to_string(),
+                );
+                MmError::err(UtxoCoinBuildError::PrivKeyPolicyNotAllowed(priv_key_err))
+            },
+        }
+    }
+
+    async fn build(self) -> MmResult<Self::ResultCoin, Self::Error> {
+        let utxo = self.build_utxo_fields().await?;
 
         let inner = Qrc20CoinFields {
             utxo,
@@ -1102,7 +1104,8 @@ impl MarketCoinOps for Qrc20Coin {
     }
 
     fn sign_message_hash(&self, message: &str) -> Option<[u8; 32]> {
-        utxo_common::sign_message_hash(self.as_ref(), message)
+        let prefix = self.as_ref().conf.sign_message_prefix.as_ref()?;
+        Some(sign_message_hash(prefix, message))
     }
 
     fn sign_message(&self, message: &str, address: Option<HDAddressSelector>) -> SignatureResult<String> {

mm2src/coins/rpc_command/init_create_account.rs

@@ -310,7 +310,8 @@ impl RpcTask for InitCreateAccountTask {
                     self.task_state.clone(),
                     task_handle,
                     utxo.is_trezor(),
-                    CoinProtocol::UTXO,
+                    // Note that the actual UtxoProtocolInfo isn't needed by trezor XPUB extractor.
+                    CoinProtocol::UTXO(Default::default()),
                 )
                 .await?,
             )),

mm2src/coins/rpc_command/offline_keys.rs

@@ -141,7 +141,7 @@ fn extract_prefix_values(
 
     match protocol {
         CoinProtocol::ETH { .. } | CoinProtocol::ERC20 { .. } | CoinProtocol::NFT { .. } => Ok(None),
-        CoinProtocol::UTXO | CoinProtocol::QTUM | CoinProtocol::QRC20 { .. } | CoinProtocol::BCH { .. } => {
+        CoinProtocol::UTXO { .. } | CoinProtocol::QTUM | CoinProtocol::QRC20 { .. } | CoinProtocol::BCH { .. } => {
             let wif_type = coin_conf["wiftype"]
                 .as_u64()
                 .ok_or_else(|| OfflineKeysError::MissingPrefixValue {