Updated on 2026-08-14

app/src/main/java/com/tangem/tap/common/feedback/AdditionalFeedbackInfo.kt

@@ -89,19 +89,19 @@ class AdditionalFeedbackInfo {
 
     fun updateOnSendError(
         walletManager: WalletManager,
-        amountToSend: Amount,
+        amountToSend: Amount?,
         feeAmount: Amount?,
-        destinationAddress: String,
+        destinationAddress: String?,
     ) {
         onSendErrorWalletInfo = createEmailWalletInfo(walletManager)
-        this.destinationAddress = destinationAddress
-        amount = amountToSend.value?.stripZeroPlainString() ?: "0"
+        this.destinationAddress = destinationAddress ?: "0"
+        amount = amountToSend?.value?.stripZeroPlainString() ?: "0"
         fee = if (feeAmount != null) {
             feeAmount.value?.stripZeroPlainString() ?: "0"
         } else {
             "Unable to receive"
         }
-        token = if (amountToSend.type is AmountType.Token) amountToSend.currencySymbol else ""
+        token = if (amountToSend?.type is AmountType.Token) amountToSend.currencySymbol else ""
     }
 
     private fun createEmailWalletInfo(walletManager: WalletManager): EmailWalletInfo {

app/src/main/java/com/tangem/tap/common/redux/legacy/LegacyMiddleware.kt

@@ -1,11 +1,16 @@
 package com.tangem.tap.common.redux.legacy
 
 import com.tangem.domain.redux.LegacyAction
+import com.tangem.domain.tokens.utils.convertToAmount
+import com.tangem.tap.common.extensions.inject
 import com.tangem.tap.common.feedback.RateCanBeBetterEmail
 import com.tangem.tap.common.feedback.SendTransactionFailedEmail
 import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.common.redux.global.GlobalAction
+import com.tangem.tap.proxy.redux.DaggerGraphState
+import com.tangem.tap.scope
 import com.tangem.tap.store
+import kotlinx.coroutines.launch
 import org.rekotlin.Middleware
 
 internal object LegacyMiddleware {
@@ -22,9 +27,29 @@ internal object LegacyMiddleware {
                         )
                     }
                     is LegacyAction.SendEmailTransactionFailed -> {
-                        store.state.globalState.feedbackManager?.sendEmail(
-                            SendTransactionFailedEmail(action.errorMessage),
-                        )
+                        if (store.inject(DaggerGraphState::feedbackManagerFeatureToggles).isLocalLogsEnabled) {
+                            store.state.globalState.feedbackManager?.sendEmail(
+                                SendTransactionFailedEmail(action.errorMessage),
+                            )
+                        } else {
+                            scope.launch {
+                                store.inject(DaggerGraphState::walletManagersFacade)
+                                    .getOrCreateWalletManager(
+                                        userWalletId = action.userWalletId,
+                                        network = action.cryptoCurrency.network,
+                                    )?.let { walletManager ->
+                                        store.state.globalState.feedbackManager?.infoHolder?.updateOnSendError(
+                                            walletManager = walletManager,
+                                            amountToSend = action.amount?.convertToAmount(action.cryptoCurrency),
+                                            feeAmount = action.fee?.convertToAmount(action.cryptoCurrency),
+                                            destinationAddress = action.destinationAddress,
+                                        )
+                                    }
+                                store.state.globalState.feedbackManager?.sendEmail(
+                                    SendTransactionFailedEmail(action.errorMessage),
+                                )
+                            }
+                        }
                     }
                 }
                 next(action)

domain/legacy/src/main/java/com/tangem/domain/redux/LegacyAction.kt

@@ -1,7 +1,10 @@
 package com.tangem.domain.redux
 
 import com.tangem.domain.models.scan.ScanResponse
+import com.tangem.domain.tokens.model.CryptoCurrency
+import com.tangem.domain.wallets.models.UserWalletId
 import org.rekotlin.Action
+import java.math.BigDecimal
 
 sealed interface LegacyAction : Action {
 
@@ -16,6 +19,20 @@ sealed interface LegacyAction : Action {
 
     /**
      * Sending an email to support when sending transaction failed
+     *
+     * @param cryptoCurrency current currency
+     * @param userWalletId selected user wallet id
+     * @param amount sending amount
+     * @param fee spending fee
+     * @param destinationAddress recipient address
+     * @param errorMessage sending error
      */
-    data class SendEmailTransactionFailed(val errorMessage: String) : LegacyAction
+    data class SendEmailTransactionFailed(
+        val cryptoCurrency: CryptoCurrency,
+        val userWalletId: UserWalletId,
+        val amount: BigDecimal?,
+        val fee: BigDecimal?,
+        val destinationAddress: String?,
+        val errorMessage: String,
+    ) : LegacyAction
 }

features/send/impl/src/main/java/com/tangem/features/send/impl/presentation/viewmodel/SendViewModel.kt

@@ -541,7 +541,31 @@ internal class SendViewModel @Inject constructor(
     }
 
     override fun onFailedTxEmailClick(errorMessage: String) {
-        reduxStateHolder.dispatch(LegacyAction.SendEmailTransactionFailed(errorMessage))
+        val recipient = uiState.recipientState?.addressTextField?.value
+        val feeValue = uiState.feeState?.fee?.amount?.value
+        val amountValue = uiState.amountState?.amountTextField?.cryptoAmount?.value
+
+        val receivingAmount = if (amountValue != null && feeValue != null) {
+            checkAndCalculateSubtractedAmount(
+                isAmountSubtractAvailable = isAmountSubtractAvailable,
+                cryptoCurrencyStatus = cryptoCurrencyStatus,
+                amountValue = amountValue,
+                feeValue = feeValue,
+                reduceAmountBy = uiState.sendState?.reduceAmountBy ?: BigDecimal.ZERO,
+            )
+        } else {
+            null
+        }
+        reduxStateHolder.dispatch(
+            LegacyAction.SendEmailTransactionFailed(
+                cryptoCurrency = cryptoCurrency,
+                userWalletId = userWalletId,
+                amount = receivingAmount,
+                fee = feeValue,
+                destinationAddress = recipient,
+                errorMessage = errorMessage,
+            ),
+        )
     }
 
     override fun onTokenDetailsClick(userWalletId: UserWalletId, currency: CryptoCurrency) =