Updated on 2026-08-14

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

@@ -32,7 +32,7 @@ import com.tangem.tap.common.analytics.AnalyticsParam
 import com.tangem.tap.domain.tasks.CreateWalletAndRescanTask
 import com.tangem.tap.domain.tasks.product.ResetToFactorySettingsTask
 import com.tangem.tap.domain.tasks.product.ScanProductTask
-import com.tangem.tap.domain.tokens.CurrenciesRepository
+import com.tangem.tap.domain.tokens.UserTokensRepository
 import com.tangem.tap.features.demo.DemoHelper
 import com.tangem.wallet.R
 import kotlinx.coroutines.Dispatchers
@@ -45,7 +45,7 @@ class TangemSdkManager(private val tangemSdk: TangemSdk, private val context: Co
 
     suspend fun scanProduct(
         analyticsHandler: AnalyticsHandler?,
-        currenciesRepository: CurrenciesRepository,
+        userTokensRepository: UserTokensRepository,
         additionalBlockchainsToDerive: Collection<Blockchain>? = null,
         messageRes: Int? = null,
     ): CompletionResult<ScanResponse> {
@@ -53,8 +53,8 @@ class TangemSdkManager(private val tangemSdk: TangemSdk, private val context: Co
 
         val message = Message(context.getString(messageRes ?: R.string.initial_message_scan_header))
         return runTaskAsyncReturnOnMain(
-            runnable = ScanProductTask(null, currenciesRepository, additionalBlockchainsToDerive),
-            cardId = null, initialMessage = message
+            runnable = ScanProductTask(null, userTokensRepository, additionalBlockchainsToDerive),
+            cardId = null, initialMessage = message,
         ).also { sendScanResultsToAnalytics(analyticsHandler, it) }
     }
 

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

@@ -2,6 +2,7 @@ package com.tangem.tap.domain
 
 import androidx.annotation.StringRes
 import com.tangem.common.core.TangemError
+import com.tangem.network.api.tangemTech.TangemTechError
 import com.tangem.wallet.R
 
 interface TapErrors
@@ -66,7 +67,6 @@ sealed class TapSdkError(override val messageResId: Int?) : Throwable(), TangemE
     object CardNotSupportedByRelease : TapSdkError(R.string.error_update_app)
 }
 
-
 fun TapErrors.assembleErrors(): MutableList<Pair<Int, List<Any>?>> {
     val idList = mutableListOf<Pair<Int, List<Any>?>>()
     when (this) {
@@ -74,4 +74,13 @@ fun TapErrors.assembleErrors(): MutableList<Pair<Int, List<Any>?>> {
         is TapError -> idList.add(Pair(this.messageResource, this.args))
     }
     return idList
-}
+}
+
+fun TangemTechError.toTapError(): TapError {
+    return when (this.code) {
+        404 -> NoDataError(this.description)
+        else -> TapError.CustomError(customMessage = this.description)
+    }
+}
+
+class NoDataError(message: String) : TapError.CustomError(customMessage = message)

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

@@ -16,7 +16,6 @@ import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.extensions.safeUpdate
 import com.tangem.tap.common.redux.global.GlobalAction
-import com.tangem.tap.currenciesRepository
 import com.tangem.tap.domain.configurable.config.ConfigManager
 import com.tangem.tap.domain.extensions.isMultiwalletAllowed
 import com.tangem.tap.domain.extensions.makePrimaryWalletManager
@@ -24,23 +23,21 @@ import com.tangem.tap.domain.extensions.makeWalletManagersForApp
 import com.tangem.tap.domain.tokens.models.BlockchainNetwork
 import com.tangem.tap.features.demo.isDemoCard
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectAction
+import com.tangem.tap.features.wallet.models.toBlockchainNetworks
 import com.tangem.tap.features.wallet.redux.WalletAction
 import com.tangem.tap.network.NetworkConnectivity
 import com.tangem.tap.store
+import com.tangem.tap.userTokensRepository
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
-
 class TapWalletManager {
     val walletManagerFactory: WalletManagerFactory
-            by lazy { WalletManagerFactory(blockchainSdkConfig) }
-
+        by lazy { WalletManagerFactory(blockchainSdkConfig) }
     val rates: RatesRepository = RatesRepository()
-
     private val blockchainSdkConfig by lazy {
         store.state.globalState.configManager?.config?.blockchainSdkConfig ?: BlockchainSdkConfig()
     }
-
     private val walletManagersThrottler =
         ThrottlerWithValues<BlockchainNetwork, Result<Wallet>>(10000)
 
@@ -65,16 +62,16 @@ class TapWalletManager {
                             WalletAction.LoadWallet.NoAccount(
                                 walletManager.wallet,
                                 blockchainNetwork,
-                                (result.error as TapError.WalletManager.NoAccountError).customMessage
-                            )
+                                (result.error as TapError.WalletManager.NoAccountError).customMessage,
+                            ),
                         )
                     }
                     else -> {
                         dispatchOnMain(
                             WalletAction.LoadWallet.Failure(
                                 walletManager.wallet,
-                                result.error.localizedMessage
-                            )
+                                result.error.localizedMessage,
+                            ),
                         )
                     }
                 }
@@ -139,22 +136,52 @@ class TapWalletManager {
     }
 
     private suspend fun loadMultiWalletData(
-        scanResponse: ScanResponse
+        scanResponse: ScanResponse,
     ) {
-        val savedCurrencies = currenciesRepository.loadSavedCurrencies(
-            scanResponse.card.cardId, scanResponse.card.settings.isHDWalletAllowed
-        )
-        if (savedCurrencies.isEmpty()) return
+        when (val tokensResult = userTokensRepository.getUserTokens(scanResponse.card)) {
+            is Result.Success -> {
+                withMainContext {
+                    val blockchainNetworks = tokensResult.data.toBlockchainNetworks()
+                    val walletManagers = walletManagerFactory.makeWalletManagersForApp(scanResponse, tokensResult.data)
+                    store.dispatch(
+                        WalletAction.MultiWallet.AddBlockchains(
+                            blockchains = blockchainNetworks,
+                            walletManagers = walletManagers,
+                            save = false,
+                        ),
+                    )
 
-        val walletManagers =
-            walletManagerFactory.makeWalletManagersForApp(scanResponse, savedCurrencies)
-        dispatchOnMain(
-            WalletAction.MultiWallet.AddBlockchains(savedCurrencies, walletManagers),
-        )
-        savedCurrencies.map {
-            if (it.tokens.isNotEmpty()) {
-                dispatchOnMain(WalletAction.MultiWallet.AddTokens(it.tokens, it))
+                    blockchainNetworks.filter { it.tokens.isNotEmpty() }
+                        .map {
+                            store.dispatch(
+                                WalletAction.MultiWallet.AddTokens(
+                                    tokens = it.tokens,
+                                    blockchain = it,
+                                    save = false,
+                                ),
+                            )
+                        }
+                    checkIfDerivationsAreMissing(blockchainNetworks, scanResponse)
+                }
             }
+            is Result.Failure -> {
+                return
+            }
+        }
+    }
+
+    private fun checkIfDerivationsAreMissing(blockchainNetworks: List<BlockchainNetwork>, scanResponse: ScanResponse) {
+        blockchainNetworks.map {
+            if (it.tokens.isNotEmpty()) {
+                WalletAction.MultiWallet.AddTokens(it.tokens, it, false)
+            }
+        }
+        val missingDerivations = blockchainNetworks
+            .filter {
+                it.derivationPath != null && !scanResponse.hasDerivation(it.blockchain, it.derivationPath)
+            }
+        if (missingDerivations.isNotEmpty()) {
+            store.dispatch(WalletAction.MultiWallet.AddMissingDerivations(missingDerivations))
         }
     }
 
@@ -172,9 +199,10 @@ class TapWalletManager {
             }
             dispatchOnMain(
                 WalletAction.MultiWallet.AddBlockchains(
-                    listOf(BlockchainNetwork.fromWalletManager(primaryWalletManager)),
-                    listOf(primaryWalletManager)
-                )
+                    blockchains = listOf(BlockchainNetwork.fromWalletManager(primaryWalletManager)),
+                    walletManagers = listOf(primaryWalletManager),
+                    save = false,
+                ),
             )
         }
     }

app/src/main/java/com/tangem/tap/domain/extensions/WalletManagerFactory.kt

@@ -1,6 +1,10 @@
 package com.tangem.tap.domain.extensions
 
-import com.tangem.blockchain.common.*
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.DerivationParams
+import com.tangem.blockchain.common.DerivationStyle
+import com.tangem.blockchain.common.WalletManager
+import com.tangem.blockchain.common.WalletManagerFactory
 import com.tangem.common.card.Card
 import com.tangem.common.card.CardWallet
 import com.tangem.common.card.EllipticCurve
@@ -99,9 +103,11 @@ fun WalletManagerFactory.makeWalletManagerForApp(
 }
 
 fun WalletManagerFactory.makeWalletManagersForApp(
-    scanResponse: ScanResponse, blockchains: List<BlockchainNetwork>,
+    scanResponse: ScanResponse, blockchains: List<Currency>,
 ): List<WalletManager> {
-    return blockchains.mapNotNull { this.makeWalletManagerForApp(scanResponse, it) }
+    return blockchains
+        .filter { it.isBlockchain() }
+        .mapNotNull { this.makeWalletManagerForApp(scanResponse, it) }
 }
 
 fun WalletManagerFactory.makePrimaryWalletManager(

app/src/main/java/com/tangem/tap/domain/tasks/product/ScanProductTask.kt

@@ -32,16 +32,14 @@ import com.tangem.operations.issuerAndUserData.ReadIssuerDataCommand
 import com.tangem.tap.domain.TapSdkError
 import com.tangem.tap.domain.extensions.getPrimaryCurve
 import com.tangem.tap.domain.extensions.getSingleWallet
-import com.tangem.tap.domain.tokens.CurrenciesRepository
+import com.tangem.tap.domain.tokens.UserTokensRepository
 import com.tangem.tap.domain.tokens.models.BlockchainNetwork
 import com.tangem.tap.preferencesStorage
-import com.tangem.tap.scope
-import kotlinx.coroutines.launch
 
 class ScanProductTask(
     val card: Card? = null,
-    private val currenciesRepository: CurrenciesRepository?,
-    private val additionalBlockchainsToDerive: Collection<Blockchain>? = null
+    private val userTokensRepository: UserTokensRepository?,
+    private val additionalBlockchainsToDerive: Collection<Blockchain>? = null,
 ) : CardSessionRunnable<ScanResponse> {
 
     override fun run(
@@ -62,7 +60,7 @@ class ScanProductTask(
         val commandProcessor = when {
             card.isTangemNote() -> ScanNoteProcessor()
             card.isTangemTwins() -> ScanTwinProcessor()
-            else -> ScanWalletProcessor(currenciesRepository, additionalBlockchainsToDerive)
+            else -> ScanWalletProcessor(userTokensRepository, additionalBlockchainsToDerive)
         }
         commandProcessor.proceed(card, session) { processorResult ->
             when (processorResult) {
@@ -111,8 +109,8 @@ private class ScanNoteProcessor : ProductCommandProcessor<ScanResponse> {
 }
 
 private class ScanWalletProcessor(
-    private val currenciesRepository: CurrenciesRepository?,
-    private val additionalBlockchainsToDerive: Collection<Blockchain>? = null
+    private val userTokensRepository: UserTokensRepository?,
+    private val additionalBlockchainsToDerive: Collection<Blockchain>? = null,
 ) : ProductCommandProcessor<ScanResponse> {
 
     var primaryCard: PrimaryCard? = null
@@ -184,47 +182,41 @@ private class ScanWalletProcessor(
         session: CardSession,
         callback: (result: CompletionResult<ScanResponse>) -> Unit,
     ) {
-        scope.launch {
-            val derivations = collectDerivations(card)
-            if (derivations.isEmpty() || !card.settings.isHDWalletAllowed) {
-                callback(
-                    CompletionResult.Success(
-                        ScanResponse(
-                            card = card,
-                            productType = ProductType.Wallet,
-                            walletData = session.environment.walletData,
-                            primaryCard = primaryCard
-                        )
-                    )
-                )
-                return@launch
-            }
+        val derivations = collectDerivations(card)
+        if (derivations.isEmpty() || !card.settings.isHDWalletAllowed) {
+            callback(
+                CompletionResult.Success(
+                    ScanResponse(
+                        card = card,
+                        productType = ProductType.Wallet,
+                        walletData = session.environment.walletData,
+                        primaryCard = primaryCard,
+                    ),
+                ),
+            )
+            return
+        }
 
-            DeriveMultipleWalletPublicKeysTask(derivations).run(session) { result ->
-                when (result) {
-                    is CompletionResult.Success -> {
-                        val response = ScanResponse(
-                            card = card,
-                            productType = ProductType.Wallet,
-                            walletData = session.environment.walletData,
-                            derivedKeys = result.data.entries,
-                            primaryCard = primaryCard
-                        )
-                        callback(CompletionResult.Success(response))
-                    }
-                    is CompletionResult.Failure -> callback(CompletionResult.Failure(result.error))
+        DeriveMultipleWalletPublicKeysTask(derivations).run(session) { result ->
+            when (result) {
+                is CompletionResult.Success -> {
+                    val response = ScanResponse(
+                        card = card,
+                        productType = ProductType.Wallet,
+                        walletData = session.environment.walletData,
+                        derivedKeys = result.data.entries,
+                        primaryCard = primaryCard,
+                    )
+                    callback(CompletionResult.Success(response))
                 }
+                is CompletionResult.Failure -> callback(CompletionResult.Failure(result.error))
             }
         }
     }
 
-    private suspend fun getBlockchainsToDerive(card: Card): List<BlockchainNetwork> {
-        val currenciesRepository = currenciesRepository ?: return emptyList()
-
-        val cardCurrencies = currenciesRepository
-            .loadSavedCurrencies(card.cardId, card.settings.isHDWalletAllowed).toMutableList()
-
-        val blockchainsToDerive = cardCurrencies.ifEmpty {
+    private fun getBlockchainsToDerive(card: Card): List<BlockchainNetwork> {
+        val userTokensRepository = userTokensRepository ?: return emptyList()
+        val blockchainsToDerive = userTokensRepository.loadBlockchainsToDerive(card).toMutableList().ifEmpty {
             mutableListOf(
                 BlockchainNetwork(Blockchain.Bitcoin, card),
                 BlockchainNetwork(Blockchain.Ethereum, card),
@@ -236,7 +228,7 @@ private class ScanWalletProcessor(
                 listOf(
                     BlockchainNetwork(Blockchain.Ethereum, card),
                     BlockchainNetwork(Blockchain.EthereumTestnet, card),
-                )
+                ),
             )
         }
         if (additionalBlockchainsToDerive != null) {
@@ -256,16 +248,14 @@ private class ScanWalletProcessor(
         return blockchainsToDerive.distinct()
     }
 
-    private suspend fun collectDerivations(card: Card): Map<ByteArrayKey, List<DerivationPath>> {
+    private fun collectDerivations(card: Card): Map<ByteArrayKey, List<DerivationPath>> {
         val blockchains = getBlockchainsToDerive(card)
         val derivations = mutableMapOf<ByteArrayKey, List<DerivationPath>>()
 
         blockchains.forEach { blockchain ->
             val curve = blockchain.blockchain.getPrimaryCurve()
-
             val wallet = card.wallets.firstOrNull { it.curve == curve } ?: return@forEach
             if (wallet.chainCode == null) return@forEach
-
             val key = wallet.publicKey.toMapKey()
             val path = blockchain.derivationPath?.let { DerivationPath(it) }
             if (path != null) {

app/src/main/java/com/tangem/tap/domain/tokens/CurrenciesRepository.kt

@@ -1,247 +1,12 @@
 package com.tangem.tap.domain.tokens
 
-import android.app.Application
-import android.content.Context
-import com.squareup.moshi.JsonAdapter
-import com.squareup.moshi.Types
 import com.tangem.blockchain.common.Blockchain
-import com.tangem.blockchain.common.DerivationStyle
-import com.tangem.blockchain.common.Token
 import com.tangem.common.card.FirmwareVersion
-import com.tangem.common.services.Result
-import com.tangem.domain.common.extensions.getTokens
-import com.tangem.domain.common.extensions.toNetworkId
-import com.tangem.network.api.tangemTech.TangemTechService
-import com.tangem.network.common.MoshiConverter
-import com.tangem.tap.common.extensions.appendIf
-import com.tangem.tap.common.extensions.readJsonFileToString
-import com.tangem.tap.domain.tokens.models.BlockchainNetwork
-import com.tangem.tap.domain.tokens.models.ObsoleteTokenDao
-import com.tangem.tap.domain.tokens.models.TokenDao
-import com.tangem.tap.features.demo.DemoHelper
-import kotlinx.coroutines.async
-import kotlinx.coroutines.coroutineScope
-import timber.log.Timber
-import java.util.*
-
-class CurrenciesRepository(
-    private val context: Application,
-    private val tangemNetworkService: TangemTechService
-) {
-
-    private val moshi = MoshiConverter.defaultMoshi()
-    private val blockchainsAdapter: JsonAdapter<List<Blockchain>> = moshi.adapter(
-        Types.newParameterizedType(List::class.java, Blockchain::class.java)
-    )
-    private val tokensAdapter: JsonAdapter<List<TokenDao>> = moshi.adapter(
-        Types.newParameterizedType(List::class.java, TokenDao::class.java)
-    )
-    private val obsoleteTokensAdapter: JsonAdapter<List<ObsoleteTokenDao>> = moshi.adapter(
-        Types.newParameterizedType(List::class.java, ObsoleteTokenDao::class.java)
-    )
-    private val currenciesAdapter: JsonAdapter<CurrenciesFromJson> =
-        moshi.adapter(CurrenciesFromJson::class.java)
-
-    private val blockchainNetworkAdapter: JsonAdapter<List<BlockchainNetwork>> =
-        moshi.adapter(Types.newParameterizedType(List::class.java, BlockchainNetwork::class.java))
-
-    fun saveUpdatedCurrency(cardId: String, blockchainNetwork: BlockchainNetwork) {
-        var changed = false
-        val currencies = loadSavedCurrenciesWithoutMigration(cardId).map {
-            if (it == blockchainNetwork) {
-                changed = true
-                blockchainNetwork
-            } else {
-                it
-            }
-        }
-        val updatedCurrencies = if (changed) currencies else currencies + blockchainNetwork
-        saveCurrencies(cardId, updatedCurrencies.distinct())
-    }
-
-    fun removeToken(cardId: String, token: Token, blockchainNetwork: BlockchainNetwork) {
-        val currencies = loadSavedCurrenciesWithoutMigration(cardId).map {
-            if (it == blockchainNetwork) {
-                it.copy(tokens = it.tokens.filterNot { it == token })
-            } else {
-                it
-            }
-        }
-        saveCurrencies(cardId, currencies)
-    }
-
-    fun removeBlockchain(cardId: String, blockchainNetwork: BlockchainNetwork) {
-        val currencies = loadSavedCurrenciesWithoutMigration(cardId)
-            .filterNot { it == blockchainNetwork }
-        saveCurrencies(cardId, currencies)
-    }
-
-    fun removeCurrencies(cardId: String) {
-        saveCurrencies(cardId, emptyList())
-    }
-
-    @Deprecated("Use BlockchainNetwork instead")
-    private fun loadSavedTokens(cardId: String): List<TokenDao> {
-        val json = try {
-            context.readFileText(getFileNameForTokens(cardId))
-        } catch (exception: Exception) {
-            return emptyList()
-        }
-
-        return try {
-            tokensAdapter.fromJson(json) ?: emptyList()
-        } catch (exception: Exception) {
-            emptyList()
-        }
-    }
-
-    @Deprecated("Use BlockchainNetwork instead")
-    private fun loadSavedBlockchains(cardId: String): List<Blockchain> {
-        return try {
-            val json = context.readFileText(getFileNameForBlockchains(cardId))
-            blockchainsAdapter.fromJson(json)?.distinct() ?: emptyList()
-        } catch (exception: Exception) {
-            emptyList()
-        }
-    }
-
-    suspend fun loadSavedCurrencies(
-        cardId: String,
-        isHdWalletSupported: Boolean = false
-    ): List<BlockchainNetwork> {
-        if (DemoHelper.isDemoCardId(cardId)) {
-            return loadDemoCurrencies()
-        }
-        return try {
-            val json = context.readFileText(getFileNameForBlockchains(cardId))
-            blockchainNetworkAdapter.fromJson(json)?.distinct() ?: emptyList()
-        } catch (exception: Exception) {
-            tryToLoadPreviousFormatAndMigrate(cardId, isHdWalletSupported)
-        }
-    }
-
-    fun loadSavedCurrenciesWithoutMigration(
-        cardId: String,
-    ): List<BlockchainNetwork> {
-        if (DemoHelper.isDemoCardId(cardId)) {
-            return loadDemoCurrencies()
-        }
-        return try {
-            val json = context.readFileText(getFileNameForBlockchains(cardId))
-            blockchainNetworkAdapter.fromJson(json)?.distinct() ?: emptyList()
-        } catch (exception: Exception) {
-            emptyList()
-        }
-    }
-
-    private fun loadDemoCurrencies(): List<BlockchainNetwork> {
-        return DemoHelper.config.demoBlockchains.map {
-            BlockchainNetwork(
-                blockchain = it,
-                derivationPath = it.derivationPath(DerivationStyle.LEGACY)?.rawPath,
-                tokens = emptyList()
-            )
-        }
-    }
-
-    private suspend fun tryToLoadPreviousFormatAndMigrate(
-        cardId: String,
-        isHdWalletSupported: Boolean = false
-    ): List<BlockchainNetwork> {
-        return try {
-            loadSavedCurrenciesOldWay(
-                cardId,
-                isHdWalletSupported
-            )
-        } catch (exception: Exception) {
-            emptyList()
-        }
-    }
-
-    private suspend fun loadSavedCurrenciesOldWay(
-        cardId: String, isHdWalletSupported: Boolean = false
-    ): List<BlockchainNetwork> {
-        val blockchains = loadSavedBlockchains(cardId)
-        val tokens = loadSavedTokens(cardId)
-        val ids = getTokensIds(tokens)
-        val derivationStyle = if (isHdWalletSupported) DerivationStyle.LEGACY else null
-        val blockchainNetworks = blockchains.map { blockchain ->
-            BlockchainNetwork(
-                blockchain = blockchain,
-                derivationPath = blockchain.derivationPath(derivationStyle)?.rawPath,
-                tokens = tokens
-                    .filter { it.blockchainDao.toBlockchain() == blockchain }
-                    .map {
-                        val token = it.toToken()
-                        token.copy(id = ids[token.contractAddress])
-                    }
-            )
-        }
-        saveCurrencies(cardId, blockchainNetworks) // migrate saved currencies
-        return blockchainNetworks
-    }
-
-    private suspend fun getTokensIds(tokens: List<TokenDao>): Map<String, String> = coroutineScope {
-        tokens.map {
-            async {
-                tangemNetworkService.getTokens(
-                    contractAddress = it.contractAddress,
-                    networkId = it.blockchainDao.toBlockchain().toNetworkId(),
-                    active = true,
-                )
-            }
-        }.map { it.await() }
-            .map { (it as? Result.Success)?.data?.coins?.firstOrNull()?.id }
-            .mapIndexedNotNull { index, id ->
-                if (id == null) null else tokens[index].contractAddress to id
-            }.toMap()
-    }
-
-    fun saveCurrencies(cardId: String, currencies: List<BlockchainNetwork>) {
-        val json = blockchainNetworkAdapter.toJson(currencies)
-        context.rewriteFile(json, getFileNameForBlockchains(cardId))
-    }
-
-    private fun Context.readFileText(fileName: String): String =
-        this.openFileInput(fileName).bufferedReader().readText()
-
-    private fun Context.rewriteFile(content: String, fileName: String) {
-        this.openFileOutput(fileName, Context.MODE_PRIVATE).use {
-            it.write(content.toByteArray(), 0, content.length)
-        }
-    }
-
-    fun getTestnetCoins(): List<Currency> {
-        val json = context.assets.readJsonFileToString(FILE_NAME_TESTNET_COINS)
-        return currenciesAdapter.fromJson(json)!!.coins
-            .map { Currency.fromJsonObject(it) }
-    }
-
-    private fun loadTokensJson(blockchain: Blockchain): String? {
-        val fileName = getFileName(blockchain)
-        return try {
-            context.assets.readJsonFileToString(fileName)
-        } catch (ex: Exception) {
-            Timber.e(ex, "Tokens with the file name %s not found", fileName)
-            null
-        }
-    }
-
-    private fun getFileName(blockchain: Blockchain): String {
-        return StringBuilder().apply {
-            append(blockchain.id.lowercase(Locale.getDefault()).replace("/test", ""))
-            append("_tokens")
-            appendIf("_testnet") { blockchain.isTestnet() }
-        }.toString()
-    }
-
-    private fun fromJsonToTokensDao(tokenJson: String, blockchain: Blockchain): List<TokenDao> {
-        return obsoleteTokensAdapter.fromJson(tokenJson)!!.map { it.toTokenDao(blockchain) }
-    }
 
+object CurrenciesRepository {
     fun getBlockchains(
         cardFirmware: FirmwareVersion,
-        isTestNet: Boolean = false
+        isTestNet: Boolean = false,
     ): List<Blockchain> {
         val blockchains = if (cardFirmware < FirmwareVersion.MultiWalletAvailable) {
             Blockchain.secp256k1Blockchains(isTestNet)
@@ -261,21 +26,6 @@ class CurrenciesRepository(
             )
         }
     }
-
-    companion object {
-        private const val FILE_NAME_PREFIX_TOKENS = "tokens"
-        private const val FILE_NAME_PREFIX_BLOCKCHAINS = "blockchains"
-        private const val FILE_NAME_TESTNET_COINS = "testnet_tokens"
-
-        fun getFileNameForTokens(cardId: String): String = "${FILE_NAME_PREFIX_TOKENS}_$cardId"
-        fun getFileNameForBlockchains(cardId: String): String =
-            "${FILE_NAME_PREFIX_BLOCKCHAINS}_$cardId"
-    }
 }
 
-fun Blockchain.getTokensName(): String {
-    return when (this) {
-        Blockchain.Fantom -> "Fantom Opera"
-        else -> this.fullName
-    }
-}
+

app/src/main/java/com/tangem/tap/domain/tokens/LoadAvailableCoinsService.kt

@@ -1,29 +1,36 @@
 package com.tangem.tap.domain.tokens
 
+import com.squareup.moshi.JsonAdapter
+import com.squareup.moshi.Moshi
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.common.services.Result
 import com.tangem.domain.common.extensions.getListOfCoins
 import com.tangem.domain.common.extensions.toNetworkId
 import com.tangem.network.api.tangemTech.CoinsResponse
 import com.tangem.network.api.tangemTech.TangemTechService
+import com.tangem.network.common.MoshiConverter
+import com.tangem.tap.common.AssetReader
 
 class LoadAvailableCoinsService(
     private val networkService: TangemTechService,
-    private val currenciesRepository: CurrenciesRepository
+    private val assetReader: AssetReader,
 ) {
+    private val moshi: Moshi by lazy { MoshiConverter.defaultMoshi() }
+    private val currenciesAdapter: JsonAdapter<CurrenciesFromJson> =
+        moshi.adapter(CurrenciesFromJson::class.java)
 
     suspend fun getSupportedTokens(
         isTestNet: Boolean = false,
         supportedBlockchains: List<Blockchain>,
         page: Int,
-        searchInput: String? = null
+        searchInput: String? = null,
     ): Result<LoadedCoins> {
         if (isTestNet) {
             return Result.Success(
                 LoadedCoins(
-                    currencies = currenciesRepository.getTestnetCoins().filter(searchInput),
+                    currencies = getTestnetCoins().filter(searchInput),
                     moreAvailable = false,
-                )
+                ),
             )
         }
         val offset = page * LOAD_PER_PAGE
@@ -56,21 +63,28 @@ class LoadAvailableCoinsService(
             active = true,
             offset = offset,
             limit = LOAD_PER_PAGE,
-            searchText = searchInput
+            searchText = searchInput,
         )
     }
 
+    fun getTestnetCoins(): List<Currency> {
+        val json = assetReader.readAssetAsString(FILE_NAME_TESTNET_COINS)
+        return currenciesAdapter.fromJson(json)!!.coins
+            .map { Currency.fromJsonObject(it) }
+    }
+
     private fun List<Currency>.filter(searchInput: String?): List<Currency> {
         if (searchInput.isNullOrBlank()) return this
 
-        return filter{
+        return filter {
             it.symbol.contains(searchInput, ignoreCase = true) ||
-                    it.name.contains(searchInput, ignoreCase = true)
+                it.name.contains(searchInput, ignoreCase = true)
         }
     }
 
     companion object {
         const val LOAD_PER_PAGE = 100
+        private const val FILE_NAME_TESTNET_COINS = "testnet_tokens"
     }
 }
 

app/src/main/java/com/tangem/tap/domain/tokens/OldUserTokensRepository.kt

@@ -0,0 +1,130 @@
+package com.tangem.tap.domain.tokens
+
+import com.squareup.moshi.JsonAdapter
+import com.squareup.moshi.Types
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.DerivationStyle
+import com.tangem.common.services.Result
+import com.tangem.domain.common.extensions.getTokens
+import com.tangem.domain.common.extensions.toNetworkId
+import com.tangem.network.api.tangemTech.TangemTechService
+import com.tangem.network.common.MoshiConverter
+import com.tangem.tap.common.FileReader
+import com.tangem.tap.domain.tokens.models.BlockchainNetwork
+import com.tangem.tap.domain.tokens.models.TokenDao
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+
+@Deprecated("Use this only for migration")
+class OldUserTokensRepository(
+    private val fileReader: FileReader,
+    private val tangemNetworkService: TangemTechService,
+) {
+    private val moshi = MoshiConverter.defaultMoshi()
+    private val blockchainsAdapter: JsonAdapter<List<Blockchain>> = moshi.adapter(
+        Types.newParameterizedType(List::class.java, Blockchain::class.java),
+    )
+    private val tokensAdapter: JsonAdapter<List<TokenDao>> = moshi.adapter(
+        Types.newParameterizedType(List::class.java, TokenDao::class.java),
+    )
+    private val blockchainNetworkAdapter: JsonAdapter<List<BlockchainNetwork>> =
+        moshi.adapter(Types.newParameterizedType(List::class.java, BlockchainNetwork::class.java))
+
+    @Deprecated("Use BlockchainNetwork instead")
+    private fun loadSavedTokens(cardId: String): List<TokenDao> {
+        val json = try {
+            fileReader.readFile(getFileNameForTokens(cardId))
+        } catch (exception: Exception) {
+            return emptyList()
+        }
+
+        return try {
+            tokensAdapter.fromJson(json) ?: emptyList()
+        } catch (exception: Exception) {
+            emptyList()
+        }
+    }
+
+    @Deprecated("Use BlockchainNetwork instead")
+    private fun loadSavedBlockchains(cardId: String): List<Blockchain> {
+        return try {
+            val json = fileReader.readFile(getFileNameForBlockchains(cardId))
+            blockchainsAdapter.fromJson(json)?.distinct() ?: emptyList()
+        } catch (exception: Exception) {
+            emptyList()
+        }
+    }
+
+    @Deprecated("Use TokensRepository instead")
+    suspend fun loadSavedCurrencies(
+        cardId: String,
+        isHdWalletSupported: Boolean = false,
+    ): List<BlockchainNetwork> {
+        return try {
+            val json = fileReader.readFile(getFileNameForBlockchains(cardId))
+            blockchainNetworkAdapter.fromJson(json)?.distinct() ?: emptyList()
+        } catch (exception: Exception) {
+            tryToLoadPreviousFormatAndMigrate(cardId, isHdWalletSupported)
+        }
+    }
+
+    private suspend fun tryToLoadPreviousFormatAndMigrate(
+        cardId: String,
+        isHdWalletSupported: Boolean = false,
+    ): List<BlockchainNetwork> {
+        return try {
+            loadSavedCurrenciesOldWay(
+                cardId,
+                isHdWalletSupported,
+            )
+        } catch (exception: Exception) {
+            emptyList()
+        }
+    }
+
+    private suspend fun loadSavedCurrenciesOldWay(
+        cardId: String, isHdWalletSupported: Boolean = false,
+    ): List<BlockchainNetwork> {
+        val blockchains = loadSavedBlockchains(cardId)
+        val tokens = loadSavedTokens(cardId)
+        val ids = getTokensIds(tokens)
+        val derivationStyle = if (isHdWalletSupported) DerivationStyle.LEGACY else null
+        val blockchainNetworks = blockchains.map { blockchain ->
+            BlockchainNetwork(
+                blockchain = blockchain,
+                derivationPath = blockchain.derivationPath(derivationStyle)?.rawPath,
+                tokens = tokens
+                    .filter { it.blockchainDao.toBlockchain() == blockchain }
+                    .map {
+                        val token = it.toToken()
+                        token.copy(id = ids[token.contractAddress])
+                    },
+            )
+        }
+        return blockchainNetworks
+    }
+
+    private suspend fun getTokensIds(tokens: List<TokenDao>): Map<String, String> = coroutineScope {
+        tokens.map {
+            async {
+                tangemNetworkService.getTokens(
+                    contractAddress = it.contractAddress,
+                    networkId = it.blockchainDao.toBlockchain().toNetworkId(),
+                    active = true,
+                )
+            }
+        }.map { it.await() }
+            .map { (it as? Result.Success)?.data?.coins?.firstOrNull()?.id }
+            .mapIndexedNotNull { index, id ->
+                if (id == null) null else tokens[index].contractAddress to id
+            }.toMap()
+    }
+
+    companion object {
+        private const val FILE_NAME_PREFIX_TOKENS = "tokens"
+        private const val FILE_NAME_PREFIX_BLOCKCHAINS = "blockchains"
+        private fun getFileNameForTokens(cardId: String): String = "${FILE_NAME_PREFIX_TOKENS}_$cardId"
+        private fun getFileNameForBlockchains(cardId: String): String =
+            "${FILE_NAME_PREFIX_BLOCKCHAINS}_$cardId"
+    }
+}

app/src/main/java/com/tangem/tap/domain/tokens/UserTokensNetworkService.kt

@@ -0,0 +1,30 @@
+package com.tangem.tap.domain.tokens
+
+import com.tangem.common.core.TangemSdkError
+import com.tangem.common.services.Result
+import com.tangem.network.api.tangemTech.TangemTechService
+import com.tangem.network.api.tangemTech.UserTokensResponse
+import com.tangem.tap.domain.NoDataError
+import com.tangem.tap.features.wallet.models.Currency
+
+class UserTokensNetworkService(private val tangemTechService: TangemTechService) {
+    suspend fun getUserTokens(userId: String): Result<UserTokensResponse> {
+        return when (val result = tangemTechService.getUserTokens(userId)) {
+            is Result.Success -> result
+            is Result.Failure -> {
+                val error = result.error
+                if (error is TangemSdkError.NetworkError && error.customMessage.contains("404")) {
+                    return Result.Failure(NoDataError(error.customMessage))
+                } else {
+                    return result
+                }
+            }
+        }
+    }
+
+    suspend fun saveUserTokens(userId: String, tokens: List<Currency>): Result<Unit> {
+        val tokensResponse = tokens.map { it.toTokenResponse() }
+        val data = UserTokensResponse(tokens = tokensResponse)
+        return tangemTechService.putUserTokens(userId, data)
+    }
+}

app/src/main/java/com/tangem/tap/domain/tokens/UserTokensRepository.kt

@@ -0,0 +1,117 @@
+package com.tangem.tap.domain.tokens
+
+import android.content.Context
+import com.tangem.blockchain.common.DerivationStyle
+import com.tangem.common.card.Card
+import com.tangem.common.extensions.calculateSha256
+import com.tangem.common.extensions.toHexString
+import com.tangem.common.services.Result
+import com.tangem.domain.common.extensions.calculateHmacSha256
+import com.tangem.network.api.tangemTech.TangemTechService
+import com.tangem.tap.common.AndroidFileReader
+import com.tangem.tap.domain.NoDataError
+import com.tangem.tap.domain.tokens.models.BlockchainNetwork
+import com.tangem.tap.features.demo.DemoHelper
+import com.tangem.tap.features.wallet.models.Currency
+import com.tangem.tap.features.wallet.models.toBlockchainNetworks
+import com.tangem.tap.features.wallet.models.toCurrencies
+import com.tangem.tap.network.NetworkConnectivity
+import com.tangem.tap.store
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+
+class UserTokensRepository(
+    private val storageService: UserTokensStorageService,
+    private val networkService: UserTokensNetworkService,
+) {
+    suspend fun getUserTokens(card: Card): Result<List<Currency>> {
+        if (DemoHelper.isDemoCardId(card.cardId)) {
+            return Result.Success(loadDemoCurrencies())
+        }
+        val userId = card.getUserId()
+        if (!NetworkConnectivity.getInstance().isOnlineOrConnecting()) {
+            return Result.Success(loadTokensOffline(card, userId))
+        }
+
+        return when (val networkResult = networkService.getUserTokens(userId)) {
+            is Result.Success -> {
+                val tokens = networkResult.data.tokens.map { Currency.fromTokenResponse(it) }
+                storageService.saveUserTokens(card.getUserId(), tokens)
+                Result.Success(tokens)
+            }
+            is Result.Failure -> {
+                handleGetUserTokensFailure(card = card, userId = userId, error = networkResult.error)
+            }
+        }
+    }
+
+    suspend fun saveUserTokens(card: Card, tokens: List<Currency>) {
+        networkService.saveUserTokens(card.getUserId(), tokens)
+        storageService.saveUserTokens(card.getUserId(), tokens)
+    }
+
+    suspend fun removeUserTokens(card: Card) {
+        networkService.saveUserTokens(card.getUserId(), emptyList())
+        storageService.saveUserTokens(card.getUserId(), emptyList())
+    }
+
+    fun loadBlockchainsToDerive(card: Card): List<BlockchainNetwork> {
+        return storageService.getUserTokens(card.getUserId())?.toBlockchainNetworks() ?: emptyList()
+    }
+
+    private fun loadDemoCurrencies(): List<Currency> {
+        return DemoHelper.config.demoBlockchains.map {
+            BlockchainNetwork(
+                blockchain = it,
+                derivationPath = it.derivationPath(DerivationStyle.LEGACY)?.rawPath,
+                tokens = emptyList(),
+            )
+        }.flatMap { it.toCurrencies() }
+    }
+
+    private suspend fun handleGetUserTokensFailure(
+        card: Card,
+        userId: String,
+        error: Throwable,
+    ): Result<List<Currency>> {
+        return when (error) {
+            is NoDataError -> {
+                val tokens = storageService.getUserTokens(card)
+                coroutineScope { launch { networkService.saveUserTokens(userId = userId, tokens = tokens) } }
+                Result.Success(tokens)
+            }
+            else -> {
+                val tokens = storageService.getUserTokens(userId) ?: storageService.getUserTokens(card)
+                Result.Success(tokens)
+            }
+        }
+    }
+
+    private suspend fun loadTokensOffline(card: Card, userId: String): List<Currency> {
+        return storageService.getUserTokens(userId) ?: storageService.getUserTokens(card)
+    }
+
+    private fun Card.getUserId(): String {
+        val walletPublicKey = this.wallets.firstOrNull()?.publicKey ?: return ""
+        return calculateUserId(walletPublicKey)
+    }
+
+    private fun calculateUserId(walletPublicKey: ByteArray): String {
+        val message = MESSAGE.toByteArray()
+        val keyHash = walletPublicKey.calculateSha256()
+        return message.calculateHmacSha256(keyHash).toHexString()
+    }
+
+    companion object {
+        const val MESSAGE = "AccountID"
+        fun init(context: Context, tangemTechService: TangemTechService): UserTokensRepository {
+            val fileReader = AndroidFileReader(context)
+            val oldUserTokensRepository = OldUserTokensRepository(
+                fileReader, store.state.domainNetworks.tangemTechService,
+            )
+            val storageService = UserTokensStorageService(oldUserTokensRepository, fileReader)
+            val networkService = UserTokensNetworkService(tangemTechService)
+            return UserTokensRepository(storageService, networkService)
+        }
+    }
+}

app/src/main/java/com/tangem/tap/domain/tokens/UserTokensStorageService.kt

@@ -0,0 +1,48 @@
+package com.tangem.tap.domain.tokens
+
+import com.squareup.moshi.JsonAdapter
+import com.tangem.Log
+import com.tangem.common.card.Card
+import com.tangem.network.api.tangemTech.UserTokensResponse
+import com.tangem.network.common.MoshiConverter
+import com.tangem.tap.common.FileReader
+import com.tangem.tap.features.wallet.models.Currency
+import com.tangem.tap.features.wallet.models.toCurrencies
+
+class UserTokensStorageService(
+    private val oldUserTokensRepository: OldUserTokensRepository,
+    private val fileReader: FileReader,
+) {
+    private val moshi = MoshiConverter.defaultMoshi()
+    private val userTokensAdapter: JsonAdapter<UserTokensResponse> =
+        moshi.adapter(UserTokensResponse::class.java)
+
+    fun getUserTokens(userId: String): List<Currency>? {
+        return try {
+            val json = fileReader.readFile(getFileNameForUserTokens(userId))
+            userTokensAdapter.fromJson(json)?.tokens?.map { Currency.fromTokenResponse(it) }
+        } catch (exception: Exception) {
+            Log.error { exception.stackTraceToString() }
+            null
+        }
+    }
+
+    @Deprecated("")
+    suspend fun getUserTokens(card: Card): List<Currency> {
+        val blockchainNetworks =
+            oldUserTokensRepository.loadSavedCurrencies(card.cardId, card.settings.isHDWalletAllowed)
+        return blockchainNetworks.flatMap { it.toCurrencies() }
+    }
+
+    fun saveUserTokens(userId: String, tokens: List<Currency>) {
+        val tokensResponse = tokens.map { it.toTokenResponse() }
+        val data = UserTokensResponse(tokens = tokensResponse)
+        val json = userTokensAdapter.toJson(data)
+        fileReader.rewriteFile(json, getFileNameForUserTokens(userId))
+    }
+
+    companion object {
+        private const val FILE_NAME_PREFIX_USER_TOKENS = "user_tokens"
+        private fun getFileNameForUserTokens(userId: String): String = "${FILE_NAME_PREFIX_USER_TOKENS}_$userId"
+    }
+}

app/src/main/java/com/tangem/tap/domain/walletconnect/WcWalletManagerFactory.kt

@@ -1,64 +0,0 @@
-package com.tangem.tap.domain.walletconnect
-
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.blockchain.common.WalletManager
-import com.tangem.blockchain.common.WalletManagerFactory
-import com.tangem.domain.common.ScanResponse
-import com.tangem.domain.common.TapWorkarounds.isTestCard
-import com.tangem.tap.domain.extensions.makeWalletManagerForApp
-import com.tangem.tap.domain.tokens.CurrenciesRepository
-import com.tangem.tap.domain.tokens.models.BlockchainNetwork
-import com.tangem.tap.features.details.redux.walletconnect.WalletForSession
-import com.tangem.tap.features.wallet.redux.WalletState
-
-class WcWalletManagerFactory(
-    private val factory: WalletManagerFactory,
-    private val currenciesRepository: CurrenciesRepository,
-) {
-    fun getWalletManager(
-        wallet: WalletForSession, blockchain: Blockchain, walletState: WalletState,
-    ): WalletManager? {
-        val blockchainToMake = if (blockchain == Blockchain.Ethereum && wallet.isTestNet) {
-            Blockchain.EthereumTestnet
-        } else {
-            blockchain
-        }
-        val blockchainNetwork = BlockchainNetwork(
-            blockchain = blockchainToMake,
-            derivationPath = wallet.derivationPath?.rawPath,
-            tokens = emptyList(),
-        )
-        return walletState.getWalletManager(blockchainNetwork)
-    }
-
-    suspend fun getWalletManager(
-        scanResponse: ScanResponse, blockchain: Blockchain, walletState: WalletState,
-    ): WalletManager? {
-        val card = scanResponse.card
-        val blockchainToMake = if (blockchain == Blockchain.Ethereum && card.isTestCard) {
-            Blockchain.EthereumTestnet
-        } else {
-            blockchain
-        }
-        val blockchainNetwork = BlockchainNetwork(
-            blockchain = blockchainToMake,
-            card = card,
-        )
-
-        return if (walletState.cardId == card.cardId) {
-            walletState.getWalletManager(blockchainNetwork)
-        } else {
-            if (currenciesRepository
-                    .loadSavedCurrencies(card.cardId, card.settings.isHDWalletAllowed)
-                    .contains(blockchainNetwork)
-            ) {
-                factory.makeWalletManagerForApp(
-                    scanResponse = scanResponse,
-                    blockchainNetwork = blockchainNetwork,
-                )
-            } else {
-                null
-            }
-        }
-    }
-}