From ccb9aa9110b673f5a27451692a4599e18b2d4972 Mon Sep 17 00:00:00 2001 From: Tangem Date: Tue, 23 Jun 2026 15:29:05 +0500 Subject: [PATCH] Updated on 2026-08-14 --- .../tangem/data/pay/di/TangemPayDataModule.kt | 14 +- .../RestoreActiveIssueOrdersUseCase.kt | 68 +++++++++ .../pay/usecase/RestoreActiveOrdersUseCase.kt | 30 ---- .../StartTangemPayOrderPollingUseCase.kt | 40 ++++-- .../RestoreActiveIssueOrdersUseCaseTest.kt | 130 ++++++++++++++++++ .../usecase/RestoreActiveOrdersUseCaseTest.kt | 72 ---------- .../StartTangemPayOrderPollingUseCaseTest.kt | 28 +++- .../wallet/child/wallet/model/WalletModel.kt | 4 +- .../subscribers/TangemPayMainSubscriber.kt | 5 + 9 files changed, 272 insertions(+), 119 deletions(-) create mode 100644 domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/RestoreActiveIssueOrdersUseCase.kt delete mode 100644 domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/RestoreActiveOrdersUseCase.kt create mode 100644 domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/RestoreActiveIssueOrdersUseCaseTest.kt delete mode 100644 domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/RestoreActiveOrdersUseCaseTest.kt diff --git a/data/visa/src/main/kotlin/com/tangem/data/pay/di/TangemPayDataModule.kt b/data/visa/src/main/kotlin/com/tangem/data/pay/di/TangemPayDataModule.kt index 071bda168c..30297c0d46 100644 --- a/data/visa/src/main/kotlin/com/tangem/data/pay/di/TangemPayDataModule.kt +++ b/data/visa/src/main/kotlin/com/tangem/data/pay/di/TangemPayDataModule.kt @@ -255,10 +255,18 @@ internal interface TangemPayDataModule { } @Provides - fun provideRestoreActiveOrdersUseCase( + fun provideRestoreActiveIssueOrdersUseCase( customerOrderRepository: CustomerOrderRepository, - ): RestoreActiveOrdersUseCase { - return RestoreActiveOrdersUseCase(customerOrderRepository) + issueCardRepository: TangemPayIssueCardRepository, + startTangemPayOrderPollingUseCase: StartTangemPayOrderPollingUseCase, + appCoroutineScope: AppCoroutineScope, + ): RestoreActiveIssueOrdersUseCase { + return RestoreActiveIssueOrdersUseCase( + customerOrderRepository = customerOrderRepository, + issueCardRepository = issueCardRepository, + startTangemPayOrderPollingUseCase = startTangemPayOrderPollingUseCase, + appCoroutineScope = appCoroutineScope, + ) } @Provides diff --git a/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/RestoreActiveIssueOrdersUseCase.kt b/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/RestoreActiveIssueOrdersUseCase.kt new file mode 100644 index 0000000000..f4b83bd2a5 --- /dev/null +++ b/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/RestoreActiveIssueOrdersUseCase.kt @@ -0,0 +1,68 @@ +package com.tangem.domain.pay.usecase + +import arrow.core.Either +import arrow.core.raise.Raise +import arrow.core.raise.catch +import arrow.core.raise.either +import com.tangem.domain.models.wallet.UserWalletId +import com.tangem.domain.pay.model.OrderStatus +import com.tangem.domain.pay.model.OrderType +import com.tangem.domain.pay.model.TangemPayOrderInfo +import com.tangem.domain.pay.repository.CustomerOrderRepository +import com.tangem.domain.pay.repository.TangemPayIssueCardRepository +import com.tangem.domain.visa.error.VisaApiError +import com.tangem.utils.coroutines.AppCoroutineScope +import com.tangem.utils.logging.TangemLogger +import kotlinx.coroutines.launch + +/** + * Restores in-flight card-issuance orders on app launch / when returning to the wallet screen. + * + * `findOrders` is the source of truth — a locally stored order id is only a hint that does not + + * survive a force close. This use case re-discovers the active issue orders, persists their ids so + * the payment-account state renders an "issuing" placeholder card, and (re)starts polling so the + * placeholder is driven to its terminal state. + * + * Non-fatal exceptions are logged and collapsed to [VisaApiError.Unspecified]; the caller treats the + * result as fire-and-forget. + * + * @property customerOrderRepository source of truth for active orders. + * @property issueCardRepository persists issue-order ids for placeholder rendering. + * @property startTangemPayOrderPollingUseCase drives a restored order to its terminal state. + */ +class RestoreActiveIssueOrdersUseCase( + private val customerOrderRepository: CustomerOrderRepository, + private val issueCardRepository: TangemPayIssueCardRepository, + private val startTangemPayOrderPollingUseCase: StartTangemPayOrderPollingUseCase, + private val appCoroutineScope: AppCoroutineScope, +) { + suspend operator fun invoke(userWalletId: UserWalletId): Either = either { + val orders = catch( + block = { + customerOrderRepository.findOrders( + userWalletId = userWalletId, + types = OrderType.issueCardTypes, + statuses = OrderStatus.activeStatuses, + ).bind() + }, + catch = { handleError(it) }, + ).filter { it.status.isActive } + + orders.forEach { order -> + issueCardRepository.storeIssueOrderId(userWalletId = userWalletId, orderId = order.id) + + appCoroutineScope.launch { + startTangemPayOrderPollingUseCase( + order = TangemPayOrderInfo(orderId = order.id, orderStatus = order.status), + userWalletId = userWalletId, + ) + } + } + } + + private fun Raise.handleError(throwable: Throwable): Nothing { + TangemLogger.e("Error in RestoreActiveIssueOrdersUseCase", throwable) + raise(VisaApiError.Unspecified) + } +} \ No newline at end of file diff --git a/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/RestoreActiveOrdersUseCase.kt b/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/RestoreActiveOrdersUseCase.kt deleted file mode 100644 index e812258ed6..0000000000 --- a/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/RestoreActiveOrdersUseCase.kt +++ /dev/null @@ -1,30 +0,0 @@ -package com.tangem.domain.pay.usecase - -import arrow.core.Either -import com.tangem.domain.models.wallet.UserWalletId -import com.tangem.domain.pay.model.Order -import com.tangem.domain.pay.model.OrderStatus -import com.tangem.domain.pay.repository.CustomerOrderRepository -import com.tangem.domain.visa.error.VisaApiError - -/** - - * same customer. - * - * Wraps `findOrders` (the source of truth) and filters to the active set (NEW / PROCESSING). - * The caller decides how to dispatch each order to the appropriate flow. - */ -class RestoreActiveOrdersUseCase( - private val customerOrderRepository: CustomerOrderRepository, -) { - suspend operator fun invoke(userWalletId: UserWalletId): Either> { - return customerOrderRepository.findOrders( - userWalletId = userWalletId, - statuses = ACTIVE_STATUSES, - ) - } - - private companion object { - val ACTIVE_STATUSES: Set = setOf(OrderStatus.NEW, OrderStatus.PROCESSING) - } -} \ No newline at end of file diff --git a/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/StartTangemPayOrderPollingUseCase.kt b/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/StartTangemPayOrderPollingUseCase.kt index d5c9ef3234..dc2b5ea60b 100644 --- a/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/StartTangemPayOrderPollingUseCase.kt +++ b/domain/visa/src/main/kotlin/com/tangem/domain/pay/usecase/StartTangemPayOrderPollingUseCase.kt @@ -6,25 +6,43 @@ import com.tangem.domain.pay.model.OrderStatus import com.tangem.domain.pay.model.TangemPayOrderInfo import com.tangem.domain.pay.repository.TangemPayCardDetailsRepository import kotlinx.coroutines.delay +import java.util.concurrent.ConcurrentHashMap class StartTangemPayOrderPollingUseCase( private val cardDetailsRepository: TangemPayCardDetailsRepository, private val paymentAccountStatusFetcher: PaymentAccountStatusFetcher, ) { + + /** + * Order keys (`walletId:orderId`) currently being polled. Keeps polling idempotent so callers that + * may fire repeatedly for the same order (e.g. order restore on every wallet (re)load) never spawn a + * second poller for it. + */ + private val activeOrders = ConcurrentHashMap.newKeySet() + suspend operator fun invoke(order: TangemPayOrderInfo, userWalletId: UserWalletId): Boolean { - while (true) { - val newOrder = if (order.orderStatus.isTerminal) { - order - } else { - cardDetailsRepository.getOrderInfo(userWalletId, order.orderId).getOrNull() - } + // A poller for this exact order is already running — `false` only reaches fire-and-forget issue + // callers (restore / issue-additional); the awaiting freeze caller always polls a fresh order id. + val key = "${userWalletId.stringValue}:${order.orderId}" + if (!activeOrders.add(key)) return false - if (newOrder != null && newOrder.orderStatus.isTerminal) { - paymentAccountStatusFetcher.invoke(userWalletId) - return newOrder.orderStatus == OrderStatus.COMPLETED - } + try { + while (true) { + val newOrder = if (order.orderStatus.isTerminal) { + order + } else { + cardDetailsRepository.getOrderInfo(userWalletId, order.orderId).getOrNull() + } - delay(POLLING_DELAY) + if (newOrder != null && newOrder.orderStatus.isTerminal) { + paymentAccountStatusFetcher.invoke(userWalletId) + return newOrder.orderStatus == OrderStatus.COMPLETED + } + + delay(POLLING_DELAY) + } + } finally { + activeOrders.remove(key) } } diff --git a/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/RestoreActiveIssueOrdersUseCaseTest.kt b/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/RestoreActiveIssueOrdersUseCaseTest.kt new file mode 100644 index 0000000000..bfbfecfd1a --- /dev/null +++ b/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/RestoreActiveIssueOrdersUseCaseTest.kt @@ -0,0 +1,130 @@ +package com.tangem.domain.pay.usecase + +import arrow.core.left +import arrow.core.right +import com.google.common.truth.Truth.assertThat +import com.tangem.domain.models.wallet.UserWalletId +import com.tangem.domain.pay.model.Order +import com.tangem.domain.pay.model.OrderStatus +import com.tangem.domain.pay.model.OrderType +import com.tangem.domain.pay.model.TangemPayOrderInfo +import com.tangem.domain.pay.repository.CustomerOrderRepository +import com.tangem.domain.pay.repository.TangemPayIssueCardRepository +import com.tangem.domain.visa.error.VisaApiError +import com.tangem.test.core.TestAppCoroutineScope +import io.mockk.coEvery +import io.mockk.coVerify +import io.mockk.mockk +import kotlinx.coroutines.test.runTest +import org.junit.jupiter.api.Test + +internal class RestoreActiveIssueOrdersUseCaseTest { + + private val orderRepository: CustomerOrderRepository = mockk() + private val issueCardRepository: TangemPayIssueCardRepository = mockk(relaxed = true) + private val startTangemPayOrderPollingUseCase: StartTangemPayOrderPollingUseCase = mockk(relaxed = true) + private val useCase = RestoreActiveIssueOrdersUseCase( + customerOrderRepository = orderRepository, + issueCardRepository = issueCardRepository, + startTangemPayOrderPollingUseCase = startTangemPayOrderPollingUseCase, + appCoroutineScope = TestAppCoroutineScope(), + ) + private val userWalletId = UserWalletId("1234567890ABCDEF") + + @Test + fun `GIVEN active issue orders WHEN invoke THEN each order is stored and polled`() = runTest { + // Arrange + val first = order(id = "first", type = OrderType.CARD_ISSUE_ADDITIONAL, status = OrderStatus.NEW) + val second = order(id = "second", type = OrderType.CARD_ISSUE_VIRTUAL_RAIN_KYC, status = OrderStatus.PROCESSING) + coEvery { + orderRepository.findOrders( + userWalletId = userWalletId, + types = ISSUE_ORDER_TYPES, + statuses = ACTIVE_STATUSES, + ) + } returns listOf(first, second).right() + + // Act + val result = useCase(userWalletId) + + // Assert + assertThat(result.isRight()).isTrue() + coVerify(exactly = 1) { issueCardRepository.storeIssueOrderId(userWalletId, first.id) } + coVerify(exactly = 1) { issueCardRepository.storeIssueOrderId(userWalletId, second.id) } + coVerify(exactly = 1) { + startTangemPayOrderPollingUseCase(TangemPayOrderInfo(first.id, first.status), userWalletId) + } + coVerify(exactly = 1) { + startTangemPayOrderPollingUseCase(TangemPayOrderInfo(second.id, second.status), userWalletId) + } + } + + @Test + fun `GIVEN no active orders WHEN invoke THEN nothing is stored or polled`() = runTest { + // Arrange + coEvery { + orderRepository.findOrders(userWalletId, types = ISSUE_ORDER_TYPES, statuses = ACTIVE_STATUSES) + } returns emptyList().right() + + // Act + val result = useCase(userWalletId) + + // Assert + assertThat(result.isRight()).isTrue() + coVerify(exactly = 0) { issueCardRepository.storeIssueOrderId(any(), any()) } + coVerify(exactly = 0) { startTangemPayOrderPollingUseCase(any(), any()) } + } + + @Test + fun `GIVEN a terminal order leaks through WHEN invoke THEN it is filtered out`() = runTest { + // Arrange + val completed = order(id = "done", type = OrderType.CARD_ISSUE_ADDITIONAL, status = OrderStatus.COMPLETED) + coEvery { + orderRepository.findOrders(userWalletId, types = ISSUE_ORDER_TYPES, statuses = ACTIVE_STATUSES) + } returns listOf(completed).right() + + // Act + val result = useCase(userWalletId) + + // Assert + assertThat(result.isRight()).isTrue() + coVerify(exactly = 0) { issueCardRepository.storeIssueOrderId(any(), any()) } + coVerify(exactly = 0) { startTangemPayOrderPollingUseCase(any(), any()) } + } + + @Test + fun `GIVEN findOrders fails WHEN invoke THEN returns Unspecified and stores nothing`() = runTest { + // Arrange + coEvery { + orderRepository.findOrders(userWalletId, types = ISSUE_ORDER_TYPES, statuses = ACTIVE_STATUSES) + } returns VisaApiError.Unspecified.left() + + // Act + val result = useCase(userWalletId) + + // Assert + assertThat(result.leftOrNull()).isEqualTo(VisaApiError.Unspecified) + coVerify(exactly = 0) { issueCardRepository.storeIssueOrderId(any(), any()) } + coVerify(exactly = 0) { startTangemPayOrderPollingUseCase(any(), any()) } + } + + private fun order(id: String, type: OrderType, status: OrderStatus): Order = Order( + id = id, + customerId = "customer", + type = type, + status = status, + step = null, + stepChangeCode = null, + productInstanceId = null, + paymentAccountId = null, + cardId = null, + withdrawTxHash = null, + createdAt = null, + updatedAt = null, + ) + + private companion object { + val ISSUE_ORDER_TYPES = OrderType.issueCardTypes + val ACTIVE_STATUSES = OrderStatus.activeStatuses + } +} \ No newline at end of file diff --git a/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/RestoreActiveOrdersUseCaseTest.kt b/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/RestoreActiveOrdersUseCaseTest.kt deleted file mode 100644 index 03fa34daf2..0000000000 --- a/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/RestoreActiveOrdersUseCaseTest.kt +++ /dev/null @@ -1,72 +0,0 @@ -package com.tangem.domain.pay.usecase - -import arrow.core.left -import arrow.core.right -import com.google.common.truth.Truth.assertThat -import com.tangem.domain.models.wallet.UserWalletId -import com.tangem.domain.pay.model.Order -import com.tangem.domain.pay.model.OrderStatus -import com.tangem.domain.pay.model.OrderType -import com.tangem.domain.pay.repository.CustomerOrderRepository -import com.tangem.domain.visa.error.VisaApiError -import io.mockk.coEvery -import io.mockk.coVerify -import io.mockk.mockk -import kotlinx.coroutines.test.runTest -import org.junit.jupiter.api.Test - -internal class RestoreActiveOrdersUseCaseTest { - - private val repository: CustomerOrderRepository = mockk() - private val useCase = RestoreActiveOrdersUseCase(repository) - private val userWalletId = UserWalletId("1234567890ABCDEF") - - @Test - fun `passes only NEW and PROCESSING statuses to findOrders`() = runTest { - val expected = setOf(OrderStatus.NEW, OrderStatus.PROCESSING) - coEvery { repository.findOrders(userWalletId, types = emptySet(), statuses = expected) } returns - emptyList().right() - - useCase(userWalletId) - - coVerify(exactly = 1) { repository.findOrders(userWalletId, types = emptySet(), statuses = expected) } - } - - @Test - fun `returns the orders found by the repository`() = runTest { - val orders = listOf( - order(id = "issue", type = OrderType.CARD_ISSUE_VIRTUAL_RAIN_KYC, status = OrderStatus.PROCESSING), - order(id = "withdraw", type = OrderType.WITHDRAW, status = OrderStatus.NEW), - ) - coEvery { repository.findOrders(userWalletId, types = emptySet(), statuses = any()) } returns orders.right() - - val result = useCase(userWalletId) - - assertThat(result.getOrNull()).containsExactlyElementsIn(orders) - } - - @Test - fun `surfaces repository errors`() = runTest { - coEvery { repository.findOrders(userWalletId, types = emptySet(), statuses = any()) } returns - VisaApiError.Unspecified.left() - - val result = useCase(userWalletId) - - assertThat(result.leftOrNull()).isEqualTo(VisaApiError.Unspecified) - } - - private fun order(id: String, type: OrderType, status: OrderStatus): Order = Order( - id = id, - customerId = "customer", - type = type, - status = status, - step = null, - stepChangeCode = null, - productInstanceId = null, - paymentAccountId = null, - cardId = null, - withdrawTxHash = null, - createdAt = null, - updatedAt = null, - ) -} \ No newline at end of file diff --git a/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/StartTangemPayOrderPollingUseCaseTest.kt b/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/StartTangemPayOrderPollingUseCaseTest.kt index 86ab6a5bf2..c14025f994 100644 --- a/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/StartTangemPayOrderPollingUseCaseTest.kt +++ b/domain/visa/src/test/kotlin/com/tangem/domain/pay/usecase/StartTangemPayOrderPollingUseCaseTest.kt @@ -9,7 +9,11 @@ import com.tangem.domain.pay.model.OrderStatus import com.tangem.domain.pay.model.TangemPayOrderInfo import com.tangem.domain.pay.repository.TangemPayCardDetailsRepository import com.tangem.domain.visa.error.VisaApiError -import io.mockk.* +import io.mockk.coEvery +import io.mockk.coVerify +import io.mockk.mockk +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.runCurrent import kotlinx.coroutines.test.runTest import org.junit.jupiter.api.Test @@ -112,6 +116,28 @@ internal class StartTangemPayOrderPollingUseCaseTest { coVerify(exactly = 1) { paymentAccountStatusFetcher.invoke(USER_WALLET_ID) } } + @Test + fun `GIVEN order already being polled WHEN invoke again for same order THEN returns false without a second poll`() = + runTest { + // Arrange — first poller never reaches a terminal status, so it keeps polling. + val order = TangemPayOrderInfo(ORDER_ID, OrderStatus.PROCESSING) + coEvery { cardDetailsRepository.getOrderInfo(USER_WALLET_ID, ORDER_ID) } returns + TangemPayOrderInfo(ORDER_ID, OrderStatus.PROCESSING).right() + + // Act — start the first poller, let it register the order and park in its poll delay, + // then invoke again for the same order. + val firstPoller = launch { useCase(order, USER_WALLET_ID) } + runCurrent() + val secondResult = useCase(order, USER_WALLET_ID) + + // Assert — the duplicate invoke is a no-op (no extra getOrderInfo, no status fetch). + assertThat(secondResult).isFalse() + coVerify(exactly = 1) { cardDetailsRepository.getOrderInfo(USER_WALLET_ID, ORDER_ID) } + coVerify(exactly = 0) { paymentAccountStatusFetcher.invoke(USER_WALLET_ID) } + + firstPoller.cancel() + } + private companion object { val USER_WALLET_ID = UserWalletId("aabbcc112233") const val ORDER_ID = "order-test-1" diff --git a/features/wallet/impl/src/main/java/com/tangem/feature/wallet/child/wallet/model/WalletModel.kt b/features/wallet/impl/src/main/java/com/tangem/feature/wallet/child/wallet/model/WalletModel.kt index 644d1602c5..8a0506515f 100644 --- a/features/wallet/impl/src/main/java/com/tangem/feature/wallet/child/wallet/model/WalletModel.kt +++ b/features/wallet/impl/src/main/java/com/tangem/feature/wallet/child/wallet/model/WalletModel.kt @@ -28,6 +28,7 @@ import com.tangem.domain.notifications.GetIsHuaweiDeviceWithoutGoogleServicesUse import com.tangem.domain.notifications.repository.NotificationsRepository import com.tangem.domain.pay.flow.PaymentAccountStatusFetcher import com.tangem.domain.pay.repository.OnboardingRepository +import com.tangem.domain.pushnotificationpreferences.PreloadWalletPushNotificationPreferencesUseCase import com.tangem.domain.qrscanning.models.ClassifiedQrContent import com.tangem.domain.qrscanning.models.QrResultSource import com.tangem.domain.qrscanning.models.QrSendTarget @@ -47,7 +48,6 @@ import com.tangem.feature.wallet.presentation.wallet.analytics.utils.SelectedWal import com.tangem.feature.wallet.presentation.wallet.domain.OnrampStatusFactory import com.tangem.feature.wallet.presentation.wallet.domain.WalletContentFetcher import com.tangem.feature.wallet.presentation.wallet.domain.WalletImageResolver -import com.tangem.domain.pushnotificationpreferences.PreloadWalletPushNotificationPreferencesUseCase import com.tangem.feature.wallet.presentation.wallet.domain.WalletNameMigrationUseCase import com.tangem.feature.wallet.presentation.wallet.loaders.WalletScreenContentLoader import com.tangem.feature.wallet.presentation.wallet.state.WalletStateController @@ -62,8 +62,8 @@ import com.tangem.feature.wallet.presentation.wallet.ui.components.visa.KycRejec import com.tangem.feature.wallet.presentation.wallet.utils.ScreenLifecycleProvider import com.tangem.features.biometry.AskBiometryComponent import com.tangem.features.hotwallet.HotWalletFeatureToggles -import com.tangem.features.pushnotificationsettings.PushNotificationSettingsFeatureToggles import com.tangem.features.pushnotifications.api.PushNotificationsModelCallbacks +import com.tangem.features.pushnotificationsettings.PushNotificationSettingsFeatureToggles import com.tangem.features.wallet.deeplink.WalletDeepLinkActionListener import com.tangem.features.wallet.featuretoggles.WalletFeatureToggles import com.tangem.utils.Provider diff --git a/features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/subscribers/TangemPayMainSubscriber.kt b/features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/subscribers/TangemPayMainSubscriber.kt index e58aa664f5..23bb81d8db 100644 --- a/features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/subscribers/TangemPayMainSubscriber.kt +++ b/features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/subscribers/TangemPayMainSubscriber.kt @@ -3,6 +3,7 @@ package com.tangem.feature.wallet.presentation.wallet.subscribers import com.tangem.domain.models.wallet.UserWallet import com.tangem.domain.pay.flow.PaymentAccountStatusSupplier import com.tangem.domain.pay.repository.TangemPayWithdrawRepository +import com.tangem.domain.pay.usecase.RestoreActiveIssueOrdersUseCase import com.tangem.feature.wallet.presentation.wallet.analytics.utils.WalletTangemPayAnalyticsEventSender import dagger.assisted.Assisted import dagger.assisted.AssistedFactory @@ -14,6 +15,7 @@ import kotlinx.coroutines.launch internal class TangemPayMainSubscriber @AssistedInject constructor( @Assisted private val userWallet: UserWallet, private val tangemPayWithdrawRepository: TangemPayWithdrawRepository, + private val restoreActiveIssueOrdersUseCase: RestoreActiveIssueOrdersUseCase, private val paymentAccountStatusSupplier: PaymentAccountStatusSupplier, private val analytics: WalletTangemPayAnalyticsEventSender, ) : WalletSubscriber() { @@ -23,6 +25,9 @@ internal class TangemPayMainSubscriber @AssistedInject constructor( // TODO: Doston move this logic to proper place(e.g. WalletBalanceFetcher) tangemPayWithdrawRepository.pollWithdrawOrdersIfNeeds(userWallet) } + coroutineScope.launch { + restoreActiveIssueOrdersUseCase(userWallet.walletId) + } subscribeToStatus(coroutineScope) return emptyFlow() }