Updated on 2026-08-14

domain/transaction/src/main/java/com/tangem/domain/transaction/usecase/AssociateAssetUseCase.kt

@@ -3,10 +3,12 @@ package com.tangem.domain.transaction.usecase
 import arrow.core.Either
 import arrow.core.raise.catch
 import arrow.core.raise.either
+import com.tangem.blockchain.common.TransactionSigner
 import com.tangem.blockchain.extensions.SimpleResult
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.network.NetworkStatus
+import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.domain.networks.single.SingleNetworkStatusProducer
 import com.tangem.domain.networks.single.SingleNetworkStatusSupplier
@@ -22,15 +24,13 @@ class AssociateAssetUseCase(
     private val walletManagersFacade: WalletManagersFacade,
     private val singleNetworkStatusSupplier: SingleNetworkStatusSupplier,
     private val multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
+    private val getHotTransactionSigner: (UserWallet.Hot) -> TransactionSigner,
 ) {
 
-    suspend operator fun invoke(
-        userWalletId: UserWalletId,
-        currency: CryptoCurrency,
-    ): Either<AssociateAssetError, Unit> {
+    suspend operator fun invoke(userWallet: UserWallet, currency: CryptoCurrency): Either<AssociateAssetError, Unit> {
         return either {
             val networkCoin = multiWalletCryptoCurrenciesSupplier.getSyncOrNull(
-                params = MultiWalletCryptoCurrenciesProducer.Params(userWalletId),
+                params = MultiWalletCryptoCurrenciesProducer.Params(userWallet.walletId),
             )
                 ?.firstOrNull {
                     val network = currency.network
@@ -38,18 +38,19 @@ class AssociateAssetUseCase(
                 }
                 ?: error("Unable to create network coin for currencyID: ${currency.id}")
 
-            if (isBalanceZero(userWalletId, networkCoin)) {
+            if (isBalanceZero(userWallet.walletId, networkCoin)) {
                 raise(AssociateAssetError.NotEnoughBalance(networkCoin))
             }
 
-            val signer = cardSdkConfigRepository.getCommonSigner(
-                cardId = null,
-                twinKey = null, // use null here because no assets support for Twin cards
-            )
+            val signer = createSigner(userWallet)
 
             catch(
                 block = {
-                    when (val result = walletManagersFacade.fulfillRequirements(userWalletId, currency, signer)) {
+                    when (val result = walletManagersFacade.fulfillRequirements(
+                        userWallet.walletId,
+                        currency,
+                        signer,
+                    )) {
                         is SimpleResult.Failure -> raise(AssociateAssetError.DataError(result.error.customMessage))
                         SimpleResult.Success -> Unit
                     }
@@ -59,6 +60,20 @@ class AssociateAssetUseCase(
         }
     }
 
+    private fun createSigner(userWallet: UserWallet): TransactionSigner {
+        return when (userWallet) {
+            is UserWallet.Hot -> getHotTransactionSigner(userWallet)
+            is UserWallet.Cold -> getColdSigner()
+        }
+    }
+
+    private fun getColdSigner(): TransactionSigner {
+        return cardSdkConfigRepository.getCommonSigner(
+            cardId = null,
+            twinKey = null, // use null here because no assets support for Twin cards
+        )
+    }
+
     private suspend fun isBalanceZero(userWalletId: UserWalletId, currency: CryptoCurrency): Boolean {
         val networkStatus = singleNetworkStatusSupplier(
             params = SingleNetworkStatusProducer.Params(

domain/transaction/src/main/java/com/tangem/domain/transaction/usecase/OpenTrustlineUseCase.kt

@@ -4,32 +4,32 @@ import arrow.core.Either
 import arrow.core.raise.catch
 import arrow.core.raise.either
 import com.tangem.blockchain.common.BlockchainSdkError
+import com.tangem.blockchain.common.TransactionSigner
 import com.tangem.blockchain.extensions.SimpleResult
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.transaction.error.OpenTrustlineError
 import com.tangem.domain.transaction.error.parseWrappedError
 import com.tangem.domain.walletmanager.WalletManagersFacade
-import com.tangem.domain.models.wallet.UserWalletId
 
 class OpenTrustlineUseCase(
     private val cardSdkConfigRepository: CardSdkConfigRepository,
     private val walletManagersFacade: WalletManagersFacade,
+    private val getHotTransactionSigner: (UserWallet.Hot) -> TransactionSigner,
 ) {
 
-    suspend operator fun invoke(
-        userWalletId: UserWalletId,
-        currency: CryptoCurrency,
-    ): Either<OpenTrustlineError, Unit> {
+    suspend operator fun invoke(userWallet: UserWallet, currency: CryptoCurrency): Either<OpenTrustlineError, Unit> {
         return either {
-            val signer = cardSdkConfigRepository.getCommonSigner(
-                cardId = null,
-                twinKey = null, // use null here because no assets support for Twin cards
-            )
+            val signer = createSigner(userWallet)
 
             catch(
                 block = {
-                    when (val result = walletManagersFacade.fulfillRequirements(userWalletId, currency, signer)) {
+                    when (val result = walletManagersFacade.fulfillRequirements(
+                        userWallet.walletId,
+                        currency,
+                        signer,
+                    )) {
                         is SimpleResult.Failure -> when (val error = result.error) {
                             is BlockchainSdkError.Stellar.MinReserveRequired ->
                                 raise(
@@ -58,4 +58,18 @@ class OpenTrustlineUseCase(
             )
         }
     }
+
+    private fun createSigner(userWallet: UserWallet): TransactionSigner {
+        return when (userWallet) {
+            is UserWallet.Hot -> getHotTransactionSigner(userWallet)
+            is UserWallet.Cold -> getColdSigner()
+        }
+    }
+
+    private fun getColdSigner(): TransactionSigner {
+        return cardSdkConfigRepository.getCommonSigner(
+            cardId = null,
+            twinKey = null, // use null here because no assets support for Twin cards
+        )
+    }
 }

domain/transaction/src/main/java/com/tangem/domain/transaction/usecase/RetryIncompleteTransactionUseCase.kt

@@ -4,33 +4,36 @@ import arrow.core.Either
 import arrow.core.raise.catch
 import arrow.core.raise.either
 import com.tangem.blockchain.common.BlockchainSdkError
+import com.tangem.blockchain.common.TransactionSigner
 import com.tangem.blockchain.extensions.SimpleResult
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.transaction.error.IncompleteTransactionError
 import com.tangem.domain.transaction.error.SendTransactionError
 import com.tangem.domain.transaction.error.parseWrappedError
 import com.tangem.domain.walletmanager.WalletManagersFacade
-import com.tangem.domain.models.wallet.UserWalletId
 
 class RetryIncompleteTransactionUseCase(
     private val cardSdkConfigRepository: CardSdkConfigRepository,
     private val walletManagersFacade: WalletManagersFacade,
+    private val getHotTransactionSigner: (UserWallet.Hot) -> TransactionSigner,
 ) {
 
     suspend operator fun invoke(
-        userWalletId: UserWalletId,
+        userWallet: UserWallet,
         currency: CryptoCurrency,
     ): Either<IncompleteTransactionError, Unit> {
         return either {
-            val signer = cardSdkConfigRepository.getCommonSigner(
-                cardId = null,
-                twinKey = null, // use null here because no assets support for Twin cards
-            )
+            val signer = createSigner(userWallet)
 
             catch(
                 block = {
-                    when (val result = walletManagersFacade.fulfillRequirements(userWalletId, currency, signer)) {
+                    when (val result = walletManagersFacade.fulfillRequirements(
+                        userWallet.walletId,
+                        currency,
+                        signer,
+                    )) {
                         is SimpleResult.Failure -> {
                             val error = result.error as? BlockchainSdkError
                             when (error) {
@@ -51,4 +54,18 @@ class RetryIncompleteTransactionUseCase(
             )
         }
     }
+
+    private fun createSigner(userWallet: UserWallet): TransactionSigner {
+        return when (userWallet) {
+            is UserWallet.Hot -> getHotTransactionSigner(userWallet)
+            is UserWallet.Cold -> getColdSigner()
+        }
+    }
+
+    private fun getColdSigner(): TransactionSigner {
+        return cardSdkConfigRepository.getCommonSigner(
+            cardId = null,
+            twinKey = null, // use null here because no assets support for Twin cards
+        )
+    }
 }

domain/transaction/src/main/java/com/tangem/domain/transaction/usecase/SendTransactionUseCase.kt

@@ -35,6 +35,7 @@ import com.tangem.domain.walletmanager.WalletManagersFacade
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import kotlin.coroutines.cancellation.CancellationException
 
 @Suppress("LongParameterList")
 class SendTransactionUseCase(
@@ -96,6 +97,8 @@ class SendTransactionUseCase(
                     is Result.Success -> sendResult.data.right()
                 }
             }
+        } catch (e: CancellationException) {
+            throw e
         } catch (ex: Exception) {
             cardSdkConfigRepository.setLinkedTerminal(linkedTerminal)
             SendTransactionError.DataError(ex.message).left()