Updated on 2026-08-14

app/src/main/java/com/tangem/tap/features/customtoken/impl/di/CustomTokenInteractorModule.kt

@@ -3,7 +3,6 @@ package com.tangem.tap.features.customtoken.impl.di
 import com.tangem.datasource.api.tangemTech.TangemTechApi
 import com.tangem.domain.card.DerivePublicKeysUseCase
 import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
-import com.tangem.features.tester.api.TesterFeatureToggles
 import com.tangem.tap.features.customtoken.impl.data.DefaultCustomTokenRepository
 import com.tangem.tap.features.customtoken.impl.domain.CustomTokenInteractor
 import com.tangem.tap.features.customtoken.impl.domain.DefaultCustomTokenInteractor
@@ -30,7 +29,6 @@ internal object CustomTokenInteractorModule {
         reduxStateHolder: AppStateHolder,
         getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
         derivePublicKeysUseCase: DerivePublicKeysUseCase,
-        testerFeatureToggles: TesterFeatureToggles,
     ): CustomTokenInteractor {
         return DefaultCustomTokenInteractor(
             featureRepository = DefaultCustomTokenRepository(
@@ -40,7 +38,6 @@ internal object CustomTokenInteractorModule {
             ),
             getSelectedWalletSyncUseCase = getSelectedWalletSyncUseCase,
             derivePublicKeysUseCase = derivePublicKeysUseCase,
-            testerFeatureToggles = testerFeatureToggles,
         )
     }
 }

app/src/main/java/com/tangem/tap/features/customtoken/impl/domain/DefaultCustomTokenInteractor.kt

@@ -1,40 +1,19 @@
 package com.tangem.tap.features.customtoken.impl.domain
 
-import com.tangem.blockchain.blockchains.cardano.CardanoUtils
 import com.tangem.blockchain.common.Blockchain
-import com.tangem.common.CompletionResult
-import com.tangem.common.card.EllipticCurve
-import com.tangem.common.core.TangemError
-import com.tangem.common.extensions.ByteArrayKey
-import com.tangem.common.extensions.toMapKey
-import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.data.tokens.utils.CryptoCurrencyFactory
 import com.tangem.domain.card.DerivePublicKeysUseCase
-import com.tangem.domain.common.configs.CardConfig
 import com.tangem.domain.common.extensions.toNetworkId
 import com.tangem.domain.common.util.derivationStyleProvider
-import com.tangem.domain.common.util.hasDerivation
 import com.tangem.domain.features.addCustomToken.CustomCurrency
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.tokens.AddCryptoCurrenciesUseCase
 import com.tangem.domain.tokens.model.CryptoCurrency
-import com.tangem.domain.wallets.models.UserWallet
 import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
-import com.tangem.features.tester.api.TesterFeatureToggles
-import com.tangem.operations.derivation.ExtendedPublicKeysMap
-import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
-import com.tangem.tap.common.extensions.dispatchOnMain
-import com.tangem.tap.common.redux.global.GlobalAction
-import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.model.Currency
 import com.tangem.tap.features.customtoken.impl.domain.models.FoundToken
-import com.tangem.tap.features.tokens.legacy.redux.TokensMiddleware
 import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.store
-import com.tangem.tap.tangemSdkManager
-import com.tangem.tap.userWalletsListManager
-import com.tangem.utils.extensions.DELAY_SDK_DIALOG_CLOSE
-import kotlinx.coroutines.delay
 import timber.log.Timber
 
 /**
@@ -48,7 +27,6 @@ class DefaultCustomTokenInteractor(
     private val featureRepository: CustomTokenRepository,
     private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
     private val derivePublicKeysUseCase: DerivePublicKeysUseCase,
-    private val testerFeatureToggles: TesterFeatureToggles,
 ) : CustomTokenInteractor {
 
     // TODO: Move to DI
@@ -70,136 +48,12 @@ class DefaultCustomTokenInteractor(
         val userWallet = getSelectedWalletSyncUseCase().fold(ifLeft = { return }, ifRight = { it })
         val currency = Currency.fromCustomCurrency(customCurrency)
 
-        if (testerFeatureToggles.isDerivePublicKeysRefactoringEnabled) {
-            val currencies = listOfNotNull(element = currency.toCryptoCurrency(userWallet.scanResponse))
-            derivePublicKeysUseCase(userWalletId = userWallet.walletId, currencies = currencies)
-                .onRight {
-                    addCryptoCurrenciesUseCase(userWalletId = userWallet.walletId, currencies = currencies)
-                }
-                .onLeft { Timber.e("Failed to derive public keys: $it") }
-        } else {
-            // TODO: delete [REDACTED_JIRA]
-            val isNeedToDerive = isNeedToDerive(userWallet, currency)
-            if (isNeedToDerive) {
-                deriveMissingBlockchains(
-                    userWallet = userWallet,
-                    currencyList = listOf(currency),
-                    onSuccess = { submitAdd(userWallet = userWallet.copy(scanResponse = it), currency = currency) },
-                ) {
-                    throw it
-                }
-            } else {
-                submitAdd(userWallet, currency)
+        val currencies = listOfNotNull(element = currency.toCryptoCurrency(userWallet.scanResponse))
+        derivePublicKeysUseCase(userWalletId = userWallet.walletId, currencies = currencies)
+            .onRight {
+                addCryptoCurrenciesUseCase(userWalletId = userWallet.walletId, currencies = currencies)
             }
-        }
-    }
-
-    private fun isNeedToDerive(userWallet: UserWallet, currency: Currency): Boolean {
-        val scanResponse = userWallet.scanResponse
-        return currency.derivationPath?.let { !scanResponse.hasDerivation(currency.blockchain, it) } ?: false
-    }
-
-    private suspend fun deriveMissingBlockchains(
-        userWallet: UserWallet,
-        currencyList: List<Currency>,
-        onSuccess: suspend (ScanResponse) -> Unit,
-        onFailure: suspend (TangemError) -> Unit,
-    ) {
-        val scanResponse = userWallet.scanResponse
-        val config = CardConfig.createConfig(scanResponse.card)
-        val derivationDataList = currencyList.mapNotNull { currency ->
-            val curve = config.primaryCurve(currency.blockchain)
-            curve?.let { getDerivations(curve, scanResponse, currency) }
-        }
-
-        val derivations = buildMap<ByteArrayKey, MutableList<DerivationPath>> {
-            derivationDataList.forEach {
-                val current = this[it.derivations.first]
-                if (current != null) {
-                    current.addAll(it.derivations.second)
-                    current.distinct()
-                } else {
-                    this[it.derivations.first] = it.derivations.second.toMutableList()
-                }
-            }
-        }
-        if (derivations.isEmpty()) {
-            onSuccess(scanResponse)
-            return
-        }
-
-        when (val result = tangemSdkManager.derivePublicKeys(cardId = null, derivations = derivations)) {
-            is CompletionResult.Success -> {
-                val newDerivedKeys = result.data.entries
-                val oldDerivedKeys = scanResponse.derivedKeys
-
-                val walletKeys = (newDerivedKeys.keys + oldDerivedKeys.keys).toSet()
-
-                val updatedDerivedKeys = walletKeys.associateWith { walletKey ->
-                    val oldDerivations = ExtendedPublicKeysMap(oldDerivedKeys[walletKey] ?: emptyMap())
-                    val newDerivations = newDerivedKeys[walletKey] ?: ExtendedPublicKeysMap(emptyMap())
-                    ExtendedPublicKeysMap(oldDerivations + newDerivations)
-                }
-
-                val updatedScanResponse = scanResponse.copy(derivedKeys = updatedDerivedKeys)
-                store.dispatchOnMain(GlobalAction.SaveScanResponse(updatedScanResponse))
-                delay(DELAY_SDK_DIALOG_CLOSE)
-
-                onSuccess(updatedScanResponse)
-            }
-            is CompletionResult.Failure -> {
-                onFailure.invoke(result.error)
-                store.dispatchDebugErrorNotification(TapError.CustomError("Error adding tokens"))
-            }
-        }
-    }
-
-    private fun getDerivations(
-        curve: EllipticCurve,
-        scanResponse: ScanResponse,
-        currency: Currency,
-    ): TokensMiddleware.DerivationData? {
-        val wallet = scanResponse.card.wallets.firstOrNull { it.curve == curve } ?: return null
-
-        val supportedCurves = currency.blockchain.getSupportedCurves()
-        val path = currency.blockchain.derivationPath(scanResponse.derivationStyleProvider.getDerivationStyle())
-            .takeIf { supportedCurves.contains(curve) }
-
-        val customPath = currency.derivationPath?.let {
-            DerivationPath(it)
-        }.takeIf { supportedCurves.contains(curve) }
-
-        val bothCandidates = listOfNotNull(path, customPath).distinct().toMutableList()
-        if (bothCandidates.isEmpty()) return null
-
-        if (currency is Currency.Blockchain && currency.blockchain == Blockchain.Cardano) {
-            currency.derivationPath?.let {
-                bothCandidates.add(CardanoUtils.extendedDerivationPath(DerivationPath(it)))
-            }
-        }
-
-        val mapKeyOfWalletPublicKey = wallet.publicKey.toMapKey()
-        val alreadyDerivedKeys: ExtendedPublicKeysMap =
-            scanResponse.derivedKeys[mapKeyOfWalletPublicKey] ?: ExtendedPublicKeysMap(emptyMap())
-        val alreadyDerivedPaths = alreadyDerivedKeys.keys.toList()
-
-        val toDerive = bothCandidates.filterNot { alreadyDerivedPaths.contains(it) }
-        if (toDerive.isEmpty()) return null
-
-        return TokensMiddleware.DerivationData(derivations = mapKeyOfWalletPublicKey to toDerive)
-    }
-
-    private suspend fun submitAdd(userWallet: UserWallet, currency: Currency) {
-        val scanResponse = userWallet.scanResponse
-        val userWalletId = userWallet.walletId
-
-        val currencyList = listOfNotNull(element = currency.toCryptoCurrency(scanResponse))
-
-        userWalletsListManager.update(userWalletId) {
-            it.copy(scanResponse = scanResponse)
-        }
-
-        addCryptoCurrenciesUseCase(userWalletId, currencyList)
+            .onLeft { Timber.e("Failed to derive public keys: $it") }
     }
 
     private fun Currency.toCryptoCurrency(scanResponse: ScanResponse): CryptoCurrency? {

app/src/main/java/com/tangem/tap/features/tokens/impl/presentation/viewmodels/TokensListMigration.kt

@@ -3,14 +3,20 @@ package com.tangem.tap.features.tokens.impl.presentation.viewmodels
 import arrow.core.Either
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Token
+import com.tangem.core.navigation.NavigationAction
 import com.tangem.data.tokens.utils.CryptoCurrencyFactory
+import com.tangem.domain.card.DerivePublicKeysUseCase
 import com.tangem.domain.common.util.derivationStyleProvider
+import com.tangem.domain.tokens.AddCryptoCurrenciesUseCase
 import com.tangem.domain.tokens.GetCryptoCurrenciesUseCase
 import com.tangem.domain.tokens.TokenWithBlockchain
-import com.tangem.domain.tokens.TokensAction
 import com.tangem.domain.tokens.model.CryptoCurrency
 import com.tangem.domain.wallets.models.UserWallet
+import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
+import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
+import com.tangem.tap.common.extensions.dispatchOnMain
+import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.store
 import timber.log.Timber
 import kotlin.properties.Delegates
@@ -24,6 +30,8 @@ import kotlin.properties.Delegates
 internal class TokensListMigration(
     private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
     private val getCurrenciesUseCase: GetCryptoCurrenciesUseCase,
+    private val derivePublicKeysUseCase: DerivePublicKeysUseCase,
+    private val addCryptoCurrenciesUseCase: AddCryptoCurrenciesUseCase,
 ) {
 
     private var currentNewCoins: List<CryptoCurrency.Coin> by Delegates.notNull()
@@ -76,31 +84,72 @@ internal class TokensListMigration(
         }
     }
 
-    fun onSaveButtonClick(
+    suspend fun onSaveButtonClick(
         changedTokensList: MutableList<TokenWithBlockchain>,
         changedBlockchainList: List<Blockchain>,
     ) {
-        store.dispatch(
-            action = TokensAction.SaveChanges(
-                currentTokens = currentNewTokens,
-                currentCoins = currentNewCoins,
-                changedTokens = changedTokensList.mapNotNull {
-                    cryptoCurrencyFactory.createToken(
-                        sdkToken = it.token,
-                        blockchain = it.blockchain,
-                        extraDerivationPath = null,
-                        derivationStyleProvider = currentUserWallet.scanResponse.derivationStyleProvider,
-                    )
-                },
-                changedCoins = changedBlockchainList.mapNotNull {
-                    cryptoCurrencyFactory.createCoin(
-                        blockchain = it,
-                        extraDerivationPath = null,
-                        derivationStyleProvider = currentUserWallet.scanResponse.derivationStyleProvider,
-                    )
-                },
-                userWallet = currentUserWallet,
-            ),
+        val changedTokens = changedTokensList.mapNotNull {
+            cryptoCurrencyFactory.createToken(
+                sdkToken = it.token,
+                blockchain = it.blockchain,
+                extraDerivationPath = null,
+                derivationStyleProvider = currentUserWallet.scanResponse.derivationStyleProvider,
+            )
+        }
+
+        val changedCoins = changedBlockchainList.mapNotNull {
+            cryptoCurrencyFactory.createCoin(
+                blockchain = it,
+                extraDerivationPath = null,
+                derivationStyleProvider = currentUserWallet.scanResponse.derivationStyleProvider,
+            )
+        }
+
+        val blockchainsToAdd = changedCoins.filterNot(currentNewCoins::contains)
+        val blockchainsToRemove = currentNewCoins.filterNot(changedCoins::contains)
+
+        val tokensToAdd = changedTokens.filterNot(currentNewTokens::contains)
+        val tokensToRemove = currentNewTokens.filterNot { token -> changedTokens.any { it == token } }
+
+        removeCurrenciesIfNeeded(
+            userWalletId = currentUserWallet.walletId,
+            currencies = blockchainsToRemove + tokensToRemove,
+        )
+
+        val isNothingToDoWithTokens = tokensToAdd.isEmpty() && tokensToRemove.isEmpty()
+        val isNothingToDoWithBlockchain = blockchainsToAdd.isEmpty() && blockchainsToRemove.isEmpty()
+        if (isNothingToDoWithTokens && isNothingToDoWithBlockchain) {
+            store.dispatchDebugErrorNotification(message = "Nothing to save")
+            store.dispatchOnMain(NavigationAction.PopBackTo())
+            return
+        }
+
+        val currencyList = blockchainsToAdd + tokensToAdd
+
+        derivePublicKeysUseCase(userWalletId = currentUserWallet.walletId, currencies = currencyList)
+            .onRight {
+                addCryptoCurrenciesUseCase(userWalletId = currentUserWallet.walletId, currencies = currencyList)
+                store.dispatchOnMain(NavigationAction.PopBackTo())
+            }
+            .onLeft { Timber.e("Failed to derive public keys: $it") }
+    }
+
+    private suspend fun removeCurrenciesIfNeeded(userWalletId: UserWalletId, currencies: List<CryptoCurrency>) {
+        if (currencies.isEmpty()) return
+        val currenciesRepository = store.state.daggerGraphState.get(DaggerGraphState::currenciesRepository)
+        val walletManagersFacade = store.state.daggerGraphState.get(DaggerGraphState::walletManagersFacade)
+
+        currenciesRepository.removeCurrencies(userWalletId = userWalletId, currencies = currencies)
+
+        walletManagersFacade.remove(
+            userWalletId = userWalletId,
+            networks = currencies
+                .filterIsInstance<CryptoCurrency.Coin>()
+                .mapTo(hashSetOf(), CryptoCurrency::network),
+        )
+        walletManagersFacade.removeTokens(
+            userWalletId = userWalletId,
+            tokens = currencies.filterIsInstance<CryptoCurrency.Token>().toSet(),
         )
     }
 }

app/src/main/java/com/tangem/tap/features/tokens/impl/presentation/viewmodels/TokensListViewModel.kt

@@ -13,12 +13,14 @@ import com.tangem.blockchain.common.Blockchain
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.ui.extensions.getActiveIconRes
 import com.tangem.core.ui.extensions.getGreyedOutIconRes
+import com.tangem.domain.card.DerivePublicKeysUseCase
 import com.tangem.domain.common.TapWorkarounds.useOldStyleDerivation
 import com.tangem.domain.common.extensions.canHandleBlockchain
 import com.tangem.domain.common.extensions.canHandleToken
 import com.tangem.domain.common.extensions.fromNetworkId
 import com.tangem.domain.common.extensions.supportedTokens
 import com.tangem.domain.common.util.cardTypesResolver
+import com.tangem.domain.tokens.AddCryptoCurrenciesUseCase
 import com.tangem.domain.tokens.GetCryptoCurrenciesUseCase
 import com.tangem.domain.tokens.TokenWithBlockchain
 import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
@@ -67,6 +69,8 @@ internal class TokensListViewModel @Inject constructor(
     private val router: TokensListRouter,
     private val dispatchers: AppCoroutineDispatcherProvider,
     private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
+    derivePublicKeysUseCase: DerivePublicKeysUseCase,
+    addCryptoCurrenciesUseCase: AddCryptoCurrenciesUseCase,
     analyticsEventHandler: AnalyticsEventHandler,
     getCurrenciesUseCase: GetCryptoCurrenciesUseCase,
 ) : ViewModel(), DefaultLifecycleObserver {
@@ -88,6 +92,8 @@ internal class TokensListViewModel @Inject constructor(
     private val tokensListMigration = TokensListMigration(
         getSelectedWalletSyncUseCase = getSelectedWalletSyncUseCase,
         getCurrenciesUseCase = getCurrenciesUseCase,
+        derivePublicKeysUseCase = derivePublicKeysUseCase,
+        addCryptoCurrenciesUseCase = addCryptoCurrenciesUseCase,
     )
 
     init {
@@ -303,10 +309,13 @@ internal class TokensListViewModel @Inject constructor(
 
         fun onSaveButtonClick() {
             analyticsSender.sendWhenSaveButtonClicked()
-            tokensListMigration.onSaveButtonClick(
-                changedTokensList = changedTokensList,
-                changedBlockchainList = changedBlockchainList,
-            )
+
+            viewModelScope.launch(dispatchers.main) {
+                tokensListMigration.onSaveButtonClick(
+                    changedTokensList = changedTokensList,
+                    changedBlockchainList = changedBlockchainList,
+                )
+            }
         }
 
         private fun onSearchValueChange(newValue: String) {

app/src/main/java/com/tangem/tap/features/tokens/legacy/redux/TokensMiddleware.kt

@@ -1,250 +0,0 @@
-package com.tangem.tap.features.tokens.legacy.redux
-
-import com.tangem.blockchain.blockchains.cardano.CardanoUtils
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.common.CompletionResult
-import com.tangem.common.card.EllipticCurve
-import com.tangem.common.doOnSuccess
-import com.tangem.common.extensions.ByteArrayKey
-import com.tangem.common.extensions.toMapKey
-import com.tangem.core.navigation.NavigationAction
-import com.tangem.crypto.hdWallet.DerivationPath
-import com.tangem.domain.common.configs.CardConfig
-import com.tangem.domain.common.util.derivationStyleProvider
-import com.tangem.domain.common.util.supportsHdWallet
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.domain.tokens.AddCryptoCurrenciesUseCase
-import com.tangem.domain.tokens.TokensAction
-import com.tangem.domain.tokens.model.CryptoCurrency
-import com.tangem.domain.wallets.models.UserWallet
-import com.tangem.domain.wallets.models.UserWalletId
-import com.tangem.operations.derivation.ExtendedPublicKeysMap
-import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
-import com.tangem.tap.common.extensions.dispatchOnMain
-import com.tangem.tap.common.redux.AppState
-import com.tangem.tap.common.redux.global.GlobalAction
-import com.tangem.tap.domain.TapError
-import com.tangem.tap.domain.card.DefaultDerivePublicKeysUseCase
-import com.tangem.tap.proxy.redux.DaggerGraphState
-import com.tangem.tap.scope
-import com.tangem.tap.store
-import com.tangem.tap.tangemSdkManager
-import com.tangem.tap.userWalletsListManager
-import kotlinx.coroutines.launch
-import org.rekotlin.Middleware
-import timber.log.Timber
-
-@Suppress("LargeClass")
-object TokensMiddleware {
-
-    // TODO: Move to DI
-    private val addCryptoCurrenciesUseCase by lazy(LazyThreadSafetyMode.NONE) {
-        val currenciesRepository = store.state.daggerGraphState.get(DaggerGraphState::currenciesRepository)
-        val networksRepository = store.state.daggerGraphState.get(DaggerGraphState::networksRepository)
-
-        AddCryptoCurrenciesUseCase(currenciesRepository, networksRepository)
-    }
-
-    val tokensMiddleware: Middleware<AppState> = { _, _ ->
-        { next ->
-            { action ->
-                when (action) {
-                    is TokensAction.SaveChanges -> handleSaveChanges(action)
-                }
-                next(action)
-            }
-        }
-    }
-
-    private fun handleSaveChanges(action: TokensAction.SaveChanges) {
-        scope.launch {
-            val scanResponse = action.userWallet.scanResponse
-
-            val currentTokens = action.currentTokens
-            val currentBlockchains = action.currentCoins
-
-            val blockchainsToAdd = action.changedCoins.filterNot(currentBlockchains::contains)
-            val blockchainsToRemove = currentBlockchains.filterNot(action.changedCoins::contains)
-
-            val tokensToAdd = action.changedTokens.filterNot(currentTokens::contains)
-            val tokensToRemove = currentTokens.filterNot { token -> action.changedTokens.any { it == token } }
-
-            removeCurrenciesIfNeeded(
-                userWalletId = action.userWallet.walletId,
-                currencies = blockchainsToRemove + tokensToRemove,
-            )
-
-            val isNothingToDoWithTokens = tokensToAdd.isEmpty() && tokensToRemove.isEmpty()
-            val isNothingToDoWithBlockchain = blockchainsToAdd.isEmpty() && blockchainsToRemove.isEmpty()
-            if (isNothingToDoWithTokens && isNothingToDoWithBlockchain) {
-                store.dispatchDebugErrorNotification(message = "Nothing to save")
-                store.dispatchOnMain(NavigationAction.PopBackTo())
-                return@launch
-            }
-
-            val currencyList = blockchainsToAdd + tokensToAdd
-
-            val featureToggles = store.state.daggerGraphState.get(DaggerGraphState::testerFeatureToggles)
-            if (featureToggles.isDerivePublicKeysRefactoringEnabled) {
-                val derivePublicKeys = DefaultDerivePublicKeysUseCase(
-                    tangemSdkManager = tangemSdkManager,
-                    derivationsRepository = store.state.daggerGraphState.get(DaggerGraphState::derivationsRepository),
-                )
-
-                derivePublicKeys(userWalletId = action.userWallet.walletId, currencies = currencyList)
-                    .onRight {
-                        addCryptoCurrenciesUseCase(
-                            userWalletId = action.userWallet.walletId,
-                            currencies = currencyList,
-                        )
-                        store.dispatchOnMain(NavigationAction.PopBackTo())
-                    }
-                    .onLeft { Timber.e("Failed to derive public keys: $it") }
-            } else {
-                // TODO: delete [REDACTED_JIRA]
-                if (scanResponse.supportsHdWallet()) {
-                    deriveMissingCoins(scanResponse = scanResponse, currencyList = currencyList) {
-                        submitAdd(
-                            userWallet = action.userWallet,
-                            updatedScanResponse = it,
-                            currencyList = currencyList,
-                        )
-                    }
-                } else {
-                    submitAdd(action.userWallet, scanResponse, currencyList)
-                }
-            }
-        }
-    }
-
-    @Deprecated(message = "Use DerivePublicKeysUseCase instead")
-    private fun deriveMissingCoins(
-        scanResponse: ScanResponse,
-        currencyList: List<CryptoCurrency>,
-        onSuccess: (ScanResponse) -> Unit,
-    ) {
-        val config = CardConfig.createConfig(scanResponse.card)
-        val derivationDataList = currencyList.mapNotNull { currency ->
-            val curve = config.primaryCurve(blockchain = Blockchain.fromId(currency.network.id.value))
-            curve?.let { getDerivations(curve, scanResponse, currency) }
-        }
-        val derivations = buildMap<ByteArrayKey, MutableList<DerivationPath>> {
-            derivationDataList.forEach {
-                val current = this[it.derivations.first]
-                if (current != null) {
-                    current.addAll(it.derivations.second)
-                    current.distinct()
-                } else {
-                    this[it.derivations.first] = it.derivations.second.toMutableList()
-                }
-            }
-        }
-
-        if (derivations.isEmpty()) {
-            onSuccess(scanResponse)
-            return
-        }
-
-        scope.launch {
-            val result = tangemSdkManager.derivePublicKeys(
-                cardId = null,
-                derivations = derivations,
-            )
-            when (result) {
-                is CompletionResult.Success -> {
-                    val newDerivedKeys = result.data.entries
-                    val oldDerivedKeys = scanResponse.derivedKeys
-
-                    val walletKeys = (newDerivedKeys.keys + oldDerivedKeys.keys).toSet()
-
-                    val updatedDerivedKeys = walletKeys.associateWith { walletKey ->
-                        val oldDerivations = ExtendedPublicKeysMap(oldDerivedKeys[walletKey] ?: emptyMap())
-                        val newDerivations = newDerivedKeys[walletKey] ?: ExtendedPublicKeysMap(emptyMap())
-                        ExtendedPublicKeysMap(oldDerivations + newDerivations)
-                    }
-                    val updatedScanResponse = scanResponse.copy(derivedKeys = updatedDerivedKeys)
-
-                    store.dispatchOnMain(GlobalAction.SaveScanResponse(updatedScanResponse))
-
-                    onSuccess(updatedScanResponse)
-                }
-                is CompletionResult.Failure -> {
-                    store.dispatchDebugErrorNotification(TapError.CustomError("Error adding tokens"))
-                }
-            }
-        }
-    }
-
-    private fun getDerivations(
-        curve: EllipticCurve,
-        scanResponse: ScanResponse,
-        currency: CryptoCurrency,
-    ): DerivationData? {
-        val wallet = scanResponse.card.wallets.firstOrNull { it.curve == curve } ?: return null
-
-        val blockchain = Blockchain.fromId(currency.network.id.value)
-        val supportedCurves = blockchain.getSupportedCurves()
-        val path = blockchain.derivationPath(scanResponse.derivationStyleProvider.getDerivationStyle())
-            .takeIf { supportedCurves.contains(curve) }
-
-        val customPath = currency.network.derivationPath.value?.let {
-            DerivationPath(it)
-        }.takeIf { supportedCurves.contains(curve) }
-
-        val bothCandidates = listOfNotNull(path, customPath).distinct().toMutableList()
-        if (bothCandidates.isEmpty()) return null
-
-        if (currency is CryptoCurrency.Coin && blockchain == Blockchain.Cardano) {
-            currency.network.derivationPath.value?.let {
-                bothCandidates.add(CardanoUtils.extendedDerivationPath(DerivationPath(it)))
-            }
-        }
-
-        val mapKeyOfWalletPublicKey = wallet.publicKey.toMapKey()
-        val alreadyDerivedKeys: ExtendedPublicKeysMap =
-            scanResponse.derivedKeys[mapKeyOfWalletPublicKey] ?: ExtendedPublicKeysMap(emptyMap())
-        val alreadyDerivedPaths = alreadyDerivedKeys.keys.toList()
-
-        val toDerive = bothCandidates.filterNot { alreadyDerivedPaths.contains(it) }
-        if (toDerive.isEmpty()) return null
-
-        return DerivationData(derivations = mapKeyOfWalletPublicKey to toDerive)
-    }
-
-    class DerivationData(val derivations: Pair<ByteArrayKey, List<DerivationPath>>)
-
-    private fun submitAdd(
-        userWallet: UserWallet,
-        updatedScanResponse: ScanResponse,
-        currencyList: List<CryptoCurrency>,
-    ) {
-        scope.launch {
-            userWalletsListManager.update(
-                userWalletId = userWallet.walletId,
-                update = { it.copy(scanResponse = updatedScanResponse) },
-            ).doOnSuccess {
-                addCryptoCurrenciesUseCase(userWallet.walletId, currencyList)
-            }
-        }
-        store.dispatchOnMain(NavigationAction.PopBackTo())
-    }
-
-    private suspend fun removeCurrenciesIfNeeded(userWalletId: UserWalletId, currencies: List<CryptoCurrency>) {
-        if (currencies.isEmpty()) return
-        val currenciesRepository = store.state.daggerGraphState.get(DaggerGraphState::currenciesRepository)
-        val walletManagersFacade = store.state.daggerGraphState.get(DaggerGraphState::walletManagersFacade)
-
-        currenciesRepository.removeCurrencies(userWalletId = userWalletId, currencies = currencies)
-
-        walletManagersFacade.remove(
-            userWalletId = userWalletId,
-            networks = currencies
-                .filterIsInstance<CryptoCurrency.Coin>()
-                .mapTo(hashSetOf(), CryptoCurrency::network),
-        )
-        walletManagersFacade.removeTokens(
-            userWalletId = userWalletId,
-            tokens = currencies.filterIsInstance<CryptoCurrency.Token>().toSet(),
-        )
-    }
-}