Updated on 2026-08-14

app/src/main/java/com/tangem/tap/common/analytics/appsflyer/AppsFlyerReferralParamsHandler.kt

@@ -4,13 +4,10 @@ import com.appsflyer.deeplink.DeepLink
 import com.tangem.datasource.local.appsflyer.AppsFlyerDeeplinkSource
 import com.tangem.datasource.local.appsflyer.AppsFlyerStore
 import com.tangem.domain.wallets.models.AppsFlyerConversionData
-import com.tangem.feature.referral.domain.SetShouldShowMobileWalletPromoUseCase
 import com.tangem.utils.coroutines.AppCoroutineScope
 import com.tangem.utils.logging.TangemLogger
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
 import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.contracts.ExperimentalContracts
@@ -19,11 +16,9 @@ import kotlin.contracts.contract
 @Singleton
 class AppsFlyerReferralParamsHandler @Inject constructor(
     private val appsFlyerStore: AppsFlyerStore,
-    private val setShouldShowMobileWalletPromoUseCase: SetShouldShowMobileWalletPromoUseCase,
     private val coroutineScope: AppCoroutineScope,
 ) {
 
-    private val mutex = Mutex()
     private val deepLinkDeferred = CompletableDeferred<String?>()
 
     fun handle(params: Map<String?, Any?>) {
@@ -48,15 +43,17 @@ class AppsFlyerReferralParamsHandler @Inject constructor(
     }
 
     suspend fun waitForDeeplink(deeplinkSource: AppsFlyerDeeplinkSource): String? {
-        val deeplinkFromCache = appsFlyerStore.getDeeplink(deeplinkSource)
-        return if (deeplinkFromCache == null) {
-            val value = when (deeplinkSource) {
-                AppsFlyerDeeplinkSource.TangemPayHotWalletOnboarding -> TANGEM_PAY_HOT_WALLET_ONBOARDING_DEEP_LINK_VALUE
-            }
-            deepLinkDeferred.await().takeIf { it == value }
-        } else {
-            deeplinkFromCache
+        appsFlyerStore.getDeeplink(deeplinkSource)?.let { return it }
+
+        val expectedValue = when (deeplinkSource) {
+            AppsFlyerDeeplinkSource.TangemPayHotWalletOnboarding -> TANGEM_PAY_HOT_WALLET_ONBOARDING_DEEP_LINK_VALUE
+            AppsFlyerDeeplinkSource.Referral -> REFERRAL_DEEP_LINK_VALUE
         }
+        val resolvedValue = deepLinkDeferred.await().takeIf { it == expectedValue }
+
+        // The deep link may have been persisted to the store while we were awaiting (e.g. from
+        // conversion-data handling, which stores the deep link but doesn't complete the deferred).
+        return resolvedValue ?: appsFlyerStore.getDeeplink(deeplinkSource)
     }
 
     private fun handle(deepLinkValue: String?, deepLinkSub1: String?, deepLinkSub2: String?) {
@@ -79,6 +76,10 @@ class AppsFlyerReferralParamsHandler @Inject constructor(
         @Suppress("NullableToStringCall")
         TangemLogger.i("refcode=$deepLinkSub1\ncampaign=$deepLinkSub2")
 
+        coroutineScope.launch {
+            appsFlyerStore.storeDeeplink(AppsFlyerDeeplinkSource.Referral, REFERRAL_DEEP_LINK_VALUE)
+        }
+
         if (!isValidParam(deepLinkSub1)) {
             TangemLogger.e("Deeplink conversion data is invalid")
             return
@@ -98,13 +99,9 @@ class AppsFlyerReferralParamsHandler @Inject constructor(
 
     private fun storeConversionData(refcode: String, campaign: String?) {
         coroutineScope.launch {
-            mutex.withLock {
-                setShouldShowMobileWalletPromoUseCase(true)
-                    .onLeft { TangemLogger.e("Error", it) }
-                appsFlyerStore.storeIfAbsent(
-                    value = AppsFlyerConversionData(refcode = refcode, campaign = campaign),
-                )
-            }
+            appsFlyerStore.storeIfAbsent(
+                value = AppsFlyerConversionData(refcode = refcode, campaign = campaign),
+            )
         }
     }
 

app/src/main/java/com/tangem/tap/domain/userWalletList/di/UserWalletsListRepositoryModule.kt

@@ -9,6 +9,7 @@ import com.tangem.common.services.secure.SecureStorage
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.datasource.local.preferences.AppPreferencesStore
+import com.tangem.domain.appsflyer.usecase.ClearAppsFlyerDeeplinkUseCase
 import com.tangem.domain.common.wallets.UserWalletSelectedHandler
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.hotwallet.repository.HotWalletRepository
@@ -17,7 +18,6 @@ import com.tangem.domain.visa.model.VisaActivationRemoteState
 import com.tangem.domain.visa.model.VisaCardActivationStatus
 import com.tangem.domain.wallets.hot.HotWalletAccessCodeAttemptsRepository
 import com.tangem.domain.wallets.hot.HotWalletPasswordRequester
-import com.tangem.feature.referral.domain.MobileWalletPromoRepository
 import com.tangem.hot.sdk.TangemHotSdk
 import com.tangem.sdk.storage.AndroidSecureStorage
 import com.tangem.sdk.storage.AndroidSecureStorageV2
@@ -57,7 +57,7 @@ internal object UserWalletsListRepositoryModule {
         trackingContextProxy: TrackingContextProxy,
         analyticsEventHandler: AnalyticsEventHandler,
         hotWalletRepository: HotWalletRepository,
-        mobileWalletPromoRepository: MobileWalletPromoRepository,
+        clearAppsFlyerDeeplinkUseCase: ClearAppsFlyerDeeplinkUseCase,
         userWalletSelectedHandler: Lazy<UserWalletSelectedHandler>,
     ): UserWalletsListRepository {
         val moshi = buildMoshi()
@@ -109,7 +109,7 @@ internal object UserWalletsListRepositoryModule {
             trackingContextProxy = trackingContextProxy,
             analyticsEventHandler = analyticsEventHandler,
             hotWalletRepository = hotWalletRepository,
-            mobileWalletPromoRepository = mobileWalletPromoRepository,
+            clearAppsFlyerDeeplinkUseCase = clearAppsFlyerDeeplinkUseCase,
             userWalletSelectedHandler = userWalletSelectedHandler,
         )
     }

app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt

@@ -14,6 +14,8 @@ import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.datasource.local.preferences.PreferencesKeys
 import com.tangem.datasource.local.preferences.utils.getSyncOrDefault
+import com.tangem.domain.appsflyer.AppsFlyerDeeplinkSource
+import com.tangem.domain.appsflyer.usecase.ClearAppsFlyerDeeplinkUseCase
 import com.tangem.domain.common.wallets.UserWalletSelectedHandler
 import com.tangem.domain.common.wallets.UserWalletTransformAction
 import com.tangem.domain.common.wallets.UserWalletsListRepository
@@ -26,7 +28,6 @@ import com.tangem.domain.wallets.analytics.WalletSettingsAnalyticEvents
 import com.tangem.domain.wallets.builder.UserWalletIdBuilder
 import com.tangem.domain.wallets.hot.HotWalletAccessCodeAttemptsRepository
 import com.tangem.domain.wallets.hot.HotWalletPasswordRequester
-import com.tangem.feature.referral.domain.MobileWalletPromoRepository
 import com.tangem.hot.sdk.TangemHotSdk
 import com.tangem.hot.sdk.model.HotWalletId
 import com.tangem.sdk.api.TangemSdkManager
@@ -60,7 +61,7 @@ internal class DefaultUserWalletsListRepository(
     private val trackingContextProxy: TrackingContextProxy,
     private val analyticsEventHandler: AnalyticsEventHandler,
     private val hotWalletRepository: HotWalletRepository,
-    private val mobileWalletPromoRepository: MobileWalletPromoRepository,
+    private val clearAppsFlyerDeeplinkUseCase: ClearAppsFlyerDeeplinkUseCase,
     private val userWalletSelectedHandler: Lazy<UserWalletSelectedHandler>,
 ) : UserWalletsListRepository {
 
@@ -620,12 +621,12 @@ internal class DefaultUserWalletsListRepository(
     }
 
     private suspend fun onFirstWalletCreated() {
-        // reset flag (that is set from AF deeplink) after creating a new wallet
-        mobileWalletPromoRepository.setShouldShowMobileWalletPromo(false)
+        // reset the referral attribution (set from AF deeplink) after creating a new wallet
+        clearAppsFlyerDeeplinkUseCase(AppsFlyerDeeplinkSource.Referral)
     }
 
     private suspend fun onAllWalletsDeleted() {
-        // reset flag (that is set from AF deeplink) after removing the last wallet
-        mobileWalletPromoRepository.setShouldShowMobileWalletPromo(false)
+        // reset the referral attribution (set from AF deeplink) after removing the last wallet
+        clearAppsFlyerDeeplinkUseCase(AppsFlyerDeeplinkSource.Referral)
     }
 }

app/src/main/java/com/tangem/tap/routing/component/impl/DefaultRoutingComponent.kt

@@ -43,7 +43,6 @@ import com.tangem.domain.onboarding.repository.OnboardingRepository
 import com.tangem.domain.settings.NeverRequestPermissionUseCase
 import com.tangem.domain.settings.NeverToInitiallyAskPermissionUseCase
 import com.tangem.domain.settings.ShouldInitiallyAskPermissionUseCase
-import com.tangem.feature.referral.domain.ShouldShowMobileWalletPromoUseCase
 import com.tangem.features.hotwallet.HotAccessCodeRequestComponent
 import com.tangem.features.hotwallet.accesscoderequest.proxy.HotWalletPasswordRequesterProxy
 import com.tangem.features.onboarding.v2.common.analytics.OnboardingEvent
@@ -69,6 +68,8 @@ import com.tangem.wallet.R
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withTimeoutOrNull
 import kotlin.time.Duration.Companion.seconds
@@ -102,7 +103,6 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
     private val shouldInitiallyAskPermissionUseCase: ShouldInitiallyAskPermissionUseCase,
     private val neverRequestPermissionUseCase: NeverRequestPermissionUseCase,
     private val featureTogglesManager: FeatureTogglesManager,
-    private val shouldShowMobileWalletPromoUseCase: ShouldShowMobileWalletPromoUseCase,
 ) : RoutingComponent,
     AppComponentContext by context,
     SnackbarHandler {
@@ -210,23 +210,8 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
     }
 
     private suspend fun navigateForEmptyWallets(): AppRoute {
-        val isHotWalletOnboardingEnabled = featureTogglesManager.isFeatureEnabled(
-            FeatureToggles.AND_15101_TANGEM_PAY_HOT_WALLET_ONBOARDING,
-        )
-        TangemLogger.i("[TangemPay][HWO] Feature toggle enabled=$isHotWalletOnboardingEnabled")
-        val afterEmptyRoute: AppRoute = if (isHotWalletOnboardingEnabled) {
-            val tangemPayHotWalletOnboardingDeepLink = withTimeoutOrNull(2.seconds) {
-                appsFlyerReferralParamsHandler.waitForDeeplink(AppsFlyerDeeplinkSource.TangemPayHotWalletOnboarding)
-            }
-            TangemLogger.i("[TangemPay][HWO] Deep link present=${tangemPayHotWalletOnboardingDeepLink != null}")
-            if (tangemPayHotWalletOnboardingDeepLink != null) {
-                AppRoute.TangemPayHotWalletOnboarding
-            } else {
-                getDefaultRoute()
-            }
-        } else {
-            getDefaultRoute()
-        }
+        val afterEmptyRoute = resolveAppsFlyerOnboardingRoute()
+            ?: AppRoute.Home(launchMode = launchMode)
 
         val shouldAskPushPermission = shouldInitiallyAskPermissionUseCase(PUSH_PERMISSION).getOrNull()
             ?: return afterEmptyRoute
@@ -246,16 +231,41 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
         }
     }
 
-    private suspend fun getDefaultRoute(): AppRoute {
-        val isHideStoriesForReferralEnabled = featureTogglesManager.isFeatureEnabled(
+    private suspend fun resolveAppsFlyerOnboardingRoute(): AppRoute? = coroutineScope {
+        val tangemPayRoute = async { resolveTangemPayHotWalletOnboardingRoute() }
+        val referralRoute = async { resolveReferralRoute() }
+        tangemPayRoute.await() ?: referralRoute.await()
+    }
+
+    private suspend fun resolveTangemPayHotWalletOnboardingRoute(): AppRoute? {
+        val isEnabled = featureTogglesManager.isFeatureEnabled(
+            FeatureToggles.AND_15101_TANGEM_PAY_HOT_WALLET_ONBOARDING,
+        )
+        TangemLogger.i("[TangemPay][HWO] Feature toggle enabled=$isEnabled")
+        if (!isEnabled) return null
+
+        val deepLink = awaitAppsFlyerDeeplink(AppsFlyerDeeplinkSource.TangemPayHotWalletOnboarding)
+        TangemLogger.i("[TangemPay][HWO] Deep link present=${deepLink != null}")
+        return if (deepLink != null) AppRoute.TangemPayHotWalletOnboarding else null
+    }
+
+    private suspend fun resolveReferralRoute(): AppRoute? {
+        val isEnabled = featureTogglesManager.isFeatureEnabled(
             FeatureToggles.TWI_1512_HIDE_STORIES_FOR_REFERRAL_ENABLED,
         )
-        // Referral users skip the Home stories screen and land directly on the
-        // mobile wallet creation flow.
-        return if (isHideStoriesForReferralEnabled && shouldShowMobileWalletPromoUseCase()) {
+        if (!isEnabled) return null
+
+        val referralDeepLink = awaitAppsFlyerDeeplink(AppsFlyerDeeplinkSource.Referral)
+        return if (referralDeepLink != null) {
             AppRoute.CreateWalletStart(mode = AppRoute.CreateWalletStart.Mode.HotWallet)
         } else {
-            AppRoute.Home(launchMode = launchMode)
+            null
+        }
+    }
+
+    private suspend fun awaitAppsFlyerDeeplink(source: AppsFlyerDeeplinkSource): String? {
+        return withTimeoutOrNull(2.seconds) {
+            appsFlyerReferralParamsHandler.waitForDeeplink(source)
         }
     }
 

app/src/test/kotlin/com/tangem/tap/common/analytics/appsflyer/AppsFlyerReferralParamsHandlerTest.kt

@@ -5,9 +5,7 @@ import com.google.common.truth.Truth.assertThat
 import com.tangem.datasource.local.appsflyer.AppsFlyerDeeplinkSource
 import com.tangem.datasource.local.appsflyer.AppsFlyerStore
 import com.tangem.domain.wallets.models.AppsFlyerConversionData
-import com.tangem.feature.referral.domain.SetShouldShowMobileWalletPromoUseCase
 import com.tangem.test.core.ProvideTestModels
-import arrow.core.right
 import com.tangem.test.core.TestAppCoroutineScope
 import io.mockk.clearMocks
 import io.mockk.coEvery
@@ -28,13 +26,9 @@ import org.junit.jupiter.params.ParameterizedTest
 class AppsFlyerReferralParamsHandlerTest {
 
     private val appsFlyerStore: AppsFlyerStore = mockk(relaxUnitFun = true)
-    private val setShouldShowMobileWalletPromoUseCase: SetShouldShowMobileWalletPromoUseCase = mockk {
-        coEvery { this@mockk.invoke(true) } returns Unit.right()
-    }
     private val handler = AppsFlyerReferralParamsHandler(
         appsFlyerStore = appsFlyerStore,
         coroutineScope = TestAppCoroutineScope(),
-        setShouldShowMobileWalletPromoUseCase = setShouldShowMobileWalletPromoUseCase,
     )
 
     @AfterEach
@@ -175,7 +169,6 @@ class AppsFlyerReferralParamsHandlerTest {
         private val localHandler = AppsFlyerReferralParamsHandler(
             appsFlyerStore = localStore,
             coroutineScope = TestAppCoroutineScope(),
-            setShouldShowMobileWalletPromoUseCase = mockk { coEvery { this@mockk.invoke(true) } returns Unit.right() },
         )
 
         @Test
@@ -240,6 +233,93 @@ class AppsFlyerReferralParamsHandlerTest {
         }
     }
 
+    @Nested
+    inner class WaitForReferralDeeplink {
+
+        private val localStore: AppsFlyerStore = mockk(relaxUnitFun = true)
+        private val localHandler = AppsFlyerReferralParamsHandler(
+            appsFlyerStore = localStore,
+            coroutineScope = TestAppCoroutineScope(),
+        )
+
+        @Test
+        fun `GIVEN cached referral deeplink WHEN waitForDeeplink THEN returns cached value`() = runTest {
+            // GIVEN
+            coEvery { localStore.getDeeplink(AppsFlyerDeeplinkSource.Referral) } returns "referral"
+
+            // WHEN
+            val result = localHandler.waitForDeeplink(AppsFlyerDeeplinkSource.Referral)
+
+            // THEN
+            assertThat(result).isEqualTo("referral")
+        }
+
+        @Test
+        fun `GIVEN no cache and referral deeplink WHEN handleDeeplink then waitForDeeplink THEN returns referral value`() =
+            runTest {
+                // GIVEN
+                coEvery { localStore.getDeeplink(AppsFlyerDeeplinkSource.Referral) } returns null
+                val deepLink = mockk<DeepLink> {
+                    every { deepLinkValue } returns "referral"
+                    every { getStringValue(any()) } returns SUCCESS_REFCODE
+                }
+
+                // WHEN
+                localHandler.handleDeeplink(deepLink)
+                val result = localHandler.waitForDeeplink(AppsFlyerDeeplinkSource.Referral)
+
+                // THEN
+                assertThat(result).isEqualTo("referral")
+                coVerify { localStore.storeDeeplink(AppsFlyerDeeplinkSource.Referral, "referral") }
+            }
+
+        @Test
+        fun `GIVEN no cache and non-referral deeplink WHEN handleDeeplink then waitForDeeplink THEN returns null`() =
+            runTest {
+                // GIVEN
+                coEvery { localStore.getDeeplink(AppsFlyerDeeplinkSource.Referral) } returns null
+                val deepLink = mockk<DeepLink> {
+                    every { deepLinkValue } returns "tpay_mobileonboard"
+                    every { getStringValue(any()) } returns null
+                }
+
+                // WHEN
+                localHandler.handleDeeplink(deepLink)
+                val result = localHandler.waitForDeeplink(AppsFlyerDeeplinkSource.Referral)
+
+                // THEN
+                assertThat(result).isNull()
+                coVerify(inverse = true) { localStore.storeDeeplink(AppsFlyerDeeplinkSource.Referral, any()) }
+            }
+
+        @Test
+        fun `GIVEN no cache WHEN handleNoDeeplink then waitForDeeplink THEN returns null`() = runTest {
+            // GIVEN
+            coEvery { localStore.getDeeplink(AppsFlyerDeeplinkSource.Referral) } returns null
+
+            // WHEN
+            localHandler.handleNoDeeplink()
+            val result = localHandler.waitForDeeplink(AppsFlyerDeeplinkSource.Referral)
+
+            // THEN
+            assertThat(result).isNull()
+        }
+
+        @Test
+        fun `GIVEN deeplink stored during wait WHEN waitForDeeplink THEN returns stored value`() = runTest {
+            // GIVEN cache is empty on the initial read but populated (e.g. from conversion-data
+            // handling) by the time we re-check after awaiting the deferred
+            coEvery { localStore.getDeeplink(AppsFlyerDeeplinkSource.Referral) } returns null andThen "referral"
+
+            // WHEN the deferred resolves without a matching value (UDL reported no deep link)
+            localHandler.handleNoDeeplink()
+            val result = localHandler.waitForDeeplink(AppsFlyerDeeplinkSource.Referral)
+
+            // THEN the value persisted during the wait is preferred
+            assertThat(result).isEqualTo("referral")
+        }
+    }
+
     private companion object Companion {
         const val SUCCESS_REFCODE = "valid_refcode"
         const val SUCCESS_CAMPAIGN = "valid_campaign"

app/src/test/kotlin/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepositoryTest.kt

@@ -7,13 +7,13 @@ import com.tangem.common.test.domain.wallet.MockUserWalletFactory
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.datasource.local.preferences.AppPreferencesStore
+import com.tangem.domain.appsflyer.usecase.ClearAppsFlyerDeeplinkUseCase
 import com.tangem.domain.common.wallets.UserWalletSelectedHandler
 import com.tangem.domain.hotwallet.repository.HotWalletRepository
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.domain.wallets.hot.HotWalletAccessCodeAttemptsRepository
 import com.tangem.domain.wallets.hot.HotWalletPasswordRequester
-import com.tangem.feature.referral.domain.MobileWalletPromoRepository
 import com.tangem.hot.sdk.TangemHotSdk
 import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.utils.Provider
@@ -45,7 +45,7 @@ internal class DefaultUserWalletsListRepositoryTest {
     private val trackingContextProxy: TrackingContextProxy = mockk(relaxed = true)
     private val analyticsEventHandler: AnalyticsEventHandler = mockk(relaxed = true)
     private val hotWalletRepository: HotWalletRepository = mockk(relaxed = true)
-    private val mobileWalletPromoRepository: MobileWalletPromoRepository = mockk(relaxed = true)
+    private val clearAppsFlyerDeeplinkUseCase: ClearAppsFlyerDeeplinkUseCase = mockk(relaxed = true)
     private val userWalletSelectedHandler: UserWalletSelectedHandler = mockk(relaxed = true)
 
     private val walletA = MockUserWalletFactory.create().copy(walletId = UserWalletId("0011"), name = "Wallet A")
@@ -61,7 +61,7 @@ internal class DefaultUserWalletsListRepositoryTest {
             selectedUserWalletRepository,
             userWalletEncryptionKeysRepository,
             trackingContextProxy,
-            mobileWalletPromoRepository,
+            clearAppsFlyerDeeplinkUseCase,
             userWalletSelectedHandler,
         )
 
@@ -82,7 +82,7 @@ internal class DefaultUserWalletsListRepositoryTest {
             trackingContextProxy = trackingContextProxy,
             analyticsEventHandler = analyticsEventHandler,
             hotWalletRepository = hotWalletRepository,
-            mobileWalletPromoRepository = mobileWalletPromoRepository,
+            clearAppsFlyerDeeplinkUseCase = clearAppsFlyerDeeplinkUseCase,
             userWalletSelectedHandler = Lazy { userWalletSelectedHandler },
         )
     }