feat(core): multi-pubkey DB support

Cargo.toml

@@ -73,4 +73,4 @@ incremental = true
 codegen-units = 256
 
 [profile.release.package.mocktopus]
-opt-level = 1 # TODO: MIR fails on optimizing this dependency, remove that..
+opt-level = 1 # TODO: MIR fails on optimizing this dependency, remove that..

mm2src/coins/eth/v2_activation.rs

@@ -8,6 +8,7 @@ use crate::nft::nft_structs::Chain;
 use common::executor::AbortedError;
 use crypto::{trezor::TrezorError, Bip32Error, CryptoCtxError, HwError};
 use enum_derives::EnumFromTrait;
+#[cfg(not(target_arch = "wasm32"))] use futures::SinkExt;
 use instant::Instant;
 use mm2_err_handle::common_errors::WithInternal;
 #[cfg(target_arch = "wasm32")]
@@ -662,6 +663,9 @@ pub(crate) async fn build_address_and_priv_key_policy(
                 .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"))]
+            run_db_migration_for_new_eth_pubkey(ctx, dhash160(activated_key.public().as_bytes()).to_string()).await?;
+
             let hd_wallet_rmd160 = *ctx.rmd160();
             let hd_wallet_storage = HDWalletCoinStorage::init_with_rmd160(ctx, ticker.to_string(), hd_wallet_rmd160)
                 .await
@@ -676,6 +680,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 {
@@ -916,3 +921,39 @@ fn compress_public_key(uncompressed: H520) -> MmResult<H264, EthActivationV2Erro
     let compressed = public_key.serialize();
     Ok(H264::from(compressed))
 }
+
+#[cfg(not(target_arch = "wasm32"))]
+async fn run_db_migration_for_new_eth_pubkey(ctx: &MmArc, db_id: String) -> MmResult<(), EthActivationV2Error> {
+    info!("Public key hash: {db_id:?}");
+
+    let db_migration_sender = ctx
+        .db_migration_watcher
+        .as_option()
+        .expect("Db migration watcher isn't intialized yet!")
+        .get_sender();
+    let mut db_migration_sender = db_migration_sender.lock().await;
+    db_migration_sender
+        .send(db_id)
+        .await
+        .map_to_mm(|err| EthActivationV2Error::InternalError(err.to_string()))?;
+
+    Ok(())
+}
+
+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 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().to_string())
+}
+
+pub(super) async fn eth_account_db_id(coin: &EthCoin) -> Option<String> {
+    if let Some(hd_wallet) = coin.derivation_method().hd_wallet() {
+        return hd_wallet
+            .get_enabled_address()
+            .await
+            .map(|addr| hex::encode(dhash160(addr.pubkey().as_bytes())));
+    }
+
+    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;
 
@@ -220,11 +221,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,10 @@ 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(None)
+            .await
+            .mm_err(HDWalletStorageError::from)
     }
 
     async fn find_account(
@@ -314,9 +316,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(None).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?;