feat(core): multi-pubkey DB support

mm2src/coins/eth/v2_activation.rs

@@ -1,5 +1,7 @@
 use super::*;
-use crate::eth::web3_transport::http_transport::HttpTransport;
+use crate::eth::eth_hd_wallet::EthHDWallet;
+use crate::eth::web3_transport::http_transport::{HttpTransport, HttpTransportNode};
+use crate::eth::web3_transport::Web3Transport;
 use crate::hd_wallet::{load_hd_accounts_from_storage, HDAccountsMutex, HDPathAccountToAddressId, HDWalletCoinStorage,
                        HDWalletStorageError, DEFAULT_GAP_LIMIT};
 use crate::nft::get_nfts_for_activation;
@@ -10,6 +12,8 @@ use common::executor::AbortedError;
 use crypto::{trezor::TrezorError, Bip32Error, CryptoCtxError, HwError};
 use enum_derives::EnumFromTrait;
 use instant::Instant;
+#[cfg(not(target_arch = "wasm32"))]
+use mm2_core::sql_connection_pool::run_db_migration_for_new_pubkey;
 use mm2_err_handle::common_errors::WithInternal;
 #[cfg(target_arch = "wasm32")]
 use mm2_metamask::{from_metamask_error, MetamaskError, MetamaskRpcError, WithMetamaskRpcError};
@@ -701,17 +705,32 @@ pub(crate) async fn build_address_and_priv_key_policy(
             // Consider storing `derivation_path` at `EthCoinImpl`.
             let path_to_coin = json::from_value(conf["derivation_path"].clone())
                 .map_to_mm(|e| EthActivationV2Error::ErrorDeserializingDerivationPath(e.to_string()))?;
-            let raw_priv_key = global_hd_ctx
-                .derive_secp256k1_secret(
-                    &path_to_address
-                        .to_derivation_path(&path_to_coin)
-                        .mm_err(|e| EthActivationV2Error::InvalidPathToAddress(e.to_string()))?,
-                )
-                .mm_err(|e| EthActivationV2Error::InternalError(e.to_string()))?;
-            let activated_key = KeyPair::from_secret_slice(raw_priv_key.as_slice())
-                .map_to_mm(|e| EthActivationV2Error::InternalError(e.to_string()))?;
+            let activated_key = {
+                let raw_priv_key = global_hd_ctx
+                    .derive_secp256k1_secret(
+                        &path_to_address
+                            .to_derivation_path(&path_to_coin)
+                            .mm_err(|e| EthActivationV2Error::InvalidPathToAddress(e.to_string()))?,
+                    )
+                    .mm_err(|e| EthActivationV2Error::InternalError(e.to_string()))?;
+                KeyPair::from_secret_slice(raw_priv_key.as_slice())
+                    .map_to_mm(|e| EthActivationV2Error::InternalError(e.to_string()))?
+            };
             let bip39_secp_priv_key = global_hd_ctx.root_priv_key().clone();
 
+            #[cfg(not(target_arch = "wasm32"))]
+            {
+                let pubkey = {
+                    let pubkey = Public::from_slice(activated_key.public().as_bytes());
+                    let addr = display_eth_address(&public_to_address(&pubkey));
+                    addr.trim_start_matches("0x").to_string()
+                };
+
+                run_db_migration_for_new_pubkey(ctx, pubkey)
+                    .await
+                    .map_to_mm(EthActivationV2Error::InternalError)?;
+            }
+
             let hd_wallet_rmd160 = *ctx.rmd160();
             let hd_wallet_storage = HDWalletCoinStorage::init_with_rmd160(ctx, ticker.to_string(), hd_wallet_rmd160)
                 .await
@@ -726,6 +745,7 @@ pub(crate) async fn build_address_and_priv_key_policy(
                 enabled_address: *path_to_address,
                 gap_limit,
             };
+
             let derivation_method = DerivationMethod::HDWallet(hd_wallet);
             Ok((
                 EthPrivKeyPolicy::HDWallet {
@@ -956,3 +976,19 @@ fn compress_public_key(uncompressed: H520) -> MmResult<H264, EthActivationV2Erro
     let compressed = public_key.serialize();
     Ok(H264::from(compressed))
 }
+
+pub(super) async fn eth_shared_db_id(coin: &EthCoin, ctx: &MmArc) -> Option<String> {
+    // Use the hd_wallet_rmd160 as the db_id in HD mode only since it's unique to a device and not tied to a single address
+    coin.derivation_method().hd_wallet().map(|_| ctx.default_shared_db_id())
+}
+
+pub(super) async fn eth_account_db_id(coin: &EthCoin) -> Option<String> {
+    match coin.derivation_method() {
+        DerivationMethod::HDWallet(hd_wallet) => hd_wallet.get_enabled_address().await.map(|addr| {
+            let pubkey = Public::from_slice(addr.pubkey().as_bytes());
+            let addr = display_eth_address(&public_to_address(&pubkey));
+            addr.trim_start_matches("0x").to_string()
+        }),
+        _ => None,
+    }
+}

mm2src/coins/hd_wallet/storage/mod.rs

@@ -14,6 +14,7 @@ use std::ops::Deref;
 #[cfg(target_arch = "wasm32")] mod wasm_storage;
 
 #[cfg(any(test, target_arch = "wasm32"))] mod mock_storage;
+
 #[cfg(any(test, target_arch = "wasm32"))]
 pub(crate) use mock_storage::HDWalletMockStorage;
 
@@ -228,11 +229,11 @@ impl Default for HDWalletCoinStorage {
 
 impl HDWalletCoinStorage {
     pub async fn init(ctx: &MmArc, coin: String) -> HDWalletStorageResult<HDWalletCoinStorage> {
-        let inner = Box::new(HDWalletStorageInstance::init(ctx).await?);
         let crypto_ctx = CryptoCtx::from_ctx(ctx)?;
         let hd_wallet_rmd160 = crypto_ctx
             .hw_wallet_rmd160()
             .or_mm_err(|| HDWalletStorageError::HDWalletUnavailable)?;
+        let inner = Box::new(HDWalletStorageInstance::init(ctx).await?);
         Ok(HDWalletCoinStorage {
             coin,
             hd_wallet_rmd160,

mm2src/coins/hd_wallet/storage/sqlite_storage.rs

@@ -101,11 +101,11 @@ impl HDWalletStorageInternalOps for HDWalletSqliteStorage {
     where
         Self: Sized,
     {
-        let shared = ctx.shared_sqlite_conn.as_option().or_mm_err(|| {
+        let shared = ctx.shared_sqlite_conn_opt().or_mm_err(|| {
             HDWalletStorageError::Internal("'MmCtx::shared_sqlite_conn' is not initialized".to_owned())
         })?;
         let storage = HDWalletSqliteStorage {
-            conn: SqliteConnShared::downgrade(shared),
+            conn: SqliteConnShared::downgrade(&shared),
         };
         storage.init_tables().await?;
         Ok(storage)
@@ -279,7 +279,8 @@ pub(crate) async fn get_all_storage_items(ctx: &MmArc) -> Vec<HDAccountStorageIt
     const SELECT_ALL_ACCOUNTS: &str =
         "SELECT account_id, account_xpub, external_addresses_number, internal_addresses_number FROM hd_account";
 
-    let conn = ctx.shared_sqlite_conn();
+    let conn = ctx.shared_sqlite_conn_opt().unwrap();
+    let conn = conn.lock().unwrap();
     let mut statement = conn.prepare(SELECT_ALL_ACCOUNTS).unwrap();
     statement
         .query_map([], |row: &Row<'_>| HDAccountStorageItem::try_from(row))

mm2src/coins/hd_wallet/storage/wasm_storage.rs

@@ -21,7 +21,7 @@ const WALLET_ID_INDEX: &str = "wallet_id";
 /// * account_id - HD account id
 const WALLET_ACCOUNT_ID_INDEX: &str = "wallet_account_id";
 
-type HDWalletDbLocked<'a> = DbLocked<'a, HDWalletDb>;
+type HDWalletDbLocked = DbLocked<HDWalletDb>;
 
 impl From<DbTransactionError> for HDWalletStorageError {
     fn from(e: DbTransactionError) -> Self {
@@ -53,17 +53,17 @@ impl From<CursorError> for HDWalletStorageError {
         let stringified_error = e.to_string();
         match e {
             // We don't expect that the `String` and `u32` types serialization to fail.
-            CursorError::ErrorSerializingIndexFieldValue {..}
+            CursorError::ErrorSerializingIndexFieldValue { .. }
             // We don't expect that the `String` and `u32` types deserialization to fail.
-            | CursorError::ErrorDeserializingIndexValue {..}
-            | CursorError::ErrorOpeningCursor {..}
-            | CursorError::AdvanceError {..}
-            | CursorError::InvalidKeyRange {..}
-            | CursorError::TypeMismatch {..}
-            | CursorError::IncorrectNumberOfKeysPerIndex {..}
+            | CursorError::ErrorDeserializingIndexValue { .. }
+            | CursorError::ErrorOpeningCursor { .. }
+            | CursorError::AdvanceError { .. }
+            | CursorError::InvalidKeyRange { .. }
+            | CursorError::TypeMismatch { .. }
+            | CursorError::IncorrectNumberOfKeysPerIndex { .. }
             | CursorError::UnexpectedState(..)
-            | CursorError::IncorrectUsage {..} => HDWalletStorageError::Internal(stringified_error),
-            CursorError::ErrorDeserializingItem {..} => HDWalletStorageError::ErrorDeserializing(stringified_error),
+            | CursorError::IncorrectUsage { .. } => HDWalletStorageError::Internal(stringified_error),
+            CursorError::ErrorDeserializingItem { .. } => HDWalletStorageError::ErrorDeserializing(stringified_error),
         }
     }
 }
@@ -270,8 +270,8 @@ impl HDWalletIndexedDbStorage {
             .or_mm_err(|| HDWalletStorageError::Internal("'HDWalletIndexedDbStorage::db' doesn't exist".to_owned()))
     }
 
-    async fn lock_db_mutex(db: &SharedDb<HDWalletDb>) -> HDWalletStorageResult<HDWalletDbLocked<'_>> {
-        db.get_or_initialize().await.mm_err(HDWalletStorageError::from)
+    async fn lock_db_mutex(db: &SharedDb<HDWalletDb>) -> HDWalletStorageResult<HDWalletDbLocked> {
+        db.get_or_initialize_shared().await.mm_err(HDWalletStorageError::from)
     }
 
     async fn find_account(
@@ -314,9 +314,10 @@ impl HDWalletIndexedDbStorage {
 }
 
 /// This function is used in `hd_wallet_storage::tests`.
+#[cfg(any(test, target_arch = "wasm32"))]
 pub(super) async fn get_all_storage_items(ctx: &MmArc) -> Vec<HDAccountStorageItem> {
     let coins_ctx = CoinsContext::from_ctx(ctx).unwrap();
-    let db = coins_ctx.hd_wallet_db.get_or_initialize().await.unwrap();
+    let db = coins_ctx.hd_wallet_db.get_or_initialize_shared().await.unwrap();
     let transaction = db.inner.transaction().await.unwrap();
     let table = transaction.table::<HDAccountTable>().await.unwrap();
     table

mm2src/coins/lightning/ln_utils.rs

@@ -39,7 +39,7 @@ pub type ChannelManager = SimpleArcChannelManager<ChainMonitor, Platform, Platfo
 pub type Router = DefaultRouter<Arc<NetworkGraph>, Arc<LogState>, Arc<Scorer>>;
 
 #[inline]
-fn ln_data_dir(ctx: &MmArc, ticker: &str) -> PathBuf { ctx.dbdir().join("LIGHTNING").join(ticker) }
+fn ln_data_dir(ctx: &MmArc, ticker: &str) -> PathBuf { ctx.dbdir(None).join("LIGHTNING").join(ticker) }
 
 #[inline]
 fn ln_data_backup_dir(ctx: &MmArc, path: Option<String>, ticker: &str) -> Option<PathBuf> {
@@ -68,15 +68,11 @@ pub async fn init_persister(
     Ok(persister)
 }
 
-pub async fn init_db(ctx: &MmArc, ticker: String) -> EnableLightningResult<SqliteLightningDB> {
-    let db = SqliteLightningDB::new(
-        ticker,
-        ctx.sqlite_connection
-            .ok_or(MmError::new(EnableLightningError::DbError(
-                "sqlite_connection is not initialized".into(),
-            )))?
-            .clone(),
-    )?;
+pub async fn init_db(ctx: &MmArc, ticker: String, db_id: Option<&str>) -> EnableLightningResult<SqliteLightningDB> {
+    let db = ctx.sqlite_conn_opt(db_id).or_mm_err(|| {
+        EnableLightningError::DbError("'MmCtx::sqlite_connection' is not found or initialized".to_owned())
+    })?;
+    let db = SqliteLightningDB::new(ticker, db)?;
 
     if !db.is_db_initialized().await? {
         db.init_db().await?;