Updated on 2026-08-14

2022-09-14 11:42:02 +03:00 · 2022-09-14 11:42:02 +03:00 · d850dc04a5
commit d850dc04a5
parent 784a908734 1b5ff5baa6
24 changed files with 198 additions and 178 deletions
--- a/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/AmountMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/AmountMiddleware.kt
@ -4,11 +4,17 @@ import com.tangem.blockchain.common.Amount
 import com.tangem.blockchain.common.TransactionError
 import com.tangem.common.extensions.isZero
 import com.tangem.tap.common.redux.AppState
-import com.tangem.tap.features.send.redux.*
+import com.tangem.tap.features.send.redux.AmountAction
+import com.tangem.tap.features.send.redux.AmountActionUi
+import com.tangem.tap.features.send.redux.FeeAction
+import com.tangem.tap.features.send.redux.FeeActionUi
+import com.tangem.tap.features.send.redux.ReceiptAction
+import com.tangem.tap.features.send.redux.SendAction
 import com.tangem.tap.features.send.redux.states.MainCurrencyType
 import com.tangem.tap.features.send.redux.states.SendState
 import org.rekotlin.Action
 import java.math.BigDecimal
+import java.util.*

 /**
 [REDACTED_AUTHOR]
@ -62,18 +68,11 @@ class AmountMiddleware {

        val amountToSend = Amount(typedAmount, sendState.getTotalAmountToSend(inputCrypto))
        val transactionErrors = walletManager.validateTransaction(amountToSend, sendState.feeState.currentFee)
-        transactionErrors.remove(TransactionError.TezosSendAll)
-        if (transactionErrors.isEmpty()) {
+        val amountFieldErrors = filterErrorsForAmountField(transactionErrors)
+        if (amountFieldErrors.isEmpty()) {
            dispatch(AmountAction.SetAmountError(null))
        } else {
-            val amountErrors = extractErrorsForAmountField(transactionErrors)
-            if (amountErrors.isNotEmpty()) {
-                transactionErrors.removeAll(amountErrors)
-                dispatch(AmountAction.SetAmountError(createValidateTransactionError(amountErrors, walletManager)))
-            }
-            if (transactionErrors.isNotEmpty()) {
-                dispatch(SendAction.SendError(createValidateTransactionError(transactionErrors, walletManager)))
-            }
+            dispatch(AmountAction.SetAmountError(createValidateTransactionError(amountFieldErrors, walletManager)))
        }
        dispatch(ReceiptAction.RefreshReceipt)
        dispatch(SendAction.ChangeSendButtonState(sendState.getButtonState()))
@ -104,4 +103,28 @@ class AmountMiddleware {

        dispatch(AmountActionUi.SetMainCurrency(type))
    }
+}
+
+private fun filterErrorsForAmountField(errors: EnumSet<TransactionError>): EnumSet<TransactionError> {
+    val showIntoAmountField = EnumSet.noneOf(TransactionError::class.java)
+    errors.forEach {
+        when (it) {
+            TransactionError.AmountExceedsBalance -> {
+                showIntoAmountField.remove(TransactionError.TotalExceedsBalance)
+                showIntoAmountField.add(it)
+            }
+            TransactionError.FeeExceedsBalance -> {
+                showIntoAmountField.remove(TransactionError.TotalExceedsBalance)
+                showIntoAmountField.add(it)
+            }
+            TransactionError.TotalExceedsBalance -> {
+                val notAcceptable = listOf(TransactionError.AmountExceedsBalance, TransactionError.FeeExceedsBalance)
+                if (!showIntoAmountField.containsAll(notAcceptable)) showIntoAmountField.add(it)
+            }
+            else -> showIntoAmountField.add(it)
+        }
+    }
+    showIntoAmountField.remove(TransactionError.TezosSendAll)
+
+    return showIntoAmountField
 }
--- a/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/SendMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/SendMiddleware.kt
@ -114,9 +114,8 @@ private fun verifyAndSendTransaction(
    val amountToSend = Amount(typedAmount, sendState.getTotalAmountToSend())

    val transactionErrors = walletManager.validateTransaction(amountToSend, feeAmount)
-    val hadTezosError = transactionErrors.remove(TransactionError.TezosSendAll)
    when {
-        hadTezosError -> {
+        transactionErrors.contains(TransactionError.TezosSendAll) -> {
            val reduceAmount = walletManager.wallet.blockchain.minimalAmount()
            dispatch(
                SendAction.Dialog.TezosWarningDialog(
@ -135,9 +134,6 @@ private fun verifyAndSendTransaction(
                ),
            )
        }
-        transactionErrors.isNotEmpty() -> {
-            dispatch(SendAction.SendError(createValidateTransactionError(transactionErrors, walletManager)))
-        }
        else -> {
            sendTransaction(
                action, walletManager, amountToSend, feeAmount, destinationAddress,
@ -272,10 +268,8 @@ private fun sendTransaction(
                            dispatch(SendAction.Dialog.SendTransactionFails.CardSdkError(tangemSdkError))
                        }
                        is BlockchainSdkError.CreateAccountUnderfunded -> {
-                            // from XLM, XRP
-                            val reserve = error.minReserve.value?.stripZeroPlainString() ?: "0"
-                            val symbol = error.minReserve.currencySymbol
-                            dispatch(SendAction.SendError(TapError.CreateAccountUnderfunded(listOf(reserve, symbol))))
+                            // from XLM, XRP, Polkadot
+                            dispatch(SendAction.Dialog.SendTransactionFails.BlockchainSdkError(error))
                        }
                        else -> {
                            when {
@ -300,29 +294,6 @@ private fun sendTransaction(
    }
 }

-fun extractErrorsForAmountField(errors: EnumSet<TransactionError>): EnumSet<TransactionError> {
-    val showIntoAmountField = EnumSet.noneOf(TransactionError::class.java)
-    errors.forEach {
-        when (it) {
-            TransactionError.AmountExceedsBalance -> {
-                showIntoAmountField.remove(TransactionError.TotalExceedsBalance)
-                showIntoAmountField.add(it)
-            }
-            TransactionError.FeeExceedsBalance -> {
-                showIntoAmountField.remove(TransactionError.TotalExceedsBalance)
-                showIntoAmountField.add(it)
-            }
-            TransactionError.TotalExceedsBalance -> {
-                val notAcceptable = listOf(TransactionError.AmountExceedsBalance, TransactionError.FeeExceedsBalance)
-                if (!showIntoAmountField.containsAll(notAcceptable)) showIntoAmountField.add(it)
-            }
-            TransactionError.InvalidAmountValue -> showIntoAmountField.add(it)
-            TransactionError.InvalidFeeValue -> showIntoAmountField.add(it)
-        }
-    }
-    return showIntoAmountField
-}
-
 fun createValidateTransactionError(
    errorList: EnumSet<TransactionError>,
    walletManager: WalletManager,
--- a/app/src/main/java/com/tangem/tap/features/send/redux/reducers/FeeReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/reducers/FeeReducer.kt
@ -1,12 +1,9 @@
 package com.tangem.tap.features.send.redux.reducers

 import com.tangem.blockchain.common.Amount
-import com.tangem.blockchain.common.AmountType
-import com.tangem.blockchain.common.Blockchain
 import com.tangem.tap.features.send.redux.FeeAction
 import com.tangem.tap.features.send.redux.FeeActionUi
 import com.tangem.tap.features.send.redux.SendScreenAction
-import com.tangem.tap.features.send.redux.states.FeePrecision
 import com.tangem.tap.features.send.redux.states.FeeState
 import com.tangem.tap.features.send.redux.states.FeeType
 import com.tangem.tap.features.send.redux.states.SendState
@ -27,10 +24,9 @@ class FeeReducer : SendInternalReducer {
            is FeeActionUi.ChangeSelectedFee -> {
                val currentFee = createValueOfFeeAmount(action.feeType, state.feeList)
                state.copy(
-                        selectedFeeType = action.feeType,
-                        currentFee = currentFee
+                    selectedFeeType = action.feeType,
+                    currentFee = currentFee,
                )
-
            }
            is FeeActionUi.ChangeIncludeFee -> state.copy(feeIsIncluded = action.isIncluded)
        }
@ -45,9 +41,9 @@ class FeeReducer : SendInternalReducer {
            is FeeAction.ChangeLayoutVisibility -> {
                fun getVisibility(current: Boolean, proposed: Boolean?): Boolean = proposed ?: current
                state.copy(
-                        mainLayoutIsVisible = getVisibility(state.mainLayoutIsVisible, action.main),
-                        controlsLayoutIsVisible = getVisibility(state.controlsLayoutIsVisible, action.controls),
-                        feeChipGroupIsVisible = getVisibility(state.feeChipGroupIsVisible, action.chipGroup)
+                    mainLayoutIsVisible = getVisibility(state.mainLayoutIsVisible, action.main),
+                    controlsLayoutIsVisible = getVisibility(state.controlsLayoutIsVisible, action.controls),
+                    feeChipGroupIsVisible = getVisibility(state.feeChipGroupIsVisible, action.chipGroup),
                )
            }
            is FeeAction.FeeCalculation.SetFeeResult -> {
@ -57,30 +53,30 @@ class FeeReducer : SendInternalReducer {
                    val currentFee = createValueOfFeeAmount(feeType, fees)

                    state.copy(
-                            selectedFeeType = feeType,
-                            feeList = fees,
-                            currentFee = currentFee,
-                            error = null,
-                            feePrecision = getFeePrecision(sendState)
+                        selectedFeeType = feeType,
+                        feeList = fees,
+                        currentFee = currentFee,
+                        error = null,
+                        feeIsApproximate = isFeeApproximate(sendState),
                    )
                } else {
                    val feeType = getCurrentFeeType(state)
                    val currentFee = createValueOfFeeAmount(feeType, fees)

                    state.copy(
-                            selectedFeeType = feeType,
-                            feeList = fees,
-                            currentFee = currentFee,
-                            error = null,
-                            feePrecision = getFeePrecision(sendState)
+                        selectedFeeType = feeType,
+                        feeList = fees,
+                        currentFee = currentFee,
+                        error = null,
+                        feeIsApproximate = isFeeApproximate(sendState),
                    )
                }
            }
            is FeeAction.FeeCalculation.SetFeeError -> {
                state.copy(
-                        feeList = null,
-                        currentFee = null,
-                        error = action.error
+                    feeList = null,
+                    currentFee = null,
+                    error = action.error,
                )
            }
        }
@ -103,26 +99,13 @@ class FeeReducer : SendInternalReducer {
        }
    }

-    private fun getFeePrecision(sendState: SendState): FeePrecision {
-        val blockchain = sendState.walletManager?.wallet?.blockchain
+    private fun isFeeApproximate(sendState: SendState): Boolean {
+        val blockchain = sendState.walletManager?.wallet?.blockchain ?: return false
+
        val amountType = sendState.amountState.typeOfAmount
-
-        val canBeLower = when (blockchain) {
-            Blockchain.Tron, Blockchain.TronTestnet -> amountType is AmountType.Token
-            Blockchain.Fantom, Blockchain.FantomTestnet -> amountType is AmountType.Token
-            Blockchain.Arbitrum, Blockchain.ArbitrumTestnet -> true
-            Blockchain.Stellar, Blockchain.StellarTestnet -> true
-            else -> false
-        }
-
-        return if (canBeLower) {
-            FeePrecision.CAN_BE_LOWER
-        } else {
-            FeePrecision.PRECISE
-        }
+        return blockchain.isFeeApproximate(amountType)
    }

-
    private fun getCurrentFeeType(state: FeeState): FeeType {
        return if (state.selectedFeeType == FeeType.SINGLE) FeeType.NORMAL else state.selectedFeeType
    }
--- a/app/src/main/java/com/tangem/tap/features/send/redux/reducers/ReceiptReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/reducers/ReceiptReducer.kt
@ -17,6 +17,7 @@ import com.tangem.tap.features.send.redux.states.ReceiptSymbols
 import com.tangem.tap.features.send.redux.states.ReceiptTokenCrypto
 import com.tangem.tap.features.send.redux.states.ReceiptTokenFiat
 import com.tangem.tap.features.send.redux.states.SendState
+import com.tangem.tap.features.wallet.redux.WalletState.Companion.CAN_BE_LOWER_SIGN
 import com.tangem.tap.features.wallet.redux.WalletState.Companion.UNKNOWN_AMOUNT_SIGN
 import com.tangem.tap.store
 import java.math.BigDecimal
@ -216,6 +217,8 @@ class ReceiptReducer : SendInternalReducer {
        }
    }

-    private fun String.addPrecisionSign(): String =
-        ("${feeState.feePrecision.symbol} $this").trim()
+    private fun String.addPrecisionSign(): String {
+        val result = if (feeState.feeIsApproximate) "$CAN_BE_LOWER_SIGN $this" else ""
+        return result.trim()
+    }
 }
--- a/app/src/main/java/com/tangem/tap/features/send/redux/states/FeeState.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/states/FeeState.kt
@ -11,21 +11,17 @@ enum class FeeType {
    SINGLE, LOW, NORMAL, PRIORITY
 }

-enum class FeePrecision(val symbol: String) {
-    PRECISE(""), CAN_BE_LOWER("<")
-}
-
 data class FeeState(
-        val selectedFeeType: FeeType = FeeType.NORMAL,
-        val feeList: List<Amount>? = null,
-        val currentFee: Amount? = null,
-        val feeIsIncluded: Boolean = false,
-        val mainLayoutIsVisible: Boolean = false,
-        val controlsLayoutIsVisible: Boolean = false,
-        val feeChipGroupIsVisible: Boolean = true,
-        val includeFeeSwitcherIsEnabled: Boolean = true,
-        val error: FeeAction.Error? = null,
-        val feePrecision: FeePrecision = FeePrecision.PRECISE
+    val selectedFeeType: FeeType = FeeType.NORMAL,
+    val feeList: List<Amount>? = null,
+    val currentFee: Amount? = null,
+    val feeIsIncluded: Boolean = false,
+    val feeIsApproximate: Boolean = false,
+    val mainLayoutIsVisible: Boolean = false,
+    val controlsLayoutIsVisible: Boolean = false,
+    val feeChipGroupIsVisible: Boolean = true,
+    val includeFeeSwitcherIsEnabled: Boolean = true,
+    val error: FeeAction.Error? = null,
 ) : SendScreenState {

    override val stateId: StateId = StateId.FEE
--- a/app/src/main/java/com/tangem/tap/features/send/ui/dialogs/SendTransactionFailsDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/ui/dialogs/SendTransactionFailsDialog.kt
@ -2,7 +2,10 @@ package com.tangem.tap.features.send.ui.dialogs

 import android.content.Context
 import androidx.appcompat.app.AlertDialog
+import com.tangem.blockchain.common.BlockchainSdkError
+import com.tangem.common.module.ModuleMessageConverter
 import com.tangem.tangem_sdk_new.extensions.localizedDescription
+import com.tangem.tap.common.extensions.stripZeroPlainString
 import com.tangem.tap.common.feedback.SendTransactionFailedEmail
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.features.send.redux.SendAction
@ -13,14 +16,14 @@ import com.tangem.wallet.R
 [REDACTED_AUTHOR]
 */
 class SendTransactionFailsDialog {
-
    companion object {
        fun create(context: Context, dialog: SendAction.Dialog.SendTransactionFails.CardSdkError): AlertDialog {
            return create(context, dialog.error.localizedDescription(context))
        }

        fun create(context: Context, dialog: SendAction.Dialog.SendTransactionFails.BlockchainSdkError): AlertDialog {
-            return create(context, dialog.error.customMessage)
+            val errorConverter = BlockchainSdkErrorConverter(context)
+            return create(context, errorConverter.convert(dialog.error))
        }

        private fun create(context: Context, errorMessage: String): AlertDialog {
@ -35,4 +38,20 @@ class SendTransactionFailsDialog {
            }.create()
        }
    }
+}
+
+private class BlockchainSdkErrorConverter(
+    private val context: Context,
+) : ModuleMessageConverter<BlockchainSdkError, String> {
+
+    override fun convert(message: BlockchainSdkError): String {
+        return when (message) {
+            is BlockchainSdkError.CreateAccountUnderfunded -> {
+                val reserve = message.minReserve.value?.stripZeroPlainString() ?: "0"
+                val symbol = message.minReserve.currencySymbol
+                context.getString(R.string.send_error_no_target_account, reserve, symbol)
+            }
+            else -> message.customMessage
+        }
+    }
 }