Updated on 2026-08-14

app/src/main/java/com/tangem/tap/routing/ProxyAppRouter.kt

@@ -42,7 +42,11 @@ internal class ProxyAppRouter(
 
     override fun replaceAll(vararg routes: AppRoute, onComplete: (isSuccess: Boolean) -> Unit) {
         safeNavigate(onComplete, message = "Replace all routes with $routes") {
-            innerRouter.replaceAll(*routes, onComplete = onComplete)
+            runCatching {
+                innerRouter.replaceAll(*routes, onComplete = onComplete)
+            }.getOrElse {
+                Timber.tag("ASDASD").e(it)
+            }
         }
     }
 
@@ -78,6 +82,7 @@ internal class ProxyAppRouter(
 
     override fun defaultCompletionHandler(isSuccess: Boolean, errorMessage: String) {
         if (!isSuccess) {
+            Timber.tag("ASDASD").d(errorMessage)
             analyticsExceptionHandler.sendException(ExceptionAnalyticsEvent(RuntimeException(errorMessage)))
             Timber.w(errorMessage)
 

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

@@ -3,22 +3,13 @@ package com.tangem.tap.routing.component
 import android.content.Intent
 import androidx.compose.runtime.Immutable
 import androidx.fragment.app.Fragment
-import com.arkivanov.decompose.router.stack.ChildStack
-import com.arkivanov.decompose.value.Value
 import com.tangem.common.routing.AppRoute
 import com.tangem.core.decompose.context.AppComponentContext
-import com.tangem.core.decompose.navigation.Router
 import com.tangem.core.ui.decompose.ComposableContentComponent
 import com.tangem.utils.Provider
 
 internal interface RoutingComponent : ComposableContentComponent {
 
-    // TODO: Remove after full navigation refactoring
-    val router: Router
-
-    // TODO: Remove after full navigation refactoring
-    val stack: Value<ChildStack<AppRoute, Child>>
-
     @Immutable
     sealed class Child {
 

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

@@ -1,14 +1,11 @@
 package com.tangem.tap.routing.component.impl
 
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
-import com.arkivanov.decompose.ComponentContext
 import com.arkivanov.decompose.router.stack.ChildStack
 import com.arkivanov.decompose.router.stack.childStack
 import com.arkivanov.decompose.value.Value
 import com.arkivanov.decompose.value.subscribe
-import com.arkivanov.essenty.lifecycle.doOnDestroy
 import com.google.android.material.snackbar.Snackbar
 import com.tangem.common.routing.AppRoute
 import com.tangem.core.decompose.context.AppComponentContext
@@ -23,7 +20,6 @@ import com.tangem.tap.routing.RootContent
 import com.tangem.tap.routing.component.RoutingComponent
 import com.tangem.tap.routing.component.RoutingComponent.Child
 import com.tangem.tap.routing.configurator.AppRouterConfig
-import com.tangem.tap.routing.toggle.RoutingFeatureToggles
 import com.tangem.tap.routing.utils.ChildFactory
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
@@ -36,35 +32,30 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
     private val childFactory: ChildFactory,
     private val appRouterConfig: AppRouterConfig,
     private val uiDependencies: UiDependencies,
-    routingFeatureToggles: RoutingFeatureToggles,
 ) : RoutingComponent,
     AppComponentContext by context,
     SnackbarHandler {
 
-    override val stack: Value<ChildStack<AppRoute, Child>> = childStack(
+    private val stack: Value<ChildStack<AppRoute, Child>> = childStack(
         source = navigationProvider.getOrCreateTyped(),
         initialStack = { getInitialStackOrInit() },
         serializer = null, // AppRoute.serializer(), // Disabled until Nav refactoring completes
-        handleBackButton = routingFeatureToggles.isNavigationRefactoringEnabled,
-        childFactory = ::child,
+        handleBackButton = true,
+        childFactory = { route, childContext ->
+            childFactory.createChild(route, childByContext(childContext))
+        },
     )
 
     init {
-        lifecycle.doOnDestroy {
-            childFactory.doOnDestroy()
-        }
+        appRouterConfig.routerScope = componentScope
+        appRouterConfig.componentRouter = router
+        appRouterConfig.snackbarHandler = this
 
-        if (routingFeatureToggles.isNavigationRefactoringEnabled) {
-            appRouterConfig.routerScope = componentScope
-            appRouterConfig.componentRouter = router
-            appRouterConfig.snackbarHandler = this
+        stack.subscribe(lifecycle) { stack ->
+            val stackItems = stack.items.map { it.configuration }
 
-            stack.subscribe(lifecycle) { stack ->
-                val stackItems = stack.items.map { it.configuration }
-
-                if (appRouterConfig.stack != stackItems) {
-                    appRouterConfig.stack = stackItems
-                }
+            if (appRouterConfig.stack != stackItems) {
+                appRouterConfig.stack = stackItems
             }
         }
     }
@@ -114,10 +105,6 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
         initialStack
     }
 
-    private fun child(route: AppRoute, context: ComponentContext): Child {
-        return childFactory.createChild(route) { childByContext(context) }
-    }
-
     @AssistedFactory
     interface Factory : RoutingComponent.Factory {
         override fun create(context: AppComponentContext, initialStack: List<AppRoute>?): DefaultRoutingComponent

app/src/main/java/com/tangem/tap/routing/toggle/RoutingFeatureToggles.kt

@@ -1,14 +0,0 @@
-package com.tangem.tap.routing.toggle
-
-import com.tangem.core.configtoggle.feature.FeatureTogglesManager
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-internal class RoutingFeatureToggles @Inject constructor(
-    private val featureTogglesManager: FeatureTogglesManager,
-) {
-
-    val isNavigationRefactoringEnabled: Boolean
-        get() = featureTogglesManager.isFeatureEnabled(name = "NAVIGATION_REFACTORING")
-}

app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt

@@ -35,10 +35,7 @@ import com.tangem.tap.features.details.ui.walletconnect.api.WalletConnectCompone
 import com.tangem.tap.features.home.api.HomeComponent
 import com.tangem.tap.features.welcome.component.WelcomeComponent
 import com.tangem.tap.routing.component.RoutingComponent.Child
-import com.tangem.tap.routing.toggle.RoutingFeatureToggles
-import com.tangem.utils.Provider
 import dagger.hilt.android.scopes.ActivityScoped
-import java.util.WeakHashMap
 import javax.inject.Inject
 import com.tangem.features.walletconnect.components.WalletConnectEntryComponent as RedesignedWalletConnectComponent
 
@@ -80,20 +77,11 @@ internal class ChildFactory @Inject constructor(
     private val nftComponentFactory: NFTComponent.Factory,
     private val nftSendComponentFactory: NFTSendComponent.Factory,
     private val testerRouter: TesterRouter,
-    private val routingFeatureToggles: RoutingFeatureToggles,
     private val walletConnectFeatureToggles: WalletConnectFeatureToggles,
 ) {
 
-    fun createChild(route: AppRoute, contextFactory: (route: AppRoute) -> AppComponentContext): Child {
-        return if (routingFeatureToggles.isNavigationRefactoringEnabled) {
-            createChildNew(route, contextFactory(route))
-        } else {
-            createChildLegacy(route, contextFactory)
-        }
-    }
-
     @Suppress("LongMethod", "CyclomaticComplexMethod")
-    private fun createChildNew(route: AppRoute, context: AppComponentContext): Child {
+    fun createChild(route: AppRoute, context: AppComponentContext): Child {
         return when (route) {
             is AppRoute.Initial -> {
                 Child.Initial
@@ -419,355 +407,5 @@ internal class ChildFactory @Inject constructor(
                 )
             }
         }
-        // endregion
-    }
-
-    @Suppress("LongMethod", "CyclomaticComplexMethod")
-    private fun createChildLegacy(route: AppRoute, contextFactory: (route: AppRoute) -> AppComponentContext): Child {
-        componentContexts[route] = contextFactory(route)
-
-        // region Child creation
-        return when (route) {
-            is AppRoute.Initial -> {
-                Child.Initial
-            }
-            is AppRoute.AccessCodeRecovery -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = Unit,
-                    componentFactory = accessCodeRecoveryComponentFactory,
-                )
-            }
-            is AppRoute.AppCurrencySelector -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = Unit,
-                    componentFactory = appCurrencySelectorComponentFactory,
-                )
-            }
-            is AppRoute.Send -> {
-                if (sendFeatureToggles.isSendV2Enabled) {
-                    route.asComponentChild(
-                        contextProvider = contextProvider(route, contextFactory),
-                        params = com.tangem.features.send.v2.api.SendComponent.Params(
-                            userWalletId = route.userWalletId,
-                            currency = route.currency,
-                            transactionId = route.transactionId,
-                            amount = route.amount,
-                            tag = route.tag,
-                            destinationAddress = route.destinationAddress,
-                        ),
-                        componentFactory = sendComponentFactoryV2,
-                    )
-                } else {
-                    route.asComponentChild(
-                        contextProvider = contextProvider(route, contextFactory),
-                        params = SendComponent.Params(
-                            userWalletId = route.userWalletId,
-                            currency = route.currency,
-                            transactionId = route.transactionId,
-                            amount = route.amount,
-                            tag = route.tag,
-                            destinationAddress = route.destinationAddress,
-                        ),
-                        componentFactory = sendComponentFactory,
-                    )
-                }
-            }
-            is AppRoute.AppSettings -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = Unit,
-                    componentFactory = appSettingsComponentFactory,
-                )
-            }
-            is AppRoute.CardSettings -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = CardSettingsComponent.Params(userWalletId = route.userWalletId),
-                    componentFactory = cardSettingsComponentFactory,
-                )
-            }
-            is AppRoute.Details -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = DetailsComponent.Params(route.userWalletId),
-                    componentFactory = detailsComponentFactory,
-                )
-            }
-            is AppRoute.DetailsSecurity -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = SecurityModeComponent.Params(
-                        userWalletId = route.userWalletId,
-                    ),
-                    componentFactory = securityModeComponentFactory,
-                )
-            }
-            is AppRoute.Disclaimer -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = DisclaimerComponent.Params(route.isTosAccepted),
-                    componentFactory = disclaimerComponentFactory,
-                )
-            }
-            is AppRoute.Home -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = Unit,
-                    componentFactory = homeComponentFactory,
-                )
-            }
-            is AppRoute.ManageTokens -> {
-                val source = when (route.source) {
-                    AppRoute.ManageTokens.Source.SETTINGS -> ManageTokensSource.SETTINGS
-                    AppRoute.ManageTokens.Source.ONBOARDING -> ManageTokensSource.ONBOARDING
-                    AppRoute.ManageTokens.Source.STORIES -> ManageTokensSource.STORIES
-                }
-
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = ManageTokensComponent.Params(route.userWalletId, source),
-                    componentFactory = manageTokensComponentFactory,
-                )
-            }
-            is AppRoute.QrScanning -> {
-                val source = when (route.source) {
-                    is AppRoute.QrScanning.Source.Send -> SourceType.SEND
-                    is AppRoute.QrScanning.Source.WalletConnect -> SourceType.WALLET_CONNECT
-                }
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = QrScanningComponent.Params(
-                        source = source,
-                        networkName = (route.source as? AppRoute.QrScanning.Source.Send)?.networkName,
-                    ),
-                    componentFactory = qrScanningComponentFactory,
-                )
-            }
-            is AppRoute.ReferralProgram -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = ReferralComponent.Params(route.userWalletId),
-                    componentFactory = referralComponentFactory,
-                )
-            }
-            is AppRoute.ResetToFactory -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = ResetCardComponent.Params(
-                        userWalletId = route.userWalletId,
-                        cardId = route.cardId,
-                        isActiveBackupStatus = route.isActiveBackupStatus,
-                        backupCardsCount = route.backupCardsCount,
-                    ),
-                    componentFactory = resetCardComponentFactory,
-                )
-            }
-            is AppRoute.Swap -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = SwapComponent.Params(
-                        currencyFrom = route.currencyFrom,
-                        currencyTo = route.currencyTo,
-                        userWalletId = route.userWalletId,
-                        isInitialReverseOrder = route.isInitialReverseOrder,
-                        screenSource = route.screenSource,
-                    ),
-                    componentFactory = swapComponentFactory,
-                )
-            }
-            is AppRoute.Wallet -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = Unit,
-                    componentFactory = walletComponentFactory,
-                )
-            }
-            is AppRoute.WalletConnectSessions -> {
-                if (walletConnectFeatureToggles.isRedesignedWalletConnectEnabled) {
-                    route.asComponentChild(
-                        contextProvider = contextProvider(route, contextFactory),
-                        params = Unit,
-                        componentFactory = redesignedWalletConnectComponentFactory,
-                    )
-                } else {
-                    route.asComponentChild(
-                        contextProvider = contextProvider(route, contextFactory),
-                        params = Unit,
-                        componentFactory = walletConnectComponentFactory,
-                    )
-                }
-            }
-            is AppRoute.CurrencyDetails -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = TokenDetailsComponent.Params(
-                        userWalletId = route.userWalletId,
-                        currency = route.currency,
-                    ),
-                    componentFactory = tokenDetailsComponentFactory,
-                )
-            }
-            is AppRoute.Welcome -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = WelcomeComponent.Params(
-                        intent = route.intent,
-                    ),
-                    componentFactory = welcomeComponentFactory,
-                )
-            }
-            is AppRoute.TesterMenu -> {
-                Child.LegacyIntent(testerRouter.getEntryIntent())
-            }
-            is AppRoute.Staking -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = StakingComponent.Params(
-                        userWalletId = route.userWalletId,
-                        cryptoCurrencyId = route.cryptoCurrencyId,
-                        yieldId = route.yieldId,
-                    ),
-                    componentFactory = stakingComponentFactory,
-                )
-            }
-            is AppRoute.PushNotification -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = Unit,
-                    componentFactory = pushNotificationsComponentFactory,
-                )
-            }
-            is AppRoute.WalletSettings -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = WalletSettingsComponent.Params(route.userWalletId),
-                    componentFactory = walletSettingsComponentFactory,
-                )
-            }
-            is AppRoute.MarketsTokenDetails -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = MarketsTokenDetailsComponent.Params(
-                        token = route.token,
-                        appCurrency = route.appCurrency,
-                        showPortfolio = route.showPortfolio,
-                        analyticsParams = route.analyticsParams?.let {
-                            MarketsTokenDetailsComponent.AnalyticsParams(
-                                blockchain = it.blockchain,
-                                source = it.source,
-                            )
-                        },
-                    ),
-                    componentFactory = marketsTokenDetailsComponentFactory,
-                )
-            }
-            is AppRoute.Onramp -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = OnrampComponent.Params(
-                        userWalletId = route.userWalletId,
-                        cryptoCurrency = route.currency,
-                        source = route.source,
-                    ),
-                    componentFactory = onrampComponentFactory,
-                )
-            }
-            is AppRoute.OnrampSuccess -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = OnrampSuccessComponent.Params(route.txId),
-                    componentFactory = onrampSuccessComponentFactory,
-                )
-            }
-            is AppRoute.BuyCrypto -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = BuyCryptoComponent.Params(userWalletId = route.userWalletId),
-                    componentFactory = buyCryptoComponentFactory,
-                )
-            }
-            is AppRoute.SellCrypto -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = SellCryptoComponent.Params(userWalletId = route.userWalletId),
-                    componentFactory = sellCryptoComponentFactory,
-                )
-            }
-            is AppRoute.SwapCrypto -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = SwapSelectTokensComponent.Params(userWalletId = route.userWalletId),
-                    componentFactory = swapSelectTokensComponentFactory,
-                )
-            }
-            is AppRoute.Onboarding -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = OnboardingEntryComponent.Params(
-                        scanResponse = route.scanResponse,
-                        mode = when (route.mode) {
-                            AppRoute.Onboarding.Mode.Onboarding -> OnboardingEntryComponent.Mode.Onboarding
-                            AppRoute.Onboarding.Mode.AddBackupWallet1 -> OnboardingEntryComponent.Mode.AddBackupWallet1
-                            AppRoute.Onboarding.Mode.WelcomeOnlyTwin -> OnboardingEntryComponent.Mode.WelcomeOnlyTwin
-                            AppRoute.Onboarding.Mode.RecreateWalletTwin ->
-                                OnboardingEntryComponent.Mode.RecreateWalletTwin
-                            AppRoute.Onboarding.Mode.ContinueFinalize ->
-                                OnboardingEntryComponent.Mode.ContinueFinalize
-                        },
-                    ),
-                    componentFactory = onboardingEntryComponentFactory,
-                )
-            }
-            is AppRoute.Stories -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = StoriesComponent.Params(
-                        storyId = route.storyId,
-                        nextScreen = route.nextScreen,
-                        screenSource = route.screenSource,
-                    ),
-                    componentFactory = storiesComponentFactory,
-                )
-            }
-            is AppRoute.NFT ->
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = NFTComponent.Params(
-                        userWalletId = route.userWalletId,
-                        walletName = route.walletName,
-                    ),
-                    componentFactory = nftComponentFactory,
-                )
-            is AppRoute.NFTSend -> {
-                route.asComponentChild(
-                    contextProvider = contextProvider(route, contextFactory),
-                    params = NFTSendComponent.Params(
-                        userWalletId = route.userWalletId,
-                        nftAsset = route.nftAsset,
-                        nftCollectionName = route.nftCollectionName,
-                    ),
-                    componentFactory = nftSendComponentFactory,
-                )
-            }
-        }
-        // endregion
-    }
-
-    fun doOnDestroy() {
-        componentContexts.clear()
-    }
-
-    private fun contextProvider(
-        appRoute: AppRoute,
-        contextFactory: (route: AppRoute) -> AppComponentContext,
-    ): Provider<AppComponentContext> = Provider {
-        componentContexts.getOrPut(appRoute) { contextFactory(appRoute) }
-    }
-
-    private companion object {
-
-        val componentContexts = WeakHashMap<AppRoute, AppComponentContext>()
     }
 }

app/src/main/java/com/tangem/tap/routing/utils/RouteMappers.kt

@@ -1,43 +1,9 @@
 package com.tangem.tap.routing.utils
 
-import androidx.fragment.app.Fragment
-import com.tangem.common.routing.AppRoute
-import com.tangem.common.routing.bundle.RouteBundleParams
 import com.tangem.core.decompose.context.AppComponentContext
 import com.tangem.core.decompose.factory.ComponentFactory
 import com.tangem.core.ui.decompose.ComposableContentComponent
-import com.tangem.tap.DecomposeFragment
 import com.tangem.tap.routing.component.RoutingComponent.Child
-import com.tangem.utils.Provider
-
-internal fun AppRoute.asFragmentChild(fragmentProvider: Provider<Fragment>): Child {
-    val provider = Provider {
-        val bundle = (this as? RouteBundleParams)?.getBundle()
-
-        fragmentProvider().apply {
-            arguments = bundle
-        }
-    }
-
-    return Child.LegacyFragment(path, provider)
-}
-
-internal fun <C : ComposableContentComponent, P : Any, F : ComponentFactory<P, C>> AppRoute.asComponentChild(
-    contextProvider: Provider<AppComponentContext>,
-    params: P,
-    componentFactory: F,
-): Child {
-    val fragmentProvider = Provider {
-        DecomposeFragment.newInstance(
-            tag = path,
-            contextProvider = contextProvider,
-            params = params,
-            componentFactory = componentFactory,
-        )
-    }
-
-    return Child.LegacyFragment(path, fragmentProvider)
-}
 
 internal fun <C : ComposableContentComponent, P : Any, F : ComponentFactory<P, C>> createComponentChild(
     context: AppComponentContext,