Updated on 2026-08-14

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

@@ -5,52 +5,29 @@ import com.tangem.TangemSdk
 import com.tangem.blockchain.common.TransactionSigner
 import com.tangem.blockchain.common.Wallet
 import com.tangem.common.CompletionResult
-import com.tangem.tap.domain.tasks.SignHashTask
+import com.tangem.common.card.Card
 import com.tangem.tap.domain.tasks.SignHashesTask
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 
 class TangemSigner(
+    private val card: Card,
     private val tangemSdk: TangemSdk,
     private val initialMessage: Message,
     private val signerCallback: (TangemSignerResponse) -> Unit,
 ) : TransactionSigner {
 
-    override suspend fun sign(
-        hash: ByteArray,
-        publicKey: Wallet.PublicKey
-    ): CompletionResult<ByteArray> {
-        return suspendCoroutine { continuation ->
-            val command = SignHashTask(hash, publicKey)
-            tangemSdk.startSessionWithRunnable(
-                runnable = command,
-                initialMessage = initialMessage,
-            ) { result ->
-                when (result) {
-                    is CompletionResult.Success -> {
-                        signerCallback(
-                            TangemSignerResponse(
-                                result.data.totalSignedHashes,
-                                result.data.remainingSignatures
-                            )
-                        )
-                        continuation.resume(CompletionResult.Success(result.data.signature))
-                    }
-                    is CompletionResult.Failure ->
-                        continuation.resume(CompletionResult.Failure(result.error))
-                }
-            }
-        }
-    }
-
     override suspend fun sign(
         hashes: List<ByteArray>,
         publicKey: Wallet.PublicKey
     ): CompletionResult<List<ByteArray>> {
         return suspendCoroutine { continuation ->
+            val cardId = if (card.backupStatus?.isActive == true) null else card.cardId
+
             val task = SignHashesTask(hashes, publicKey)
             tangemSdk.startSessionWithRunnable(
                 runnable = task,
+                cardId = cardId,
                 initialMessage = initialMessage,
             ) { result ->
                 when (result) {
@@ -69,6 +46,21 @@ class TangemSigner(
             }
         }
     }
+
+    override suspend fun sign(
+        hash: ByteArray,
+        publicKey: Wallet.PublicKey
+    ): CompletionResult<ByteArray> {
+        val result = sign(
+            hashes = listOf(hash),
+            publicKey = publicKey
+        )
+
+        return when (result) {
+            is CompletionResult.Success -> CompletionResult.Success(result.data.first())
+            is CompletionResult.Failure -> CompletionResult.Failure(result.error)
+        }
+    }
 }
 
 data class TangemSignerResponse(

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

@@ -175,7 +175,11 @@ private fun sendTransaction(
             tangemSdk.config.linkedTerminal = false
         }
 
-        val signer = TangemSigner(tangemSdk, action.messageForSigner) { signResponse ->
+        val signer = TangemSigner(
+            card = card,
+            tangemSdk = tangemSdk,
+            initialMessage = action.messageForSigner
+        ) { signResponse ->
             store.dispatch(
                 GlobalAction.UpdateWalletSignedHashes(
                     walletSignedHashes = signResponse.totalSignedHashes,

app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/TradeCryptoMiddleware.kt

@@ -45,6 +45,7 @@ class TradeCryptoMiddleware {
 
         val selectedWalletData = store.state.walletState.getSelectedWalletData() ?: return
         val exchangeManager = store.state.globalState.exchangeManager ?: return
+        val card = store.state.globalState.scanResponse?.card ?: return
         val appCurrency = store.state.globalState.appCurrency
 
         val addresses = selectedWalletData.walletAddresses?.list.orEmpty()
@@ -59,7 +60,13 @@ class TradeCryptoMiddleware {
                 return
             }
 
-            scope.launch { exchangeManager.buyErc20TestnetTokens(walletManager, currency.token) }
+            scope.launch {
+                exchangeManager.buyErc20TestnetTokens(
+                    card = card,
+                    walletManager = walletManager,
+                    token = currency.token
+                )
+            }
             return
         }
 

app/src/main/java/com/tangem/tap/network/exchangeServices/CurrencyExchangeManager.kt

@@ -7,6 +7,7 @@ import com.tangem.blockchain.common.AmountType
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Token
 import com.tangem.blockchain.extensions.Result
+import com.tangem.common.card.Card
 import com.tangem.tap.common.extensions.safeUpdate
 import com.tangem.tap.common.redux.global.CryptoCurrencyName
 import com.tangem.tap.common.redux.global.GlobalAction
@@ -68,7 +69,11 @@ class CurrencyExchangeManager(
     enum class Action { Buy, Sell }
 }
 
-suspend fun CurrencyExchangeManager.buyErc20TestnetTokens(walletManager: EthereumWalletManager, token: Token) {
+suspend fun CurrencyExchangeManager.buyErc20TestnetTokens(
+    card: Card,
+    walletManager: EthereumWalletManager,
+    token: Token,
+) {
     walletManager.safeUpdate()
 
     val amountToSend = Amount(walletManager.wallet.blockchain)
@@ -85,7 +90,9 @@ suspend fun CurrencyExchangeManager.buyErc20TestnetTokens(walletManager: Ethereu
     val transaction = walletManager.createTransaction(amountToSend, fee, destinationAddress)
 
     val signer = TangemSigner(
-        tangemSdk = tangemSdk, Message()
+        card = card,
+        tangemSdk = tangemSdk,
+        initialMessage = Message(),
     ) { signResponse ->
         store.dispatch(
             GlobalAction.UpdateWalletSignedHashes(