Updated on 2026-08-14

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

@@ -20,6 +20,7 @@ import com.tangem.tap.store
 import com.tangem.tap.tangemSdkManager
 import com.tangem.utils.coroutines.JobHolder
 import com.tangem.utils.coroutines.saveIn
+import com.tangem.utils.logging.TangemLogger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.distinctUntilChanged
@@ -29,7 +30,6 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 import org.rekotlin.Action
 import org.rekotlin.Middleware
-import timber.log.Timber
 
 @Suppress("MemberNameEqualsClassName")
 class DetailsMiddleware {
@@ -228,7 +228,7 @@ class DetailsMiddleware {
                     )
                 }
                 .doOnFailure { error ->
-                    Timber.e(error, "Unable to delete saved access codes")
+                    TangemLogger.e("Unable to delete saved access codes", error)
                 }
         }
     }

app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/model/CardSettingsModel.kt

@@ -10,6 +10,8 @@ import com.tangem.core.analytics.Analytics
 import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.Model
 import com.tangem.core.decompose.model.ParamsContainer
+import com.tangem.core.decompose.ui.UiMessageSender
+import com.tangem.core.ui.message.dialog.Dialogs
 import com.tangem.domain.card.CardTypesResolver
 import com.tangem.domain.card.ScanCardProcessor
 import com.tangem.domain.card.common.util.cardTypesResolver
@@ -25,9 +27,7 @@ import com.tangem.domain.wallets.usecase.GetUserWalletUseCase
 import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.tap.common.analytics.events.AnalyticsParam
 import com.tangem.tap.common.analytics.events.Settings
-import com.tangem.tap.common.extensions.dispatchDialogShow
 import com.tangem.tap.common.extensions.dispatchNavigationAction
-import com.tangem.tap.common.redux.AppDialog
 import com.tangem.tap.features.details.ui.cardsettings.CardInfo
 import com.tangem.tap.features.details.ui.cardsettings.CardSettingsScreenState
 import com.tangem.tap.features.details.ui.cardsettings.api.CardSettingsComponent
@@ -36,11 +36,10 @@ import com.tangem.tap.features.details.ui.common.utils.*
 import com.tangem.tap.store
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.extensions.addIf
-import com.tangem.wallet.R
+import com.tangem.utils.logging.TangemLogger
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
-import timber.log.Timber
 import javax.inject.Inject
 
 @Suppress("LongParameterList")
@@ -56,6 +55,7 @@ internal class CardSettingsModel @Inject constructor(
     private val cardSdkConfigRepository: CardSdkConfigRepository,
     private val settingsRepository: SettingsRepository,
     private val onboardingRepository: OnboardingRepository,
+    private val uiMessageSender: UiMessageSender,
 ) : Model() {
 
     private val params = paramsContainer.require<CardSettingsComponent.Params>()
@@ -115,12 +115,7 @@ internal class CardSettingsModel @Inject constructor(
                 if (userWalletId == scannedUserWalletId || scannedUserWalletId == null) {
                     cardSettingsInteractor.initialize(scanResponse)
                 } else {
-                    store.dispatchDialogShow(
-                        AppDialog.SimpleOkDialogRes(
-                            headerId = R.string.common_warning,
-                            messageId = R.string.error_wrong_wallet_tapped,
-                        ),
-                    )
+                    uiMessageSender.send(Dialogs.wrongWalletTapped())
                 }
             }
     }
@@ -244,7 +239,7 @@ internal class CardSettingsModel @Inject constructor(
         when (val result = tangemSdkManager.setAccessCode(scanResponse.card.cardId)) {
             is CompletionResult.Success -> Analytics.send(Settings.CardSettings.UserCodeChanged())
             is CompletionResult.Failure -> {
-                Timber.e("Failed to change access code: ${result.error}")
+                TangemLogger.e("Failed to change access code: ${result.error}")
             }
         }
     }

app/src/main/java/com/tangem/tap/features/details/ui/resetcard/model/ResetCardModel.kt

@@ -28,6 +28,7 @@ import com.tangem.tap.features.details.ui.resetcard.api.ResetCardComponent
 import com.tangem.tap.store
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.extensions.DELAY_SDK_DIALOG_CLOSE
+import com.tangem.utils.logging.TangemLogger
 import com.tangem.wallet.R
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.toImmutableList
@@ -35,7 +36,6 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
-import timber.log.Timber
 import javax.inject.Inject
 
 @Suppress("LongParameterList")
@@ -190,7 +190,7 @@ internal class ResetCardModel @Inject constructor(
             resetCardUseCase(cardId = primaryCardId, params = currentUserCodeParams).onRight {
                 deleteSavedAccessCodesUseCase(cardId = primaryCardId)
                 val hasUserWallets = deleteWalletUseCase(userWalletId = currentUserWalletId).getOrElse { error ->
-                    Timber.e("Unable to delete user wallet: $error")
+                    TangemLogger.e("Unable to delete user wallet: $error")
                     return@launch
                 }
 

app/src/main/java/com/tangem/tap/features/main/MainViewModel.kt

@@ -1,5 +1,6 @@
 package com.tangem.tap.features.main
 
+import android.os.Build
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.tangem.blockchainsdk.BlockchainSDKFactory
@@ -39,16 +40,17 @@ import com.tangem.domain.wallets.usecase.GetSavedWalletsCountUseCase
 import com.tangem.domain.wallets.usecase.GetSelectedWalletUseCase
 import com.tangem.domain.wallets.usecase.UpdateRemoteWalletsInfoUseCase
 import com.tangem.feature.swap.analytics.StoriesEvents
+import com.tangem.security.DeviceSecurityInfoProvider
 import com.tangem.tap.network.exchangeServices.SellService
 import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.tap.routing.configurator.AppRouterConfig
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.utils.logging.TangemLogger
 import com.tangem.wallet.BuildConfig
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
-import timber.log.Timber
 import javax.inject.Inject
 
 @Suppress("LongParameterList", "LargeClass")
@@ -81,6 +83,7 @@ internal class MainViewModel @Inject constructor(
     private val getSelectedWalletUseCase: GetSelectedWalletUseCase,
     private val appRouterConfig: AppRouterConfig,
     private val sellService: SellService,
+    private val deviceSecurityInfoProvider: DeviceSecurityInfoProvider,
     getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
 ) : ViewModel() {
 
@@ -121,6 +124,7 @@ internal class MainViewModel @Inject constructor(
         deleteDeprecatedLogsUseCase()
 
         sendKeyboardIdentifierEvent()
+        sendMediaTekVulnerabilityEvent()
 
         preloadImages()
     }
@@ -144,13 +148,14 @@ internal class MainViewModel @Inject constructor(
             // await while initial route stack is initialized
             appRouterConfig.initializedState.first { it }
 
+            TangemLogger.withTag("MainActivity").i("Splash screen dismissed")
             isSplashScreenShown = false
         }
     }
 
     private suspend fun fetchUserCountry() {
         fetchUserCountryUseCase().onLeft {
-            Timber.e("Unable to fetch the user country code $it")
+            TangemLogger.e("Unable to fetch the user country code $it")
         }
     }
 
@@ -184,8 +189,8 @@ internal class MainViewModel @Inject constructor(
 
     private suspend fun fetchStakingOptions() {
         fetchStakingOptionsUseCase()
-            .onLeft { Timber.e(it.toString(), "Unable to fetch staking options") }
-            .onRight { Timber.d("Staking options were fetched successfully") }
+            .onLeft { TangemLogger.e("Unable to fetch staking options: $it") }
+            .onRight { TangemLogger.d("Staking options were fetched successfully") }
     }
 
     private fun initializeOffRamp() {
@@ -335,13 +340,14 @@ internal class MainViewModel @Inject constructor(
         listenToFlipsUseCase.changeUpdateEnabled(isUpdateEnabled = true)
     }
 
-    @Suppress("NullableToStringCall")
     private fun sendKeyboardIdentifierEvent() {
         viewModelScope.launch {
             val keyboardId = keyboardValidator.getKeyboardId()
 
             if (keyboardId != null) {
-                Timber.d("Keyboard ID: https://play.google.com/store/apps/details?id=${keyboardId.getPackageName()}")
+                TangemLogger.d(
+                    "Keyboard ID: https://play.google.com/store/apps/details?id=${keyboardId.getPackageName()}",
+                )
 
                 analyticsEventHandler.send(
                     event = TechAnalyticsEvent.KeyboardIdentifier(
@@ -351,7 +357,28 @@ internal class MainViewModel @Inject constructor(
                     ),
                 )
             } else {
-                Timber.e("Unable to get keyboard identifier")
+                TangemLogger.e("Unable to get keyboard identifier")
+            }
+        }
+    }
+
+    private fun sendMediaTekVulnerabilityEvent() {
+        viewModelScope.launch(dispatchers.io) {
+            val isVulnerable = deviceSecurityInfoProvider.isVulnerableToMediaTekExploit
+
+            if (isVulnerable) {
+                analyticsEventHandler.send(
+                    event = TechAnalyticsEvent.MediaTekVulnerability(
+                        model = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) Build.SOC_MODEL else "unknown",
+                        manufacturer = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                            Build.SOC_MANUFACTURER
+                        } else {
+                            "unknown"
+                        },
+                        hardware = Build.HARDWARE,
+                        patch = Build.VERSION.SECURITY_PATCH,
+                    ),
+                )
             }
         }
     }
@@ -365,7 +392,7 @@ internal class MainViewModel @Inject constructor(
                     refresh = true,
                 ).fold(
                     ifLeft = { error ->
-                        Timber.e(error)
+                        TangemLogger.e("Error", error)
                         analyticsEventHandler.send(
                             StoriesEvents.Error(
                                 type = StoryContentIds.STORY_FIRST_TIME_SWAP.analyticType,
@@ -382,7 +409,7 @@ internal class MainViewModel @Inject constructor(
                 )
             }
         } catch (ex: Exception) {
-            Timber.e(ex)
+            TangemLogger.e("Error", ex)
             analyticsEventHandler.send(
                 StoriesEvents.Error(
                     type = StoryContentIds.STORY_FIRST_TIME_SWAP.analyticType,
@@ -407,7 +434,7 @@ internal class MainViewModel @Inject constructor(
                     associateAndUpdateWallets(applicationId = applicationId)
                 }
             }
-            .onLeft(Timber::e)
+            .onLeft { TangemLogger.e("Error", it) }
     }
 
     private suspend fun associateAndUpdateWallets(applicationId: ApplicationId) {

app/src/main/java/com/tangem/tap/features/onboarding/OnboardingDialog.kt

@@ -1,10 +0,0 @@
-package com.tangem.tap.features.onboarding
-
-import com.tangem.domain.redux.StateDialog
-
-/**
-[REDACTED_AUTHOR]
- */
-sealed class OnboardingDialog : StateDialog {
-    data class WalletActivationError(val onConfirm: () -> Unit) : OnboardingDialog()
-}

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/BackupDialog.kt

@@ -1,14 +0,0 @@
-package com.tangem.tap.features.onboarding.products.wallet.redux
-
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.domain.redux.StateDialog
-
-sealed class BackupDialog : StateDialog {
-    data class UnfinishedBackupFound(
-        val scanResponse: ScanResponse? = null,
-    ) : BackupDialog()
-
-    data class ConfirmDiscardingBackup(
-        val scanResponse: ScanResponse? = null,
-    ) : BackupDialog()
-}

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/BackupMiddleware.kt

@@ -1,63 +0,0 @@
-package com.tangem.tap.features.onboarding.products.wallet.redux
-
-import com.tangem.common.routing.AppRoute
-import com.tangem.core.analytics.Analytics
-import com.tangem.tap.backupService
-import com.tangem.tap.common.analytics.events.Onboarding.Finished
-import com.tangem.tap.common.extensions.dispatchNavigationAction
-import com.tangem.tap.common.extensions.inject
-import com.tangem.tap.common.redux.AppState
-import com.tangem.tap.features.demo.DemoHelper
-import com.tangem.tap.mainScope
-import com.tangem.tap.proxy.redux.DaggerGraphState
-import com.tangem.tap.store
-import kotlinx.coroutines.launch
-import org.rekotlin.Middleware
-
-@Suppress("MemberNameEqualsClassName")
-class BackupMiddleware {
-    val backupMiddleware: Middleware<AppState> = { dispatch, state ->
-        { next ->
-            { action ->
-                if (action is BackupAction) handleBackupAction(state, action)
-                next(action)
-            }
-        }
-    }
-}
-
-@Suppress("LongMethod", "ComplexMethod", "MagicNumber")
-private fun handleBackupAction(appState: () -> AppState?, action: BackupAction) {
-    if (DemoHelper.tryHandle(appState)) return
-
-    when (action) {
-        is BackupAction.DiscardBackup -> {
-            backupService.discardSavedBackup()
-        }
-        is BackupAction.DiscardSavedBackup -> {
-            mainScope.launch {
-                backupService.discardSavedBackup()
-
-                val onboardingRepository = store.inject(DaggerGraphState::onboardingRepository)
-                val cardRepository = store.inject(DaggerGraphState::cardRepository)
-                val unfinishedBackup = onboardingRepository.getUnfinishedFinalizeOnboarding() ?: return@launch
-
-                cardRepository.finishCardActivation(unfinishedBackup.card.cardId)
-                onboardingRepository.clearUnfinishedFinalizeOnboarding()
-                Analytics.send(Finished())
-            }
-        }
-        is BackupAction.ResumeFoundUnfinishedBackup -> {
-            if (action.unfinishedBackupScanResponse != null) {
-                store.dispatchNavigationAction {
-                    replaceAll(
-                        AppRoute.Onboarding(
-                            scanResponse = action.unfinishedBackupScanResponse,
-                            mode = AppRoute.Onboarding.Mode.ContinueFinalize,
-                        ),
-                    )
-                }
-            }
-        }
-    }
-}

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletAction.kt

@@ -1,19 +0,0 @@
-package com.tangem.tap.features.onboarding.products.wallet.redux
-
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.domain.models.wallet.UserWalletId
-import org.rekotlin.Action
-
-sealed class OnboardingWalletAction : Action {
-    data class WalletSaved(val userWalletId: UserWalletId) : OnboardingWalletAction()
-}
-
-sealed class BackupAction : Action {
-
-    data object DiscardBackup : BackupAction()
-    data object DiscardSavedBackup : BackupAction()
-
-    data class ResumeFoundUnfinishedBackup(
-        val unfinishedBackupScanResponse: ScanResponse?,
-    ) : BackupAction()
-}

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/ConfirmDiscardingBackupDialog.kt

@@ -1,29 +0,0 @@
-package com.tangem.tap.features.onboarding.products.wallet.ui.dialogs
-
-import android.content.Context
-import androidx.appcompat.app.AlertDialog
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.tap.common.redux.global.GlobalAction
-import com.tangem.tap.features.onboarding.products.wallet.redux.BackupAction
-import com.tangem.tap.store
-import com.tangem.wallet.R
-
-object ConfirmDiscardingBackupDialog {
-    fun create(context: Context, unfinishedBackupScanResponse: ScanResponse? = null): AlertDialog {
-        return MaterialAlertDialogBuilder(context, R.style.CustomMaterialDialog).apply {
-            setTitle(R.string.welcome_interrupted_backup_discard_title)
-            setMessage(R.string.welcome_interrupted_backup_discard_message)
-            setPositiveButton(R.string.welcome_interrupted_backup_discard_resume) { _, _ ->
-                store.dispatch(BackupAction.ResumeFoundUnfinishedBackup(unfinishedBackupScanResponse))
-            }
-            setNegativeButton(R.string.welcome_interrupted_backup_discard_discard) { _, _ ->
-                store.dispatch(BackupAction.DiscardSavedBackup)
-            }
-            setOnDismissListener {
-                store.dispatch(GlobalAction.HideDialog)
-            }
-            setCancelable(false)
-        }.create()
-    }
-}

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/UnfinishedBackupFoundDialog.kt

@@ -1,33 +0,0 @@
-package com.tangem.tap.features.onboarding.products.wallet.ui.dialogs
-
-import android.content.Context
-import androidx.appcompat.app.AlertDialog
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.tangem.core.analytics.Analytics
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.features.onboarding.v2.common.analytics.OnboardingEvent
-import com.tangem.tap.common.redux.global.GlobalAction
-import com.tangem.tap.features.onboarding.products.wallet.redux.BackupAction
-import com.tangem.tap.features.onboarding.products.wallet.redux.BackupDialog
-import com.tangem.tap.store
-import com.tangem.wallet.R
-
-object UnfinishedBackupFoundDialog {
-    fun create(context: Context, scanResponse: ScanResponse? = null): AlertDialog {
-        return MaterialAlertDialogBuilder(context, R.style.CustomMaterialDialog).apply {
-            setTitle(R.string.common_warning)
-            setMessage(R.string.welcome_interrupted_backup_alert_message)
-            setPositiveButton(R.string.welcome_interrupted_backup_alert_resume) { _, _ ->
-                Analytics.send(OnboardingEvent.Backup.ResumeInterruptedBackup())
-                store.dispatch(GlobalAction.HideDialog)
-                store.dispatch(BackupAction.ResumeFoundUnfinishedBackup(scanResponse))
-            }
-            setNegativeButton(R.string.welcome_interrupted_backup_alert_discard) { _, _ ->
-                Analytics.send(OnboardingEvent.Backup.CancelInterruptedBackup())
-                store.dispatch(GlobalAction.HideDialog)
-                store.dispatch(GlobalAction.ShowDialog(BackupDialog.ConfirmDiscardingBackup(scanResponse)))
-            }
-            setCancelable(false)
-        }.create()
-    }
-}

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/WalletActivationErrorDialog.kt

@@ -1,45 +0,0 @@
-package com.tangem.tap.features.onboarding.products.wallet.ui.dialogs
-
-import android.app.Dialog
-import android.content.Context
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.tangem.core.analytics.Analytics
-import com.tangem.core.analytics.models.AnalyticsParam
-import com.tangem.core.analytics.models.Basic
-import com.tangem.domain.feedback.models.FeedbackEmailType
-import com.tangem.tap.common.extensions.dispatchDialogHide
-import com.tangem.tap.common.extensions.inject
-import com.tangem.tap.features.onboarding.OnboardingDialog
-import com.tangem.tap.proxy.redux.DaggerGraphState
-import com.tangem.tap.scope
-import com.tangem.tap.store
-import com.tangem.wallet.R
-import kotlinx.coroutines.launch
-
-object WalletActivationErrorDialog {
-
-    fun create(context: Context, dialog: OnboardingDialog.WalletActivationError): Dialog {
-        return MaterialAlertDialogBuilder(context, R.style.CustomMaterialDialog).apply {
-            setTitle(context.getString(R.string.onboarding_activation_error_title))
-            setMessage(context.getString(R.string.onboarding_activation_error_message))
-            setPositiveButton(R.string.common_ok) { _, _ -> dialog.onConfirm() }
-            setNegativeButton(R.string.common_support) { _, _ ->
-                // changed on email support [REDACTED_TASK_KEY]
-                Analytics.send(Basic.ButtonSupport(AnalyticsParam.ScreensSources.Intro))
-
-                val scanResponse = store.state.globalState.scanResponse
-                    ?: error("ScanResponse must be not null")
-
-                val cardInfo = store.inject(DaggerGraphState::getWalletMetaInfoUseCase).invoke(scanResponse).getOrNull()
-                    ?: error("CardInfo must be not null")
-
-                scope.launch {
-                    store.inject(DaggerGraphState::sendFeedbackEmailUseCase)
-                        .invoke(type = FeedbackEmailType.DirectUserRequest(cardInfo))
-                }
-            }
-            setOnDismissListener { store.dispatchDialogHide() }
-            setCancelable(false)
-        }.create()
-    }
-}

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/WalletAlreadyWasUsedDialog.kt

@@ -1,33 +0,0 @@
-package com.tangem.tap.features.onboarding.products.wallet.ui.dialogs
-
-import android.content.Context
-import androidx.appcompat.app.AlertDialog
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.tangem.tap.common.redux.global.GlobalAction
-import com.tangem.tap.store
-import com.tangem.wallet.R
-
-object WalletAlreadyWasUsedDialog {
-
-    fun create(context: Context, onOk: () -> Unit, onCancel: () -> Unit, onSupport: () -> Unit): AlertDialog {
-        return MaterialAlertDialogBuilder(context, R.style.CustomMaterialDialog).apply {
-            setTitle(R.string.security_alert_title)
-            setMessage(R.string.wallet_been_activated_message)
-            setPositiveButton(R.string.this_is_my_wallet_title) { dialog, _ ->
-                onOk()
-                dialog.dismiss()
-            }
-            setNeutralButton(R.string.common_cancel) { dialog, _ ->
-                onCancel()
-                dialog.dismiss()
-            }
-            setNegativeButton(R.string.alert_button_request_support) { dialog, _ ->
-                onSupport()
-                dialog.dismiss()
-            }
-            setOnDismissListener {
-                store.dispatch(GlobalAction.HideDialog)
-            }
-        }.create()
-    }
-}

app/src/main/java/com/tangem/tap/features/scanfails/ScanFailsComponent.kt

@@ -0,0 +1,43 @@
+package com.tangem.tap.features.scanfails
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.tangem.core.analytics.models.AnalyticsParam
+import com.tangem.core.decompose.context.AppComponentContext
+import com.tangem.core.decompose.factory.ComponentFactory
+import com.tangem.core.decompose.model.getOrCreateModel
+import com.tangem.core.ui.decompose.ComposableContentComponent
+import com.tangem.domain.card.ScanFailsRequester
+import com.tangem.tap.features.scanfails.ui.ScanFailsDialogContent
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+
+internal class ScanFailsComponent @AssistedInject constructor(
+    @Assisted appComponentContext: AppComponentContext,
+    @Assisted params: Unit,
+) : AppComponentContext by appComponentContext, ComposableContentComponent, ScanFailsRequester {
+
+    private val model: ScanFailsModel = getOrCreateModel(params)
+
+    override suspend fun show(source: AnalyticsParam.ScreensSources): ScanFailsRequester.Result {
+        model.show(source)
+        return model.waitResult()
+    }
+
+    @Composable
+    override fun Content(modifier: Modifier) {
+        val state by model.uiState.collectAsStateWithLifecycle()
+
+        if (state.isShown) {
+            ScanFailsDialogContent(state = state)
+        }
+    }
+
+    @AssistedFactory
+    interface Factory : ComponentFactory<Unit, ScanFailsComponent> {
+        override fun create(context: AppComponentContext, params: Unit): ScanFailsComponent
+    }
+}

app/src/main/java/com/tangem/tap/features/scanfails/ScanFailsModel.kt

@@ -0,0 +1,72 @@
+package com.tangem.tap.features.scanfails
+
+import com.tangem.common.TangemBlogUrlBuilder
+import com.tangem.core.analytics.api.AnalyticsEventHandler
+import com.tangem.core.analytics.models.AnalyticsParam
+import com.tangem.core.analytics.models.Basic
+import com.tangem.core.decompose.di.ModelScoped
+import com.tangem.core.decompose.model.Model
+import com.tangem.core.navigation.url.UrlOpener
+import com.tangem.domain.card.ScanFailsRequester
+import com.tangem.domain.feedback.SendFeedbackEmailUseCase
+import com.tangem.domain.feedback.models.FeedbackEmailType
+import com.tangem.tap.common.analytics.events.ScanFailsDialogAnalytics
+import com.tangem.tap.features.scanfails.ui.ScanFailsUM
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@ModelScoped
+internal class ScanFailsModel @Inject constructor(
+    override val dispatchers: CoroutineDispatcherProvider,
+    private val analyticsEventHandler: AnalyticsEventHandler,
+    private val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
+    private val urlOpener: UrlOpener,
+) : Model() {
+
+    private val result = MutableStateFlow<ScanFailsRequester.Result?>(null)
+
+    val uiState: StateFlow<ScanFailsUM>
+        field = MutableStateFlow(ScanFailsUM(onDismiss = ::dismiss))
+
+    fun show(source: AnalyticsParam.ScreensSources) {
+        result.value = null
+        uiState.update {
+            ScanFailsUM(
+                isShown = true,
+                onHowToScan = { onHowToScan(source) },
+                onRequestSupport = { onRequestSupport(source) },
+                onDismiss = ::dismiss,
+            )
+        }
+    }
+
+    suspend fun waitResult(): ScanFailsRequester.Result {
+        return result.filterNotNull().first().also { result.value = null }
+    }
+
+    fun dismiss() {
+        result.value = ScanFailsRequester.Result.Dismissed
+        uiState.update { it.copy(isShown = false) }
+    }
+
+    private fun onHowToScan(source: AnalyticsParam.ScreensSources) {
+        analyticsEventHandler.send(
+            ScanFailsDialogAnalytics(
+                button = ScanFailsDialogAnalytics.Buttons.HOW_TO_SCAN,
+                source = source,
+            ),
+        )
+        modelScope.launch {
+            urlOpener.openUrl(TangemBlogUrlBuilder.build(TangemBlogUrlBuilder.Post.HowToScan))
+        }
+    }
+
+    private fun onRequestSupport(source: AnalyticsParam.ScreensSources) {
+        analyticsEventHandler.send(Basic.ButtonSupport(source))
+        modelScope.launch {
+            sendFeedbackEmailUseCase(type = FeedbackEmailType.ScanningProblem)
+        }
+    }
+}

app/src/main/java/com/tangem/tap/features/scanfails/ScanFailsRequesterProxy.kt

@@ -0,0 +1,22 @@
+package com.tangem.tap.features.scanfails
+
+import com.tangem.core.analytics.models.AnalyticsParam
+import com.tangem.domain.card.ScanFailsRequester
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withTimeout
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class ScanFailsRequesterProxy @Inject constructor() : ScanFailsRequester {
+
+    val componentRequester = MutableStateFlow<ScanFailsRequester?>(null)
+
+    override suspend fun show(source: AnalyticsParam.ScreensSources): ScanFailsRequester.Result {
+        return withTimeout(timeMillis = 1000) {
+            componentRequester.filterNotNull().first()
+        }.show(source)
+    }
+}

app/src/main/java/com/tangem/tap/features/scanfails/di/ScanFailsModule.kt

@@ -0,0 +1,38 @@
+package com.tangem.tap.features.scanfails.di
+
+import com.tangem.core.decompose.factory.ComponentFactory
+import com.tangem.core.decompose.model.Model
+import com.tangem.domain.card.ScanFailsCounter
+import com.tangem.domain.card.ScanFailsRequester
+import com.tangem.tap.domain.scanCard.DefaultScanFailsCounter
+import com.tangem.tap.features.scanfails.ScanFailsComponent
+import com.tangem.tap.features.scanfails.ScanFailsModel
+import com.tangem.tap.features.scanfails.ScanFailsRequesterProxy
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import dagger.multibindings.ClassKey
+import dagger.multibindings.IntoMap
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal interface ScanFailsModule {
+
+    @Binds
+    fun bindComponentFactory(impl: ScanFailsComponent.Factory): ComponentFactory<Unit, ScanFailsComponent>
+
+    @Binds
+    @IntoMap
+    @ClassKey(ScanFailsModel::class)
+    fun bindModel(model: ScanFailsModel): Model
+
+    @Binds
+    @Singleton
+    fun bindRequester(impl: ScanFailsRequesterProxy): ScanFailsRequester
+
+    @Binds
+    @Singleton
+    fun bindScanFailsCounter(impl: DefaultScanFailsCounter): ScanFailsCounter
+}

app/src/main/java/com/tangem/tap/features/scanfails/ui/ScanFailsDialogContent.kt

@@ -0,0 +1,119 @@
+package com.tangem.tap.features.scanfails.ui
+
+import android.content.res.Configuration
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import com.tangem.core.ui.extensions.LocalUserInteractionTracker
+import com.tangem.core.ui.extensions.stringResourceSafe
+import com.tangem.core.ui.extensions.trackUserInteraction
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.core.ui.res.TangemThemePreview
+import com.tangem.wallet.R
+
+@Composable
+internal fun ScanFailsDialogContent(state: ScanFailsUM) {
+    val userInteractionTracker = LocalUserInteractionTracker.current
+
+    Dialog(
+        onDismissRequest = state.onDismiss,
+        properties = DialogProperties(dismissOnClickOutside = true),
+    ) {
+        Column(
+            modifier = Modifier
+                .trackUserInteraction(userInteractionTracker)
+                .background(
+                    color = TangemTheme.colors.background.primary,
+                    shape = RoundedCornerShape(16.dp),
+                )
+                .padding(vertical = 16.dp, horizontal = 38.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(24.dp),
+        ) {
+            Text(
+                text = stringResourceSafe(R.string.common_warning),
+                color = TangemTheme.colors.text.primary1,
+                style = TangemTheme.typography.h3,
+                textAlign = TextAlign.Center,
+            )
+
+            Text(
+                text = stringResourceSafe(R.string.alert_troubleshooting_scan_card_title),
+                color = TangemTheme.colors.text.secondary,
+                style = TangemTheme.typography.body2,
+                textAlign = TextAlign.Center,
+            )
+
+            DialogTextButton(
+                text = stringResourceSafe(R.string.alert_button_how_to_scan),
+                onClick = state.onHowToScan,
+                color = TangemTheme.colors.text.accent,
+                modifier = Modifier.testTag(ScanFailsDialogTestTags.HOW_TO_SCAN_BUTTON),
+            )
+
+            DialogTextButton(
+                text = stringResourceSafe(R.string.alert_button_request_support),
+                onClick = state.onRequestSupport,
+                color = TangemTheme.colors.text.accent,
+                modifier = Modifier.testTag(ScanFailsDialogTestTags.REQUEST_SUPPORT_BUTTON),
+            )
+
+            DialogTextButton(
+                text = stringResourceSafe(R.string.common_cancel),
+                onClick = state.onDismiss,
+                color = TangemTheme.colors.text.warning,
+                modifier = Modifier.testTag(ScanFailsDialogTestTags.CANCEL_BUTTON),
+            )
+        }
+    }
+}
+
+@Composable
+private fun DialogTextButton(text: String, onClick: () -> Unit, color: Color, modifier: Modifier = Modifier) {
+    Text(
+        text = text.uppercase(),
+        color = color,
+        style = TangemTheme.typography.button,
+        textAlign = TextAlign.Center,
+        modifier = modifier.clickable(onClick = onClick),
+    )
+}
+
+object ScanFailsDialogTestTags {
+    const val HOW_TO_SCAN_BUTTON = "scan_fails_how_to_scan_button"
+    const val REQUEST_SUPPORT_BUTTON = "scan_fails_request_support_button"
+    const val CANCEL_BUTTON = "scan_fails_cancel_button"
+}
+
+// region Preview
+@Preview(showBackground = true, widthDp = 360)
+@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
+@Preview(showBackground = true, widthDp = 360, fontScale = 2f)
+@Composable
+private fun ScanFailsDialogContentPreview() {
+    TangemThemePreview {
+        ScanFailsDialogContent(
+            state = ScanFailsUM(
+                isShown = true,
+                onHowToScan = {},
+                onRequestSupport = {},
+                onDismiss = {},
+            ),
+        )
+    }
+}
+// endregion Preview

app/src/main/java/com/tangem/tap/features/scanfails/ui/ScanFailsUM.kt

@@ -0,0 +1,8 @@
+package com.tangem.tap.features.scanfails.ui
+
+internal data class ScanFailsUM(
+    val isShown: Boolean = false,
+    val onHowToScan: () -> Unit = {},
+    val onRequestSupport: () -> Unit = {},
+    val onDismiss: () -> Unit = {},
+)