Updated on 2026-08-14

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

@@ -6,9 +6,7 @@ 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.guard
 import com.tangem.common.extensions.toMapKey
-import com.tangem.common.flatMap
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.data.tokens.utils.CryptoCurrencyFactory
 import com.tangem.domain.common.configs.CardConfig
@@ -18,12 +16,9 @@ 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.models.UserWalletId
 import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
 import com.tangem.operations.derivation.ExtendedPublicKeysMap
-import com.tangem.tap.*
 import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.redux.global.GlobalAction
@@ -32,10 +27,11 @@ import com.tangem.tap.features.customtoken.impl.domain.models.FoundToken
 import com.tangem.tap.features.tokens.legacy.redux.TokensMiddleware
 import com.tangem.tap.features.wallet.models.Currency
 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 kotlinx.coroutines.launch
-import timber.log.Timber
 
 /**
  * Default implementation of custom token interactor
@@ -178,70 +174,35 @@ class DefaultCustomTokenInteractor(
     }
 
     private suspend fun submitAdd(userWallet: UserWallet, currency: Currency) {
+        val cryptoCurrencyFactory = CryptoCurrencyFactory()
+
         val scanResponse = userWallet.scanResponse
-        val walletFeatureToggles = store.state.daggerGraphState.get(DaggerGraphState::walletFeatureToggles)
+        val userWalletId = userWallet.walletId
 
-        if (walletFeatureToggles.isRedesignedScreenEnabled) {
-            val cryptoCurrencyFactory = CryptoCurrencyFactory()
-
-            submitNewAdd(
-                userWalletId = userWallet.walletId,
-                updatedScanResponse = scanResponse,
-                currencyList = listOfNotNull(
-                    when (currency) {
-                        is Currency.Blockchain -> {
-                            cryptoCurrencyFactory.createCoin(
-                                blockchain = currency.blockchain,
-                                extraDerivationPath = currency.derivationPath,
-                                derivationStyleProvider = scanResponse.derivationStyleProvider,
-                            )
-                        }
-                        is Currency.Token -> {
-                            cryptoCurrencyFactory.createToken(
-                                sdkToken = currency.token,
-                                blockchain = currency.blockchain,
-                                extraDerivationPath = currency.derivationPath,
-                                derivationStyleProvider = scanResponse.derivationStyleProvider,
-                            )
-                        }
-                    },
-                ),
-            )
-        } else {
-            submitLegacyAdd(scanResponse = scanResponse, currency = currency)
-        }
-    }
-
-    private suspend fun submitLegacyAdd(scanResponse: ScanResponse, currency: Currency) {
-        val selectedUserWallet = userWalletsListManager.selectedUserWalletSync.guard {
-            Timber.e("Unable to add currencies, no user wallet selected")
-            return
-        }
-
-        userWalletsListManager.update(
-            userWalletId = selectedUserWallet.walletId,
-            update = { userWallet -> userWallet.copy(scanResponse = scanResponse) },
+        val currencyList = listOfNotNull(
+            when (currency) {
+                is Currency.Blockchain -> {
+                    cryptoCurrencyFactory.createCoin(
+                        blockchain = currency.blockchain,
+                        extraDerivationPath = currency.derivationPath,
+                        derivationStyleProvider = scanResponse.derivationStyleProvider,
+                    )
+                }
+                is Currency.Token -> {
+                    cryptoCurrencyFactory.createToken(
+                        sdkToken = currency.token,
+                        blockchain = currency.blockchain,
+                        extraDerivationPath = currency.derivationPath,
+                        derivationStyleProvider = scanResponse.derivationStyleProvider,
+                    )
+                }
+            },
         )
-            .flatMap { updatedUserWallet ->
-                walletCurrenciesManager.addCurrencies(
-                    userWallet = updatedUserWallet,
-                    currenciesToAdd = listOf(currency),
-                )
-            }
-    }
 
-    private fun submitNewAdd(
-        userWalletId: UserWalletId,
-        updatedScanResponse: ScanResponse,
-        currencyList: List<CryptoCurrency>,
-    ) {
-        scope.launch {
-            userWalletsListManager.update(
-                userWalletId = userWalletId,
-                update = { it.copy(scanResponse = updatedScanResponse) },
-            )
-
-            addCryptoCurrenciesUseCase(userWalletId, currencyList)
+        userWalletsListManager.update(userWalletId) {
+            it.copy(scanResponse = scanResponse)
         }
+
+        addCryptoCurrenciesUseCase(userWalletId, currencyList)
     }
 }

app/src/main/java/com/tangem/tap/features/send/redux/middlewares/SendMiddleware.kt

@@ -11,7 +11,6 @@ import com.tangem.blockchain.common.*
 import com.tangem.blockchain.common.transaction.Fee
 import com.tangem.blockchain.extensions.SimpleResult
 import com.tangem.common.core.TangemSdkError
-import com.tangem.common.extensions.guard
 import com.tangem.core.analytics.Analytics
 import com.tangem.core.navigation.NavigationAction
 import com.tangem.domain.common.TapWorkarounds.isStart2Coin
@@ -39,20 +38,15 @@ import com.tangem.tap.features.demo.isDemoCard
 import com.tangem.tap.features.send.redux.*
 import com.tangem.tap.features.send.redux.FeeAction.RequestFee
 import com.tangem.tap.features.send.redux.states.*
-import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.scope
 import com.tangem.tap.store
-import com.tangem.tap.userWalletsListManager
-import com.tangem.tap.walletCurrenciesManager
 import com.tangem.utils.extensions.DELAY_SDK_DIALOG_CLOSE
 import com.tangem.wallet.R
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import org.rekotlin.Action
 import org.rekotlin.Middleware
-import timber.log.Timber
 import java.util.EnumSet
 
 /**
@@ -277,9 +271,6 @@ private fun sendTransaction(
                         Analytics.sendSelectedCurrencyEvent(mainCurrencyType)
                         dispatch(NavigationAction.PopBackTo())
                     }
-                    scope.launch(Dispatchers.IO) {
-                        updateAfterTransaction(walletManager)
-                    }
                 }
                 is SimpleResult.Failure -> {
                     updateFeedbackManagerInfo(
@@ -418,32 +409,4 @@ private fun updateWarnings(dispatch: (Action) -> Unit) {
 
     val warnings = warningsManager.getWarnings(WarningMessage.Location.SendScreen, listOf(blockchain))
     dispatch(SendAction.Warnings.Set(warnings))
-}
-
-private suspend fun updateAfterTransaction(walletManager: WalletManager) {
-    val walletFeatureToggles = store.state.daggerGraphState.get(DaggerGraphState::walletFeatureToggles)
-    if (!walletFeatureToggles.isRedesignedScreenEnabled) {
-        updateWalletsLegacy(walletManager)
-    }
-}
-
-private suspend fun updateWalletsLegacy(walletManager: WalletManager) {
-    updateWallet(walletManager)
-    delay(timeMillis = 11000) // more than 10000 to avoid throttling
-    updateWallet(walletManager)
-}
-
-private suspend fun updateWallet(walletManager: WalletManager) {
-    val selectedUserWallet = userWalletsListManager.selectedUserWalletSync.guard {
-        Timber.e("Unable to update wallet, no user wallet selected")
-        return
-    }
-    val wallet = walletManager.wallet
-    walletCurrenciesManager.update(
-        userWallet = selectedUserWallet,
-        currency = Currency.Blockchain(
-            blockchain = wallet.blockchain,
-            derivationPath = wallet.publicKey.derivationPath?.rawPath,
-        ),
-    )
 }

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

@@ -11,7 +11,6 @@ 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.usecase.GetSelectedWalletSyncUseCase
-import com.tangem.features.wallet.featuretoggles.WalletFeatureToggles
 import com.tangem.tap.store
 import timber.log.Timber
 import kotlin.properties.Delegates
@@ -19,12 +18,10 @@ import kotlin.properties.Delegates
 /**
  * Class that divide a new and legacy logic when user uses tokens list screen
  *
- * @property walletFeatureToggles         wallet feature toggles
  * @property getSelectedWalletSyncUseCase use case that returns selected wallet
  * @property getCurrenciesUseCase         use case that returns crypto currencies of a specified wallet
  */
 internal class TokensListMigration(
-    private val walletFeatureToggles: WalletFeatureToggles,
     private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
     private val getCurrenciesUseCase: GetCryptoCurrenciesUseCase,
 ) {
@@ -80,24 +77,11 @@ internal class TokensListMigration(
     }
 
     fun onSaveButtonClick(
-        currentTokensList: List<TokenWithBlockchain>,
-        currentBlockchainList: List<Blockchain>,
-        changedTokensList: MutableList<TokenWithBlockchain>,
-        changedBlockchainList: List<Blockchain>,
-    ) {
-        if (walletFeatureToggles.isRedesignedScreenEnabled) {
-            saveByNewWay(changedTokensList = changedTokensList, changedBlockchainList = changedBlockchainList)
-        } else {
-            saveByOldWay(currentTokensList, currentBlockchainList, changedTokensList, changedBlockchainList)
-        }
-    }
-
-    private fun saveByNewWay(
         changedTokensList: MutableList<TokenWithBlockchain>,
         changedBlockchainList: List<Blockchain>,
     ) {
         store.dispatch(
-            action = TokensAction.NewSaveChanges(
+            action = TokensAction.SaveChanges(
                 currentTokens = currentNewTokens,
                 currentCoins = currentNewCoins,
                 changedTokens = changedTokensList.mapNotNull {
@@ -119,23 +103,4 @@ internal class TokensListMigration(
             ),
         )
     }
-
-    private fun saveByOldWay(
-        currentTokensList: List<TokenWithBlockchain>,
-        currentBlockchainList: List<Blockchain>,
-        changedTokensList: MutableList<TokenWithBlockchain>,
-        changedBlockchainList: List<Blockchain>,
-    ) {
-        val scanResponse = store.state.globalState.scanResponse ?: return
-
-        store.dispatch(
-            action = TokensAction.LegacySaveChanges(
-                currentTokens = currentTokensList,
-                currentBlockchains = currentBlockchainList,
-                changedTokens = changedTokensList,
-                changedBlockchains = changedBlockchainList,
-                scanResponse = scanResponse,
-            ),
-        )
-    }
 }

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

@@ -22,7 +22,6 @@ import com.tangem.domain.common.util.cardTypesResolver
 import com.tangem.domain.tokens.GetCryptoCurrenciesUseCase
 import com.tangem.domain.tokens.TokenWithBlockchain
 import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
-import com.tangem.features.wallet.featuretoggles.WalletFeatureToggles
 import com.tangem.tap.common.extensions.fullNameWithoutTestnet
 import com.tangem.tap.common.extensions.getNetworkName
 import com.tangem.tap.features.tokens.impl.domain.TokensListInteractor
@@ -70,7 +69,6 @@ internal class TokensListViewModel @Inject constructor(
     private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
     analyticsEventHandler: AnalyticsEventHandler,
     getCurrenciesUseCase: GetCryptoCurrenciesUseCase,
-    walletFeatureToggles: WalletFeatureToggles,
 ) : ViewModel(), DefaultLifecycleObserver {
 
     private val isManageAccess = store.state.tokensState.isManageAccess
@@ -88,7 +86,6 @@ internal class TokensListViewModel @Inject constructor(
     private var changedBlockchainList: MutableList<Blockchain> = mutableListOf()
 
     private val tokensListMigration = TokensListMigration(
-        walletFeatureToggles = walletFeatureToggles,
         getSelectedWalletSyncUseCase = getSelectedWalletSyncUseCase,
         getCurrenciesUseCase = getCurrenciesUseCase,
     )
@@ -307,8 +304,6 @@ internal class TokensListViewModel @Inject constructor(
         fun onSaveButtonClick() {
             analyticsSender.sendWhenSaveButtonClicked()
             tokensListMigration.onSaveButtonClick(
-                currentTokensList = currentTokensList,
-                currentBlockchainList = currentBlockchainList,
                 changedTokensList = changedTokensList,
                 changedBlockchainList = changedBlockchainList,
             )

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

@@ -2,14 +2,11 @@ package com.tangem.tap.features.tokens.legacy.redux
 
 import com.tangem.blockchain.blockchains.cardano.CardanoUtils
 import com.tangem.blockchain.common.Blockchain
-import com.tangem.blockchain.common.derivation.DerivationStyle
 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.guard
 import com.tangem.common.extensions.toMapKey
-import com.tangem.common.flatMap
 import com.tangem.core.navigation.NavigationAction
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.domain.common.configs.CardConfig
@@ -17,26 +14,24 @@ 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.TokenWithBlockchain
 import com.tangem.domain.tokens.TokensAction
 import com.tangem.domain.tokens.model.CryptoCurrency
 import com.tangem.domain.walletconnect.WalletConnectActions
 import com.tangem.domain.wallets.models.UserWallet
 import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.operations.derivation.ExtendedPublicKeysMap
-import com.tangem.tap.*
 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.features.wallet.models.Currency
 import com.tangem.tap.proxy.redux.DaggerGraphState
-import com.tangem.utils.extensions.DELAY_SDK_DIALOG_CLOSE
-import kotlinx.coroutines.delay
+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 {
@@ -53,15 +48,14 @@ object TokensMiddleware {
         { next ->
             { action ->
                 when (action) {
-                    is TokensAction.LegacySaveChanges -> handleLegacySaveChanges(action)
-                    is TokensAction.NewSaveChanges -> handleNewSaveChanges(action)
+                    is TokensAction.SaveChanges -> handleSaveChanges(action)
                 }
                 next(action)
             }
         }
     }
 
-    private fun handleNewSaveChanges(action: TokensAction.NewSaveChanges) {
+    private fun handleSaveChanges(action: TokensAction.SaveChanges) {
         scope.launch {
             val scanResponse = action.userWallet.scanResponse
 
@@ -74,7 +68,7 @@ object TokensMiddleware {
             val tokensToAdd = action.changedTokens.filterNot(currentTokens::contains)
             val tokensToRemove = currentTokens.filterNot { token -> action.changedTokens.any { it == token } }
 
-            removeNewCurrenciesIfNeeded(
+            removeCurrenciesIfNeeded(
                 userWalletId = action.userWallet.walletId,
                 currencies = blockchainsToRemove + tokensToRemove,
             )
@@ -91,140 +85,14 @@ object TokensMiddleware {
 
             if (scanResponse.supportsHdWallet()) {
                 deriveMissingCoins(scanResponse = scanResponse, currencyList = currencyList) {
-                    submitNewAdd(
+                    submitAdd(
                         userWallet = action.userWallet,
                         updatedScanResponse = it,
                         currencyList = currencyList,
                     )
                 }
             } else {
-                submitNewAdd(
-                    userWallet = action.userWallet,
-                    updatedScanResponse = scanResponse,
-                    currencyList = currencyList,
-                )
-            }
-        }
-    }
-
-    private fun handleLegacySaveChanges(action: TokensAction.LegacySaveChanges) {
-        scope.launch {
-            val scanResponse = action.scanResponse
-
-            val currentTokens = action.currentTokens
-            val currentBlockchains = action.currentBlockchains
-
-            val blockchainsToAdd = action.changedBlockchains.filterNot(currentBlockchains::contains)
-            val blockchainsToRemove = currentBlockchains.filterNot(action.changedBlockchains::contains)
-
-            val tokensToAdd = action.changedTokens.filterNot(currentTokens::contains)
-            val tokensToRemove =
-                currentTokens.filterNot { token -> action.changedTokens.any { it.token == token.token } }
-
-            removeLegacyCurrenciesIfNeeded(
-                currencies = convertToCurrencies(
-                    blockchains = blockchainsToRemove,
-                    tokens = tokensToRemove,
-                    derivationStyle = scanResponse.derivationStyleProvider.getDerivationStyle(),
-                ),
-            )
-
-            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 = convertToCurrencies(
-                blockchains = blockchainsToAdd,
-                tokens = tokensToAdd,
-                derivationStyle = scanResponse.derivationStyleProvider.getDerivationStyle(),
-            )
-
-            if (scanResponse.supportsHdWallet()) {
-                deriveMissingBlockchains(scanResponse, currencyList) {
-                    submitLegacyAdd(it, currencyList)
-                    store.dispatchOnMain(NavigationAction.PopBackTo())
-                }
-            } else {
-                submitLegacyAdd(scanResponse, currencyList)
-                store.dispatchOnMain(NavigationAction.PopBackTo())
-            }
-        }
-    }
-
-    private fun convertToCurrencies(
-        blockchains: List<Blockchain>,
-        tokens: List<TokenWithBlockchain>,
-        derivationStyle: DerivationStyle?,
-    ): List<Currency> {
-        return blockchains.map { Currency.Blockchain(it, it.derivationPath(derivationStyle)?.rawPath) } +
-            tokens.map {
-                Currency.Token(
-                    token = it.token,
-                    blockchain = it.blockchain,
-                    derivationPath = it.blockchain.derivationPath(derivationStyle)?.rawPath,
-                )
-            }
-    }
-
-    private fun deriveMissingBlockchains(
-        scanResponse: ScanResponse,
-        currencyList: List<Currency>,
-        onSuccess: (ScanResponse) -> Unit,
-    ) {
-        val config = CardConfig.createConfig(scanResponse.card)
-        val derivationDataList = currencyList.mapNotNull { currency ->
-            val curve = config.primaryCurve(currency.blockchain)
-            curve?.let { getLegacyDerivations(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))
-                    delay(DELAY_SDK_DIALOG_CLOSE)
-
-                    onSuccess(updatedScanResponse)
-                }
-                is CompletionResult.Failure -> {
-                    store.dispatchDebugErrorNotification(TapError.CustomError("Error adding tokens"))
-                }
+                submitAdd(action.userWallet, scanResponse, currencyList)
             }
         }
     }
@@ -237,7 +105,7 @@ object TokensMiddleware {
         val config = CardConfig.createConfig(scanResponse.card)
         val derivationDataList = currencyList.mapNotNull { currency ->
             val curve = config.primaryCurve(blockchain = Blockchain.fromId(currency.network.id.value))
-            curve?.let { getNewDerivations(curve, scanResponse, currency) }
+            curve?.let { getDerivations(curve, scanResponse, currency) }
         }
         val derivations = buildMap<ByteArrayKey, MutableList<DerivationPath>> {
             derivationDataList.forEach {
@@ -286,42 +154,7 @@ object TokensMiddleware {
         }
     }
 
-    private fun getLegacyDerivations(
-        curve: EllipticCurve,
-        scanResponse: ScanResponse,
-        currency: Currency,
-    ): 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 DerivationData(derivations = mapKeyOfWalletPublicKey to toDerive)
-    }
-
-    private fun getNewDerivations(
+    private fun getDerivations(
         curve: EllipticCurve,
         scanResponse: ScanResponse,
         currency: CryptoCurrency,
@@ -359,28 +192,7 @@ object TokensMiddleware {
 
     class DerivationData(val derivations: Pair<ByteArrayKey, List<DerivationPath>>)
 
-    private fun submitLegacyAdd(scanResponse: ScanResponse, currencyList: List<Currency>) {
-        val selectedUserWallet = userWalletsListManager.selectedUserWalletSync.guard {
-            Timber.e("Unable to add currencies, no user wallet selected")
-            return
-        }
-        scope.launch {
-            userWalletsListManager.update(
-                userWalletId = selectedUserWallet.walletId,
-                update = { userWallet ->
-                    userWallet.copy(scanResponse = scanResponse)
-                },
-            )
-                .flatMap { updatedUserWallet ->
-                    walletCurrenciesManager.addCurrencies(
-                        userWallet = updatedUserWallet,
-                        currenciesToAdd = currencyList,
-                    )
-                }
-        }
-    }
-
-    private fun submitNewAdd(
+    private fun submitAdd(
         userWallet: UserWallet,
         updatedScanResponse: ScanResponse,
         currencyList: List<CryptoCurrency>,
@@ -398,16 +210,7 @@ object TokensMiddleware {
         store.dispatchOnMain(NavigationAction.PopBackTo())
     }
 
-    private suspend fun removeLegacyCurrenciesIfNeeded(currencies: List<Currency>) {
-        if (currencies.isEmpty()) return
-        val selectedUserWallet = userWalletsListManager.selectedUserWalletSync.guard {
-            Timber.e("Unable to remove currencies, no user wallet selected")
-            return
-        }
-        walletCurrenciesManager.removeCurrencies(selectedUserWallet, currencies)
-    }
-
-    private suspend fun removeNewCurrenciesIfNeeded(userWalletId: UserWalletId, currencies: List<CryptoCurrency>) {
+    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)