GiftedHacker/tangem-app-android-audited
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Updated on 2026-08-14

Browse source
This commit is contained in:
Tangem 2026-06-01 20:49:04 +05:00
commit d01eb9153f
19 changed files with 971 additions and 94 deletions
Download patch file Download diff file Expand all files Collapse all files

3
features/approval/api/src/main/java/com/tangem/features/approval/api/SelectApprovalTypeComponent.kt
View file

@ -25,11 +25,12 @@ interface SelectApprovalTypeComponent : ComposableBottomSheetComponent {
val cryptoCurrencyStatus: CryptoCurrencyStatus,
val amountFooter: TextReference,
val initialApproveType: ApproveType = ApproveType.LIMITED,
val spenderAddress: String,
val callback: Callback,
)
interface Callback {
fun onApproveTypeSelected(approveType: ApproveType)
fun onApproveTypeSelected(spenderAddress: String, approveType: ApproveType)
fun onCancelClick()
}

2
features/approval/impl/src/main/java/com/tangem/features/approval/impl/model/SelectApprovalTypeModel.kt
View file

@ -43,7 +43,7 @@ internal class SelectApprovalTypeModel @Inject constructor(
}
fun onConfirmClick() {
params.callback.onApproveTypeSelected(uiState.value.approveType)
params.callback.onApproveTypeSelected(params.spenderAddress, uiState.value.approveType)
}
fun onCancelClick() {

3
features/swap/domain/build.gradle.kts
View file

@ -53,6 +53,9 @@ dependencies {
implementation(projects.domain.balanceHiding)
implementation(projects.domain.yieldSupply)
/** Common modules */
implementation(projects.common.ui)
/** Core modules */
implementation(projects.core.configToggles)
implementation(projects.core.utils)

114
features/swap/domain/src/main/java/com/tangem/feature/swap/domain/SwapInteractorImpl.kt
View file

@ -16,6 +16,7 @@ import com.tangem.blockchain.yieldsupply.providers.ethereum.yield.EthereumYieldS
import com.tangem.blockchainsdk.utils.fromNetworkId
import com.tangem.blockchainsdk.utils.toBlockchain
import com.tangem.blockchainsdk.utils.toNetworkId
import com.tangem.common.ui.bottomsheet.permission.state.ApproveType
import com.tangem.core.ui.extensions.stringReference
import com.tangem.core.ui.format.bigdecimal.fiat
import com.tangem.core.ui.format.bigdecimal.format
@ -252,7 +253,7 @@ internal class SwapInteractorImpl @Inject constructor(
}
}
@Suppress("LongMethod")
@Suppress("LongMethod", "CyclomaticComplexMethod")
private suspend fun manageDex(
fromSwapCurrencyStatus: SwapCurrencyStatus,
toSwapCurrencyStatus: SwapCurrencyStatus,
@ -271,7 +272,7 @@ internal class SwapInteractorImpl @Inject constructor(
)
}
val maybeQuotes = repository.findBestQuote(
val maybeQuote = repository.findBestQuote(
userWallet = fromSwapCurrencyStatus.userWallet,
fromContractAddress = fromSwapCurrencyStatus.currency.getContractAddress(),
fromNetwork = fromSwapCurrencyStatus.currency.network.rawId,
@ -284,7 +285,7 @@ internal class SwapInteractorImpl @Inject constructor(
rateType = RateType.FLOAT,
)
if (maybeQuotes.getOrNull()?.txType == ExpressTxType.SEND) {
if (maybeQuote.getOrNull()?.txType == ExpressTxType.SEND) {
return manageCex(
fromSwapCurrencyStatus = fromSwapCurrencyStatus,
toSwapCurrencyStatus = toSwapCurrencyStatus,
@ -295,28 +296,32 @@ internal class SwapInteractorImpl @Inject constructor(
}
val fromTokenAddress = getTokenAddress(fromSwapCurrencyStatus.currency)
// TODO CHECK YIELD APPROVE
val isYieldSwap = fromSwapCurrencyStatus.isYieldSwapActive &&
fromSwapCurrencyStatus.currency is CryptoCurrency.Token
val isAllowedToSpend = if (isYieldSwap) {
maybeQuotes.isRight() &&
fromSwapCurrencyStatus.status.value.yieldSupplyStatus?.isAllowedToSpend == true
} else {
maybeQuotes.fold(
ifRight = { quotes ->
quotes.allowanceContract?.let { allowanceContract ->
getAllowanceInfoUseCase(
userWalletId = fromSwapCurrencyStatus.userWalletId,
cryptoCurrency = fromSwapCurrencyStatus.currency,
spenderAddress = allowanceContract,
requiredAmount = amount.value,
).getOrNull() is AllowanceInfo.Enough
} != false
},
ifLeft = { false },
val spenderAddress = if (isYieldSwap) {
yieldModuleAddressProvider.getOrFetch(
userWalletId = fromSwapCurrencyStatus.userWalletId,
network = fromSwapCurrencyStatus.currency.network,
)
} else {
maybeQuote.getOrNull()?.allowanceContract
}
if (isAllowedToSpend && allowPermissionsHandler.isAddressAllowanceInProgress(fromTokenAddress)) {
val allowanceInfo = spenderAddress?.let { allowanceContract ->
getAllowanceInfoUseCase(
userWalletId = fromSwapCurrencyStatus.userWalletId,
cryptoCurrency = fromSwapCurrencyStatus.currency,
spenderAddress = allowanceContract,
requiredAmount = amount.value,
).getOrNull()
} ?: AllowanceInfo.Enough(allowance = BigDecimal.ZERO)
if (allowanceInfo is AllowanceInfo.Enough &&
allowPermissionsHandler.isAddressAllowanceInProgress(fromTokenAddress)
) {
allowPermissionsHandler.removeAddressFromProgress(fromTokenAddress)
cryptoCurrencyBalanceFetcher(
userWalletId = fromSwapCurrencyStatus.userWalletId,
@ -324,7 +329,21 @@ internal class SwapInteractorImpl @Inject constructor(
)
}
val isBalanceWithoutFeeEnough = isBalanceEnough(fromSwapCurrencyStatus, amount, null)
val quoteAllowanceContract = maybeQuotes.getOrNull()?.allowanceContract
val isIntegratedApproveActive = swapFeatureToggles.isSwapIntegratedApproveEnabled
val isAllowanceSatisfied = if (isIntegratedApproveActive) {
allowanceInfo !is AllowanceInfo.ResetNeeded
} else {
allowanceInfo is AllowanceInfo.Enough
}
// For yield swaps the on-chain allowance is not sufficient on its own: spending also
// requires the yield-module proxy approval (yieldSupplyStatus.isAllowedToSpend).
// For regular swaps a failed quote must not proceed to exchange-data loading.
val isAllowedToSpend = if (isYieldSwap) {
isAllowanceSatisfied &&
fromSwapCurrencyStatus.status.value.yieldSupplyStatus?.isAllowedToSpend == true
} else {
isAllowanceSatisfied && maybeQuote.isRight()
}
return if (isAllowedToSpend && isBalanceWithoutFeeEnough) {
provider to loadDexSwapDataNoFee(
provider = provider,
@ -332,7 +351,8 @@ internal class SwapInteractorImpl @Inject constructor(
toSwapCurrencyStatus = toSwapCurrencyStatus,
amount = amount,
expressOperationType = expressOperationType,
quoteAllowanceContract = quoteAllowanceContract,
allowanceInfo = allowanceInfo,
spenderAddress = spenderAddress,
)
} else {
val quoteBalanceStatus = if (isBalanceWithoutFeeEnough) {
@ -342,7 +362,7 @@ internal class SwapInteractorImpl @Inject constructor(
}
provider to getQuotesState(
provider = provider,
quoteDataModel = maybeQuotes,
quoteDataModel = maybeQuote,
amount = amount,
fromSwapCurrencyStatus = fromSwapCurrencyStatus,
toSwapCurrencyStatus = toSwapCurrencyStatus,
@ -395,7 +415,8 @@ internal class SwapInteractorImpl @Inject constructor(
toSwapCurrencyStatus = toSwapCurrencyStatus,
amount = amount,
expressOperationType = expressOperationType,
quoteAllowanceContract = maybeQuotes.getOrNull()?.allowanceContract,
allowanceInfo = null,
spenderAddress = null,
)
} else {
provider to getQuotesState(
@ -1594,7 +1615,8 @@ internal class SwapInteractorImpl @Inject constructor(
toSwapCurrencyStatus: SwapCurrencyStatus,
amount: SwapAmount,
expressOperationType: ExpressOperationType,
quoteAllowanceContract: String? = null,
allowanceInfo: AllowanceInfo?,
spenderAddress: String?,
): SwapState {
val fromNetworkAddress = fromSwapCurrencyStatus.status.value.networkAddress
val dexFromAddress = fromNetworkAddress?.defaultAddress?.value.orEmpty()
@ -1617,8 +1639,8 @@ internal class SwapInteractorImpl @Inject constructor(
expressOperationType = expressOperationType,
).map { swapData ->
val dexTx = swapData.transaction as? ExpressTransactionModel.DEX
if (dexTx != null && quoteAllowanceContract != null && dexTx.allowanceContract == null) {
swapData.copy(transaction = dexTx.copy(allowanceContract = quoteAllowanceContract))
if (dexTx != null && spenderAddress != null && dexTx.allowanceContract == null) {
swapData.copy(transaction = dexTx.copy(allowanceContract = spenderAddress))
} else {
swapData
}
@ -1636,8 +1658,24 @@ internal class SwapInteractorImpl @Inject constructor(
swapData = swapData,
provider = provider,
)
val isIntegratedApprovalNeeded = swapFeatureToggles.isSwapIntegratedApproveEnabled &&
allowanceInfo is AllowanceInfo.NotEnough
swapState.copy(
permissionState = PermissionDataState.Empty,
permissionState = if (isIntegratedApprovalNeeded) {
PermissionDataState.PermissionSettings(
type = ApproveType.LIMITED,
spenderAddress = spenderAddress.orEmpty(),
)
} else if (allowanceInfo is AllowanceInfo.NotEnough) {
// Integrated estimation failed earlier this session — show the legacy
// separate-approval UI so the user approves before swapping.
PermissionDataState.PermissionRequired(
isResetApproval = false,
spenderAddress = spenderAddress.orEmpty(),
)
} else {
PermissionDataState.Empty
},
currencyCheck = manageWarnings(
fromSwapCurrencyStatus = fromSwapCurrencyStatus,
amount = amount,
@ -1760,13 +1798,23 @@ internal class SwapInteractorImpl @Inject constructor(
cryptoCurrency = fromToken,
spenderAddress = spenderAddress,
requiredAmount = swapAmount.value,
).getOrNull()
).getOrNull() ?: return quotesLoadedState.copy(permissionState = PermissionDataState.Empty)
val isIntegratedApprovalNeeded = swapFeatureToggles.isSwapIntegratedApproveEnabled &&
allowanceInfo is AllowanceInfo.NotEnough
return quotesLoadedState.copy(
permissionState = PermissionDataState.PermissionRequired(
isResetApproval = allowanceInfo is AllowanceInfo.ResetNeeded,
spenderAddress = spenderAddress,
),
permissionState = if (isIntegratedApprovalNeeded) {
PermissionDataState.PermissionSettings(
type = ApproveType.LIMITED,
spenderAddress = spenderAddress,
)
} else {
PermissionDataState.PermissionRequired(
isResetApproval = allowanceInfo is AllowanceInfo.ResetNeeded,
spenderAddress = spenderAddress,
)
},
)
}

6
features/swap/domain/src/main/java/com/tangem/feature/swap/domain/models/ui/SwapState.kt
View file

@ -1,6 +1,7 @@
package com.tangem.feature.swap.domain.models.ui
import androidx.compose.runtime.Immutable
import com.tangem.common.ui.bottomsheet.permission.state.ApproveType
import com.tangem.core.ui.extensions.TextReference
import com.tangem.domain.appcurrency.model.AppCurrency
import com.tangem.domain.models.wallet.UserWallet
@ -104,6 +105,11 @@ sealed class PermissionDataState {
val spenderAddress: String,
) : PermissionDataState()
data class PermissionSettings(
val type: ApproveType,
val spenderAddress: String,
) : PermissionDataState()
object PermissionLoading : PermissionDataState()
object Empty : PermissionDataState()

2
features/swap/domain/src/test/kotlin/com/tangem/feature/swap/domain/SwapInteractorImplFindBestQuoteTest.kt
View file

@ -28,6 +28,7 @@ import io.mockk.every
import io.mockk.mockk
import io.mockk.mockkStatic
import kotlinx.coroutines.test.runTest
import org.junit.Ignore
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test
@ -1037,6 +1038,7 @@ internal class SwapInteractorImplFindBestQuoteTest : SwapInteractorImplTestBase(
assertThat(required.isResetApproval).isTrue()
}
@Ignore("Check in final integrated approve test")
@Test
fun `should fallback to no-permission state when yield-module proxy address is unresolvable`() = runTest {
// Given — yield store returns null (e.g. network unreachable on first resolve)

51
features/swap/impl/src/main/java/com/tangem/feature/swap/DefaultSwapComponent.kt
View file

@ -20,22 +20,16 @@ import com.tangem.core.decompose.context.AppComponentContext
import com.tangem.core.decompose.context.childByContext
import com.tangem.core.decompose.model.getOrCreateModel
import com.tangem.core.decompose.navigation.inner.InnerRouter
import com.tangem.core.ui.R
import com.tangem.core.ui.decompose.ComposableContentComponent
import com.tangem.core.ui.extensions.resourceReference
import com.tangem.core.ui.extensions.wrappedList
import com.tangem.core.ui.res.TangemTheme
import com.tangem.core.ui.utils.parseBigDecimalOrNull
import com.tangem.domain.models.currency.CryptoCurrencyStatus
import com.tangem.domain.models.wallet.isHotWallet
import com.tangem.feature.swap.component.SwapFeeSelectorBlockComponent
import com.tangem.feature.swap.domain.models.ui.PermissionDataState
import com.tangem.feature.swap.model.SwapModel
import com.tangem.feature.swap.models.SwapPermissionUM
import com.tangem.feature.swap.router.SwapRoute
import com.tangem.feature.swap.ui.SwapScreen
import com.tangem.feature.swap.ui.SwapSuccessScreen
import com.tangem.features.approval.api.GiveApprovalComponent
import com.tangem.features.approval.api.GiveApprovalEntryComponent
import com.tangem.features.commonfeatures.api.choosetoken.ChooseTokenComponent
import com.tangem.features.send.v2.api.analytics.CommonSendAnalyticEvents
import com.tangem.features.swap.SwapComponent
@ -50,7 +44,7 @@ internal class DefaultSwapComponent @AssistedInject constructor(
@Assisted appComponentContext: AppComponentContext,
@Assisted private val params: SwapComponent.Params,
private val swapFeeSelectorBlockComponentFactory: SwapFeeSelectorBlockComponent.Factory,
private val giveApprovalComponentFactory: GiveApprovalComponent.Factory,
private val giveApprovalEntryComponentFactory: GiveApprovalEntryComponent.Factory,
private val chooseTokenComponentFactory: ChooseTokenComponent.Factory,
) : SwapComponent, AppComponentContext by appComponentContext {
@ -78,12 +72,10 @@ internal class DefaultSwapComponent @AssistedInject constructor(
source = model.approvalSlotNavigation,
serializer = null,
handleBackButton = true,
childFactory = { _, factoryContext ->
val approvalParams = getApprovalParams()
?: error("Approval params are not available")
giveApprovalComponentFactory.create(
childFactory = { params, factoryContext ->
giveApprovalEntryComponentFactory.create(
context = childByContext(factoryContext),
params = approvalParams,
params = GiveApprovalEntryComponent.Params(params),
)
},
)
@ -159,9 +151,8 @@ internal class DefaultSwapComponent @AssistedInject constructor(
val isAmountEmptyOrZero = dataState.amount?.parseBigDecimalOrNull().isNullOrZero()
val isInsufficientFunds = model.uiState.isInsufficientFunds
val isProviderMissing = dataState.selectedProvider == null
val loadedState = dataState.getCurrentLoadedSwapState()
val isPermissionNotReady = loadedState?.permissionState !is PermissionDataState.Empty
val isSwapNotReady = !isInTransferMode && (isProviderMissing || isPermissionNotReady)
val isPermissionNotNeeded = model.isPermissionNotNeeded
val isSwapNotReady = !isInTransferMode && (isProviderMissing || !isPermissionNotNeeded)
val isTangemPayWithdrawal = model.isTangemPayWithdrawal()
isAmountEmptyOrZero || isInsufficientFunds || isSwapNotReady || isTangemPayWithdrawal
@ -249,34 +240,6 @@ internal class DefaultSwapComponent @AssistedInject constructor(
}
}
private fun getApprovalParams(): GiveApprovalComponent.Params? {
val permissionState = model.uiState.permissionUM as? SwapPermissionUM.PermissionRequired ?: return null
val fromSwapCurrencyStatus = model.dataState.fromSwapCurrencyStatus ?: return null
val feeCryptoCurrency = model.dataState.feePaidCryptoCurrency ?: return null
val providerName = model.dataState.selectedProvider?.name.orEmpty()
val isHoldToConfirm = fromSwapCurrencyStatus.userWallet.isHotWallet
return GiveApprovalComponent.Params(
userWalletId = params.userWalletId,
cryptoCurrencyStatus = fromSwapCurrencyStatus.status,
feeCryptoCurrencyStatus = feeCryptoCurrency,
amount = model.dataState.amount.orEmpty(),
spenderAddress = permissionState.spenderAddress,
amountFooter = if (permissionState.isResetApproval) {
resourceReference(R.string.update_approval_permission_subtitle)
} else {
resourceReference(
id = R.string.give_permission_swap_subtitle,
formatArgs = wrappedList(providerName, fromSwapCurrencyStatus.currency.symbol),
)
},
feeFooter = resourceReference(R.string.swap_give_permission_fee_footer),
isResetApproval = permissionState.isResetApproval,
isHoldToConfirm = isHoldToConfirm,
callback = model.approvalCallback,
)
}
private fun onChildBack() {
val isEmptyStack = childStack.value.backStack.isEmpty()
val isSuccess = model.uiState.successState != null

12
features/swap/impl/src/main/java/com/tangem/feature/swap/converters/SwapProviderStateBuilder.kt
View file

@ -59,6 +59,7 @@ internal object SwapProviderStateBuilder {
),
selectionType = selectionType,
percentLowerThenBest = PercentDifference.Empty,
approvalSettings = ProviderState.ApprovalSettings.Empty,
onProviderClick = onProviderClick,
)
}
@ -76,6 +77,7 @@ internal object SwapProviderStateBuilder {
selectionType: ProviderState.SelectionType,
needApplyFCARestrictions: Boolean,
onProviderClick: (String) -> Unit,
onApprovalSelectClick: (SwapProvider) -> Unit = {},
): ProviderState.Content {
return provider.toContent(
subtitle = buildSelectableSubtitle(toTokenInfo),
@ -88,6 +90,12 @@ internal object SwapProviderStateBuilder {
percentLowerThenBest = pricesLowerBest[provider.providerId]
?.let(PercentDifference::Value)
?: PercentDifference.Value(0f),
approvalSettings = when (permissionState) {
is PermissionDataState.PermissionSettings -> ProviderState.ApprovalSettings.Content(
onApprovalSelectClick = { onApprovalSelectClick(provider) },
)
else -> ProviderState.ApprovalSettings.Empty
},
onProviderClick = onProviderClick,
)
}
@ -111,6 +119,7 @@ internal object SwapProviderStateBuilder {
),
selectionType = selectionType,
percentLowerThenBest = PercentDifference.Empty,
approvalSettings = ProviderState.ApprovalSettings.Empty,
onProviderClick = onProviderClick,
)
}
@ -147,11 +156,13 @@ internal object SwapProviderStateBuilder {
}
}
@Suppress("LongParameterList")
private fun SwapProvider.toContent(
subtitle: TextReference,
additionalBadge: ProviderState.AdditionalBadge,
selectionType: ProviderState.SelectionType,
percentLowerThenBest: PercentDifference,
approvalSettings: ProviderState.ApprovalSettings,
onProviderClick: (String) -> Unit,
): ProviderState.Content {
return ProviderState.Content(
@ -165,6 +176,7 @@ internal object SwapProviderStateBuilder {
percentLowerThenBest = percentLowerThenBest,
namePrefix = ProviderState.PrefixType.NONE,
onProviderClick = onProviderClick,
approvalSettings = approvalSettings,
)
}

133
features/swap/impl/src/main/java/com/tangem/feature/swap/model/SwapModel.kt
View file

@ -15,6 +15,7 @@ import com.tangem.blockchain.common.transaction.TransactionFee
import com.tangem.blockchainsdk.utils.fromNetworkId
import com.tangem.common.routing.AppRoute
import com.tangem.common.routing.AppRouter
import com.tangem.common.ui.bottomsheet.permission.state.ApproveType
import com.tangem.core.analytics.api.AnalyticsErrorHandler
import com.tangem.core.analytics.api.AnalyticsEventHandler
import com.tangem.core.analytics.models.AnalyticsParam
@ -57,6 +58,7 @@ import com.tangem.domain.models.currency.CryptoCurrency
import com.tangem.domain.models.currency.CryptoCurrencyStatus
import com.tangem.domain.models.network.Network
import com.tangem.domain.models.wallet.UserWalletId
import com.tangem.domain.models.wallet.isHotWallet
import com.tangem.domain.pay.WithdrawalResult
import com.tangem.domain.pay.usecase.GetPaymentAccountCryptoCurrencyStatusUseCase
import com.tangem.domain.settings.usercountry.GetUserCountryUseCase
@ -89,10 +91,7 @@ import com.tangem.feature.swap.domain.models.SwapAmount
import com.tangem.feature.swap.domain.models.domain.*
import com.tangem.feature.swap.domain.models.ui.*
import com.tangem.feature.swap.domain.transfer.SwapTransferInteractor
import com.tangem.feature.swap.models.SwapAlertUM
import com.tangem.feature.swap.models.SwapStateHolder
import com.tangem.feature.swap.models.TokenSelectionDirection
import com.tangem.feature.swap.models.UiActions
import com.tangem.feature.swap.models.*
import com.tangem.feature.swap.models.states.SwapNotificationUM
import com.tangem.feature.swap.router.SwapRoute
import com.tangem.feature.swap.ui.StateBuilder
@ -100,6 +99,8 @@ import com.tangem.feature.swap.ui.transfer.SwapTransferStateBuilder
import com.tangem.feature.swap.utils.formatToUIRepresentation
import com.tangem.feature.swap.utils.getContractAddress
import com.tangem.features.approval.api.GiveApprovalComponent
import com.tangem.features.approval.api.GiveApprovalEntryComponent
import com.tangem.features.approval.api.SelectApprovalTypeComponent
import com.tangem.features.commonfeatures.api.choosetoken.ChooseTokenAnalyticsPayload
import com.tangem.features.commonfeatures.api.choosetoken.ChooseTokenBridge
import com.tangem.features.commonfeatures.api.choosetoken.ChooseTokenResult
@ -163,7 +164,7 @@ internal class SwapModel @Inject constructor(
private val messageSender: UiMessageSender,
private val initialCurrenciesResolver: InitialCurrenciesResolver,
private val allowPermissionsHandler: AllowPermissionsHandler,
swapFeatureToggles: SwapFeatureToggles,
private val swapFeatureToggles: SwapFeatureToggles,
private val getSwapUiModeUseCase: GetSwapUiModeUseCase,
private val setSwapUiModeUseCase: SetSwapUiModeUseCase,
private val calculateAmountUseCase: CalculateAmountUseCase,
@ -223,7 +224,7 @@ internal class SwapModel @Inject constructor(
}
var uiState: SwapStateHolder by mutableStateOf(stateBuilder.createInitialLoadingState())
private set
internal set
val feeSelectorRepository = FeeSelectorRepository()
@ -249,9 +250,17 @@ internal class SwapModel @Inject constructor(
private var preselectedFromCurrency: CryptoCurrency? = null
private var preselectedToCurrency: CryptoCurrency? = null
val approvalSlotNavigation = SlotNavigation<Unit>()
val isPermissionNotNeeded: Boolean
get() {
val permissionState = dataState.getCurrentLoadedSwapState()?.permissionState
return permissionState == PermissionDataState.Empty ||
swapFeatureToggles.isSwapIntegratedApproveEnabled &&
permissionState is PermissionDataState.PermissionSettings
}
val approvalCallback = object : GiveApprovalComponent.Callback {
val approvalSlotNavigation = SlotNavigation<GiveApprovalEntryComponent.Mode>()
internal val approvalFullCallback = object : GiveApprovalComponent.Callback {
override fun onApproveClick() {}
override fun onApproveDone() {
@ -276,6 +285,46 @@ internal class SwapModel @Inject constructor(
}
}
internal val approvalSelectorCallback = object : SelectApprovalTypeComponent.Callback {
override fun onApproveTypeSelected(spenderAddress: String, approveType: ApproveType) {
val (swapState, permission) = dataState.lastLoadedSwapStates.firstNotNullOfOrNull { (provider, state) ->
if (state !is SwapState.QuotesLoadedState) return@firstNotNullOfOrNull null
val permissionState = state.permissionState
if (permissionState is PermissionDataState.PermissionSettings &&
permissionState.spenderAddress == spenderAddress
) {
state to permissionState
} else {
null
}
} ?: return
if (permission.type == approveType) {
approvalSlotNavigation.dismiss()
return
}
dataState = dataState.copy(
lastLoadedSwapStates = dataState.lastLoadedSwapStates.toMutableMap().apply {
put(
swapState.swapProvider,
swapState.copy(permissionState = permission.copy(type = approveType)),
)
},
)
approvalSlotNavigation.dismiss()
modelScope.launch {
feeSelectorRepository.state.value = FeeSelectorUM.Loading
feeSelectorReloadTrigger.triggerLoadingState()
feeSelectorReloadTrigger.triggerUpdate()
}
}
override fun onCancelClick() {
approvalSlotNavigation.dismiss()
}
}
init {
subscribeToTokenSelection()
@ -974,8 +1023,6 @@ internal class SwapModel @Inject constructor(
tokenSwapInfoForProviders = successStates.entries
.associate { it.key.providerId to it.value.toTokenInfo },
)
val isPermissionNotNeeded =
dataState.getCurrentLoadedSwapState()?.permissionState == PermissionDataState.Empty
if (shouldUpdateFeeBlock && isPermissionNotNeeded) {
modelScope.launch { feeSelectorReloadTrigger.triggerUpdate() }
} else {
@ -1783,13 +1830,27 @@ internal class SwapModel @Inject constructor(
onPredefinedPercentSelected = ::onPredefinedPercentSelected,
onReduceToAmount = ::onReduceAmountClicked,
onReduceByAmount = ::onReduceAmountClicked,
openPermissionBottomSheet = {
onApproveClick = {
singleTaskScheduler.cancelTask()
sendGivePermissionClickedEvent()
approvalSlotNavigation.activate(Unit)
val approval = getApprovalParams()
if (approval != null) {
approvalSlotNavigation.activate(
GiveApprovalEntryComponent.Mode.FullApproval(approval),
)
}
},
onApproveTypeSelect = { provider ->
val approval = getSelectApprovalTypeParams(provider)
if (approval != null) {
approvalSlotNavigation.activate(
GiveApprovalEntryComponent.Mode.SelectOnly(approval),
)
}
},
onAmountSelected = { onAmountSelected(it) },
onProviderClick = { providerId ->
singleTaskScheduler.cancelTask()
analyticsEventHandler.send(SwapEvents.ProviderClicked())
val states = dataState.lastLoadedSwapStates.getLastLoadedSuccessStates()
val pricesLowerBest = getPricesLowerBest(providerId, states)
@ -2394,6 +2455,54 @@ internal class SwapModel @Inject constructor(
}
}
internal fun getSelectApprovalTypeParams(provider: SwapProvider): SelectApprovalTypeComponent.Params? {
val fromSwapCurrencyStatus = dataState.fromSwapCurrencyStatus ?: return null
val swapState = dataState.lastLoadedSwapStates[provider] as? SwapState.QuotesLoadedState ?: return null
val permissionState = swapState.permissionState as? PermissionDataState.PermissionSettings ?: return null
val providerName = swapState.swapProvider.name
val approvalType = permissionState.type
return SelectApprovalTypeComponent.Params(
userWalletId = params.userWalletId,
cryptoCurrencyStatus = fromSwapCurrencyStatus.status,
initialApproveType = approvalType,
amountFooter = resourceReference(
id = R.string.give_permission_swap_subtitle,
formatArgs = wrappedList(providerName, fromSwapCurrencyStatus.currency.symbol),
),
spenderAddress = permissionState.spenderAddress,
callback = approvalSelectorCallback,
)
}
internal fun getApprovalParams(): GiveApprovalComponent.Params? {
val permissionState = uiState.permissionUM as? SwapPermissionUM.PermissionRequired ?: return null
val fromSwapCurrencyStatus = dataState.fromSwapCurrencyStatus ?: return null
val feeCryptoCurrency = dataState.feePaidCryptoCurrency ?: return null
val providerName = dataState.selectedProvider?.name.orEmpty()
val isHoldToConfirm = fromSwapCurrencyStatus.userWallet.isHotWallet
return GiveApprovalComponent.Params(
userWalletId = params.userWalletId,
cryptoCurrencyStatus = fromSwapCurrencyStatus.status,
feeCryptoCurrencyStatus = feeCryptoCurrency,
amount = dataState.amount.orEmpty(),
spenderAddress = permissionState.spenderAddress,
amountFooter = if (permissionState.isResetApproval) {
resourceReference(R.string.update_approval_permission_subtitle)
} else {
resourceReference(
id = R.string.give_permission_swap_subtitle,
formatArgs = wrappedList(providerName, fromSwapCurrencyStatus.currency.symbol),
)
},
feeFooter = resourceReference(R.string.swap_give_permission_fee_footer),
isResetApproval = permissionState.isResetApproval,
isHoldToConfirm = isHoldToConfirm,
callback = approvalFullCallback,
)
}
private companion object {
const val INITIAL_AMOUNT = ""
const val UPDATE_DELAY = 10000L

2
features/swap/impl/src/main/java/com/tangem/feature/swap/model/SwapNotificationsFactory.kt
View file

@ -249,7 +249,7 @@ internal class SwapNotificationsFactory(
if (quoteModel.permissionState is PermissionDataState.PermissionRequired) {
add(
SwapNotificationUM.Info.PermissionNeeded(
onApproveClick = actions.openPermissionBottomSheet,
onApproveClick = actions.onApproveClick,
onLearnMoreClick = { actions.onLinkClick(TangemSiteUrlBuilder.HELP_CENTER_SWAP_URL) },
),
)

4
features/swap/impl/src/main/java/com/tangem/feature/swap/models/UiActions.kt
View file

@ -4,6 +4,7 @@ import com.tangem.domain.models.currency.CryptoCurrency
import com.tangem.domain.express.models.ProviderFilterType
import com.tangem.domain.swap.models.PredefinedPercentAmount
import com.tangem.feature.swap.domain.models.SwapAmount
import com.tangem.feature.swap.domain.models.domain.SwapProvider
import com.tangem.feature.swap.domain.models.domain.SwapUIMode
import java.math.BigDecimal
@ -18,7 +19,8 @@ internal data class UiActions(
val onPredefinedPercentSelected: (PredefinedPercentAmount) -> Unit,
val onReduceToAmount: (SwapAmount) -> Unit,
val onReduceByAmount: (SwapAmount, reduceBy: BigDecimal) -> Unit,
val openPermissionBottomSheet: () -> Unit,
val onApproveClick: () -> Unit,
val onApproveTypeSelect: (SwapProvider) -> Unit,
// region new actions
val onRetryClick: () -> Unit,
val onProviderClick: (String) -> Unit,

1
features/swap/impl/src/main/java/com/tangem/feature/swap/ui/ChooseProviderBottomSheet.kt
View file

@ -178,6 +178,7 @@ private fun Preview_ChooseProviderBottomSheet() {
percentLowerThenBest = PercentDifference.Value(-1.0f),
selectionType = ProviderState.SelectionType.SELECT,
namePrefix = ProviderState.PrefixType.NONE,
approvalSettings = ProviderState.ApprovalSettings.Empty,
onProviderClick = {},
),
ProviderState.Unavailable(

5
features/swap/impl/src/main/java/com/tangem/feature/swap/ui/StateBuilder.kt
View file

@ -99,7 +99,7 @@ internal class StateBuilder(
onMaxAmountSelected = actions.onMaxAmountSelected,
onPredefinedPercentSelected = actions.onPredefinedPercentSelected,
changeCardsButtonState = ChangeCardsButtonState.DISABLED,
onShowPermissionBottomSheet = actions.openPermissionBottomSheet,
onShowPermissionBottomSheet = actions.onApproveClick,
onSelectTokenClick = actions.onSelectTokenClick,
onSuccess = actions.onSuccess,
providerState = ProviderState.Empty(),
@ -1033,6 +1033,7 @@ internal class StateBuilder(
pricesLowerBest = pricesLowerBest,
onProviderSelect = actions.onProviderSelect,
needApplyFCARestrictions = needApplyFCARestrictions,
onApprovalSelectClick = actions.onApproveTypeSelect,
)
}
.sortedWith(ProviderPercentDiffComparator)
@ -1136,6 +1137,7 @@ internal class StateBuilder(
private fun Map.Entry<SwapProvider, SwapState>.convertToProviderBottomSheetState(
pricesLowerBest: Map<String, Float>,
onProviderSelect: (String) -> Unit,
onApprovalSelectClick: (SwapProvider) -> Unit,
needApplyFCARestrictions: Boolean,
): ProviderState? {
val provider = this.key
@ -1150,6 +1152,7 @@ internal class StateBuilder(
selectionType = ProviderState.SelectionType.SELECT,
needApplyFCARestrictions = needApplyFCARestrictions,
onProviderClick = onProviderSelect,
onApprovalSelectClick = onApprovalSelectClick,
)
}
is SwapState.SwapError -> getProviderStateForError(

70
features/swap/impl/src/test/java/com/tangem/feature/swap/model/SwapModelApprovalFullCallbackTest.kt Normal file
View file

@ -0,0 +1,70 @@
package com.tangem.feature.swap.model
import com.tangem.domain.models.currency.CryptoCurrency
import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
/**
* Tests for [SwapModel.approvalFullCallback] (the full give-approval flow callback).
*
* Covers the synchronously-verifiable side effects. The quote-reload path
* ([SwapModel] `startLoadingQuotesFromLastState`) short-circuits because `dataState.amount` is null
* in these setups, keeping the callbacks side-effect-bounded.
*/
@OptIn(ExperimentalCoroutinesApi::class)
internal class SwapModelApprovalFullCallbackTest : SwapModelTestBase() {
@BeforeEach
fun setUp() {
setUpBase()
}
@Test
fun `GIVEN token from-currency WHEN onApproveDone THEN adds contract address to in-progress`() = runTest {
val model = createModel()
val token = mockk<CryptoCurrency.Token>(relaxed = true) {
every { contractAddress } returns "0xContract"
}
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = swapCurrencyStatus(currency = token),
)
model.approvalFullCallback.onApproveDone()
verify(exactly = 1) { allowPermissionsHandler.addAddressToInProgress("0xContract") }
}
@Test
fun `GIVEN null from-currency WHEN onApproveDone THEN does not add address to in-progress`() = runTest {
val model = createModel()
model.dataState = model.dataState.copy(fromSwapCurrencyStatus = null)
model.approvalFullCallback.onApproveDone()
verify(exactly = 0) { allowPermissionsHandler.addAddressToInProgress(any()) }
}
@Test
fun `GIVEN failure WHEN onApproveFailed THEN sends alert message`() = runTest {
val model = createModel()
model.approvalFullCallback.onApproveFailed()
verify(exactly = 1) { messageSender.send(any()) }
}
@Test
fun `WHEN onApproveClick THEN no interactions`() = runTest {
val model = createModel()
// onApproveClick is intentionally a no-op; assert it does not crash.
model.approvalFullCallback.onApproveClick()
verify(exactly = 0) { allowPermissionsHandler.addAddressToInProgress(any()) }
}
}

111
features/swap/impl/src/test/java/com/tangem/feature/swap/model/SwapModelApprovalSelectorCallbackTest.kt Normal file
View file

@ -0,0 +1,111 @@
package com.tangem.feature.swap.model
import com.google.common.truth.Truth.assertThat
import com.tangem.common.ui.bottomsheet.permission.state.ApproveType
import com.tangem.feature.swap.domain.models.ui.PermissionDataState
import com.tangem.features.send.v2.api.entity.FeeSelectorUM
import io.mockk.coVerify
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
/**
* Tests for [SwapModel.approvalSelectorCallback] (the [PermissionDataState.PermissionSettings]
* approval-type selector).
*/
@OptIn(ExperimentalCoroutinesApi::class)
internal class SwapModelApprovalSelectorCallbackTest : SwapModelTestBase() {
@BeforeEach
fun setUp() {
setUpBase()
}
@Test
fun `GIVEN no current loaded state WHEN onApproveTypeSelected THEN no state change and no reload`() = runTest {
val model = createModel()
val before = model.dataState
model.approvalSelectorCallback.onApproveTypeSelected("0xSpender", ApproveType.UNLIMITED)
assertThat(model.dataState).isEqualTo(before)
coVerify(exactly = 0) { feeSelectorReloadTrigger.triggerLoadingState() }
coVerify(exactly = 0) { feeSelectorReloadTrigger.triggerUpdate() }
}
@Test
fun `GIVEN permission is not PermissionSettings WHEN onApproveTypeSelected THEN no reload`() = runTest {
val provider = swapProvider()
val model = createModel()
model.dataState = model.dataState.copy(
selectedProvider = provider,
lastLoadedSwapStates = mapOf(provider to quotesLoadedState(provider, PermissionDataState.Empty)),
)
model.approvalSelectorCallback.onApproveTypeSelected("0xSpender", ApproveType.UNLIMITED)
coVerify(exactly = 0) { feeSelectorReloadTrigger.triggerLoadingState() }
coVerify(exactly = 0) { feeSelectorReloadTrigger.triggerUpdate() }
}
@Test
fun `GIVEN same approve type WHEN onApproveTypeSelected THEN no state change and no reload`() = runTest {
val provider = swapProvider()
val model = createModel()
model.dataState = model.dataState.copy(
selectedProvider = provider,
lastLoadedSwapStates = mapOf(
provider to quotesLoadedState(provider, permissionSettings(type = ApproveType.LIMITED)),
),
)
val before = model.dataState
model.approvalSelectorCallback.onApproveTypeSelected("0xSpender", ApproveType.LIMITED)
assertThat(model.dataState).isEqualTo(before)
coVerify(exactly = 0) { feeSelectorReloadTrigger.triggerLoadingState() }
coVerify(exactly = 0) { feeSelectorReloadTrigger.triggerUpdate() }
}
@Test
fun `GIVEN different approve type WHEN onApproveTypeSelected THEN updates state and triggers reload`() = runTest {
val provider = swapProvider()
val model = createModel()
model.dataState = model.dataState.copy(
selectedProvider = provider,
lastLoadedSwapStates = mapOf(
provider to quotesLoadedState(provider, permissionSettings(type = ApproveType.LIMITED)),
),
)
model.approvalSelectorCallback.onApproveTypeSelected("0xSpender", ApproveType.UNLIMITED)
val updated = model.dataState.getCurrentLoadedSwapState()
val settings = updated?.permissionState as? PermissionDataState.PermissionSettings
assertThat(settings).isNotNull()
assertThat(settings!!.type).isEqualTo(ApproveType.UNLIMITED)
assertThat(model.feeSelectorRepository.state.value).isEqualTo(FeeSelectorUM.Loading)
coVerify(exactly = 1) { feeSelectorReloadTrigger.triggerLoadingState() }
coVerify(exactly = 1) { feeSelectorReloadTrigger.triggerUpdate() }
}
@Test
fun `GIVEN any state WHEN onCancelClick THEN no state change and no reload`() = runTest {
val provider = swapProvider()
val model = createModel()
model.dataState = model.dataState.copy(
selectedProvider = provider,
lastLoadedSwapStates = mapOf(
provider to quotesLoadedState(provider, permissionSettings()),
),
)
val before = model.dataState
model.approvalSelectorCallback.onCancelClick()
assertThat(model.dataState).isEqualTo(before)
coVerify(exactly = 0) { feeSelectorReloadTrigger.triggerLoadingState() }
coVerify(exactly = 0) { feeSelectorReloadTrigger.triggerUpdate() }
}
}

142
features/swap/impl/src/test/java/com/tangem/feature/swap/model/SwapModelGetApprovalParamsTest.kt Normal file
View file

@ -0,0 +1,142 @@
package com.tangem.feature.swap.model
import com.google.common.truth.Truth.assertThat
import com.tangem.domain.models.currency.CryptoCurrency
import com.tangem.domain.models.currency.CryptoCurrencyStatus
import com.tangem.domain.models.wallet.UserWallet
import com.tangem.feature.swap.models.SwapPermissionUM
import io.mockk.every
import io.mockk.mockk
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
/**
* Tests for [SwapModel.getApprovalParams].
*
* Builds [com.tangem.features.approval.api.GiveApprovalComponent.Params] only when:
* - `uiState.permissionUM` is [SwapPermissionUM.PermissionRequired]
* - `fromSwapCurrencyStatus` is non-null
* - `feePaidCryptoCurrency` is non-null
*/
internal class SwapModelGetApprovalParamsTest : SwapModelTestBase() {
@BeforeEach
fun setUp() {
setUpBase()
}
@Test
fun `GIVEN permissionUM is not PermissionRequired THEN returns null`() {
val model = createModel()
// default uiState has permissionUM == Empty
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = swapCurrencyStatus(),
feePaidCryptoCurrency = mockk(relaxed = true),
)
assertThat(model.getApprovalParams()).isNull()
}
@Test
fun `GIVEN null fromSwapCurrencyStatus THEN returns null`() {
val model = createModel()
model.uiState = model.uiState.copy(
permissionUM = SwapPermissionUM.PermissionRequired(isResetApproval = false, spenderAddress = "0xSpender"),
)
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = null,
feePaidCryptoCurrency = mockk(relaxed = true),
)
assertThat(model.getApprovalParams()).isNull()
}
@Test
fun `GIVEN null feePaidCryptoCurrency THEN returns null`() {
val model = createModel()
model.uiState = model.uiState.copy(
permissionUM = SwapPermissionUM.PermissionRequired(isResetApproval = false, spenderAddress = "0xSpender"),
)
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = swapCurrencyStatus(),
feePaidCryptoCurrency = null,
)
assertThat(model.getApprovalParams()).isNull()
}
@Test
fun `GIVEN give-approval prerequisites met THEN builds params with give footer`() {
val model = createModel()
val coldWallet = mockk<UserWallet.Cold>(relaxed = true)
val currency = mockk<CryptoCurrency>(relaxed = true) { every { symbol } returns "DAI" }
val status = mockk<CryptoCurrencyStatus>(relaxed = true)
val from = swapCurrencyStatus(wallet = coldWallet, status = status, currency = currency)
val feeStatus: CryptoCurrencyStatus = mockk(relaxed = true)
val provider = swapProvider(name = "1inch")
model.uiState = model.uiState.copy(
permissionUM = SwapPermissionUM.PermissionRequired(isResetApproval = false, spenderAddress = "0xSpender"),
)
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = from,
feePaidCryptoCurrency = feeStatus,
selectedProvider = provider,
amount = "12.5",
)
val params = model.getApprovalParams()
assertThat(params).isNotNull()
assertThat(params!!.userWalletId).isEqualTo(userWalletId)
assertThat(params.cryptoCurrencyStatus).isEqualTo(status)
assertThat(params.feeCryptoCurrencyStatus).isEqualTo(feeStatus)
assertThat(params.amount).isEqualTo("12.5")
assertThat(params.spenderAddress).isEqualTo("0xSpender")
assertThat(params.isResetApproval).isFalse()
// Cold wallet -> not hold-to-confirm
assertThat(params.isHoldToConfirm).isFalse()
assertThat(params.callback).isSameInstanceAs(model.approvalFullCallback)
}
@Test
fun `GIVEN hot wallet THEN isHoldToConfirm is true`() {
val model = createModel()
val hotWallet = mockk<UserWallet.Hot>(relaxed = true)
val from = swapCurrencyStatus(wallet = hotWallet)
model.uiState = model.uiState.copy(
permissionUM = SwapPermissionUM.PermissionRequired(isResetApproval = false, spenderAddress = "0xSpender"),
)
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = from,
feePaidCryptoCurrency = mockk(relaxed = true),
amount = "1",
)
val params = model.getApprovalParams()
assertThat(params).isNotNull()
assertThat(params!!.isHoldToConfirm).isTrue()
}
@Test
fun `GIVEN reset approval THEN isResetApproval is true`() {
val model = createModel()
val from = swapCurrencyStatus()
model.uiState = model.uiState.copy(
permissionUM = SwapPermissionUM.PermissionRequired(isResetApproval = true, spenderAddress = "0xSpender"),
)
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = from,
feePaidCryptoCurrency = mockk(relaxed = true),
amount = "1",
)
val params = model.getApprovalParams()
assertThat(params).isNotNull()
assertThat(params!!.isResetApproval).isTrue()
}
}

76
features/swap/impl/src/test/java/com/tangem/feature/swap/model/SwapModelGetSelectApprovalTypeParamsTest.kt Normal file
View file

@ -0,0 +1,76 @@
package com.tangem.feature.swap.model
import com.google.common.truth.Truth.assertThat
import com.tangem.common.ui.bottomsheet.permission.state.ApproveType
import com.tangem.domain.models.currency.CryptoCurrency
import com.tangem.domain.models.currency.CryptoCurrencyStatus
import com.tangem.feature.swap.domain.models.ui.PermissionDataState
import com.tangem.feature.swap.domain.models.ui.SwapState
import io.mockk.every
import io.mockk.mockk
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
/**
* Tests for [SwapModel.getSelectApprovalTypeParams].
*
* Builds [com.tangem.features.approval.api.SelectApprovalTypeComponent.Params] from the current
* `fromSwapCurrencyStatus` and the provider's loaded swap state. Returns `null` when prerequisites
* are missing. `initialApproveType` is taken from [PermissionDataState.PermissionSettings.type] or
* falls back to [ApproveType.LIMITED].
*/
internal class SwapModelGetSelectApprovalTypeParamsTest : SwapModelTestBase() {
@BeforeEach
fun setUp() {
setUpBase()
}
@Test
fun `GIVEN null fromSwapCurrencyStatus THEN returns null`() {
val provider = swapProvider()
val model = createModel()
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = null,
lastLoadedSwapStates = mapOf(provider to quotesLoadedState(provider, permissionSettings())),
)
assertThat(model.getSelectApprovalTypeParams(provider)).isNull()
}
@Test
fun `GIVEN provider state is not QuotesLoadedState THEN returns null`() {
val provider = swapProvider()
val notLoaded: SwapState.EmptyAmountState = mockk(relaxed = true)
val model = createModel()
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = swapCurrencyStatus(),
lastLoadedSwapStates = mapOf(provider to notLoaded),
)
assertThat(model.getSelectApprovalTypeParams(provider)).isNull()
}
@Test
fun `GIVEN PermissionSettings present THEN uses its type as initialApproveType`() {
val provider = swapProvider(name = "ParaSwap")
val currency = mockk<CryptoCurrency>(relaxed = true) { every { symbol } returns "USDT" }
val status = mockk<CryptoCurrencyStatus>(relaxed = true)
val from = swapCurrencyStatus(status = status, currency = currency)
val model = createModel()
model.dataState = model.dataState.copy(
fromSwapCurrencyStatus = from,
lastLoadedSwapStates = mapOf(
provider to quotesLoadedState(provider, permissionSettings(type = ApproveType.UNLIMITED)),
),
)
val params = model.getSelectApprovalTypeParams(provider)
assertThat(params).isNotNull()
assertThat(params!!.userWalletId).isEqualTo(userWalletId)
assertThat(params.cryptoCurrencyStatus).isEqualTo(status)
assertThat(params.initialApproveType).isEqualTo(ApproveType.UNLIMITED)
assertThat(params.callback).isSameInstanceAs(model.approvalSelectorCallback)
}
}

92
features/swap/impl/src/test/java/com/tangem/feature/swap/model/SwapModelIsPermissionNotNeededTest.kt Normal file
View file

@ -0,0 +1,92 @@
package com.tangem.feature.swap.model
import com.google.common.truth.Truth.assertThat
import com.tangem.feature.swap.domain.models.ui.PermissionDataState
import io.mockk.every
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
/**
* Tests for [SwapModel.isPermissionNotNeeded].
*
* The getter is `true` when the current loaded swap state needs no approval:
* - always when [PermissionDataState.Empty]
* - additionally for [PermissionDataState.PermissionSettings] when the integrated-approve toggle is ON
*/
internal class SwapModelIsPermissionNotNeededTest : SwapModelTestBase() {
@BeforeEach
fun setUp() {
setUpBase()
}
private fun modelWithPermissionState(
permissionState: PermissionDataState,
isIntegratedApproveEnabled: Boolean,
): SwapModel {
every { swapFeatureToggles.isSwapIntegratedApproveEnabled } returns isIntegratedApproveEnabled
val provider = swapProvider()
val model = createModel()
model.dataState = model.dataState.copy(
selectedProvider = provider,
lastLoadedSwapStates = mapOf(provider to quotesLoadedState(provider, permissionState)),
)
return model
}
@Test
fun `GIVEN toggle OFF and Empty permission THEN permission is not needed`() {
val model = modelWithPermissionState(PermissionDataState.Empty, isIntegratedApproveEnabled = false)
assertThat(model.isPermissionNotNeeded).isTrue()
}
@Test
fun `GIVEN toggle OFF and PermissionSettings THEN permission is needed`() {
val model = modelWithPermissionState(permissionSettings(), isIntegratedApproveEnabled = false)
assertThat(model.isPermissionNotNeeded).isFalse()
}
@Test
fun `GIVEN toggle OFF and PermissionRequired THEN permission is needed`() {
val model = modelWithPermissionState(
PermissionDataState.PermissionRequired(isResetApproval = false, spenderAddress = "0x"),
isIntegratedApproveEnabled = false,
)
assertThat(model.isPermissionNotNeeded).isFalse()
}
@Test
fun `GIVEN toggle ON and Empty permission THEN permission is not needed`() {
val model = modelWithPermissionState(PermissionDataState.Empty, isIntegratedApproveEnabled = true)
assertThat(model.isPermissionNotNeeded).isTrue()
}
@Test
fun `GIVEN toggle ON and PermissionSettings THEN permission is not needed`() {
val model = modelWithPermissionState(permissionSettings(), isIntegratedApproveEnabled = true)
assertThat(model.isPermissionNotNeeded).isTrue()
}
@Test
fun `GIVEN toggle ON and PermissionRequired THEN permission is needed`() {
val model = modelWithPermissionState(
PermissionDataState.PermissionRequired(isResetApproval = false, spenderAddress = "0x"),
isIntegratedApproveEnabled = true,
)
assertThat(model.isPermissionNotNeeded).isFalse()
}
@Test
fun `GIVEN no current loaded state THEN permission is needed`() {
every { swapFeatureToggles.isSwapIntegratedApproveEnabled } returns true
val model = createModel()
assertThat(model.isPermissionNotNeeded).isFalse()
}
}

236
features/swap/impl/src/test/java/com/tangem/feature/swap/model/SwapModelTestBase.kt Normal file
View file

@ -0,0 +1,236 @@
package com.tangem.feature.swap.model
import arrow.core.right
import com.tangem.common.ui.bottomsheet.permission.state.ApproveType
import com.tangem.core.analytics.api.AnalyticsErrorHandler
import com.tangem.core.analytics.api.AnalyticsEventHandler
import com.tangem.core.decompose.model.MutableParamsContainer
import com.tangem.core.decompose.navigation.Router
import com.tangem.core.decompose.ui.UiMessageSender
import com.tangem.core.navigation.url.UrlOpener
import com.tangem.common.routing.AppRouter
import com.tangem.datasource.local.appsflyer.AppsFlyerStore
import com.tangem.domain.account.status.usecase.GetAccountCurrencyStatusUseCase
import com.tangem.domain.account.status.usecase.GetFeePaidCryptoCurrencyStatusSyncUseCase
import com.tangem.domain.account.status.usecase.IsAccountsModeEnabledUseCase
import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
import com.tangem.domain.feedback.GetWalletMetaInfoUseCase
import com.tangem.domain.feedback.SaveBlockchainErrorUseCase
import com.tangem.domain.feedback.SendFeedbackEmailUseCase
import com.tangem.domain.models.currency.CryptoCurrency
import com.tangem.domain.models.currency.CryptoCurrencyStatus
import com.tangem.domain.models.wallet.UserWallet
import com.tangem.domain.models.wallet.UserWalletId
import com.tangem.domain.pay.usecase.GetPaymentAccountCryptoCurrencyStatusUseCase
import com.tangem.domain.settings.usercountry.GetUserCountryUseCase
import com.tangem.domain.settings.usercountry.models.UserCountry
import com.tangem.domain.stories.ShouldShowStoriesUseCase
import com.tangem.domain.swap.models.SwapCurrencyStatus
import com.tangem.domain.swap.usecase.CalculateAmountUseCase
import com.tangem.domain.tangempay.GetTangemPayCustomerIdUseCase
import com.tangem.domain.tangempay.TangemPayWithdrawUseCase
import com.tangem.domain.tangempay.TangemPayWithdrawWithSwapUseCase
import com.tangem.domain.tokens.GetMinimumTransactionAmountSyncUseCase
import com.tangem.domain.tokens.UpdateDelayedNetworkStatusUseCase
import com.tangem.domain.transaction.usecase.gasless.IsGaslessFeeSupportedForNetwork
import com.tangem.domain.txhistory.usecase.GetExplorerTransactionUrlUseCase
import com.tangem.feature.swap.domain.GetSwapUiModeUseCase
import com.tangem.feature.swap.domain.SetSwapUiModeUseCase
import com.tangem.feature.swap.domain.AllowPermissionsHandler
import com.tangem.feature.swap.domain.SwapInteractor
import com.tangem.feature.swap.domain.models.domain.ExchangeProviderType
import com.tangem.feature.swap.domain.models.domain.SwapProvider
import com.tangem.feature.swap.domain.models.ui.PermissionDataState
import com.tangem.feature.swap.domain.models.ui.SwapState
import com.tangem.feature.swap.domain.transfer.SwapTransferInteractor
import com.tangem.feature.swap.ui.transfer.SwapTransferStateBuilder
import com.tangem.features.commonfeatures.api.choosetoken.ChooseTokenBridge
import com.tangem.features.send.v2.api.subcomponents.feeSelector.FeeSelectorReloadTrigger
import com.tangem.features.swap.SwapComponent
import com.tangem.features.swap.SwapFeatureToggles
import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider
import io.mockk.coEvery
import io.mockk.every
import io.mockk.mockk
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.emptyFlow
/**
* Shared test infrastructure for [SwapModel] unit tests.
*
* Wires every constructor dependency as a relaxed MockK and stubs the init-block calls so that
* constructing the model has no observable side effects. See `swap-model-test-plan.md` for details.
*/
internal abstract class SwapModelTestBase {
protected val router: Router = mockk(relaxed = true)
protected val appRouter: AppRouter = mockk(relaxed = true)
protected val analyticsEventHandler: AnalyticsEventHandler = mockk(relaxed = true)
protected val analyticsErrorEventHandler: AnalyticsErrorHandler = mockk(relaxed = true)
protected val getSelectedAppCurrencyUseCase: GetSelectedAppCurrencyUseCase = mockk(relaxed = true)
protected val updateDelayedCurrencyStatusUseCase: UpdateDelayedNetworkStatusUseCase = mockk(relaxed = true)
protected val getFeePaidCryptoCurrencyStatusSyncUseCase: GetFeePaidCryptoCurrencyStatusSyncUseCase =
mockk(relaxed = true)
protected val getWalletMetaInfoUseCase: GetWalletMetaInfoUseCase = mockk(relaxed = true)
protected val saveBlockchainErrorUseCase: SaveBlockchainErrorUseCase = mockk(relaxed = true)
protected val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase = mockk(relaxed = true)
protected val getMinimumTransactionAmountSyncUseCase: GetMinimumTransactionAmountSyncUseCase =
mockk(relaxed = true)
protected val getExplorerTransactionUrlUseCase: GetExplorerTransactionUrlUseCase = mockk(relaxed = true)
protected val shouldShowStoriesUseCase: ShouldShowStoriesUseCase = mockk(relaxed = true)
protected val isAccountsModeEnabledUseCase: IsAccountsModeEnabledUseCase = mockk(relaxed = true)
protected val swapInteractor: SwapInteractor = mockk(relaxed = true)
protected val swapTransferInteractor: SwapTransferInteractor = mockk(relaxed = true)
protected val swapTransferStateBuilder: SwapTransferStateBuilder = mockk(relaxed = true)
protected val urlOpener: UrlOpener = mockk(relaxed = true)
protected val getAccountCurrencyStatusUseCase: GetAccountCurrencyStatusUseCase = mockk(relaxed = true)
protected val getPaymentAccountCryptoCurrencyStatusUseCase: GetPaymentAccountCryptoCurrencyStatusUseCase =
mockk(relaxed = true)
protected val tangemPayWithdrawWithSwapUseCase: TangemPayWithdrawWithSwapUseCase = mockk(relaxed = true)
protected val isGaslessFeeSupportedForNetwork: IsGaslessFeeSupportedForNetwork = mockk(relaxed = true)
protected val feeSelectorReloadTrigger: FeeSelectorReloadTrigger = mockk(relaxed = true)
protected val getTangemPayCustomerIdUseCase: GetTangemPayCustomerIdUseCase = mockk(relaxed = true)
protected val appsFlyerStore: AppsFlyerStore = mockk(relaxed = true)
protected val messageSender: UiMessageSender = mockk(relaxed = true)
protected val initialCurrenciesResolver: InitialCurrenciesResolver = mockk(relaxed = true)
protected val allowPermissionsHandler: AllowPermissionsHandler = mockk(relaxed = true)
protected val swapFeatureToggles: SwapFeatureToggles = mockk(relaxed = true)
protected val getSwapUiModeUseCase: GetSwapUiModeUseCase = mockk(relaxed = true)
protected val setSwapUiModeUseCase: SetSwapUiModeUseCase = mockk(relaxed = true)
protected val calculateAmountUseCase: CalculateAmountUseCase = mockk(relaxed = true)
private val chooseTokenBridgeFactory: ChooseTokenBridge.Factory = mockk(relaxed = true)
private val getUserCountryUseCase: GetUserCountryUseCase = mockk(relaxed = true)
private val getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase = mockk(relaxed = true)
protected val userWalletId = UserWalletId(stringValue = "0123456789ABCDEF")
/** Stubs init-block calls so [createModel] has no side effects. Call from `@BeforeEach`. */
protected fun setUpBase() {
val bridge = mockk<ChooseTokenBridge>(relaxed = true) {
every { onCurrencyChosen } returns Channel()
every { onClose } returns Channel()
}
every { chooseTokenBridgeFactory.create(any(), any(), any()) } returns bridge
every { getUserCountryUseCase.invokeSync() } returns UserCountry.Other("US").right()
every { getBalanceHidingSettingsUseCase.invoke() } returns emptyFlow()
coEvery { isAccountsModeEnabledUseCase.invokeSync() } returns false
coEvery { shouldShowStoriesUseCase.invokeSync(any()) } returns false
coEvery { initialCurrenciesResolver.invoke(any(), any(), any(), any()) } returns (null to null)
every { getSelectedAppCurrencyUseCase.invoke() } returns emptyFlow()
every { swapFeatureToggles.isSwapIntegratedApproveEnabled } returns true
}
protected fun createParams(): SwapComponent.Params = SwapComponent.Params(
userWalletId = userWalletId,
cryptoCurrency = null,
screenSource = "Test",
)
@Suppress("LongMethod")
protected fun createModel(): SwapModel = SwapModel(
paramsContainer = MutableParamsContainer(createParams()),
getUserCountryUseCase = getUserCountryUseCase,
getBalanceHidingSettingsUseCase = getBalanceHidingSettingsUseCase,
chooseTokenBridgeFactory = chooseTokenBridgeFactory,
router = router,
appRouter = appRouter,
dispatchers = TestingCoroutineDispatcherProvider(),
analyticsEventHandler = analyticsEventHandler,
analyticsErrorEventHandler = analyticsErrorEventHandler,
getSelectedAppCurrencyUseCase = getSelectedAppCurrencyUseCase,
updateDelayedCurrencyStatusUseCase = updateDelayedCurrencyStatusUseCase,
getFeePaidCryptoCurrencyStatusSyncUseCase = getFeePaidCryptoCurrencyStatusSyncUseCase,
getWalletMetaInfoUseCase = getWalletMetaInfoUseCase,
saveBlockchainErrorUseCase = saveBlockchainErrorUseCase,
sendFeedbackEmailUseCase = sendFeedbackEmailUseCase,
getMinimumTransactionAmountSyncUseCase = getMinimumTransactionAmountSyncUseCase,
getExplorerTransactionUrlUseCase = getExplorerTransactionUrlUseCase,
shouldShowStoriesUseCase = shouldShowStoriesUseCase,
isAccountsModeEnabledUseCase = isAccountsModeEnabledUseCase,
swapInteractor = swapInteractor,
swapTransferInteractor = swapTransferInteractor,
swapTransferStateBuilder = swapTransferStateBuilder,
urlOpener = urlOpener,
getAccountCurrencyStatusUseCase = getAccountCurrencyStatusUseCase,
getPaymentAccountCryptoCurrencyStatusUseCase = getPaymentAccountCryptoCurrencyStatusUseCase,
tangemPayWithdrawWithSwapUseCase = tangemPayWithdrawWithSwapUseCase,
isGaslessFeeSupportedForNetwork = isGaslessFeeSupportedForNetwork,
feeSelectorReloadTrigger = feeSelectorReloadTrigger,
getTangemPayCustomerIdUseCase = getTangemPayCustomerIdUseCase,
appsFlyerStore = appsFlyerStore,
messageSender = messageSender,
initialCurrenciesResolver = initialCurrenciesResolver,
allowPermissionsHandler = allowPermissionsHandler,
swapFeatureToggles = swapFeatureToggles,
getSwapUiModeUseCase = getSwapUiModeUseCase,
setSwapUiModeUseCase = setSwapUiModeUseCase,
calculateAmountUseCase = calculateAmountUseCase,
)
// region builders
protected fun swapProvider(
id: String = "provider-1",
name: String = "1inch",
type: ExchangeProviderType = ExchangeProviderType.DEX,
): SwapProvider = SwapProvider(
providerId = id,
name = name,
type = type,
imageLarge = "",
termsOfUse = null,
privacyPolicy = null,
slippage = null,
)
protected fun permissionSettings(
type: ApproveType = ApproveType.LIMITED,
spender: String = "0xSpender",
): PermissionDataState.PermissionSettings = PermissionDataState.PermissionSettings(
type = type,
spenderAddress = spender,
)
protected fun quotesLoadedState(
provider: SwapProvider,
permissionState: PermissionDataState = PermissionDataState.Empty,
): SwapState.QuotesLoadedState = mockk(relaxed = true) {
every { swapProvider } returns provider
every { this@mockk.permissionState } returns permissionState
every {
copy(
fromTokenInfo = any(),
toTokenInfo = any(),
priceImpact = any(),
preparedSwapConfigState = any(),
permissionState = any(),
swapDataModel = any(),
currencyCheck = any(),
validationResult = any(),
minAdaValue = any(),
swapProvider = any(),
)
} answers {
quotesLoadedState(
provider = provider,
permissionState = arg(4),
)
}
}
protected fun swapCurrencyStatus(
wallet: UserWallet = mockk(relaxed = true),
status: CryptoCurrencyStatus = mockk(relaxed = true),
currency: CryptoCurrency = mockk(relaxed = true),
): SwapCurrencyStatus = mockk(relaxed = true) {
every { userWallet } returns wallet
every { this@mockk.status } returns status
every { this@mockk.currency } returns currency
}
// endregion
}