Updated on 2026-08-14

app/src/main/java/com/tangem/tap/domain/TapWalletManager.kt

@@ -45,7 +45,7 @@ class TapWalletManager {
     suspend fun loadWalletData(walletManager: WalletManager) {
         val blockchain = walletManager.wallet.blockchain
         val result = if (walletManagersThrottler.isStillThrottled(blockchain)) {
-            delay(200)
+            delay(500)
             Result.Success(walletManager.wallet)
         } else {
             walletManagersThrottler.updateThrottlingTo(blockchain)
@@ -60,7 +60,7 @@ class TapWalletManager {
         } else {
             val blockchain = walletManager.wallet.blockchain
             if (walletManagersThrottler.isStillThrottled(blockchain)) {
-                delay(200)
+                delay(500)
                 Result.Success(walletManager.wallet)
             } else {
                 walletManagersThrottler.updateThrottlingTo(blockchain)
@@ -87,13 +87,16 @@ class TapWalletManager {
 
     suspend fun loadFiatRate(fiatCurrency: FiatCurrencyName, currencies: List<Currency>) {
         val results = mutableListOf<Pair<Currency, Result<BigDecimal>?>>()
-        currencies.forEach {
-            if (!fiatRatesThrottler.isStillThrottled(it)) {
-                fiatRatesThrottler.updateThrottlingTo(it)
-                results.add(it to coinMarketCapService.getRate(it.currencySymbol, fiatCurrency))
-                handleFiatRatesResult(results)
+        val toUpdate = currencies.filter { !fiatRatesThrottler.isStillThrottled(it) }
+        toUpdate.forEach { fiatRatesThrottler.updateThrottlingTo(it) }
+        toUpdate.map {
+            coroutineScope {
+                async {
+                    results.add(it to coinMarketCapService.getRate(it.currencySymbol, fiatCurrency))
+                }
             }
-        }
+        }.awaitAll()
+        handleFiatRatesResult(results.toList())
     }
 
     suspend fun onCardScanned(data: ScanResponse) {
@@ -315,8 +318,7 @@ class TapWalletManager {
                         store.dispatch(WalletAction.LoadFiatRate.Success(rate))
                     }
                     is Result.Failure -> store.dispatch(WalletAction.LoadFiatRate.Failure)
-                    null -> {
-                    }
+                    null -> {}
                 }
             }
         }

app/src/main/java/com/tangem/tap/features/wallet/redux/WalletAction.kt

@@ -81,7 +81,7 @@ sealed class WalletAction : Action {
     }
 
     data class LoadFiatRate(
-        val wallet: Wallet? = null, val currency: Currency? = null,
+        val wallet: Wallet? = null, val currencyList: List<Currency>? = null,
     ) : WalletAction() {
         data class Success(val fiatRate: Pair<Currency, BigDecimal?>) : WalletAction()
         object Failure : WalletAction()

app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/MultiWalletMiddleware.kt

@@ -3,7 +3,6 @@ package com.tangem.tap.features.wallet.redux.middlewares
 import com.tangem.blockchain.common.*
 import com.tangem.blockchain.extensions.Result
 import com.tangem.common.extensions.isZero
-import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.extensions.safeUpdate
 import com.tangem.tap.common.redux.global.GlobalState
 import com.tangem.tap.common.redux.navigation.AppScreen
@@ -47,7 +46,7 @@ class MultiWalletMiddleware {
                 globalState.scanResponse?.card?.cardId?.let {
                     currenciesRepository.saveAddedToken(it, action.token)
                 }
-                addToken(action.token, walletState, globalState)
+                addTokens(listOf(action.token), walletState, globalState)
             }
             is WalletAction.MultiWallet.AddTokens -> {
                 addTokens(action.tokens, walletState, globalState)
@@ -62,7 +61,9 @@ class MultiWalletMiddleware {
                             }
                     }
                 }
-                store.dispatch(WalletAction.LoadFiatRate(currency = Currency.Blockchain(action.blockchain)))
+                store.dispatch(WalletAction.LoadFiatRate(
+                    currencyList = listOf(Currency.Blockchain(action.blockchain)))
+                )
                 store.dispatch(WalletAction.LoadWallet(action.blockchain)
                 )
             }
@@ -172,80 +173,41 @@ class MultiWalletMiddleware {
         }
     }
 
-    private fun addToken(token: Token, walletState: WalletState?, globalState: GlobalState?) {
+    private fun addTokens(tokens: List<Token>, walletState: WalletState?, globalState: GlobalState?) {
         val scanResponse = globalState?.scanResponse ?: return
+        val wmFactory = globalState.tapWalletManager.walletManagerFactory
 
-        val walletManager = walletState?.getWalletManager(token)
-            ?: globalState.tapWalletManager.walletManagerFactory.makeWalletManagerForApp(
-                scanResponse,
-                token.blockchain
-            )?.also { walletManager ->
-                store.dispatch(WalletAction.MultiWallet.AddWalletManagers(walletManager))
-                store.dispatch(WalletAction.MultiWallet.AddBlockchain(walletManager.wallet.blockchain))
-            }
-
-        store.dispatch(WalletAction.LoadFiatRate(currency = Currency.Token(token)))
-
-        scope.launch {
-            when (val result = walletManager?.addToken(token)) {
-                is Result.Success -> {
-                    store.dispatchOnMain(WalletAction.MultiWallet.TokenLoaded(result.data, token))
+        val groupedTokens = tokens.groupBy { it.blockchain }
+        val walletManagers = groupedTokens.mapNotNull { entry ->
+            val blockchain = entry.key
+            val tokensList = entry.value
+            val walletManager = walletState?.getWalletManager(blockchain)
+                ?: wmFactory.makeWalletManagerForApp(scanResponse, blockchain)?.also {
+                    store.dispatch(WalletAction.MultiWallet.AddWalletManagers(it))
+                    store.dispatch(WalletAction.MultiWallet.AddBlockchain(blockchain))
                 }
-                is Result.Failure -> {
-                    when (val result = walletManager.safeUpdate()) {
-                        is com.tangem.common.services.Result.Success -> {
-                            val tokenAmount = result.data.getTokenAmount(token) ?: return@launch
-                            store.dispatchOnMain(WalletAction.MultiWallet.TokenLoaded(tokenAmount, token))
-                        }
-                        is com.tangem.common.services.Result.Failure -> {
-                        }
+            store.dispatch(WalletAction.LoadFiatRate(currencyList = tokensList.map { Currency.Token(it) }))
+            walletManager?.apply {
+                scope.launch { async { addTokens(tokensList) }.await() }
+            }
+        }
+        scope.launch {
+            walletManagers.forEach { walletManager ->
+                when (val result = walletManager.safeUpdate()) {
+                    is com.tangem.common.services.Result.Success -> {
+                        val wallet = result.data
+                        wallet.getTokens()
+                            .filter { tokens.contains(it) }
+                            .mapNotNull { token -> wallet.getTokenAmount(token)?.let { Pair(token, it) } }
+                            .forEach {
+                                withContext(Dispatchers.Main) {
+                                    store.dispatch(WalletAction.MultiWallet.TokenLoaded(it.second, it.first))
+                                }
+                            }
                     }
+                    is com.tangem.common.services.Result.Failure -> {}
                 }
             }
         }
     }
-
-    private fun addTokens(
-        tokens: List<Token>,
-        walletState: WalletState?,
-        globalState: GlobalState?,
-    ) {
-        val scanResponse = globalState?.scanResponse ?: return
-
-        val tokensWithManagers = tokens.map { token ->
-            val walletManager = walletState?.getWalletManager(token)
-                ?: globalState.tapWalletManager.walletManagerFactory.makeWalletManagerForApp(
-                    scanResponse,
-                    token.blockchain
-                )?.also { walletManager ->
-                    store.dispatch(WalletAction.MultiWallet.AddWalletManagers(walletManager))
-                    store.dispatch(WalletAction.MultiWallet.AddBlockchain(walletManager.wallet.blockchain))
-                }
-            store.dispatch(
-                WalletAction.LoadFiatRate(currency = Currency.Token(token))
-            )
-            TokenWithManager(token, walletManager)
-        }
-        scope.launch {
-            tokensWithManagers.forEach {
-                when (val result = it.walletManager?.addToken(it.token)) {
-                    is Result.Success -> {
-                        store.dispatchOnMain(WalletAction.MultiWallet.TokenLoaded(result.data, it.token))
-                    }
-                    is Result.Failure -> {
-                        when (val result = it.walletManager.safeUpdate()) {
-                            is com.tangem.common.services.Result.Success -> {
-                                val tokenAmount = result.data.getTokenAmount(it.token) ?: return@launch
-                                store.dispatchOnMain(WalletAction.MultiWallet.TokenLoaded(tokenAmount, it.token))
-                            }
-                            is com.tangem.common.services.Result.Failure -> {
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    private data class TokenWithManager(val token: Token, val walletManager: WalletManager?)
 }