Updated on 2026-08-14

data/tokens/src/main/kotlin/com/tangem/data/tokens/AccountListCryptoCurrenciesFetcher.kt

@@ -3,8 +3,11 @@ package com.tangem.data.tokens
 import arrow.core.Either
 import arrow.core.right
 import com.tangem.data.common.account.WalletAccountsFetcher
+import com.tangem.datasource.api.tangemTech.models.account.flattenTokens
 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.core.utils.catchOn
+import com.tangem.domain.express.ExpressServiceFetcher
+import com.tangem.domain.express.models.ExpressAsset
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.isMultiCurrency
 import com.tangem.domain.tokens.MultiWalletCryptoCurrenciesFetcher
@@ -16,6 +19,7 @@ import com.tangem.utils.coroutines.CoroutineDispatcherProvider
  *
  * @property userWalletsStore      [UserWallet]'s store
  * @property walletAccountsFetcher instance of [WalletAccountsFetcher] to fetch accounts for a multi wallet
+ * @property expressServiceFetcher fetcher of express service
  * @property dispatchers           dispatchers
  *
 [REDACTED_AUTHOR]
@@ -23,6 +27,7 @@ import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 internal class AccountListCryptoCurrenciesFetcher(
     private val userWalletsStore: UserWalletsStore,
     private val walletAccountsFetcher: WalletAccountsFetcher,
+    private val expressServiceFetcher: ExpressServiceFetcher,
     private val dispatchers: CoroutineDispatcherProvider,
 ) : MultiWalletCryptoCurrenciesFetcher {
 
@@ -32,7 +37,14 @@ internal class AccountListCryptoCurrenciesFetcher(
 
             if (!userWallet.isMultiCurrency) error("${this::class.simpleName} supports only multi-currency wallet")
 
-            walletAccountsFetcher.fetch(userWalletId = params.userWalletId)
+            val response = walletAccountsFetcher.fetch(userWalletId = params.userWalletId)
+
+            expressServiceFetcher.fetch(
+                userWallet = userWallet,
+                assetIds = response.flattenTokens().mapTo(hashSetOf()) {
+                    ExpressAsset.ID(networkId = it.networkId, contractAddress = it.contractAddress)
+                },
+            )
 
             Unit.right()
         }

data/tokens/src/main/kotlin/com/tangem/data/tokens/di/MultiWalletCryptoCurrenciesFetcherModule.kt

@@ -41,6 +41,7 @@ internal class MultiWalletCryptoCurrenciesFetcherModule {
             AccountListCryptoCurrenciesFetcher(
                 userWalletsStore = userWalletsStore,
                 walletAccountsFetcher = walletAccountsFetcher,
+                expressServiceFetcher = expressServiceFetcher,
                 dispatchers = dispatchers,
             )
         } else {

data/tokens/src/test/kotlin/com/tangem/data/tokens/AccountListCryptoCurrenciesFetcherTest.kt

@@ -1,10 +1,13 @@
 package com.tangem.data.tokens
 
 import arrow.core.left
+import arrow.core.right
 import com.tangem.common.test.utils.assertEither
 import com.tangem.common.test.utils.assertEitherRight
 import com.tangem.data.common.account.WalletAccountsFetcher
+import com.tangem.datasource.api.tangemTech.models.account.GetWalletAccountsResponse
 import com.tangem.datasource.local.userwallet.UserWalletsStore
+import com.tangem.domain.express.ExpressServiceFetcher
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.domain.models.wallet.isMultiCurrency
@@ -21,11 +24,13 @@ internal class AccountListCryptoCurrenciesFetcherTest {
 
     private val userWalletsStore: UserWalletsStore = mockk(relaxUnitFun = true)
     private val walletAccountsFetcher: WalletAccountsFetcher = mockk(relaxUnitFun = true)
+    private val expressServiceFetcher: ExpressServiceFetcher = mockk()
     private val dispatchers = TestingCoroutineDispatcherProvider()
 
     private val fetcher = AccountListCryptoCurrenciesFetcher(
         userWalletsStore = userWalletsStore,
         walletAccountsFetcher = walletAccountsFetcher,
+        expressServiceFetcher = expressServiceFetcher,
         dispatchers = dispatchers,
     )
 
@@ -59,9 +64,11 @@ internal class AccountListCryptoCurrenciesFetcherTest {
         // Arrange
         val params = MultiWalletCryptoCurrenciesFetcher.Params(userWalletId = userWalletId)
         val mockUserWallet = mockk<UserWallet> { every { isMultiCurrency } returns true }
+        val response = mockk<GetWalletAccountsResponse>(relaxed = true)
 
         every { userWalletsStore.getSyncStrict(key = params.userWalletId) } returns mockUserWallet
-        coEvery { walletAccountsFetcher.fetch(userWalletId = params.userWalletId) } returns mockk()
+        coEvery { walletAccountsFetcher.fetch(userWalletId = params.userWalletId) } returns response
+        coEvery { expressServiceFetcher.fetch(userWallet = mockUserWallet, assetIds = emptySet()) } returns Unit.right()
 
         // Act
         val actual = fetcher(params)
@@ -72,6 +79,7 @@ internal class AccountListCryptoCurrenciesFetcherTest {
         coVerify(ordering = Ordering.SEQUENCE) {
             userWalletsStore.getSyncStrict(key = params.userWalletId)
             walletAccountsFetcher.fetch(userWalletId = params.userWalletId)
+            expressServiceFetcher.fetch(userWallet = mockUserWallet, assetIds = emptySet())
         }
     }
 

domain/account/status/build.gradle.kts

@@ -19,6 +19,7 @@ dependencies {
     api(projects.domain.account)
     api(projects.domain.core)
     api(projects.domain.common)
+    api(projects.domain.express)
     api(projects.domain.quotes)
     api(projects.domain.models)
     api(projects.domain.networks)

domain/account/status/src/main/java/com/tangem/domain/account/status/di/AccountStatusUseCaseModule.kt

@@ -5,9 +5,10 @@ import com.tangem.domain.account.status.supplier.SingleAccountStatusListSupplier
 import com.tangem.domain.account.status.usecase.GetAccountCurrencyByAddressUseCase
 import com.tangem.domain.account.status.usecase.GetAccountCurrencyStatusUseCase
 import com.tangem.domain.account.status.usecase.GetCryptoCurrencyActionsUseCaseV2
-import com.tangem.domain.account.status.usecase.SaveCryptoCurrenciesUseCase
+import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.account.supplier.SingleAccountListSupplier
 import com.tangem.domain.common.wallets.UserWalletsListRepository
+import com.tangem.domain.express.ExpressServiceFetcher
 import com.tangem.domain.networks.multi.MultiNetworkStatusFetcher
 import com.tangem.domain.networks.multi.MultiNetworkStatusSupplier
 import com.tangem.domain.networks.utils.NetworksCleaner
@@ -23,6 +24,8 @@ import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
 import javax.inject.Singleton
 
 @Module
@@ -78,9 +81,10 @@ internal object AccountStatusUseCaseModule {
         stakingIdFactory: StakingIdFactory,
         networksCleaner: NetworksCleaner,
         stakingCleaner: StakingCleaner,
+        expressServiceFetcher: ExpressServiceFetcher,
         dispatchers: CoroutineDispatcherProvider,
-    ): SaveCryptoCurrenciesUseCase {
-        return SaveCryptoCurrenciesUseCase(
+    ): ManageCryptoCurrenciesUseCase {
+        return ManageCryptoCurrenciesUseCase(
             singleAccountListSupplier = singleAccountListSupplier,
             accountsCRUDRepository = accountsCRUDRepository,
             currenciesRepository = currenciesRepository,
@@ -91,6 +95,8 @@ internal object AccountStatusUseCaseModule {
             stakingIdFactory = stakingIdFactory,
             networksCleaner = networksCleaner,
             stakingCleaner = stakingCleaner,
+            expressServiceFetcher = expressServiceFetcher,
+            parallelUpdatingScope = CoroutineScope(SupervisorJob() + dispatchers.default),
             dispatchers = dispatchers,
         )
     }

domain/account/status/src/main/java/com/tangem/domain/account/status/usecase/ManageCryptoCurrenciesUseCase.kt

@@ -7,6 +7,8 @@ import com.tangem.domain.account.producer.SingleAccountListProducer
 import com.tangem.domain.account.repository.AccountsCRUDRepository
 import com.tangem.domain.account.supplier.SingleAccountListSupplier
 import com.tangem.domain.core.utils.eitherOn
+import com.tangem.domain.express.ExpressServiceFetcher
+import com.tangem.domain.express.models.ExpressAsset
 import com.tangem.domain.models.account.Account
 import com.tangem.domain.models.account.AccountId
 import com.tangem.domain.models.currency.CryptoCurrency
@@ -41,7 +43,7 @@ import timber.log.Timber
 [REDACTED_AUTHOR]
  */
 @Suppress("LongParameterList")
-class SaveCryptoCurrenciesUseCase(
+class ManageCryptoCurrenciesUseCase(
     private val singleAccountListSupplier: SingleAccountListSupplier,
     private val accountsCRUDRepository: AccountsCRUDRepository,
     private val currenciesRepository: CurrenciesRepository,
@@ -52,6 +54,8 @@ class SaveCryptoCurrenciesUseCase(
     private val stakingIdFactory: StakingIdFactory,
     private val networksCleaner: NetworksCleaner,
     private val stakingCleaner: StakingCleaner,
+    private val expressServiceFetcher: ExpressServiceFetcher,
+    private val parallelUpdatingScope: CoroutineScope,
     private val dispatchers: CoroutineDispatcherProvider,
 ) {
 
@@ -85,10 +89,11 @@ class SaveCryptoCurrenciesUseCase(
 
             derivePublicKeys(userWalletId = userWalletId, currencies = modifiedCurrencyList.added)
 
-            val jobs = refreshBalances(userWalletId = userWalletId, currencies = modifiedCurrencyList.added) +
+            parallelUpdatingScope.launch {
+                refreshBalances(userWalletId = userWalletId, currencies = modifiedCurrencyList.added)
+                refreshExpress(userWalletId = userWalletId, currencies = modifiedCurrencyList.total)
                 clearMetadata(userWalletId = userWalletId, currencies = modifiedCurrencyList.removed)
-
-            jobs.joinAll()
+            }
         }
     }
 
@@ -114,7 +119,14 @@ class SaveCryptoCurrenciesUseCase(
 
             val tokenToAdd = findToken(userWalletId, contractAddress, networkId)
 
-            refreshBalances(userWalletId = userWalletId, currencies = listOf(tokenToAdd)).joinAll()
+            val modifiedCurrencyList = account.cryptoCurrencies.modify(add = listOf(tokenToAdd), remove = emptyList())
+
+            saveAccount(account = account.copy(cryptoCurrencies = modifiedCurrencyList.total.toSet()))
+
+            parallelUpdatingScope.launch {
+                refreshBalances(userWalletId = userWalletId, currencies = listOf(tokenToAdd))
+                refreshExpress(userWalletId = userWalletId, currencies = modifiedCurrencyList.total)
+            }
 
             tokenToAdd
         }
@@ -234,15 +246,13 @@ class SaveCryptoCurrenciesUseCase(
         )
     }
 
-    private suspend fun refreshBalances(userWalletId: UserWalletId, currencies: List<CryptoCurrency>): List<Job> {
-        if (currencies.isEmpty()) return emptyList()
+    private suspend fun refreshBalances(userWalletId: UserWalletId, currencies: List<CryptoCurrency>) {
+        if (currencies.isEmpty()) return
 
-        return coroutineScope {
-            listOf(
-                launch { refreshNetworks(userWalletId = userWalletId, currencies = currencies) },
-                launch { refreshYieldBalances(userWalletId = userWalletId, currencies = currencies) },
-                launch { refreshQuotes(currencies = currencies) },
-            )
+        coroutineScope {
+            launch { refreshNetworks(userWalletId = userWalletId, currencies = currencies) }
+            launch { refreshYieldBalances(userWalletId = userWalletId, currencies = currencies) }
+            launch { refreshQuotes(currencies = currencies) }
         }
     }
 
@@ -276,8 +286,25 @@ class SaveCryptoCurrenciesUseCase(
         )
     }
 
-    private suspend fun clearMetadata(userWalletId: UserWalletId, currencies: List<CryptoCurrency>): List<Job> {
-        if (currencies.isEmpty()) return emptyList()
+    private suspend fun refreshExpress(userWalletId: UserWalletId, currencies: List<CryptoCurrency>) {
+        if (currencies.isEmpty()) return
+
+        coroutineScope {
+            launch {
+                val assetIds = currencies.mapTo(hashSetOf()) {
+                    ExpressAsset.ID(
+                        networkId = it.network.backendId,
+                        contractAddress = (it as? CryptoCurrency.Token)?.contractAddress,
+                    )
+                }
+
+                expressServiceFetcher.fetch(userWalletId = userWalletId, assetIds = assetIds)
+            }
+        }
+    }
+
+    private suspend fun clearMetadata(userWalletId: UserWalletId, currencies: List<CryptoCurrency>) {
+        if (currencies.isEmpty()) return
 
         return coroutineScope {
             listOf(

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/utils/list/CustomTokenFormUseCasesFacade.kt

@@ -4,7 +4,7 @@ import arrow.core.Either
 import arrow.core.left
 import arrow.core.right
 import com.tangem.domain.account.producer.SingleAccountProducer
-import com.tangem.domain.account.status.usecase.SaveCryptoCurrenciesUseCase
+import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.account.supplier.SingleAccountSupplier
 import com.tangem.domain.managetokens.CheckIsCurrencyNotAddedUseCase
 import com.tangem.domain.models.currency.CryptoCurrency
@@ -20,14 +20,14 @@ internal class CustomTokenFormUseCasesFacade @AssistedInject constructor(
     private val addCryptoCurrenciesUseCase: AddCryptoCurrenciesUseCase,
     private val derivePublicKeysUseCase: DerivePublicKeysUseCase,
     private val checkIsCurrencyNotAddedUseCase: CheckIsCurrencyNotAddedUseCase,
-    private val saveCryptoCurrenciesUseCase: SaveCryptoCurrenciesUseCase,
+    private val manageCryptoCurrenciesUseCase: ManageCryptoCurrenciesUseCase,
     private val singleAccountSupplier: SingleAccountSupplier,
     @Assisted private val mode: AddCustomTokenMode,
 ) {
 
     suspend fun addCryptoCurrenciesUseCase(currency: CryptoCurrency): Either<Throwable, Unit> = when (mode) {
         is AddCustomTokenMode.Account -> {
-            saveCryptoCurrenciesUseCase(accountId = mode.accountId, add = currency)
+            manageCryptoCurrenciesUseCase(accountId = mode.accountId, add = currency)
         }
         is AddCustomTokenMode.Wallet -> {
             addCryptoCurrenciesUseCase.invoke(

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/utils/list/ManageTokensUseCasesFacade.kt

@@ -5,7 +5,7 @@ import arrow.core.left
 import arrow.core.right
 import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
 import com.tangem.domain.account.producer.SingleAccountProducer
-import com.tangem.domain.account.status.usecase.SaveCryptoCurrenciesUseCase
+import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.account.supplier.SingleAccountSupplier
 import com.tangem.domain.managetokens.*
 import com.tangem.domain.managetokens.model.CurrencyUnsupportedState
@@ -30,7 +30,7 @@ internal class ManageTokensUseCasesFacade @AssistedInject constructor(
     private val checkCurrencyUnsupportedUseCase: CheckCurrencyUnsupportedUseCase,
     private val coldWalletAndHasMissedDerivationsUseCase: ColdWalletAndHasMissedDerivationsUseCase,
     private val saveManagedTokensUseCase: SaveManagedTokensUseCase,
-    private val saveCryptoCurrenciesUseCase: SaveCryptoCurrenciesUseCase,
+    private val manageCryptoCurrenciesUseCase: ManageCryptoCurrenciesUseCase,
     private val customTokensRepository: CustomTokensRepository,
     private val accountsFeatureToggles: AccountsFeatureToggles,
     private val singleAccountSupplier: SingleAccountSupplier,
@@ -66,7 +66,7 @@ internal class ManageTokensUseCasesFacade @AssistedInject constructor(
                     currency = customCurrency,
                 )
 
-                saveCryptoCurrenciesUseCase(accountId = mode.accountId, remove = currency)
+                manageCryptoCurrenciesUseCase(accountId = mode.accountId, remove = currency)
             }
             is ManageTokensMode.Wallet -> removeCustomCurrencyUseCase.invoke(
                 userWalletId = mode.userWalletId,
@@ -140,7 +140,7 @@ internal class ManageTokensUseCasesFacade @AssistedInject constructor(
         currenciesToRemove: Map<ManagedCryptoCurrency.Token, Set<Network>>,
     ): Either<Throwable, Unit> = when (mode) {
         is ManageTokensMode.Account -> {
-            saveCryptoCurrenciesUseCase(
+            manageCryptoCurrenciesUseCase(
                 accountId = mode.accountId,
                 add = currenciesToAdd.mapToCryptoCurrencies(userWalletId = mode.accountId.userWalletId),
                 remove = currenciesToRemove.mapToCryptoCurrencies(userWalletId = mode.accountId.userWalletId),

features/markets/impl/src/main/kotlin/com/tangem/features/markets/portfolio/add/impl/model/AddTokenModel.kt

@@ -5,7 +5,7 @@ import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.Model
 import com.tangem.core.decompose.model.ParamsContainer
 import com.tangem.domain.account.status.usecase.GetAccountCurrencyStatusUseCase
-import com.tangem.domain.account.status.usecase.SaveCryptoCurrenciesUseCase
+import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.wallets.usecase.ColdWalletAndHasMissedDerivationsUseCase
 import com.tangem.features.markets.portfolio.add.api.SelectedNetwork
 import com.tangem.features.markets.portfolio.add.api.SelectedPortfolio
@@ -28,7 +28,7 @@ internal class AddTokenModel @Inject constructor(
     private val coldWalletAndHasMissedDerivationsUseCase: ColdWalletAndHasMissedDerivationsUseCase,
     override val dispatchers: CoroutineDispatcherProvider,
     private val analyticsEventHandler: AnalyticsEventHandler,
-    private val saveCryptoCurrenciesUseCase: SaveCryptoCurrenciesUseCase,
+    private val manageCryptoCurrenciesUseCase: ManageCryptoCurrenciesUseCase,
     private val getAccountCurrencyStatusUseCase: GetAccountCurrencyStatusUseCase,
 ) : Model() {
 
@@ -68,7 +68,7 @@ internal class AddTokenModel @Inject constructor(
             analyticsEventHandler.send(analyticsEventBuilder.addToPortfolioContinue(blockchainNames))
             val cryptoCurrency = selectedNetwork.cryptoCurrency
             val accountId = selectedPortfolio.account.account.account.accountId
-            saveCryptoCurrenciesUseCase(
+            manageCryptoCurrenciesUseCase(
                 accountId = accountId,
                 add = cryptoCurrency,
             )

features/referral/domain/src/main/java/com/tangem/feature/referral/domain/ReferralInteractorImpl.kt

@@ -2,7 +2,7 @@ package com.tangem.feature.referral.domain
 
 import arrow.core.getOrElse
 import com.tangem.common.core.TangemSdkError
-import com.tangem.domain.account.status.usecase.SaveCryptoCurrenciesUseCase
+import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.models.PortfolioId
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.wallet.UserWalletId
@@ -22,7 +22,7 @@ internal class ReferralInteractorImpl(
     private val derivePublicKeysUseCase: DerivePublicKeysUseCase,
     private val getUserWalletUseCase: GetUserWalletUseCase,
     private val addCryptoCurrenciesUseCase: AddCryptoCurrenciesUseCase,
-    private val saveCryptoCurrenciesUseCase: SaveCryptoCurrenciesUseCase,
+    private val manageCryptoCurrenciesUseCase: ManageCryptoCurrenciesUseCase,
 ) : ReferralInteractor {
 
     private val tokensForReferral = mutableListOf<TokenData>()
@@ -49,7 +49,7 @@ internal class ReferralInteractorImpl(
 
         when (portfolioId) {
             is PortfolioId.Account -> {
-                saveCryptoCurrenciesUseCase(accountId = portfolioId.accountId, add = cryptoCurrency)
+                manageCryptoCurrenciesUseCase(accountId = portfolioId.accountId, add = cryptoCurrency)
             }
             is PortfolioId.Wallet -> {
                 derivePublicKeysUseCase(userWallet.walletId, listOfNotNull(cryptoCurrency)).getOrElse {

features/referral/domain/src/main/java/com/tangem/feature/referral/domain/di/ReferralDomainModule.kt

@@ -2,7 +2,7 @@ package com.tangem.feature.referral.domain.di
 
 import com.tangem.core.decompose.di.ModelComponent
 import com.tangem.core.decompose.di.ModelScoped
-import com.tangem.domain.account.status.usecase.SaveCryptoCurrenciesUseCase
+import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.tokens.AddCryptoCurrenciesUseCase
 import com.tangem.domain.wallets.usecase.DerivePublicKeysUseCase
 import com.tangem.domain.wallets.usecase.GetUserWalletUseCase
@@ -26,7 +26,7 @@ class ReferralDomainModule {
         derivePublicKeysUseCase: DerivePublicKeysUseCase,
         getUserWalletUseCase: GetUserWalletUseCase,
         addCryptoCurrenciesUseCase: AddCryptoCurrenciesUseCase,
-        saveCryptoCurrenciesUseCase: SaveCryptoCurrenciesUseCase,
+        manageCryptoCurrenciesUseCase: ManageCryptoCurrenciesUseCase,
     ): ReferralInteractor {
         return ReferralInteractorImpl(
             repository = referralRepository,
@@ -34,7 +34,7 @@ class ReferralDomainModule {
             derivePublicKeysUseCase = derivePublicKeysUseCase,
             getUserWalletUseCase = getUserWalletUseCase,
             addCryptoCurrenciesUseCase = addCryptoCurrenciesUseCase,
-            saveCryptoCurrenciesUseCase = saveCryptoCurrenciesUseCase,
+            manageCryptoCurrenciesUseCase = manageCryptoCurrenciesUseCase,
         )
     }
 }

features/tokendetails/impl/src/main/kotlin/com/tangem/feature/tokendetails/presentation/tokendetails/model/TokenDetailsModel.kt

@@ -34,7 +34,7 @@ import com.tangem.core.ui.haptic.VibratorHapticManager
 import com.tangem.core.ui.message.SnackbarMessage
 import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
 import com.tangem.domain.account.status.usecase.GetAccountCurrencyStatusUseCase
-import com.tangem.domain.account.status.usecase.SaveCryptoCurrenciesUseCase
+import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
@@ -149,7 +149,7 @@ internal class TokenDetailsModel @Inject constructor(
     private val needShowYieldSupplyDepositedWarningUseCase: NeedShowYieldSupplyDepositedWarningUseCase,
     private val accountsFeatureToggles: AccountsFeatureToggles,
     private val getAccountCryptoCurrencyStatusUseCase: GetAccountCurrencyStatusUseCase,
-    private val saveCryptoCurrenciesUseCase: SaveCryptoCurrenciesUseCase,
+    private val manageCryptoCurrenciesUseCase: ManageCryptoCurrenciesUseCase,
 ) : Model(), TokenDetailsClickIntents, YieldSupplyDepositedWarningComponent.ModelCallback {
 
     private val params = paramsContainer.require<TokenDetailsComponent.Params>()
@@ -724,7 +724,7 @@ internal class TokenDetailsModel @Inject constructor(
                     return@launch
                 }
 
-                saveCryptoCurrenciesUseCase(accountId = accountId, remove = cryptoCurrency)
+                manageCryptoCurrenciesUseCase(accountId = accountId, remove = cryptoCurrency)
             } else {
                 removeCurrencyUseCase(userWalletId, cryptoCurrency)
             }

features/tokendetails/impl/src/main/kotlin/com/tangem/feature/tokendetails/presentation/tokendetails/state/factory/express/ExchangeStatusFactory.kt

@@ -6,7 +6,7 @@ import com.tangem.datasource.local.swap.ExpressAnalyticsStatus
 import com.tangem.datasource.local.swap.SwapTransactionStatusStore
 import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
 import com.tangem.domain.account.status.usecase.GetAccountCurrencyStatusUseCase
-import com.tangem.domain.account.status.usecase.SaveCryptoCurrenciesUseCase
+import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.models.account.AccountId
 import com.tangem.domain.models.currency.CryptoCurrency
@@ -41,7 +41,7 @@ internal class ExchangeStatusFactory @AssistedInject constructor(
     private val addCryptoCurrenciesUseCase: AddCryptoCurrenciesUseCase,
     private val accountsFeatureToggles: AccountsFeatureToggles,
     private val getAccountCurrencyStatusUseCase: GetAccountCurrencyStatusUseCase,
-    private val saveCryptoCurrenciesUseCase: SaveCryptoCurrenciesUseCase,
+    private val manageCryptoCurrenciesUseCase: ManageCryptoCurrenciesUseCase,
     private val swapTransactionStatusStore: SwapTransactionStatusStore,
     private val analyticsEventsHandler: AnalyticsEventHandler,
     @Assisted private val clickIntents: TokenDetailsClickIntents,
@@ -205,7 +205,7 @@ internal class ExchangeStatusFactory @AssistedInject constructor(
 
         if (refundNetwork == null || refundContractAddress == null) return null
 
-        return saveCryptoCurrenciesUseCase.add(
+        return manageCryptoCurrenciesUseCase.add(
             accountId = accountId,
             contractAddress = refundContractAddress,
             networkId = refundNetwork,

features/wallet/impl/src/main/java/com/tangem/feature/wallet/child/wallet/model/intents/WalletCurrencyActionsClickIntents.kt

@@ -24,7 +24,7 @@ import com.tangem.core.ui.haptic.TangemHapticEffect
 import com.tangem.core.ui.haptic.VibratorHapticManager
 import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
 import com.tangem.domain.account.status.usecase.GetAccountCurrencyStatusUseCase
-import com.tangem.domain.account.status.usecase.SaveCryptoCurrenciesUseCase
+import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
 import com.tangem.domain.appcurrency.extenstions.unwrap
 import com.tangem.domain.core.lce.Lce
@@ -157,7 +157,7 @@ internal class WalletCurrencyActionsClickIntentsImplementor @Inject constructor(
     private val removeCurrencyUseCase: RemoveCurrencyUseCase,
     private val accountsFeatureToggles: AccountsFeatureToggles,
     private val getAccountCurrencyStatusUseCase: GetAccountCurrencyStatusUseCase,
-    private val saveCryptoCurrenciesUseCase: SaveCryptoCurrenciesUseCase,
+    private val manageCryptoCurrenciesUseCase: ManageCryptoCurrenciesUseCase,
 ) : BaseWalletClickIntents(), WalletCurrencyActionsClickIntents {
 
     override fun onSendClick(
@@ -360,7 +360,7 @@ internal class WalletCurrencyActionsClickIntentsImplementor @Inject constructor(
                     return@launch
                 }
 
-                saveCryptoCurrenciesUseCase(accountId = accountId, remove = cryptoCurrencyStatus.currency)
+                manageCryptoCurrenciesUseCase(accountId = accountId, remove = cryptoCurrencyStatus.currency)
             } else {
                 removeCurrencyUseCase(userWalletId, cryptoCurrencyStatus.currency)
             }