[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

@@ -25,7 +25,7 @@ use bitcrypto::{keccak256, sha256};
 use common::executor::{abortable_queue::AbortableQueue, AbortableSystem, Timer};
 use common::log::{error, info, warn};
 use common::{get_utc_timestamp, now_ms, small_rng, DEX_FEE_ADDR_RAW_PUBKEY};
-use crypto::privkey::key_pair_from_secret;
+use crypto::{privkey::key_pair_from_secret, Bip44PathToCoin};
 use derive_more::Display;
 use ethabi::{Contract, Token};
 pub use ethcore_transaction::SignedTransaction as SignedEthTx;
@@ -62,15 +62,15 @@ use web3_transport::{EthFeeHistoryNamespace, Web3Transport, Web3TransportNode};
 use super::{coin_conf, AsyncMutex, BalanceError, BalanceFut, 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, SignatureError, SignatureResult, SwapOps,
-            TradeFee, TradePreimageError, TradePreimageFut, TradePreimageResult, TradePreimageValue, Transaction,
-            TransactionDetails, TransactionEnum, TransactionErr, TransactionFut, TxMarshalingErr,
-            UnexpectedDerivationMethod, ValidateAddressResult, ValidateInstructionsErr, ValidateOtherPubKeyErr,
-            ValidatePaymentError, ValidatePaymentFut, ValidatePaymentInput, VerificationError, VerificationResult,
-            WatcherOps, WatcherSearchForSwapTxSpendInput, WatcherValidatePaymentInput, WithdrawError, WithdrawFee,
-            WithdrawFut, WithdrawRequest, WithdrawResult};
+            PaymentInstructions, PaymentInstructionsErr, PrivKeyBuildPolicy, PrivKeyPolicyNotAllowed,
+            RawTransactionError, RawTransactionFut, RawTransactionRequest, RawTransactionRes, RawTransactionResult,
+            RpcClientType, RpcTransportEventHandler, RpcTransportEventHandlerShared, SearchForSwapTxSpendInput,
+            SignatureError, SignatureResult, SwapOps, TradeFee, TradePreimageError, TradePreimageFut,
+            TradePreimageResult, TradePreimageValue, Transaction, TransactionDetails, TransactionEnum, TransactionErr,
+            TransactionFut, TxMarshalingErr, UnexpectedDerivationMethod, ValidateAddressResult,
+            ValidateInstructionsErr, ValidateOtherPubKeyErr, ValidatePaymentError, ValidatePaymentFut,
+            ValidatePaymentInput, VerificationError, VerificationResult, WatcherOps, WatcherSearchForSwapTxSpendInput,
+            WatcherValidatePaymentInput, WithdrawError, WithdrawFee, WithdrawFut, WithdrawRequest, WithdrawResult};
 
 pub use rlp;
 
@@ -79,6 +79,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
@@ -3681,8 +3682,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() {
@@ -3712,7 +3713,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};
@@ -1241,14 +1242,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();
 
@@ -1455,13 +1456,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

@@ -15,6 +15,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),
 }
 
@@ -132,8 +137,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());
     }
@@ -173,8 +178,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![];
@@ -263,3 +267,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<Bip44PathToCoin> = 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_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.rs

@@ -1197,7 +1197,7 @@ pub async fn start_lightning(
     let persister = ln_utils::init_persister(ctx, conf.ticker.clone(), params.backup_path).await?;
 
     // Initialize the KeysManager
-    let keys_manager = ln_utils::init_keys_manager(ctx)?;
+    let keys_manager = ln_utils::init_keys_manager(&platform)?;
 
     // Initialize the P2PGossipSync. This is used for providing routes to send payments over
     let network_graph = Arc::new(

mm2src/coins/lightning/ln_errors.rs

@@ -1,4 +1,5 @@
 use crate::utxo::rpc_clients::UtxoRpcError;
+use crate::PrivKeyPolicyNotAllowed;
 use common::HttpStatusCode;
 use db_common::sqlite::rusqlite::Error as SqlError;
 use derive_more::Display;
@@ -9,7 +10,7 @@ use std::num::TryFromIntError;
 pub type EnableLightningResult<T> = Result<T, MmError<EnableLightningError>>;
 pub type SaveChannelClosingResult<T> = Result<T, MmError<SaveChannelClosingError>>;
 
-#[derive(Debug, Deserialize, Display, Serialize, SerializeErrorType)]
+#[derive(Debug, Display, Serialize, SerializeErrorType)]
 #[serde(tag = "error_type", content = "error_data")]
 pub enum EnableLightningError {
     #[display(fmt = "Invalid request: {}", _0)]
@@ -24,6 +25,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)]
@@ -36,7 +39,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(_)
@@ -61,6 +66,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) }
+}
+
 #[derive(Display, PartialEq)]
 pub enum SaveChannelClosingError {
     #[display(fmt = "DB error: {}", _0)]

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())))