[r2r] Global HD account

mm2src/coins/coin_balance.rs

@@ -128,7 +128,7 @@ where
 {
     async fn coin_balance_report(&self) -> BalanceResult<CoinBalanceReport> {
         match self.derivation_method() {
-            DerivationMethod::Iguana(my_address) => self
+            DerivationMethod::SingleAddress(my_address) => self
                 .my_balance()
                 .compat()
                 .await
@@ -176,7 +176,7 @@ where
         XPubExtractor: HDXPubExtractor + Sync,
     {
         match self.derivation_method() {
-            DerivationMethod::Iguana(my_address) => self
+            DerivationMethod::SingleAddress(my_address) => self
                 .my_balance()
                 .compat()
                 .await

mm2src/coins/eth.rs

@@ -62,10 +62,10 @@ use web3_transport::{EthFeeHistoryNamespace, Web3Transport, Web3TransportNode};
 use super::{coin_conf, AsyncMutex, BalanceError, BalanceFut, CheckIfMyPaymentSentArgs, CoinBalance, CoinFutSpawner,
             CoinProtocol, CoinTransportMetrics, CoinsContext, FeeApproxStage, FoundSwapTxSpend, HistorySyncState,
             MarketCoinOps, MmCoin, MyAddressError, NegotiateSwapContractAddrErr, NumConversError, NumConversResult,
-            PaymentInstructions, PaymentInstructionsErr, RawTransactionError, RawTransactionFut,
-            RawTransactionRequest, RawTransactionRes, RawTransactionResult, RpcClientType, RpcTransportEventHandler,
-            RpcTransportEventHandlerShared, SearchForSwapTxSpendInput, SendMakerPaymentArgs,
-            SendMakerRefundsPaymentArgs, SendMakerSpendsTakerPaymentArgs, SendTakerPaymentArgs,
+            PaymentInstructions, PaymentInstructionsErr, PrivKeyBuildPolicy, PrivKeyPolicyNotAllowed,
+            RawTransactionError, RawTransactionFut, RawTransactionRequest, RawTransactionRes, RawTransactionResult,
+            RpcClientType, RpcTransportEventHandler, RpcTransportEventHandlerShared, SearchForSwapTxSpendInput,
+            SendMakerPaymentArgs, SendMakerRefundsPaymentArgs, SendMakerSpendsTakerPaymentArgs, SendTakerPaymentArgs,
             SendTakerRefundsPaymentArgs, SendTakerSpendsMakerPaymentArgs, SignatureError, SignatureResult, SwapOps,
             TradeFee, TradePreimageError, TradePreimageFut, TradePreimageResult, TradePreimageValue, Transaction,
             TransactionDetails, TransactionEnum, TransactionErr, TransactionFut, TxMarshalingErr,
@@ -80,6 +80,7 @@ pub use rlp;
 mod web3_transport;
 
 #[path = "eth/v2_activation.rs"] pub mod v2_activation;
+use v2_activation::key_pair_from_priv_key_policy;
 
 /// https://github.com/artemii235/etomic-swap/blob/master/contracts/EtomicSwap.sol
 /// Dev chain (195.201.0.6:8565) contract address: 0xa09ad3cd7e96586ebd05a2607ee56b56fb2db8fd
@@ -3579,8 +3580,8 @@ pub async fn eth_coin_from_conf_and_request(
     ticker: &str,
     conf: &Json,
     req: &Json,
-    priv_key: &[u8],
     protocol: CoinProtocol,
+    priv_key_policy: PrivKeyBuildPolicy,
 ) -> Result<EthCoin, String> {
     let mut urls: Vec<String> = try_s!(json::from_value(req["urls"].clone()));
     if urls.is_empty() {
@@ -3610,7 +3611,7 @@ pub async fn eth_coin_from_conf_and_request(
         }
     }
 
-    let key_pair: KeyPair = try_s!(KeyPair::from_secret_slice(priv_key));
+    let key_pair = try_s!(key_pair_from_priv_key_policy(conf, priv_key_policy));
     let my_address = key_pair.address();
 
     let mut web3_instances = vec![];

mm2src/coins/eth/eth_tests.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::IguanaPrivKey;
 use common::block_on;
 use mm2_core::mm_ctx::{MmArc, MmCtxBuilder};
 use mm2_test_helpers::for_tests::{ETH_MAINNET_NODE, ETH_MAINNET_SWAP_CONTRACT};
@@ -1230,14 +1231,14 @@ fn polygon_check_if_my_payment_sent() {
         "swap_contract_address": "0x9130b257d37a52e52f21054c4da3450c72f595ce",
     });
 
-    let priv_key = [1; 32];
+    let priv_key_policy = PrivKeyBuildPolicy::IguanaPrivKey(IguanaPrivKey::from([1; 32]));
     let coin = block_on(eth_coin_from_conf_and_request(
         &ctx,
         "MATIC",
         &conf,
         &request,
-        &priv_key,
         CoinProtocol::ETH,
+        priv_key_policy,
     ))
     .unwrap();
 
@@ -1445,13 +1446,14 @@ fn test_eth_validate_valid_and_invalid_pubkey() {
         3, 98, 177, 3, 108, 39, 234, 144, 131, 178, 103, 103, 127, 80, 230, 166, 53, 68, 147, 215, 42, 216, 144, 72,
         172, 110, 180, 13, 123, 179, 10, 49,
     ];
+    let priv_key_policy = PrivKeyBuildPolicy::IguanaPrivKey(IguanaPrivKey::from(priv_key));
     let coin = block_on(eth_coin_from_conf_and_request(
         &ctx,
         "MATIC",
         &conf,
         &request,
-        &priv_key,
         CoinProtocol::ETH,
+        priv_key_policy,
     ))
     .unwrap();
     // Test expected to pass at this point as we're using a valid pubkey to validate against a valid pubkey

mm2src/coins/eth/v2_activation.rs

@@ -1,5 +1,6 @@
 use super::*;
 use common::executor::AbortedError;
+use crypto::StandardHDPathToCoin;
 
 #[derive(Display, Serialize, SerializeErrorType)]
 #[serde(tag = "error_type", content = "error_data")]
@@ -16,6 +17,11 @@ pub enum EthActivationV2Error {
     UnreachableNodes(String),
     #[display(fmt = "Enable request for ETH coin must have at least 1 node")]
     AtLeastOneNodeRequired,
+    #[display(fmt = "'derivation_path' field is not found in config")]
+    DerivationPathIsNotSet,
+    #[display(fmt = "Error deserializing 'derivation_path': {}", _0)]
+    ErrorDeserializingDerivationPath(String),
+    PrivKeyPolicyNotAllowed(PrivKeyPolicyNotAllowed),
     InternalError(String),
 }
 
@@ -141,8 +147,8 @@ pub async fn eth_coin_from_conf_and_request_v2(
     ticker: &str,
     conf: &Json,
     req: EthActivationV2Request,
-    priv_key: &[u8],
-) -> Result<EthCoin, MmError<EthActivationV2Error>> {
+    priv_key_policy: PrivKeyBuildPolicy,
+) -> MmResult<EthCoin, EthActivationV2Error> {
     if req.nodes.is_empty() {
         return Err(EthActivationV2Error::AtLeastOneNodeRequired.into());
     }
@@ -182,8 +188,7 @@ pub async fn eth_coin_from_conf_and_request_v2(
         }
     }
 
-    let key_pair: KeyPair =
-        KeyPair::from_secret_slice(priv_key).map_err(|e| EthActivationV2Error::InternalError(e.to_string()))?;
+    let key_pair = key_pair_from_priv_key_policy(conf, priv_key_policy)?;
     let my_address = checksum_address(&format!("{:02x}", key_pair.address()));
 
     let mut web3_instances = vec![];
@@ -272,3 +277,29 @@ pub async fn eth_coin_from_conf_and_request_v2(
 
     Ok(EthCoin(Arc::new(coin)))
 }
+
+/// Processes the given `priv_key_policy` and generates corresponding `KeyPair`.
+/// This function expects either [`PrivKeyBuildPolicy::IguanaPrivKey`]
+/// or [`PrivKeyBuildPolicy::GlobalHDAccount`], otherwise returns `PrivKeyPolicyNotAllowed` error.
+pub(crate) fn key_pair_from_priv_key_policy(
+    conf: &Json,
+    priv_key_policy: PrivKeyBuildPolicy,
+) -> MmResult<KeyPair, EthActivationV2Error> {
+    let priv_key = match priv_key_policy {
+        PrivKeyBuildPolicy::IguanaPrivKey(iguana) => iguana,
+        PrivKeyBuildPolicy::GlobalHDAccount(global_hd_ctx) => {
+            // Consider storing `derivation_path` at `EthCoinImpl`.
+            let derivation_path: Option<StandardHDPathToCoin> = json::from_value(conf["derivation_path"].clone())
+                .map_to_mm(|e| EthActivationV2Error::ErrorDeserializingDerivationPath(e.to_string()))?;
+            let derivation_path = derivation_path.or_mm_err(|| EthActivationV2Error::DerivationPathIsNotSet)?;
+            global_hd_ctx
+                .derive_secp256k1_secret(&derivation_path)
+                .mm_err(|e| EthActivationV2Error::InternalError(e.to_string()))?
+        },
+        PrivKeyBuildPolicy::Trezor => {
+            let priv_key_err = PrivKeyPolicyNotAllowed::HardwareWalletNotSupported;
+            return MmError::err(EthActivationV2Error::PrivKeyPolicyNotAllowed(priv_key_err));
+        },
+    };
+    KeyPair::from_secret_slice(priv_key.as_slice()).map_to_mm(|e| EthActivationV2Error::InternalError(e.to_string()))
+}

mm2src/coins/hd_pubkey.rs

@@ -4,7 +4,7 @@ use crypto::hw_rpc_task::{HwConnectStatuses, TrezorRpcTaskConnectProcessor};
 use crypto::trezor::trezor_rpc_task::{TrezorRpcTaskProcessor, TryIntoUserAction};
 use crypto::trezor::utxo::IGNORE_XPUB_MAGIC;
 use crypto::trezor::{ProcessTrezorResponse, TrezorError, TrezorProcessingError};
-use crypto::{CryptoCtx, CryptoInitError, DerivationPath, EcdsaCurve, HardwareWalletArc, HwError, HwProcessingError,
+use crypto::{CryptoCtx, CryptoCtxError, DerivationPath, EcdsaCurve, HardwareWalletArc, HwError, HwProcessingError,
              XPub, XPubConverter, XpubError};
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
@@ -22,8 +22,8 @@ pub enum HDExtractPubkeyError {
     Internal(String),
 }
 
-impl From<CryptoInitError> for HDExtractPubkeyError {
-    fn from(e: CryptoInitError) -> Self { HDExtractPubkeyError::Internal(e.to_string()) }
+impl From<CryptoCtxError> for HDExtractPubkeyError {
+    fn from(e: CryptoCtxError) -> Self { HDExtractPubkeyError::Internal(e.to_string()) }
 }
 
 impl From<TrezorError> for HDExtractPubkeyError {

mm2src/coins/hd_wallet.rs

@@ -2,8 +2,8 @@ use crate::hd_pubkey::HDXPubExtractor;
 use crate::hd_wallet_storage::HDWalletStorageError;
 use crate::{BalanceError, WithdrawError};
 use async_trait::async_trait;
-use crypto::{Bip32DerPathError, Bip32Error, Bip44Chain, Bip44DerPathError, Bip44DerivationPath, ChildNumber,
-             DerivationPath, HwError};
+use crypto::{Bip32DerPathError, Bip32Error, Bip44Chain, ChildNumber, DerivationPath, HwError, StandardHDPath,
+             StandardHDPathError};
 use derive_more::Display;
 use itertools::Itertools;
 use mm2_err_handle::prelude::*;
@@ -125,7 +125,9 @@ pub enum NewAccountCreatingError {
 }
 
 impl From<Bip32DerPathError> for NewAccountCreatingError {
-    fn from(e: Bip32DerPathError) -> Self { NewAccountCreatingError::Internal(Bip44DerPathError::from(e).to_string()) }
+    fn from(e: Bip32DerPathError) -> Self {
+        NewAccountCreatingError::Internal(StandardHDPathError::from(e).to_string())
+    }
 }
 
 impl From<HDWalletStorageError> for NewAccountCreatingError {
@@ -190,8 +192,8 @@ pub struct HDAccountAddressId {
     pub address_id: u32,
 }
 
-impl From<Bip44DerivationPath> for HDAccountAddressId {
-    fn from(der_path: Bip44DerivationPath) -> Self {
+impl From<StandardHDPath> for HDAccountAddressId {
+    fn from(der_path: StandardHDPath) -> Self {
         HDAccountAddressId {
             account_id: der_path.account_id(),
             chain: der_path.chain(),

mm2src/coins/hd_wallet_storage/mod.rs

@@ -1,6 +1,6 @@
 use crate::hd_wallet::HDWalletCoinOps;
 use async_trait::async_trait;
-use crypto::{CryptoCtx, CryptoInitError, XPub};
+use crypto::{CryptoCtx, CryptoCtxError, XPub};
 use derive_more::Display;
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
@@ -49,8 +49,8 @@ pub enum HDWalletStorageError {
     Internal(String),
 }
 
-impl From<CryptoInitError> for HDWalletStorageError {
-    fn from(e: CryptoInitError) -> Self { HDWalletStorageError::Internal(e.to_string()) }
+impl From<CryptoCtxError> for HDWalletStorageError {
+    fn from(e: CryptoCtxError) -> Self { HDWalletStorageError::Internal(e.to_string()) }
 }
 
 impl HDWalletStorageError {
@@ -226,7 +226,7 @@ impl HDWalletCoinStorage {
         let inner = Box::new(HDWalletStorageInstance::init(ctx).await?);
         let crypto_ctx = CryptoCtx::from_ctx(ctx)?;
         let hd_wallet_rmd160 = crypto_ctx
-            .hd_wallet_rmd160()
+            .hw_wallet_rmd160()
             .or_mm_err(|| HDWalletStorageError::HDWalletUnavailable)?;
         Ok(HDWalletCoinStorage {
             coin,

mm2src/coins/lightning/ln_errors.rs

@@ -1,4 +1,5 @@
 use crate::utxo::rpc_clients::UtxoRpcError;
+use crate::PrivKeyPolicyNotAllowed;
 use common::executor::AbortedError;
 use common::HttpStatusCode;
 use db_common::sqlite::rusqlite::Error as SqlError;
@@ -11,7 +12,7 @@ use std::num::TryFromIntError;
 pub type EnableLightningResult<T> = Result<T, MmError<EnableLightningError>>;
 pub type SaveChannelClosingResult<T> = Result<T, MmError<SaveChannelClosingError>>;
 
-#[derive(Clone, Debug, Deserialize, Display, Serialize, SerializeErrorType)]
+#[derive(Clone, Debug, Display, Serialize, SerializeErrorType)]
 #[serde(tag = "error_type", content = "error_data")]
 pub enum EnableLightningError {
     #[display(fmt = "Invalid request: {}", _0)]
@@ -26,6 +27,8 @@ pub enum EnableLightningError {
     InvalidAddress(String),
     #[display(fmt = "Invalid path: {}", _0)]
     InvalidPath(String),
+    #[display(fmt = "Private key policy is not allowed: {}", _0)]
+    PrivKeyPolicyNotAllowed(PrivKeyPolicyNotAllowed),
     #[display(fmt = "System time error {}", _0)]
     SystemTimeError(String),
     #[display(fmt = "RPC error {}", _0)]
@@ -42,7 +45,9 @@ pub enum EnableLightningError {
 impl HttpStatusCode for EnableLightningError {
     fn status_code(&self) -> StatusCode {
         match self {
-            EnableLightningError::InvalidRequest(_) | EnableLightningError::RpcError(_) => StatusCode::BAD_REQUEST,
+            EnableLightningError::InvalidRequest(_)
+            | EnableLightningError::RpcError(_)
+            | EnableLightningError::PrivKeyPolicyNotAllowed(_) => StatusCode::BAD_REQUEST,
             EnableLightningError::UnsupportedMode(_, _) => StatusCode::NOT_IMPLEMENTED,
             EnableLightningError::InvalidAddress(_)
             | EnableLightningError::InvalidPath(_)
@@ -69,6 +74,10 @@ impl From<UtxoRpcError> for EnableLightningError {
     fn from(e: UtxoRpcError) -> Self { EnableLightningError::RpcError(e.to_string()) }
 }
 
+impl From<PrivKeyPolicyNotAllowed> for EnableLightningError {
+    fn from(e: PrivKeyPolicyNotAllowed) -> Self { EnableLightningError::PrivKeyPolicyNotAllowed(e) }
+}
+
 impl From<RpcTaskError> for EnableLightningError {
     fn from(e: RpcTaskError) -> Self { EnableLightningError::RpcTaskError(e.to_string()) }
 }

mm2src/coins/lightning/ln_events.rs

@@ -208,7 +208,7 @@ fn sign_funding_transaction(
     let my_address = coin
         .as_ref()
         .derivation_method
-        .iguana_or_err()
+        .single_addr_or_err()
         .map_err(|e| SignFundingTransactionError::Internal(e.to_string()))?;
     let key_pair = coin
         .as_ref()
@@ -526,7 +526,7 @@ impl LightningEventHandler {
         }
 
         // Todo: add support for Hardware wallets for funding transactions and spending spendable outputs (channel closing transactions)
-        let my_address = match self.platform.coin.as_ref().derivation_method.iguana_or_err() {
+        let my_address = match self.platform.coin.as_ref().derivation_method.single_addr_or_err() {
             Ok(addr) => addr.clone(),
             Err(e) => {
                 error!("{}", e);

mm2src/coins/lightning/ln_utils.rs

@@ -79,9 +79,17 @@ pub async fn init_db(ctx: &MmArc, ticker: String) -> EnableLightningResult<Sqlit
     Ok(db)
 }
 
-pub fn init_keys_manager(ctx: &MmArc) -> EnableLightningResult<Arc<KeysManager>> {
+pub fn init_keys_manager(platform: &Platform) -> EnableLightningResult<Arc<KeysManager>> {
     // The current time is used to derive random numbers from the seed where required, to ensure all random generation is unique across restarts.
-    let seed: [u8; 32] = ctx.secp256k1_key_pair().private().secret.into();
+    // TODO validate that this is right
+    let seed: [u8; 32] = platform
+        .coin
+        .as_ref()
+        .priv_key_policy
+        .key_pair_or_err()?
+        .private()
+        .secret
+        .into();
     let cur = get_local_duration_since_epoch().map_to_mm(|e| EnableLightningError::SystemTimeError(e.to_string()))?;
 
     Ok(Arc::new(KeysManager::new(&seed, cur.as_secs(), cur.subsec_nanos())))