Updated on 2026-08-14

core/res/src/main/res/values/strings.xml

@@ -681,7 +681,7 @@
     <string name="warning_express_no_exchangeable_coins_title">No available tokens to swap</string>
     <string name="warning_express_not_enough_fee_for_token_tx_description">To make a transaction you need to deposit some %1$s %2$s</string>
     <string name="warning_express_not_enough_fee_for_token_tx_title">Unable to cover %s fee</string>
-    <string name="warning_express_refresh_required_title">Service temporary unavailable</string>
+    <string name="warning_express_refresh_required_title">Service temporarily unavailable</string>
     <string name="warning_express_too_minimal_amount_description">Please change the amount to swap</string>
     <string name="warning_express_too_minimal_amount_title">The amount to swap must be at least %s</string>
     <string name="warning_failed_to_verify_card_message">This card might be a production sample or counterfeit</string>

features/swap/data/src/main/java/com/tangem/feature/swap/SwapRepositoryImpl.kt

@@ -9,6 +9,7 @@ import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Token
 import com.tangem.blockchain.extensions.Result
 import com.tangem.data.tokens.utils.CryptoCurrencyFactory
+import com.tangem.datasource.api.common.response.ApiResponse
 import com.tangem.datasource.api.common.response.ApiResponseError
 import com.tangem.datasource.api.common.response.getOrThrow
 import com.tangem.datasource.api.express.TangemExpressApi
@@ -28,6 +29,7 @@ import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.feature.swap.converters.*
 import com.tangem.feature.swap.domain.SwapRepository
 import com.tangem.feature.swap.domain.models.DataError
+import com.tangem.feature.swap.domain.models.ExpressException
 import com.tangem.feature.swap.domain.models.createFromAmountWithOffset
 import com.tangem.feature.swap.domain.models.data.AggregatedSwapDataModel
 import com.tangem.feature.swap.domain.models.domain.*
@@ -62,49 +64,61 @@ internal class SwapRepositoryImpl @Inject constructor(
         currencyList: List<CryptoCurrency>,
     ): PairsWithProviders {
         return withContext(coroutineDispatcher.io) {
-            val initial = NetworkLeastTokenInfo(
-                contractAddress = initialCurrency.contractAddress,
-                network = initialCurrency.network,
-            )
-            val currenciesList = currencyList.map { leastTokenInfoConverter.convert(it) }
-
-            val pairs = async {
-                getPairsInternal(
-                    from = arrayListOf(initial),
-                    to = currenciesList,
+            try {
+                val initial = NetworkLeastTokenInfo(
+                    contractAddress = initialCurrency.contractAddress,
+                    network = initialCurrency.network,
                 )
+                val currenciesList = currencyList.map { leastTokenInfoConverter.convert(it) }
+
+                val pairsDeferred = async {
+                    getPairsInternal(
+                        from = arrayListOf(initial),
+                        to = currenciesList,
+                    )
+                }
+
+                val reversedPairsDeferred = async {
+                    getPairsInternal(
+                        from = currenciesList,
+                        to = arrayListOf(initial),
+                    )
+                }
+
+                val pairs = pairsDeferred.await().getOrThrow()
+                val reversedPairs = reversedPairsDeferred.await().getOrThrow()
+
+                val allPairs = pairs + reversedPairs
+
+                val providers = tangemExpressApi.getProviders().getOrThrow()
+
+                return@withContext swapPairInfoConverter.convert(
+                    SwapPairsWithProviders(
+                        swapPair = allPairs,
+                        providers = providers,
+                    ),
+                )
+            } catch (exception: Exception) {
+                if (exception is ApiResponseError.HttpException) {
+                    throw ExpressException(errorsDataConverter.convert(exception.errorBody ?: ""))
+                } else {
+                    throw exception
+                }
             }
 
-            val reversedPairs = async {
-                getPairsInternal(
-                    from = currenciesList,
-                    to = arrayListOf(initial),
-                )
-            }
-
-            val allPairs = pairs.await() + reversedPairs.await()
-
-            val providers = tangemExpressApi.getProviders().getOrThrow()
-
-            return@withContext swapPairInfoConverter.convert(
-                SwapPairsWithProviders(
-                    swapPair = allPairs,
-                    providers = providers,
-                ),
-            )
         }
     }
 
     private suspend fun getPairsInternal(
         from: List<NetworkLeastTokenInfo>,
         to: List<NetworkLeastTokenInfo>,
-    ): List<SwapPair> {
+    ): ApiResponse<List<SwapPair>> {
         return tangemExpressApi.getPairs(
             PairsRequestBody(
                 from = from,
                 to = to,
             ),
-        ).getOrThrow()
+        )
     }
 
     override suspend fun getExchangeStatus(txId: String): Either<UnknownError, ExchangeStatusModel> {

features/swap/domain/src/main/java/com/tangem/feature/swap/domain/models/ExpressException.kt

@@ -0,0 +1,3 @@
+package com.tangem.feature.swap.domain.models
+
+class ExpressException(val dataError: DataError) : Exception()

features/swap/presentation/src/main/java/com/tangem/feature/swap/ui/StateBuilder.kt

@@ -579,14 +579,18 @@ internal class StateBuilder(
         }
     }
 
-    fun createInitialErrorState(uiState: SwapStateHolder, onRefreshClick: () -> Unit): SwapStateHolder {
+    fun createInitialErrorState(
+        uiState: SwapStateHolder,
+        code: Int,
+        onRefreshClick: () -> Unit,
+    ): SwapStateHolder {
         return uiState.copy(
             warnings = listOf(
                 SwapWarning.GeneralWarning(
                     notificationConfig = NotificationConfig(
                         title = TextReference.Res(R.string.warning_express_refresh_required_title),
-                        subtitle = TextReference.EMPTY,
-                        iconResId = R.drawable.ic_alert_circle_24,
+                        subtitle = TextReference.Res(R.string.generic_error_code, wrappedList(code)),
+                        iconResId = R.drawable.ic_alert_triangle_20,
                         buttonsState = NotificationConfig.ButtonsState.PrimaryButtonConfig(
                             text = TextReference.Res(R.string.warning_button_refresh),
                             onClick = onRefreshClick,

features/swap/presentation/src/main/java/com/tangem/feature/swap/viewmodels/SwapViewModel.kt

@@ -18,6 +18,7 @@ import com.tangem.feature.swap.analytics.SwapEvents
 import com.tangem.feature.swap.domain.BlockchainInteractor
 import com.tangem.feature.swap.domain.SwapInteractor
 import com.tangem.feature.swap.domain.models.DataError
+import com.tangem.feature.swap.domain.models.ExpressException
 import com.tangem.feature.swap.domain.models.domain.PermissionOptions
 import com.tangem.feature.swap.domain.models.domain.SwapDataModel
 import com.tangem.feature.swap.domain.models.domain.SwapProvider
@@ -174,13 +175,14 @@ internal class SwapViewModel @Inject constructor(
                     selectedCurrency = null,
                 )
 
-                uiState = stateBuilder.createInitialErrorState(uiState) {
-                    uiState = stateBuilder.createInitialLoadingState(
-                        initialCurrency = initialCryptoCurrency,
-                        networkInfo = blockchainInteractor.getBlockchainInfo(initialCryptoCurrency.network.backendId),
-                    )
-                    initTokens()
-                }
+                uiState =
+                    stateBuilder.createInitialErrorState(uiState, (it as? ExpressException)?.dataError?.code ?: DataError.UnknownError.code) {
+                        uiState = stateBuilder.createInitialLoadingState(
+                            initialCurrency = initialCryptoCurrency,
+                            networkInfo = blockchainInteractor.getBlockchainInfo(initialCryptoCurrency.network.backendId),
+                        )
+                        initTokens()
+                    }
             }
         }
     }