feat(core): multi-pubkey DB support #2093

onur-ozkan · 2024-04-01T09:30:57Z

This pull request enables support for managing multiple public keys in mm2 databases. Initially, a single database instance is generated using the startup public key rmd160. With this update, the mm_ctx will manage multiple database instances by leveraging the public key from MmCoin::account_db_id if defined, or defaulting to the mm2 startup public key.

Completed

Introduced sql_connection_pool for managing all instances of shared and sqlite connections from one place
Introduced async_sql_connection_pool for managing all instances of async sqlite connections from one place
Refactored indexeddb driver implementation to allow multi pubkey support
Refactored SwapContext, MySwapStorage, MakerSwapStorage, TakerSwapStorage NftCtx, UtxoBlockHeaderStorage, Zcoin storages(web only), lp_ordermatch and other storage impl to support multipubkey
Implement database migrations upon new database instance creation or account activation using a custom public key.
swap_kick_start and orders_kick_start unfinished swaps/orders upon new database instance creation or account activation using a custom public key.

Checklists for next PR

TODO: discuss and enhance get_public_key, get_public_key_hash, show_priv_key rpc for multi pubkey dbs in a another PR

Signed-off-by: onur-ozkan <[email protected]>

shamardy

We still have a long way to go in this PR review! Next iteration :)
Please don't forget to merge with latest dev.

shamardy · 2024-07-19T02:15:13Z

mm2src/coins/eth/v2_activation.rs

+        return hd_wallet
+            .get_enabled_address()
+            .await
+            .map(|addr| hex::encode(dhash160(addr.pubkey().as_bytes())));


We should use the address without the 0x prefix as the eth_account_db_id which will be an H160 pubkey hash similar to other db_ids.

We can use same pubkey hash as utxo and tendermint for external EVM wallets btw but it will be a bit more complex to do so. We request from the user to sign a message and extract the public key from it, it's actually implemented for metamask here for uncompressed format

komodo-defi-framework/mm2src/crypto/src/metamask_ctx.rs

Lines 56 to 73 in 0058f71

let (hash, sig) = metamask_session

.sign_typed_data_v4(eth_account_str.clone(), adex_eip712_request(domain, request))

.await?;

let sig = sig.strip_prefix("0x").unwrap_or(&sig);

let signature = Signature::from_str(sig)

.map_to_mm(|_| MetamaskError::Internal(format!("'{sig}' signature is invalid")))?;

let pubkey = recover_pubkey(hash, signature).mm_err(|_| {

let error = format!("Couldn't recover a public key from the signature: '{sig}'");

MetamaskError::Internal(error)

})?;

let recovered_address = address_from_pubkey_uncompressed(pubkey);

if eth_account != recovered_address {

let error =

format!("Recovered address '{recovered_address:?}' should be the same as '{eth_account:?}'");

return MmError::err(MetamaskError::Internal(error));

}

But we use compressed format for getting pubkey hash for utxo and tendermint so we should do the same for EVM. I will check if I can get the same public key from metamask as the one from Keplr for the same seed this way.

Drawback of this is that for external wallets, we have to let the user sign a message at the start (while coin is activating) to get the public key.

mm2src/coins/eth/v2_activation.rs

shamardy · 2024-07-19T02:39:02Z

mm2src/mm2_db/src/indexed_db/db_lock.rs

+        let db_id = ctx.rmd160().to_string();
+        let shared_db_id = ctx.default_shared_db_id().to_string();
        ConstructibleDb {
-            mutex: AsyncMutex::new(None),
+            locks: Arc::new(RwLock::new(HashMap::default())),
            db_namespace: ctx.db_namespace,
-            wallet_rmd160: None,
+            db_id,
+            shared_db_id,


Why the change here? global_db shouldn't have db_id or shared_db_id. This is used for wallets db which is a global db that stores encrypted mnemonics/seeds for all wallets.

komodo-defi-framework/mm2src/mm2_main/src/lp_wallet.rs

Line 94 in 7a2ebaf

wallets_db: ConstructibleDb::new_global_db(ctx),

Related:

komodo-defi-framework/mm2src/mm2_main/src/lp_wallet.rs

Lines 99 to 100 in 7a2ebaf

// TODO

pub async fn wallets_db(&self) -> InitDbResult<WalletsDbLocked> { self.wallets_db.get_or_initialize(None).await }

fixed. thanks for the catch!

I don't understand why the 2 below functions are needed and not only one

komodo-defi-framework/mm2src/mm2_db/src/indexed_db/indexed_db.rs

Lines 113 to 119 in 0856b54

pub fn display_db_id(&self) -> String { self.db_id.clone().unwrap_or_else(|| "KOMODEFI".to_string()) }

pub fn db_id(&self) -> String {

self.db_id

.clone()

.unwrap_or_else(|| hex::encode(H160::default().as_slice()))

}

seems like a leftover.. removed

shamardy · 2024-07-19T02:48:48Z

mm2src/coins/eth/v2_activation.rs

@@ -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?;


This should also use the same db_id as eth_account_db_id stated in my first comment.

mm2src/coins/eth/v2_activation.rs

shamardy

Next review iteration!

shamardy · 2024-07-23T23:43:42Z

mm2src/mm2_main/src/lp_native_dex.rs

-    #[cfg(not(target_arch = "wasm32"))]
-    {
-        let dbdir = ctx.dbdir();
-        fs::create_dir_all(&dbdir).map_to_mm(|e| MmInitError::ErrorCreatingDbDir {
-            path: dbdir.clone(),
-            error: e.to_string(),
-        })?;
-    }
-


I think the base db dir should be created here to allow the below to work

komodo-defi-framework/mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs

Lines 22 to 32 in ffe761e

pub(super) async fn save_encrypted_passphrase(

ctx: &MmArc,

wallet_name: &str,

encrypted_passphrase_data: &EncryptedData,

) -> WalletsStorageResult<()> {

let wallet_path = ctx.wallet_file_path(wallet_name);

ensure_file_is_writable(&wallet_path).map_to_mm(WalletsStorageError::FsWriteError)?;

mm2_io::fs::write_json(encrypted_passphrase_data, &wallet_path, true)

.await

.mm_err(|e| WalletsStorageError::FsWriteError(e.to_string()))

}

which is run as part of this function

komodo-defi-framework/mm2src/mm2_main/src/lp_native_dex.rs

Lines 544 to 545 in a78704d

// This either initializes the cryptographic context or sets up the context for "no login mode".

initialize_wallet_passphrase(&ctx).await?;

and saving mnmonic file will fail otherwise.

thanks for the catch !

mm2src/mm2_main/src/lp_native_dex.rs

shamardy · 2024-07-23T23:56:03Z

mm2src/mm2_main/src/lp_ordermatch.rs

@@ -5378,12 +5418,11 @@ pub struct HistoricalOrder {
    conf_settings: Option<OrderConfirmationsSettings>,
 }

-pub async fn orders_kick_start(ctx: &MmArc) -> Result<HashSet<String>, String> {
+pub async fn orders_kick_start(ctx: &MmArc, db_id: Option<&str>) -> Result<HashSet<String>, String> {


Similar to swaps kickstarts, we need to only kickstart orders if the coin is activated with the same db_id as the order's db_id ref.

komodo-defi-framework/mm2src/mm2_main/src/lp_swap.rs

Lines 1545 to 1601 in 9a8494e

let taker_coin = loop {

match lp_coinfind(&ctx, &taker_coin_ticker).await {

Ok(Some(c)) => {

if taker_coin_db_id == c.account_db_id().await.as_deref() {

break c;

};

info!(

"Can't kickstart the swap {} until the coin {} is activated with pubkey: {}",

swap.uuid(),

taker_coin_ticker,

taker_coin_db_id.unwrap_or(&ctx.rmd160.to_string())

);

Timer::sleep(5.).await;

},

Ok(None) => {

info!(

"Can't kickstart the swap {} until the coin {} is activated",

swap.uuid(),

taker_coin_ticker

);

Timer::sleep(5.).await;

},

Err(e) => {

error!("Error {} on {} find attempt", e, taker_coin_ticker);

return;

},

};

};

let maker_coin = loop {

match lp_coinfind(&ctx, &maker_coin_ticker).await {

Ok(Some(c)) => {

if maker_coin_db_id == c.account_db_id().await.as_deref() {

break c;

};

info!(

"Can't kickstart the swap {} until the coin {} is activated with pubkey: {}",

swap.uuid(),

maker_coin_ticker,

maker_coin_db_id.unwrap_or(&ctx.rmd160.to_string())

);

Timer::sleep(5.).await;

},

Ok(None) => {

info!(

"Can't kickstart the swap {} until the coin {} is activated",

swap.uuid(),

maker_coin_ticker

);

Timer::sleep(5.).await;

},

Err(e) => {

error!("Error {} on {} find attempt", e, maker_coin_ticker);

return;

},

};

};

Sorry if I wasn't clear about this. I meant that if the other coin of the order was with a different db_id. Similar to what we done with swaps before if you remember.

shamardy

Some more review notes related to your latest fixes!

shamardy · 2024-07-27T00:20:27Z

mm2src/coins/eth/v2_activation.rs

+        DerivationMethod::HDWallet(hd_wallet) => hd_wallet.get_enabled_address().await.map(|addr| {
+            // Skip the first byte of the uncompressed public key before converting to the eth address.
+            let pubkey = Public::from_slice(&addr.pubkey().as_bytes()[1..]);
+            public_to_address(&pubkey).to_string()


I think you should use display_eth_address function and strip the 0x at the start

I think you should use display_eth_address function and strip the 0x at the start

I think the below would be much simpler than what you implemented

let address = display_eth_address(&addr.address()); address.trim_start_matches("0x").to_string()

shamardy · 2024-07-27T00:20:53Z

mm2src/coins/eth/v2_activation.rs

-                let pubkey = dhash160(activated_key.public().as_bytes()).to_string();
+                // Skip the first byte of the uncompressed public key before converting to the eth address.
+                let pubkey = Public::from_slice(&activated_key.public().as_bytes()[1..]);
+                let pubkey = public_to_address(&pubkey).to_string();


shamardy · 2024-07-27T00:25:28Z

mm2src/mm2_main/src/lp_native_dex.rs

+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let dbdir = ctx.dbdir(None);
+        fs::create_dir_all(&dbdir).map_to_mm(|e| MmInitError::ErrorCreatingDbDir {
+            path: dbdir.clone(),
+            error: e.to_string(),
+        })?;
+    }


This should be before initialize_wallet_passphrase as it was done before

komodo-defi-framework/mm2src/mm2_main/src/lp_native_dex.rs

Lines 553 to 554 in 1675a53

// This either initializes the cryptographic context or sets up the context for "no login mode".

initialize_wallet_passphrase(&ctx).await?;

You don't need to create the default db dir, only the global one. We probably also need to ensure_dir_is_writable, just in case.

shamardy · 2024-07-27T00:32:17Z

mm2src/mm2_main/src/lp_ordermatch.rs

@@ -5378,12 +5418,11 @@ pub struct HistoricalOrder {
    conf_settings: Option<OrderConfirmationsSettings>,
 }

-pub async fn orders_kick_start(ctx: &MmArc) -> Result<HashSet<String>, String> {
+pub async fn orders_kick_start(ctx: &MmArc, db_id: Option<&str>) -> Result<HashSet<String>, String> {


Sorry if I wasn't clear about this. I meant that if the other coin of the order was with a different db_id. Similar to what we done with swaps before if you remember.

shamardy

Thanks you for the fixes! Next review iteration where I only focus on lp_ordermatch.rs!

Please merge with latest dev to get docker tests to pass. We should also start writing all the testcases we discussed before related to swaps / orders when we activate one of the coins with a different db_id (whether it's the one that has the swap/orders data or not). I remember we discussed a lot of these cases.

shamardy · 2024-08-05T16:20:33Z

mm2src/mm2_main/src/lp_ordermatch.rs

+    base_coin_account_id: Option<String>,
+    rel_coin_account_id: Option<String>,


Please add doc comments for these. And similar others.

shamardy · 2024-08-05T16:40:38Z

mm2src/mm2_main/src/lp_ordermatch.rs

-        coins.insert(order.request.base.clone());
-        coins.insert(order.request.rel.clone());
-        taker_orders.insert(order.request.uuid, order);
+        let order_base_coin_account_id = order.base_coin_account_id.clone().unwrap_or(ctx.default_db_id());


Taker order is not always loaded from rel coin db_id as it depends on if the order is buy or sell ref

komodo-defi-framework/mm2src/mm2_main/src/lp_ordermatch.rs

Lines 1688 to 1692 in 117aa44

pub fn account_id(&self) -> &Option<String> {

match self.request.action {

TakerAction::Buy => &self.rel_coin_account_id,

TakerAction::Sell => &self.base_coin_account_id,

}

Maybe we should add a function called other_coin_account_id to TakerOrder and MakerOrder and use it here and here

komodo-defi-framework/mm2src/mm2_main/src/lp_ordermatch.rs

Line 5451 in 117aa44

let order_rel_coin_db_id = order.rel_coin_account_id.clone().unwrap_or(ctx.default_db_id());

and any other appropriate place.

shamardy · 2024-08-05T16:47:53Z

mm2src/mm2_main/src/lp_ordermatch.rs

    #[cfg(target_arch = "wasm32")]
    ordermatch_db: ConstructibleDb<OrdermatchDb>,
 }

+#[allow(unused)]


Why did you add this? I can see that this is actually used.

shamardy · 2024-08-05T16:56:49Z

mm2src/mm2_main/src/lp_ordermatch.rs

@@ -2970,12 +2999,13 @@ fn lp_connect_start_bob(ctx: MmArc, maker_match: MakerMatch, maker_order: MakerO
            },
        };

+        let account_db_id = maker_coin.account_db_id().await;


Shouldn't we use the orders db_id to have swap files/data saved in the same place as the order files/data?

shamardy · 2024-08-05T16:57:37Z

mm2src/mm2_main/src/lp_ordermatch.rs

@@ -3121,6 +3153,7 @@ fn lp_connected_alice(ctx: MmArc, taker_order: TakerOrder, taker_match: TakerMat
        );

        let now = now_sec();
+        let account_db_id = taker_coin.account_db_id().await;


shamardy · 2024-08-05T17:03:30Z

mm2src/mm2_main/src/lp_ordermatch.rs

+        storage.load_order_from_history(req.uuid, db_id.as_deref()).await,
+        &storage.select_order_status(req.uuid, db_id.as_deref()).await,
+    ) {
+        info!("Order with UUID=({})", req.uuid);


No need for this info

shamardy · 2024-08-05T17:30:53Z

mm2src/mm2_main/src/lp_ordermatch.rs

-            maker_orders_ctx.add_order(ctx.weak(), order.clone(), None);
+            let order_rel_coin_db_id = order.rel_coin_account_id.clone().unwrap_or(ctx.default_db_id());
+
+            loop {


This loop and the other one will never end if the other coin is not enabled with the right address / db_id. We should rethink this whole kickstarting approach. This is where the code looks for if the coin for an order is enabled or not

komodo-defi-framework/mm2src/mm2_main/src/lp_ordermatch.rs

Lines 4644 to 4654 in 117aa44

if let Ok(Some(coin)) = lp_coinfind(&ctx, &ticker).await {

let balance = match coin.my_spendable_balance().compat().await {

Ok(balance) => balance,

Err(_) => continue,

};

if Some(&balance) != current_balance.as_ref() {

let coins_ctx = CoinsContext::from_ctx(&ctx).unwrap();

coins_ctx.balance_updated(&coin, &balance).await;

current_balance = Some(balance);

}

}

laruh

Huge work!
Here is the next review iteration

laruh · 2024-08-08T08:47:43Z

mm2src/coins/eth/v2_activation.rs

+            #[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)?;
+            }
+


Could you please clarify why this block is only for non-wasm target? is it bcz IDB automatically handles schema changes?

WASM doesn't need theses operations only SQL needs running migration when opening db and also additional directory checks which of course WASM doesn't need

laruh · 2024-08-08T10:42:34Z

mm2src/mm2_core/src/sql_connection_pool.rs

+    }
+
+    /// Test method for initializing a single-user database connection in-memory.
+    pub fn init_test(ctx: &MmArc) -> Result<(), String> { Self::init_impl_test(ctx, None, DbIdConnKind::Single) }


I suppose this is used only in tests, we can add #[cfg(all(feature = "for-tests", not(target_arch = "wasm32")))] annotation for this function

strange that clippy didnt warn about unused functions in prod code.

laruh · 2024-08-08T10:43:25Z

mm2src/mm2_core/src/sql_connection_pool.rs

+    }
+
+    /// Initialize a database connection.
+    pub async fn init_test(ctx: &MmArc, db_id: Option<&str>) -> Result<(), String> {


here too, lets add #[cfg(all(feature = "for-tests", not(target_arch = "wasm32")))] annotation

I had some problem doing this(init_test isn't really used directly in tests and some other functions also uses it which aren't annotated with tests cfg) but I guess I can pick it up again after working on more important stuffs in this PR.. thanks for the catch !

laruh · 2024-08-08T11:22:21Z

mm2src/coins/nft/nft_structs.rs

+#[derive(Debug, Serialize)]
+pub struct NftsTransferHistoryLists {


Please add doc comm for new NftsTransferHistoryLists structure

laruh · 2024-08-08T11:23:59Z

mm2src/coins/nft/nft_structs.rs

@@ -653,7 +662,7 @@ pub struct NftTransferHistoryFilters {
 }

 /// Contains parameters required to update NFT transfer history and NFT list.
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Clone)]


its not critical but please make Clone first, as we try to keep alphabetical order in derive

laruh · 2024-08-08T12:10:30Z

mm2src/coins/nft.rs

+pub async fn find_unique_nft_account_ids(
+    ctx: &MmArc,
+    chains: Vec<Chain>,
+) -> Result<HashMap<String, Vec<Chain>>, String> {
+    let cctx = try_s!(CoinsContext::from_ctx(ctx));
+    let coins = cctx.coins.lock().await;
+    let coins = coins.values().collect::<Vec<_>>();
+
+    let mut active_id_chains = HashMap::new();
+    for coin in coins.iter() {
+        if coin.is_available() {
+            // Use default if no db_id
+            let db_id = coin
+                .inner
+                .account_db_id()
+                .await
+                .unwrap_or_else(|| ctx.rmd160.to_string());
+            let entry = active_id_chains.entry(db_id).or_insert_with(Vec::new);
+            if let Ok(chain) = Chain::from_ticker(coin.inner.ticker()) {
+                if chains.contains(&chain) {
+                    entry.push(chain);
+                }
+            }
+        }
+    }
+
+    Ok(active_id_chains)
+}


It could be simplified

async fn find_unique_nft_account_ids( ctx: &MmArc, chains: Vec<Chain>, ) -> Result<HashMap<String, Vec<Chain>>, String> { let cctx = try_s!(CoinsContext::from_ctx(ctx)); let coins = cctx.coins.lock().await; let mut active_id_chains: HashMap<String, Vec<Chain>> = HashMap::new(); for coin in coins.values() { if coin.is_available() { // Use default if no db_id let db_id = coin .inner .account_db_id() .await .unwrap_or_else(|| ctx.rmd160.to_string()); if let Ok(chain) = Chain::from_ticker(coin.inner.ticker()) { if chains.contains(&chain) { active_id_chains.entry(db_id).or_default().push(chain); } } } } Ok(active_id_chains) }

You can avoid collecting values into a Vec, and directly iterate over coins.values().
instead of creating entry object, you can call .entry(db_id).or_default().
Also seems like there is no need in pub

laruh · 2024-08-08T12:12:43Z

mm2src/coins/nft.rs

+    let coins = coins.values().collect::<Vec<_>>();
+
+    for coin in coins.iter() {
+        if coin.is_available() {
+            // Use default if no db_id
+            let db_id = coin
+                .inner
+                .account_db_id()
+                .await
+                .unwrap_or_else(|| ctx.rmd160.to_string());
+            if let Ok(chain) = Chain::from_ticker(coin.inner.ticker()) {
+                if chains == chain {
+                    return Ok(Some((db_id, chain)));
+                }
+            }
+        }
+    }


Here you also dont have to collect coins into vector

let coins = cctx.coins.lock().await; for coin in coins.values() { if coin.is_available() { // Use default if no db_id let db_id = coin .inner .account_db_id() .await .unwrap_or_else(|| ctx.rmd160.to_string()); if let Ok(chain) = Chain::from_ticker(coin.inner.ticker()) { if chains == chain { return Ok(Some((db_id, chain))); } } } }

laruh

I have question

laruh · 2024-08-09T11:15:29Z

mm2src/coins/z_coin/storage/walletdb/wasm/mod.rs

@@ -744,7 +746,7 @@ mod wasm_test {
    //    async fn create_to_address_fails_on_unverified_notes() {
    //        // init blocks_db
    //        let ctx = mm_ctx_with_custom_db();
-    //        let blockdb = BlockDbImpl::new(&ctx, TICKER.to_string(), PathBuf::new()).await.unwrap();
+    //        let blockdb = BlockDbImpl::new(&ctx, TICKER.to_string(), PathBuf::new(), None).await.unwrap();


There is a todo above Todo: Uncomment after improving tx creation time
could you tell what the problem with this?
I remember that there was an issue with blocks synchronisation, which was fixed by adding sync params. but what about tx creation time?

generating zcoin txs uses lot of resource and takes time to run...there're some optimization for native targets that cannot be achieved with WASM yet

onur-ozkan added 3 commits March 28, 2024 16:27

WIP: resolve db paths by account keys

aa0909f

Signed-off-by: onur-ozkan <[email protected]>

WIP: handle db ids optionally

f051600

Signed-off-by: onur-ozkan <[email protected]>

use dummy values to fix build errors for development

c8a434e

Signed-off-by: onur-ozkan <[email protected]>

onur-ozkan added enhancement New feature or request in progress Changes will be made from the author labels Apr 1, 2024

borngraced added 2 commits April 9, 2024 14:49

fix conflicts after merge

3e0061f

more wip changes and start coin pubkey for indexeddb storage

c6146d0

borngraced self-assigned this Apr 9, 2024

borngraced added 5 commits April 9, 2024 23:50

Z coin or default pubkey for initializing blocksdb

eff374c

zcoin - allow db_id for walletdb

fef8a4e

wip — SwapsContext

6247766

changes to maker and taker swap db_id

fa0f5ab

complete zcoin dbs multi pubkey support for WASM target

947ab8d

borngraced linked an issue Apr 10, 2024 that may be closed by this pull request

Implementing Per-Coin Database Paths Based on PubkeyHash for Enhanced Modularization #2094

Open

borngraced added 3 commits April 10, 2024 17:13

fix clippy/fmt

ae95d4e

impl account_db_id for wasm target

c0d13e7

complete some todos in swap mod

71c4e9c

borngraced marked this pull request as ready for review April 10, 2024 20:01

borngraced added 12 commits April 10, 2024 21:03

minor changes to DbIdentifier constructor(new)

be3dc81

changes to swaps db

ffbc262

handle recv_swap_msg with db_id

07c1168

add todos for StateMachineStorage for TakerSwapStorage

1ec96bc

add todos for StateMachineStorage for TakerSwapStorage

3ccfa00

get_swap_repr

29763e2

mark account_db_id as todo for native target

cf749eb

impl find_unique_active_account_ids and use for swap_kick_starts

368441c

make swap_v2 multi_key

7095605

WIP - start nft multi key support

8823be2

WIP - my_swaps_storage

42a22b1

fix field assignment outside of initializer

23f0566

Merge remote-tracking branch 'origin/dev' into multi-pubkey-dbs

7e3d3a6

shamardy reviewed Jul 19, 2024

View reviewed changes

borngraced added 3 commits July 19, 2024 12:14

fix review notes

5470b25

merge with dev and fix conflicts

d57e394

fix clippy

b690e93

shamardy reviewed Jul 23, 2024

View reviewed changes

fix review notes and remove left over

1675a53

shamardy mentioned this pull request Jul 26, 2024

feat(nft-swap): complete refund methods #2129

Merged

shamardy reviewed Jul 27, 2024

View reviewed changes

borngraced added 9 commits July 28, 2024 16:16

use display_eth_address

5e02fa4

minor changes and improvements

5f72e83

cargo fmt

a0cf3cb

Merge remote-tracking branch 'origin/dev' into multi-pubkey-dbs

0c817e8

allow swap continuation with correct db_id on swap restart for swap_v2

34f9d27

improve swap_v2 swap kickstart and eth pubkey deriv

79f3792

Fix: Improve db_id validation for taker order processing

117aa44

cleanups

2f3086c

merge with dev and fix conflicts

c6b3648

shamardy self-requested a review August 5, 2024 12:25

shamardy reviewed Aug 5, 2024

View reviewed changes

borngraced added 5 commits August 6, 2024 13:50

save dev state

06ce83b

Merge remote-tracking branch 'origin/dev' into multi-pubkey-dbs

eb9d74a

fix clippy

5cbfd89

fix orders_kick_start

cea464b

fix minor review notes

07a478c

laruh requested changes Aug 8, 2024

View reviewed changes

laruh reviewed Aug 9, 2024

View reviewed changes

shamardy self-assigned this Aug 9, 2024

shamardy added in progress Changes will be made from the author and removed under review labels Aug 9, 2024

	let (hash, sig) = metamask_session
	.sign_typed_data_v4(eth_account_str.clone(), adex_eip712_request(domain, request))
	.await?;

	let sig = sig.strip_prefix("0x").unwrap_or(&sig);
	let signature = Signature::from_str(sig)
	.map_to_mm(\|_\| MetamaskError::Internal(format!("'{sig}' signature is invalid")))?;
	let pubkey = recover_pubkey(hash, signature).mm_err(\|_\| {
	let error = format!("Couldn't recover a public key from the signature: '{sig}'");
	MetamaskError::Internal(error)
	})?;

	let recovered_address = address_from_pubkey_uncompressed(pubkey);
	if eth_account != recovered_address {
	let error =
	format!("Recovered address '{recovered_address:?}' should be the same as '{eth_account:?}'");
	return MmError::err(MetamaskError::Internal(error));
	}

	// TODO
	pub async fn wallets_db(&self) -> InitDbResult<WalletsDbLocked> { self.wallets_db.get_or_initialize(None).await }

	pub fn display_db_id(&self) -> String { self.db_id.clone().unwrap_or_else(\|\| "KOMODEFI".to_string()) }

	pub fn db_id(&self) -> String {
	self.db_id
	.clone()
	.unwrap_or_else(\|\| hex::encode(H160::default().as_slice()))
	}

	pub(super) async fn save_encrypted_passphrase(
	ctx: &MmArc,
	wallet_name: &str,
	encrypted_passphrase_data: &EncryptedData,
	) -> WalletsStorageResult<()> {
	let wallet_path = ctx.wallet_file_path(wallet_name);
	ensure_file_is_writable(&wallet_path).map_to_mm(WalletsStorageError::FsWriteError)?;
	mm2_io::fs::write_json(encrypted_passphrase_data, &wallet_path, true)
	.await
	.mm_err(\|e\| WalletsStorageError::FsWriteError(e.to_string()))
	}

	// This either initializes the cryptographic context or sets up the context for "no login mode".
	initialize_wallet_passphrase(&ctx).await?;

	let taker_coin = loop {
	match lp_coinfind(&ctx, &taker_coin_ticker).await {
	Ok(Some(c)) => {
	if taker_coin_db_id == c.account_db_id().await.as_deref() {
	break c;
	};
	info!(
	"Can't kickstart the swap {} until the coin {} is activated with pubkey: {}",
	swap.uuid(),
	taker_coin_ticker,
	taker_coin_db_id.unwrap_or(&ctx.rmd160.to_string())
	);
	Timer::sleep(5.).await;
	},
	Ok(None) => {
	info!(
	"Can't kickstart the swap {} until the coin {} is activated",
	swap.uuid(),
	taker_coin_ticker
	);
	Timer::sleep(5.).await;
	},
	Err(e) => {
	error!("Error {} on {} find attempt", e, taker_coin_ticker);
	return;
	},
	};
	};

	let maker_coin = loop {
	match lp_coinfind(&ctx, &maker_coin_ticker).await {
	Ok(Some(c)) => {
	if maker_coin_db_id == c.account_db_id().await.as_deref() {
	break c;
	};
	info!(
	"Can't kickstart the swap {} until the coin {} is activated with pubkey: {}",
	swap.uuid(),
	maker_coin_ticker,
	maker_coin_db_id.unwrap_or(&ctx.rmd160.to_string())
	);
	Timer::sleep(5.).await;
	},
	Ok(None) => {
	info!(
	"Can't kickstart the swap {} until the coin {} is activated",
	swap.uuid(),
	maker_coin_ticker
	);
	Timer::sleep(5.).await;
	},
	Err(e) => {
	error!("Error {} on {} find attempt", e, maker_coin_ticker);
	return;
	},
	};
	};

		base_coin_account_id: Option<String>,
		rel_coin_account_id: Option<String>,

	pub fn account_id(&self) -> &Option<String> {
	match self.request.action {
	TakerAction::Buy => &self.rel_coin_account_id,
	TakerAction::Sell => &self.base_coin_account_id,
	}

	if let Ok(Some(coin)) = lp_coinfind(&ctx, &ticker).await {
	let balance = match coin.my_spendable_balance().compat().await {
	Ok(balance) => balance,
	Err(_) => continue,
	};
	if Some(&balance) != current_balance.as_ref() {
	let coins_ctx = CoinsContext::from_ctx(&ctx).unwrap();
	coins_ctx.balance_updated(&coin, &balance).await;
	current_balance = Some(balance);
	}
	}

		#[derive(Debug, Serialize)]
		pub struct NftsTransferHistoryLists {

feat(core): multi-pubkey DB support #2093

Are you sure you want to change the base?

feat(core): multi-pubkey DB support #2093

Conversation

onur-ozkan commented Apr 1, 2024 • edited by borngraced Loading

Completed

Checklists for next PR

shamardy left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

shamardy Jul 19, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

shamardy left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

shamardy left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

shamardy left a comment

Choose a reason for hiding this comment

shamardy Aug 5, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

laruh left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

borngraced Aug 8, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

laruh left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

onur-ozkan commented Apr 1, 2024 •

edited by borngraced

Loading

shamardy Jul 19, 2024 •

edited

Loading

shamardy Aug 5, 2024 •

edited

Loading

borngraced Aug 8, 2024 •

edited

Loading