Updated on 2026-08-14

2024-05-13 13:48:13 +08:00 · 2024-05-13 13:48:13 +08:00 · 11cf593007
commit 11cf593007
parent a8142a7ddf
6 changed files with 1585 additions and 1456 deletions
--- a/core/res/src/main/res/values-ru/strings.xml
+++ b/core/res/src/main/res/values-ru/strings.xml
--- a/core/res/src/main/res/values/strings.xml
+++ b/core/res/src/main/res/values/strings.xml
--- a/features/send/impl/src/main/java/com/tangem/features/send/impl/presentation/state/SendNotification.kt
+++ b/features/send/impl/src/main/java/com/tangem/features/send/impl/presentation/state/SendNotification.kt
@ -161,4 +161,28 @@ internal sealed class SendNotification(val config: NotificationConfig) {
            ),
        )
    }
+
+    sealed interface Cardano {
+
+        data class MinAdaValueCharged(val tokenName: String, val minAdaValue: String) : Warning(
+            title = resourceReference(id = R.string.cardano_coin_will_be_send_with_token_title),
+            subtitle = resourceReference(
+                id = R.string.cardano_coin_will_be_send_with_token_description,
+                formatArgs = wrappedList(minAdaValue, tokenName),
+            ),
+        )
+
+        data object InsufficientBalanceToTransferCoin : Error(
+            title = resourceReference(id = R.string.cardano_max_amount_has_token_title),
+            subtitle = resourceReference(id = R.string.cardano_max_amount_has_token_description),
+        )
+
+        data class InsufficientBalanceToTransferToken(val tokenName: String) : Error(
+            title = resourceReference(id = R.string.cardano_insufficient_balance_to_send_token_title),
+            subtitle = resourceReference(
+                id = R.string.cardano_insufficient_balance_to_send_token_description,
+                formatArgs = wrappedList(tokenName),
+            ),
+        )
+    }
 }
--- a/features/send/impl/src/main/java/com/tangem/features/send/impl/presentation/state/confirm/SendNotificationFactory.kt
+++ b/features/send/impl/src/main/java/com/tangem/features/send/impl/presentation/state/confirm/SendNotificationFactory.kt
@ -1,6 +1,7 @@
 package com.tangem.features.send.impl.presentation.state.confirm

 import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.BlockchainSdkError
 import com.tangem.blockchain.common.transaction.Fee
 import com.tangem.blockchain.common.transaction.TransactionFee
 import com.tangem.blockchainsdk.utils.fromNetworkId
@ -8,6 +9,7 @@ import com.tangem.blockchainsdk.utils.minimalAmount
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.ui.extensions.networkIconResId
 import com.tangem.core.ui.utils.BigDecimalFormatter
+import com.tangem.core.ui.utils.parseBigDecimal
 import com.tangem.core.ui.utils.parseToBigDecimal
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.tokens.GetBalanceNotEnoughForFeeWarningUseCase
@ -15,6 +17,8 @@ import com.tangem.domain.tokens.model.CryptoCurrency
 import com.tangem.domain.tokens.model.CryptoCurrencyStatus
 import com.tangem.domain.tokens.model.warnings.CryptoCurrencyWarning
 import com.tangem.domain.tokens.repository.CurrencyChecksRepository
+import com.tangem.domain.tokens.utils.convertToAmount
+import com.tangem.domain.transaction.usecase.ValidateTransactionUseCase
 import com.tangem.domain.wallets.models.UserWallet
 import com.tangem.features.send.impl.R
 import com.tangem.features.send.impl.presentation.analytics.SendAnalyticEvents
@ -23,6 +27,7 @@ import com.tangem.features.send.impl.presentation.state.fee.*
 import com.tangem.features.send.impl.presentation.state.fields.SendTextField
 import com.tangem.features.send.impl.presentation.utils.getFiatString
 import com.tangem.features.send.impl.presentation.viewmodel.SendClickIntents
+import com.tangem.lib.crypto.BlockchainUtils
 import com.tangem.lib.crypto.BlockchainUtils.isTezos
 import com.tangem.utils.Provider
 import kotlinx.collections.immutable.ImmutableList
@ -46,6 +51,7 @@ internal class SendNotificationFactory(
    private val clickIntents: SendClickIntents,
    private val analyticsEventHandler: AnalyticsEventHandler,
    private val getBalanceNotEnoughForFeeWarningUseCase: GetBalanceNotEnoughForFeeWarningUseCase,
+    private val validateTransactionUseCase: ValidateTransactionUseCase,
 ) {

    fun create(): Flow<ImmutableList<SendNotification>> = stateRouterProvider().currentState
@ -77,8 +83,9 @@ internal class SendNotificationFactory(
                addFeeUnreachableNotification(feeState.feeSelectorState)
                addExceedBalanceNotification(feeValue, sendingAmount)
                addExceedsBalanceNotification(feeState.fee)
-                addDustWarningNotification(feeValue, sendingAmount)
+                addDustWarningNotificationForSpecificBlockchains(feeValue, sendingAmount)
                addTransactionLimitErrorNotification(feeValue, sendingAmount)
+
                // warnings
                addExistentialWarningNotification(feeValue, amountValue)
                addFeeCoverageNotification(
@ -89,6 +96,9 @@ internal class SendNotificationFactory(
                addHighFeeWarningNotification(amountValue, sendState.ignoreAmountReduce)
                addTooHighNotification(feeState.feeSelectorState)
                addTooLowNotification(feeState)
+
+                // blockchain specific
+                addCardanoNotifications(sendingAmount, feeState.fee, state)
            }.toImmutableList()
        }

@ -275,23 +285,35 @@ internal class SendNotificationFactory(
        }
    }

-    private suspend fun MutableList<SendNotification>.addDustWarningNotification(
-        feeAmount: BigDecimal,
-        receivedAmount: BigDecimal,
+    private suspend fun MutableList<SendNotification>.addDustWarningNotificationForSpecificBlockchains(
+        feeValue: BigDecimal,
+        sendingAmount: BigDecimal,
    ) {
-        val cryptoCurrencyStatus = cryptoCurrencyStatusProvider()
-        val dustValue = currencyChecksRepository.getDustValue(
-            userWalletProvider().walletId,
-            cryptoCurrencyStatus.currency.network,
-        ) ?: return
+        val isCardano = BlockchainUtils.isCardano(cryptoCurrencyStatusProvider().currency.network.id.value)

-        if (checkDustLimits(feeAmount, receivedAmount, dustValue)) {
-            add(
-                SendNotification.Error.MinimumAmountError(dustValue.toPlainString()),
-            )
+        if (!isCardano) {
+            addDustWarningNotification(feeValue, sendingAmount)
        }
    }

+    private fun checkDustLimits(feeAmount: BigDecimal, receivedAmount: BigDecimal, dustValue: BigDecimal): Boolean {
+        val cryptoCurrencyStatus = cryptoCurrencyStatusProvider()
+
+        val change = when (cryptoCurrencyStatus.currency) {
+            is CryptoCurrency.Coin -> {
+                val balance = cryptoCurrencyStatus.value.amount ?: BigDecimal.ZERO
+                balance - (feeAmount + receivedAmount)
+            }
+            is CryptoCurrency.Token -> {
+                val balance = coinCryptoCurrencyStatusProvider().value.amount ?: BigDecimal.ZERO
+                balance - feeAmount
+            }
+        }
+
+        val isChangeLowerThanDust = change < dustValue && change > BigDecimal.ZERO
+        return receivedAmount < dustValue || isChangeLowerThanDust
+    }
+
    private fun MutableList<SendNotification>.addTooLowNotification(feeState: SendStates.FeeState) {
        val feeSelectorState = feeState.feeSelectorState as? FeeSelectorState.Content ?: return
        val multipleFees = feeSelectorState.fees as? TransactionFee.Choosable ?: return
@ -393,13 +415,88 @@ internal class SendNotificationFactory(
        return Blockchain.fromNetworkId(this.currency.network.backendId) == Blockchain.Arbitrum
    }

-    private fun checkDustLimits(feeAmount: BigDecimal, receivedAmount: BigDecimal, dustValue: BigDecimal): Boolean {
-        val cryptoCurrencyStatus = cryptoCurrencyStatusProvider()
-        val balance = cryptoCurrencyStatus.value.amount ?: BigDecimal.ZERO
+    private suspend fun MutableList<SendNotification>.addCardanoNotifications(
+        sendingAmount: BigDecimal,
+        fee: Fee?,
+        state: SendUiState,
+    ) {
+        val sendingCurrency = cryptoCurrencyStatusProvider().currency
+        if (!BlockchainUtils.isCardano(sendingCurrency.network.id.value)) return

-        val totalAmount = feeAmount + receivedAmount
-        val change = balance - totalAmount
-        val isChangeLowerThanDust = change < dustValue && change > BigDecimal.ZERO
-        return receivedAmount < dustValue || isChangeLowerThanDust
+        validateTransactionUseCase(
+            amount = sendingAmount.convertToAmount(sendingCurrency),
+            fee = fee ?: return,
+            memo = state.recipientState?.memoTextField?.value,
+            destination = requireNotNull(state.recipientState?.addressTextField?.value),
+            userWalletId = userWalletProvider().walletId,
+            network = sendingCurrency.network,
+        ).fold(
+            ifLeft = {
+                addCardanoTransactionValidationError(
+                    error = it as? BlockchainSdkError.Cardano ?: return@fold,
+                    sendingCurrency = sendingCurrency,
+                    sendingAmount = sendingAmount,
+                    fee = fee,
+                )
+            },
+            ifRight = {
+                (fee as? Fee.CardanoToken)?.let {
+                    add(
+                        SendNotification.Cardano.MinAdaValueCharged(
+                            tokenName = sendingCurrency.name,
+                            minAdaValue = it.minAdaValue.parseBigDecimal(sendingCurrency.decimals),
+                        ),
+                    )
+                }
+            },
+        )
+    }
+
+    private suspend fun MutableList<SendNotification>.addCardanoTransactionValidationError(
+        error: BlockchainSdkError.Cardano,
+        sendingCurrency: CryptoCurrency,
+        sendingAmount: BigDecimal,
+        fee: Fee,
+    ) {
+        when (error) {
+            BlockchainSdkError.Cardano.InsufficientMinAdaBalanceToSendToken -> {
+                add(SendNotification.Cardano.InsufficientBalanceToTransferToken(sendingCurrency.name))
+            }
+            BlockchainSdkError.Cardano.InsufficientRemainingBalanceToWithdrawTokens -> {
+                when (sendingCurrency) {
+                    is CryptoCurrency.Coin -> SendNotification.Cardano.InsufficientBalanceToTransferCoin
+                    is CryptoCurrency.Token -> {
+                        SendNotification.Cardano.InsufficientBalanceToTransferToken(sendingCurrency.name)
+                    }
+                }.let(::add)
+            }
+            BlockchainSdkError.Cardano.InsufficientRemainingBalance,
+            BlockchainSdkError.Cardano.InsufficientSendingAdaAmount,
+            -> {
+                addDustWarningNotification(
+                    feeValue = fee.amount.value ?: BigDecimal.ZERO,
+                    sendingAmount = sendingAmount,
+                )
+            }
+        }
+    }
+
+    private suspend fun MutableList<SendNotification>.addDustWarningNotification(
+        feeValue: BigDecimal,
+        sendingAmount: BigDecimal,
+    ) {
+        val cryptoCurrencyStatus = cryptoCurrencyStatusProvider()
+        val dustValue = currencyChecksRepository.getDustValue(
+            userWalletProvider().walletId,
+            cryptoCurrencyStatus.currency.network,
+        ) ?: return
+
+        if (checkDustLimits(feeValue, sendingAmount, dustValue)) {
+            add(
+                SendNotification.Error.MinimumAmountError(
+                    amount = dustValue.parseBigDecimal(cryptoCurrencyStatus.currency.decimals),
+                ),
+            )
+        }
    }
 }
--- a/features/send/impl/src/main/java/com/tangem/features/send/impl/presentation/viewmodel/SendViewModel.kt
+++ b/features/send/impl/src/main/java/com/tangem/features/send/impl/presentation/viewmodel/SendViewModel.kt
@ -30,10 +30,7 @@ import com.tangem.domain.tokens.model.Network
 import com.tangem.domain.tokens.repository.CurrencyChecksRepository
 import com.tangem.domain.tokens.utils.convertToAmount
 import com.tangem.domain.transaction.error.GetFeeError
-import com.tangem.domain.transaction.usecase.CreateTransactionUseCase
-import com.tangem.domain.transaction.usecase.GetFeeUseCase
-import com.tangem.domain.transaction.usecase.IsFeeApproximateUseCase
-import com.tangem.domain.transaction.usecase.SendTransactionUseCase
+import com.tangem.domain.transaction.usecase.*
 import com.tangem.domain.txhistory.usecase.GetExplorerTransactionUrlUseCase
 import com.tangem.domain.txhistory.usecase.GetFixedTxHistoryItemsUseCase
 import com.tangem.domain.wallets.models.UserWallet
@ -95,6 +92,7 @@ internal class SendViewModel @Inject constructor(
    private val neverShowTapHelpUseCase: NeverShowTapHelpUseCase,
    private val getExplorerTransactionUrlUseCase: GetExplorerTransactionUrlUseCase,
    private val listenToQrScanningUseCase: ListenToQrScanningUseCase,
+    validateTransactionUseCase: ValidateTransactionUseCase,
    currencyChecksRepository: CurrencyChecksRepository,
    isFeeApproximateUseCase: IsFeeApproximateUseCase,
    validateWalletMemoUseCase: ValidateWalletMemoUseCase,
@ -173,6 +171,7 @@ internal class SendViewModel @Inject constructor(
        clickIntents = this,
        analyticsEventHandler = analyticsEventHandler,
        getBalanceNotEnoughForFeeWarningUseCase = getBalanceNotEnoughForFeeWarningUseCase,
+        validateTransactionUseCase = validateTransactionUseCase,
    )

    private val sendScreenAnalyticSender by lazy(LazyThreadSafetyMode.NONE) {
--- a/libs/crypto/src/main/java/com/tangem/lib/crypto/BlockchainUtils.kt
+++ b/libs/crypto/src/main/java/com/tangem/lib/crypto/BlockchainUtils.kt
@ -44,4 +44,9 @@ object BlockchainUtils {
        val blockchain = Blockchain.fromId(networkId)
        return blockchain == Blockchain.Tezos
    }
+
+    fun isCardano(networkId: String): Boolean {
+        val blockchain = Blockchain.fromId(networkId)
+        return blockchain == Blockchain.Cardano
+    }
 }