Updated on 2026-08-14

app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectMiddleware.kt

@@ -1,11 +1,10 @@
 package com.tangem.tap.features.details.redux.walletconnect
 
 import com.tangem.blockchain.common.*
-import com.tangem.common.CompletionResult
 import com.tangem.common.card.Card
+import com.tangem.common.extensions.guard
 import com.tangem.common.extensions.toHexString
 import com.tangem.tap.*
-import com.tangem.tap.common.analytics.FirebaseAnalyticsHandler
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.extensions.getFromClipboard
 import com.tangem.tap.common.redux.AppState
@@ -18,9 +17,6 @@ import com.tangem.tap.domain.isMultiwalletAllowed
 import com.tangem.tap.domain.walletconnect.WalletConnectManager
 import com.tangem.tap.features.wallet.redux.WalletAction
 import com.tangem.wallet.R
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import org.rekotlin.Middleware
 
 class WalletConnectMiddleware {
@@ -132,43 +128,29 @@ class WalletConnectMiddleware {
     }
 
     private fun handleScanCard(wcUri: String) {
-        scope.launch {
-            val result = tangemSdkManager.scanProduct(
-                FirebaseAnalyticsHandler,
-                R.string.wallet_connect_scan_card_message
-            )
-            withContext(Dispatchers.Main) {
-                when (result) {
-                    is CompletionResult.Success -> {
-                        val card = result.data.card
-
-                        if (!card.isMultiwalletAllowed) {
-                            store.dispatchOnMain(WalletConnectAction.UnsupportedCard)
-                            return@withContext
-                        }
-
-                        val walletManager = getWalletManager(card)
-                        if (walletManager == null) {
-                            store.dispatchOnMain(WalletConnectAction.UnsupportedCard)
-                            return@withContext
-                        }
-
-                        val key = walletManager.wallet.publicKey
-                        store.dispatchOnMain(WalletConnectAction.OpenSession(
-                            wcUri = wcUri,
-                            wallet = WalletForSession(
-                                card.cardId, key.toHexString(),
-                                isTestNet = card.isTestCard
-                            ),
-                        ))
-                    }
-                    is CompletionResult.Failure ->
-                        store.dispatchOnMain(WalletConnectAction.FailureEstablishingSession(
-                            null
-                        ))
-                }
+        store.dispatch(GlobalAction.ScanCard({ scanResponse ->
+            val card = scanResponse.card
+            if (!card.isMultiwalletAllowed) {
+                store.dispatchOnMain(WalletConnectAction.UnsupportedCard)
+                return@ScanCard
             }
-        }
+
+            val walletManager = getWalletManager(card).guard {
+                store.dispatchOnMain(WalletConnectAction.UnsupportedCard)
+                return@ScanCard
+            }
+
+            val key = walletManager.wallet.publicKey
+            store.dispatchOnMain(WalletConnectAction.OpenSession(
+                wcUri = wcUri,
+                wallet = WalletForSession(
+                    card.cardId, key.toHexString(),
+                    isTestNet = card.isTestCard
+                ),
+            ))
+        }, {
+            store.dispatchOnMain(WalletConnectAction.FailureEstablishingSession(null))
+        }, R.string.wallet_connect_scan_card_message))
     }
 
     private fun getWalletManager(card: Card): WalletManager? {

app/src/main/java/com/tangem/tap/features/home/HomeFragment.kt

@@ -27,6 +27,7 @@ class HomeFragment : Fragment(R.layout.fragment_home), StoreSubscriber<HomeState
         super.onCreate(savedInstanceState)
         val inflater = TransitionInflater.from(requireContext())
         exitTransition = inflater.inflateTransition(R.transition.fade)
+        store.dispatch(HomeAction.Init)
     }
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
@@ -39,7 +40,6 @@ class HomeFragment : Fragment(R.layout.fragment_home), StoreSubscriber<HomeState
         )
 
         store.dispatch(HomeAction.SetFragmentShareTransition(shareTransition))
-        store.dispatch(HomeAction.Init)
 
         tv_header.setText(R.string.home_welcome_header)
         tv_body.setText(R.string.home_welcome_body)

app/src/main/java/com/tangem/tap/features/home/redux/HomeAction.kt

@@ -10,7 +10,9 @@ sealed class HomeAction : Action {
     object GoToShop : HomeAction()
 
     // internal
+    data class ShouldScanCardOnResume(val shouldScanCard: Boolean):HomeAction()
     object Init : HomeAction()
+
     data class SetFragmentShareTransition(val shareTransition: FragmentShareTransition?) : HomeAction()
     data class SetTermsOfUseState(val isDisclaimerAccepted: Boolean) : HomeAction()
     data class ChangeScanCardButtonState(val state: IndeterminateProgressButton) : HomeAction()

app/src/main/java/com/tangem/tap/features/home/redux/HomeMiddleware.kt

@@ -3,6 +3,7 @@ package com.tangem.tap.features.home.redux
 import com.tangem.tap.common.entities.IndeterminateProgressButton
 import com.tangem.tap.common.extensions.dispatchOpenUrl
 import com.tangem.tap.common.post
+import com.tangem.tap.common.postUi
 import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.common.redux.navigation.AppScreen
@@ -35,6 +36,12 @@ private val homeMiddleware: Middleware<AppState> = { dispatch, state ->
                     store.dispatch(GlobalAction.GetMoonPayUserStatus)
                     store.dispatch(HomeAction.SetTermsOfUseState(preferencesStorage.wasDisclaimerAccepted()))
                 }
+                is HomeAction.ShouldScanCardOnResume -> {
+                    if (action.shouldScanCard) {
+                        store.dispatch(HomeAction.ShouldScanCardOnResume(false))
+                        postUi(700) { store.dispatch(HomeAction.ReadCard) }
+                    }
+                }
                 is HomeAction.ReadCard -> handleReadCard()
                 is HomeAction.GoToShop -> store.dispatchOpenUrl(HomeMiddleware.CARD_SHOP_URI)
             }

app/src/main/java/com/tangem/tap/features/home/redux/HomeReducer.kt

@@ -18,8 +18,8 @@ private fun internalReduce(action: Action, state: AppState): HomeState {
         is HomeAction.SetFragmentShareTransition -> {
             state = state.copy(shareTransition = action.shareTransition)
         }
-        is HomeAction.SetTermsOfUseState -> {
-            state = state.copy(isDisclaimerAccepted = action.isDisclaimerAccepted)
+        is HomeAction.ShouldScanCardOnResume -> {
+            state = state.copy(shouldScanCardOnResume = action.shouldScanCard)
         }
         is HomeAction.ChangeScanCardButtonState -> {
             state = state.copy(btnScanState = action.state)

app/src/main/java/com/tangem/tap/features/home/redux/HomeState.kt

@@ -6,7 +6,7 @@ import com.tangem.tap.features.send.redux.states.ButtonState
 import org.rekotlin.StateType
 
 data class HomeState(
-    val isDisclaimerAccepted: Boolean = false,
+    val shouldScanCardOnResume: Boolean = false,
     val shareTransition: FragmentShareTransition? = null,
     val btnScanState: IndeterminateProgressButton = IndeterminateProgressButton(ButtonState.ENABLED),
 ) : StateType

app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WalletMiddleware.kt

@@ -22,10 +22,10 @@ import com.tangem.tap.domain.extensions.toSendableAmounts
 import com.tangem.tap.domain.twins.TwinsHelper
 import com.tangem.tap.features.details.redux.DetailsAction
 import com.tangem.tap.features.details.redux.twins.CreateTwinWallet
+import com.tangem.tap.features.home.redux.HomeAction
 import com.tangem.tap.features.send.redux.PrepareSendScreen
 import com.tangem.tap.features.wallet.redux.*
 import com.tangem.tap.network.NetworkStateChanged
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import org.rekotlin.Action
 import org.rekotlin.Middleware
@@ -145,18 +145,8 @@ class WalletMiddleware {
 
                     }
                     is WalletAction.Scan -> {
-                        scope.launch {
-                            val result = tangemSdkManager.scanProduct(FirebaseAnalyticsHandler)
-                            scope.launch(Dispatchers.Main) {
-                                store.dispatch(GlobalAction.ScanFailsCounter.ChooseBehavior(result))
-                                when (result) {
-                                    is CompletionResult.Success -> {
-                                        tangemSdkManager.changeDisplayedCardIdNumbersCount(result.data.card)
-                                        globalState?.tapWalletManager?.onCardScanned(result.data, true)
-                                    }
-                                }
-                            }
-                        }
+                        store.dispatch(HomeAction.ShouldScanCardOnResume(true))
+                        store.dispatch(NavigationAction.PopBackTo(AppScreen.Home))
                     }
                     is WalletAction.LoadCardInfo -> {
                         scope.launch {