Updated on 2026-08-14

2023-06-29 13:33:17 +03:00 · 2023-06-29 13:33:17 +03:00 · 2822193ff8
commit 2822193ff8
parent a4a9ec50f5 9c99bab352
156 changed files with 4469 additions and 3234 deletions
--- a/app/src/main/java/com/tangem/tap/features/home/HomeFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/home/HomeFragment.kt
@ -12,36 +12,47 @@ import androidx.compose.ui.platform.ComposeView
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsControllerCompat
 import androidx.fragment.app.Fragment
-import com.google.accompanist.appcompattheme.AppCompatTheme
+import androidx.fragment.app.activityViewModels
 import com.tangem.core.analytics.Analytics
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.feature.learn2earn.presentation.Learn2earnViewModel
 import com.tangem.tap.common.analytics.events.IntroductionProcess
 import com.tangem.tap.common.redux.navigation.AppScreen
 import com.tangem.tap.common.redux.navigation.NavigationAction
 import com.tangem.tap.features.home.compose.StoriesScreen
 import com.tangem.tap.features.home.redux.HomeAction
 import com.tangem.tap.features.home.redux.HomeState
+import com.tangem.tap.features.home.redux.Stories
 import com.tangem.tap.features.tokens.legacy.redux.TokensAction
 import com.tangem.tap.store
+import dagger.hilt.android.AndroidEntryPoint
 import org.rekotlin.StoreSubscriber

+@AndroidEntryPoint
 class HomeFragment : Fragment(), StoreSubscriber<HomeState> {

    private var homeState: MutableState<HomeState> = mutableStateOf(store.state.homeState)

+    private val learn2earnViewModel by activityViewModels<Learn2earnViewModel>()
+
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        store.dispatch(HomeAction.OnCreate)
        store.dispatch(HomeAction.Init)
+        if (learn2earnViewModel.uiState.storyScreenState.isVisible) {
+            store.dispatch(HomeAction.InsertStory(position = 0, Stories.OneInchPromo))
+            // re init homeState after inserting learn2earn story
+            homeState = mutableStateOf(store.state.homeState)
+        }
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
        return ComposeView(inflater.context).apply {
            setContent {
-                BackHandler {
-                    requireActivity().finish()
-                }
-
-                AppCompatTheme {
+                TangemTheme {
+                    BackHandler {
+                        requireActivity().finish()
+                    }
                    ScreenContent()
                }
            }
@ -79,7 +90,8 @@ class HomeFragment : Fragment(), StoreSubscriber<HomeState> {
    @Composable
    private fun ScreenContent() {
        StoriesScreen(
-            homeState,
+            homeState = homeState,
+            onLearn2earnClick = learn2earnViewModel.uiState.storyScreenState.onClick,
            onScanButtonClick = {
                Analytics.send(IntroductionProcess.ButtonScanCard())
                store.dispatch(HomeAction.ReadCard())
--- a/app/src/main/java/com/tangem/tap/features/home/compose/StoriesScreen.kt
+++ b/app/src/main/java/com/tangem/tap/features/home/compose/StoriesScreen.kt
@ -5,29 +5,11 @@ package com.tangem.tap.features.home.compose
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
 import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.navigationBarsPadding
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.statusBars
-import androidx.compose.foundation.layout.union
-import androidx.compose.foundation.layout.windowInsetsPadding
+import androidx.compose.foundation.layout.*
 import androidx.compose.material.Button
 import androidx.compose.material.ButtonDefaults
 import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
+import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
@ -43,38 +25,40 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.google.accompanist.systemuicontroller.rememberSystemUiController
-import com.tangem.tap.features.home.compose.content.FirstStoriesContent
-import com.tangem.tap.features.home.compose.content.StoriesCurrencies
-import com.tangem.tap.features.home.compose.content.StoriesRevolutionaryWallet
-import com.tangem.tap.features.home.compose.content.StoriesUltraSecureBackup
-import com.tangem.tap.features.home.compose.content.StoriesWalletForEveryone
-import com.tangem.tap.features.home.compose.content.StoriesWeb3
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.feature.learn2earn.presentation.ui.Learn2earnStoriesScreen
+import com.tangem.tap.features.home.compose.content.*
 import com.tangem.tap.features.home.compose.views.HomeButtons
 import com.tangem.tap.features.home.compose.views.StoriesProgressBar
 import com.tangem.tap.features.home.redux.HomeState
+import com.tangem.tap.features.home.redux.Stories
 import com.tangem.wallet.R
 import kotlin.math.max

-private const val STEPS = 6
-
@Suppress("LongMethod", "ComplexMethod")
@Composable
 fun StoriesScreen(
    homeState: MutableState<HomeState>,
+    onLearn2earnClick: () -> Unit,
    onScanButtonClick: () -> Unit,
    onShopButtonClick: () -> Unit,
    onSearchTokensClick: () -> Unit,
 ) {
-    val currentStep = remember { mutableStateOf(1) }
    val systemUiController = rememberSystemUiController()
+    val state = homeState.value

-    val isDarkBackground = currentStep.value !in 3..5
+    var currentStory by remember { mutableStateOf(state.firstStory) }
+    val currentStep = { state.stepOf(currentStory) }

    val goToPreviousScreen = {
-        currentStep.value = max(1, currentStep.value - 1)
+        currentStory = state.stories[max(0, currentStep() - 1)]
    }
    val goToNextScreen = {
-        currentStep.value = if (currentStep.value < STEPS) currentStep.value + 1 else 1
+        currentStory = if (currentStep() < state.stories.lastIndex) {
+            state.stories[currentStep() + 1]
+        } else {
+            state.firstStory
+        }
    }

    val isPressed = remember { mutableStateOf(false) }
@ -82,10 +66,10 @@ fun StoriesScreen(

    val hideContent = remember { mutableStateOf(true) }

-    LaunchedEffect(key1 = isDarkBackground) {
+    LaunchedEffect(key1 = currentStory.isDarkBackground) {
        systemUiController.setSystemBarsColor(
            color = Color.Transparent,
-            darkIcons = !isDarkBackground,
+            darkIcons = !currentStory.isDarkBackground,
        )
    }

@ -134,7 +118,7 @@ fun StoriesScreen(
                    },
            )
        }
-        if (!isDarkBackground) {
+        if (!currentStory.isDarkBackground) {
            Image(
                modifier = Modifier.fillMaxSize(),
                painter = painterResource(id = R.drawable.ic_overlay),
@ -154,9 +138,9 @@ fun StoriesScreen(
            verticalArrangement = Arrangement.Center,
        ) {
            StoriesProgressBar(
-                steps = STEPS,
-                currentStep = currentStep.value,
-                stepDuration = currentStep.duration(),
+                steps = state.stories.lastIndex,
+                currentStep = currentStep(),
+                stepDuration = currentStory.duration,
                paused = isPaused,
                onStepFinish = goToNextScreen,
            )
@ -169,15 +153,16 @@ fun StoriesScreen(
                    .height(17.dp)
                    .alpha(if (hideContent.value) 0f else 1f)
                    .align(Alignment.Start),
-                colorFilter = if (isDarkBackground) null else ColorFilter.tint(Color.Black),
+                colorFilter = if (currentStory.isDarkBackground) null else ColorFilter.tint(Color.Black),
            )
-            when (currentStep.value) {
-                1 -> FirstStoriesContent(isPaused, currentStep.duration()) { hideContent.value = it }
-                2 -> StoriesRevolutionaryWallet(currentStep.duration())
-                3 -> StoriesUltraSecureBackup(isPaused, currentStep.duration())
-                4 -> StoriesCurrencies(isPaused, currentStep.duration())
-                5 -> StoriesWeb3(isPaused, currentStep.duration())
-                6 -> StoriesWalletForEveryone(currentStep.duration())
+            when (currentStory) {
+                Stories.OneInchPromo -> Learn2earnStoriesScreen(onLearn2earnClick)
+                Stories.TangemIntro -> FirstStoriesContent(isPaused, currentStory.duration) { hideContent.value = it }
+                Stories.RevolutionaryWallet -> StoriesRevolutionaryWallet(currentStory.duration)
+                Stories.UltraSecureBackup -> StoriesUltraSecureBackup(isPaused, currentStory.duration)
+                Stories.Currencies -> StoriesCurrencies(isPaused, currentStory.duration)
+                Stories.Web3 -> StoriesWeb3(isPaused, currentStory.duration)
+                Stories.WalletForEveryone -> StoriesWalletForEveryone(currentStory.duration)
            }
        }
        Column(
@ -186,7 +171,7 @@ fun StoriesScreen(
                .align(Alignment.BottomCenter)
                .fillMaxWidth(),
        ) {
-            if (currentStep.value == 4) {
+            if (currentStory == Stories.Currencies) {
                Button(
                    onClick = onSearchTokensClick,
                    modifier = Modifier
@ -210,29 +195,31 @@ fun StoriesScreen(
                    )
                }
            }
-            HomeButtons(
-                modifier = Modifier
-                    .padding(start = 16.dp, top = 0.dp, end = 16.dp, bottom = 37.dp)
-                    .fillMaxWidth(),
-                isDarkBackground = isDarkBackground,
-                btnScanStateInProgress = homeState.value.btnScanStateInProgress,
-                onScanButtonClick = onScanButtonClick,
-                onShopButtonClick = onShopButtonClick,
-            )
+
+            if (currentStory != Stories.OneInchPromo) {
+                HomeButtons(
+                    modifier = Modifier
+                        .padding(
+                            start = TangemTheme.dimens.size16,
+                            end = TangemTheme.dimens.size16,
+                            bottom = TangemTheme.dimens.size36,
+                        )
+                        .fillMaxWidth(),
+                    isDarkBackground = currentStory.isDarkBackground,
+                    btnScanStateInProgress = homeState.value.btnScanStateInProgress,
+                    onScanButtonClick = onScanButtonClick,
+                    onShopButtonClick = onShopButtonClick,
+                )
+            }
        }
    }
 }

-@Suppress("MagicNumber")
-private fun MutableState<Int>.duration(): Int = when (this.value) {
-    1 -> 8000
-    else -> 6000
-}
-
@Preview
@Composable
 private fun StoriesScreenPreview() {
    StoriesScreen(
+        onLearn2earnClick = {},
        onScanButtonClick = {},
        onShopButtonClick = {},
        onSearchTokensClick = {},
--- a/app/src/main/java/com/tangem/tap/features/home/compose/views/StoriesProgressBar.kt
+++ b/app/src/main/java/com/tangem/tap/features/home/compose/views/StoriesProgressBar.kt
@ -4,12 +4,7 @@ import androidx.compose.animation.core.Animatable
 import androidx.compose.animation.core.LinearEasing
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
@ -52,7 +47,7 @@ fun StoriesProgressBar(
 //            .height()
            .padding(start = 9.dp, end = 9.dp, top = 16.dp),
    ) {
-        for (index in 1..steps) {
+        for (index in 0..steps) {
            Row(
                modifier = Modifier
                    .height(2.dp)
--- a/app/src/main/java/com/tangem/tap/features/home/redux/HomeAction.kt
+++ b/app/src/main/java/com/tangem/tap/features/home/redux/HomeAction.kt
@ -11,6 +11,8 @@ sealed class HomeAction : Action {
    object OnCreate : HomeAction()
    object Init : HomeAction()

+    data class InsertStory(val position: Int, val story: Stories) : HomeAction()
+
    data class ReadCard(
        val analyticsEvent: AnalyticsEvent? = Basic.CardWasScanned(AnalyticsParam.ScannedFrom.Introduction),
    ) : HomeAction()
--- a/app/src/main/java/com/tangem/tap/features/home/redux/HomeReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/home/redux/HomeReducer.kt
@ -12,6 +12,13 @@ private fun internalReduce(action: Action, state: AppState): HomeState {

    var state = state.homeState
    when (action) {
+        is HomeAction.InsertStory -> {
+            state = state.copy(
+                stories = state.stories.toMutableList().apply {
+                    add(action.position, action.story)
+                },
+            )
+        }
        is HomeAction.ScanInProgress -> {
            state = state.copy(scanInProgress = action.scanInProgress)
        }
--- a/app/src/main/java/com/tangem/tap/features/home/redux/HomeState.kt
+++ b/app/src/main/java/com/tangem/tap/features/home/redux/HomeState.kt
@ -8,8 +8,38 @@ import org.rekotlin.StateType
 data class HomeState(
    val scanInProgress: Boolean = false,
    val btnScanState: IndeterminateProgressButton = IndeterminateProgressButton(ButtonState.ENABLED),
+    val stories: List<Stories> = initDefaultStories(),
 ) : StateType {

+    val firstStory: Stories
+        get() = stories[0]
+
    val btnScanStateInProgress: Boolean
        get() = btnScanState.progressState == ProgressState.Loading
+
+    fun stepOf(story: Stories): Int = stories.indexOf(story)
+
+    companion object {
+        fun initDefaultStories(): List<Stories> = listOf(
+            Stories.TangemIntro,
+            Stories.RevolutionaryWallet,
+            Stories.UltraSecureBackup,
+            Stories.Currencies,
+            Stories.Web3,
+            Stories.WalletForEveryone,
+        )
+    }
+}
+
+sealed class Stories(
+    val isDarkBackground: Boolean,
+    val duration: Int,
+) {
+    object OneInchPromo : Stories(true, duration = 8000)
+    object TangemIntro : Stories(true, duration = 8000)
+    object RevolutionaryWallet : Stories(true, duration = 6000)
+    object UltraSecureBackup : Stories(false, duration = 6000)
+    object Currencies : Stories(false, duration = 6000)
+    object Web3 : Stories(false, duration = 6000)
+    object WalletForEveryone : Stories(true, duration = 6000)
 }
--- a/app/src/main/java/com/tangem/tap/features/intentHandler/IntentHandler.kt
+++ b/app/src/main/java/com/tangem/tap/features/intentHandler/IntentHandler.kt
@ -0,0 +1,10 @@
+package com.tangem.tap.features.intentHandler
+
+import android.content.Intent
+
+/**
+[REDACTED_AUTHOR]
+ */
+interface IntentHandler {
+    suspend fun handleIntent(intent: Intent?): Boolean
+}
--- a/app/src/main/java/com/tangem/tap/features/intentHandler/IntentProcessor.kt
+++ b/app/src/main/java/com/tangem/tap/features/intentHandler/IntentProcessor.kt
@ -0,0 +1,31 @@
+package com.tangem.tap.features.intentHandler
+
+import android.content.Intent
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+[REDACTED_AUTHOR]
+ */
+// TODO: fixme: close it with the combined interfaces IntentHandler and IntentHandlerHolder
+class IntentProcessor {
+
+    private val intentHandlers = CopyOnWriteArrayList<IntentHandler>()
+
+    fun addHandler(handler: IntentHandler) {
+        intentHandlers.add(handler)
+    }
+
+    fun removeIntentHandler(handler: IntentHandler) {
+        intentHandlers.remove(handler)
+    }
+
+    fun removeAll() {
+        intentHandlers.clear()
+    }
+
+    suspend fun handleIntent(intent: Intent?) {
+        intentHandlers.forEach {
+            it.handleIntent(intent)
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/intentHandler/handlers/BackgroundScanIntentHandler.kt
+++ b/app/src/main/java/com/tangem/tap/features/intentHandler/handlers/BackgroundScanIntentHandler.kt
@ -0,0 +1,52 @@
+package com.tangem.tap.features.intentHandler.handlers
+
+import android.content.Intent
+import android.nfc.NfcAdapter
+import android.nfc.Tag
+import android.os.Build
+import com.tangem.tap.features.home.redux.HomeAction
+import com.tangem.tap.features.intentHandler.IntentHandler
+import com.tangem.tap.features.welcome.redux.WelcomeAction
+import com.tangem.tap.scope
+import com.tangem.tap.store
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+/**
+[REDACTED_AUTHOR]
+ */
+class BackgroundScanIntentHandler(
+    private val hasSavedUserWalletsProvider: () -> Boolean,
+) : IntentHandler {
+
+    private val nfcActions = arrayOf(
+        NfcAdapter.ACTION_NDEF_DISCOVERED,
+        NfcAdapter.ACTION_TECH_DISCOVERED,
+        NfcAdapter.ACTION_TAG_DISCOVERED,
+    )
+
+    override suspend fun handleIntent(intent: Intent?): Boolean {
+        if (intent == null || intent.action !in nfcActions) return false
+
+        val tag: Tag? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            intent.getParcelableExtra(NfcAdapter.EXTRA_TAG, Tag::class.java)
+        } else {
+            @Suppress("DEPRECATION")
+            intent.getParcelableExtra(NfcAdapter.EXTRA_TAG)
+        }
+        if (tag == null) return false
+
+        intent.action = null
+        if (hasSavedUserWalletsProvider.invoke()) {
+            // TODO: Remove delay after [REDACTED_JIRA]
+            scope.launch {
+                delay(timeMillis = 200)
+                store.dispatch(WelcomeAction.ProceedWithCard)
+            }
+        } else {
+            store.dispatch(HomeAction.ReadCard())
+        }
+
+        return true
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/intentHandler/handlers/BuyCurrencyIntentHandler.kt
+++ b/app/src/main/java/com/tangem/tap/features/intentHandler/handlers/BuyCurrencyIntentHandler.kt
@ -0,0 +1,30 @@
+package com.tangem.tap.features.intentHandler.handlers
+
+import android.content.Intent
+import android.net.Uri
+import com.tangem.core.analytics.Analytics
+import com.tangem.tap.common.analytics.events.AnalyticsParam
+import com.tangem.tap.common.analytics.events.Token
+import com.tangem.tap.features.intentHandler.IntentHandler
+import com.tangem.tap.network.exchangeServices.ExchangeUrlBuilder
+import com.tangem.tap.store
+
+/**
+[REDACTED_AUTHOR]
+ */
+class BuyCurrencyIntentHandler : IntentHandler {
+
+    override suspend fun handleIntent(intent: Intent?): Boolean {
+        val data = intent?.data ?: return false
+        val currency = store.state.walletState.selectedCurrency ?: return false
+
+        val successUri = Uri.parse(ExchangeUrlBuilder.SUCCESS_URL)
+        return if (data.host == successUri.host && data.authority == successUri.authority) {
+            val currencyType = AnalyticsParam.CurrencyType.Currency(currency)
+            Analytics.send(Token.Bought(currencyType))
+            true
+        } else {
+            false
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/intentHandler/handlers/SellCurrencyIntentHandler.kt
+++ b/app/src/main/java/com/tangem/tap/features/intentHandler/handlers/SellCurrencyIntentHandler.kt
@ -0,0 +1,44 @@
+package com.tangem.tap.features.intentHandler.handlers
+
+import android.content.Intent
+import com.tangem.tap.features.intentHandler.IntentHandler
+import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.store
+import timber.log.Timber
+
+/**
+[REDACTED_AUTHOR]
+ */
+class SellCurrencyIntentHandler : IntentHandler {
+
+    override suspend fun handleIntent(intent: Intent?): Boolean {
+        return try {
+            val intentData = intent?.data ?: return false
+            val transactionID = intentData.getQueryParameter(TRANSACTION_ID_PARAM) ?: return false
+            val currency = intentData.getQueryParameter(CURRENCY_CODE_PARAM) ?: return false
+            val amount = intentData.getQueryParameter(CURRENCY_AMOUNT_PARAM) ?: return false
+            val destinationAddress = intentData.getQueryParameter(DEPOSIT_WALLET_ADDRESS_PARAM) ?: return false
+
+            Timber.d("MoonPay Sell: $amount $currency to $destinationAddress")
+            store.dispatch(
+                WalletAction.TradeCryptoAction.SendCrypto(
+                    currencyId = currency,
+                    amount = amount,
+                    destinationAddress = destinationAddress,
+                    transactionId = transactionID,
+                ),
+            )
+            true
+        } catch (exception: Exception) {
+            Timber.d("Not MoonPay URL")
+            false
+        }
+    }
+
+    private companion object {
+        private const val TRANSACTION_ID_PARAM = "transactionId"
+        private const val CURRENCY_CODE_PARAM = "baseCurrencyCode"
+        private const val CURRENCY_AMOUNT_PARAM = "baseCurrencyAmount"
+        private const val DEPOSIT_WALLET_ADDRESS_PARAM = "depositWalletAddress"
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/intentHandler/handlers/WalletConnectLinkIntentHandler.kt
+++ b/app/src/main/java/com/tangem/tap/features/intentHandler/handlers/WalletConnectLinkIntentHandler.kt
@ -0,0 +1,37 @@
+package com.tangem.tap.features.intentHandler.handlers
+
+import android.content.Intent
+import com.tangem.tap.common.extensions.removePrefixOrNull
+import com.tangem.tap.domain.walletconnect.WalletConnectManager
+import com.tangem.tap.features.details.redux.walletconnect.WalletConnectAction
+import com.tangem.tap.features.intentHandler.IntentHandler
+import com.tangem.tap.store
+
+/**
+[REDACTED_AUTHOR]
+ */
+class WalletConnectLinkIntentHandler : IntentHandler {
+
+    override suspend fun handleIntent(intent: Intent?): Boolean {
+        val intentData = intent?.data ?: return false
+        val scheme = intent.scheme ?: return false
+
+        val wcUri = when (scheme) {
+            WalletConnectManager.WC_SCHEME -> intentData.toString()
+            TANGEM_SCHEME -> intentData.toString().removePrefixOrNull(TANGEM_WC_PREFIX)
+            else -> null
+        }
+
+        return if (wcUri == null) {
+            false
+        } else {
+            store.dispatch(WalletConnectAction.HandleDeepLink(wcUri))
+            true
+        }
+    }
+
+    private companion object {
+        private const val TANGEM_SCHEME = "tangem"
+        private const val TANGEM_WC_PREFIX = "tangem://wc?uri="
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/send/redux/SendScreenAction.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/SendScreenAction.kt
@ -6,7 +6,6 @@ import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.WalletManager
 import com.tangem.common.core.TangemSdkError
 import com.tangem.tap.common.analytics.events.Token.Send.AddressEntered
-import com.tangem.tap.common.redux.ErrorAction
 import com.tangem.tap.common.redux.StateDialog
 import com.tangem.tap.common.redux.ToastNotificationAction
 import com.tangem.tap.domain.TapError
@ -34,15 +33,14 @@ data class PrepareSendScreen(
    val tokenRate: BigDecimal? = null,
 ) : SendScreenAction

-// Address or PayId
-sealed class AddressPayIdActionUi : SendScreenActionUi {
-    data class HandleUserInput(val data: String) : AddressPayIdActionUi()
-    data class PasteAddressPayId(val data: String, val sourceType: AddressEntered.SourceType) : AddressPayIdActionUi()
-    data class CheckClipboard(val data: String?) : AddressPayIdActionUi()
-    data class CheckAddressPayId(val sourceType: AddressEntered.SourceType?) : AddressPayIdActionUi()
-    data class SetTruncateHandler(val handler: (String) -> String) : AddressPayIdActionUi()
-    data class TruncateOrRestore(val truncate: Boolean) : AddressPayIdActionUi()
-    data class ChangePayIdState(val sendingToPayIdEnabled: Boolean) : AddressPayIdActionUi()
+// Address
+sealed class AddressActionUi : SendScreenActionUi {
+    data class HandleUserInput(val data: String) : AddressActionUi()
+    data class PasteAddress(val data: String, val sourceType: AddressEntered.SourceType) : AddressActionUi()
+    data class CheckClipboard(val data: String?) : AddressActionUi()
+    data class CheckAddress(val sourceType: AddressEntered.SourceType?) : AddressActionUi()
+    data class SetTruncateHandler(val handler: (String) -> String) : AddressActionUi()
+    data class TruncateOrRestore(val truncate: Boolean) : AddressActionUi()
 }

 sealed class TransactionExtrasAction : SendScreenActionUi {
@ -76,27 +74,15 @@ sealed class TransactionExtrasAction : SendScreenActionUi {
    }
 }

-sealed class AddressPayIdVerifyAction : SendScreenAction {
+sealed class AddressVerifyAction : SendScreenAction {
    enum class Error {
-        PAY_ID_UNSUPPORTED_BY_BLOCKCHAIN,
-        PAY_ID_NOT_REGISTERED,
-        PAY_ID_REQUEST_FAILED,
        ADDRESS_INVALID_OR_UNSUPPORTED_BY_BLOCKCHAIN,
        ADDRESS_SAME_AS_WALLET,
    }

-    data class ChangePasteBtnEnableState(val isEnabled: Boolean) : AddressPayIdVerifyAction()
+    data class ChangePasteBtnEnableState(val isEnabled: Boolean) : AddressVerifyAction()

-    sealed class PayIdVerification : AddressPayIdVerifyAction() {
-        data class SetPayIdError(val error: Error?) : PayIdVerification()
-        data class SetPayIdWalletAddress(
-            val payId: String,
-            val payIdWalletAddress: String,
-            val isUserInput: Boolean,
-        ) : PayIdVerification()
-    }
-
-    sealed class AddressVerification : AddressPayIdVerifyAction() {
+    sealed class AddressVerification : AddressVerifyAction() {
        data class SetAddressError(val error: Error?) : AddressVerification()
        data class SetWalletAddress(val address: String, val isUserInput: Boolean) : AddressVerification()
    }
@ -155,8 +141,6 @@ sealed class SendAction : SendScreenAction {
        override val messageResource: Int = R.string.send_transaction_success
    }

-    data class SendError(override val error: TapError) : SendAction(), ErrorAction
-
    sealed class Dialog : SendAction(), StateDialog {
        data class TezosWarningDialog(
            val reduceCallback: () -> Unit,
--- a/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/AddressPayIdMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/AddressPayIdMiddleware.kt
@ -2,49 +2,39 @@ package com.tangem.tap.features.send.redux.middlewares

 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Wallet
-import com.tangem.common.services.Result
 import com.tangem.core.analytics.Analytics
 import com.tangem.tap.common.analytics.events.Token.Send.AddressEntered
 import com.tangem.tap.common.redux.AppState
-import com.tangem.tap.domain.PayIdManager
-import com.tangem.tap.domain.isPayIdSupported
 import com.tangem.tap.features.send.redux.*
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction.AddressVerification.SetAddressError
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction.AddressVerification.SetWalletAddress
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction.Error
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction.PayIdVerification.SetPayIdError
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction.PayIdVerification.SetPayIdWalletAddress
-import com.tangem.tap.scope
-import com.tangem.tap.store
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
+import com.tangem.tap.features.send.redux.AddressVerifyAction.AddressVerification.SetAddressError
+import com.tangem.tap.features.send.redux.AddressVerifyAction.AddressVerification.SetWalletAddress
+import com.tangem.tap.features.send.redux.AddressVerifyAction.Error
 import org.rekotlin.Action
 import org.rekotlin.DispatchFunction

 /**
 [REDACTED_AUTHOR]
 */
-internal class AddressPayIdMiddleware {
+internal class AddressMiddleware {

-    fun handle(action: AddressPayIdActionUi, appState: AppState?, dispatch: (Action) -> Unit) {
+    fun handle(action: AddressActionUi, appState: AppState?, dispatch: (Action) -> Unit) {
        when (action) {
-            is AddressPayIdActionUi.HandleUserInput -> handleUserInput(action.data, appState, dispatch)
-            is AddressPayIdActionUi.PasteAddressPayId -> pasteAddressPayId(action.data, action.sourceType, dispatch)
-            is AddressPayIdActionUi.CheckClipboard -> verifyClipboard(action.data, appState, dispatch)
-            is AddressPayIdActionUi.CheckAddressPayId -> verifyAddressPayId(action.sourceType, appState, dispatch)
+            is AddressActionUi.HandleUserInput -> handleUserInput(action.data, appState, dispatch)
+            is AddressActionUi.PasteAddress -> pasteAddress(action.data, action.sourceType, dispatch)
+            is AddressActionUi.CheckClipboard -> verifyClipboard(action.data, appState, dispatch)
+            is AddressActionUi.CheckAddress -> verifyAddress(action.sourceType, appState, dispatch)
            else -> return
        }
    }

    private fun handleUserInput(input: String, appState: AppState?, dispatch: DispatchFunction) {
        val sendState = appState?.sendState ?: return
-        if (input == sendState.addressPayIdState.viewFieldValue.value) return
+        if (input == sendState.addressState.viewFieldValue.value) return

        setAddressAndCheck(data = input, sourceType = null, isUserInput = true, dispatch = dispatch)
    }

-    private fun pasteAddressPayId(data: String, sourceType: AddressEntered.SourceType, dispatch: (Action) -> Unit) {
+    private fun pasteAddress(data: String, sourceType: AddressEntered.SourceType, dispatch: (Action) -> Unit) {
        setAddressAndCheck(data = data, sourceType = sourceType, isUserInput = false, dispatch = dispatch)
    }

@ -54,74 +44,27 @@ internal class AddressPayIdMiddleware {
        isUserInput: Boolean,
        dispatch: (Action) -> Unit,
    ) {
-        val potentialPayId = data.lowercase()
-        if (isPayIdEnabled() && PayIdManager.isPayId(potentialPayId)) {
-            dispatch(SetPayIdWalletAddress(potentialPayId, "", isUserInput))
-        } else {
-            dispatch(SetWalletAddress(data, isUserInput))
-        }
-        dispatch(AddressPayIdActionUi.CheckAddressPayId(sourceType))
+        dispatch(SetWalletAddress(data, isUserInput))
+        dispatch(AddressActionUi.CheckAddress(sourceType))
    }

-    private fun verifyAddressPayId(
+    private fun verifyAddress(
        sourceType: AddressEntered.SourceType?,
        appState: AppState?,
        dispatch: (Action) -> Unit,
    ) {
        val sendState = appState?.sendState ?: return
        val wallet = sendState.walletManager?.wallet ?: return
-        val addressPayId = sendState.addressPayIdState.normalFieldValue ?: return
-        val isUserInput = sendState.addressPayIdState.viewFieldValue.isFromUserInput
+        val address = sendState.addressState.normalFieldValue ?: return
+        val isUserInput = sendState.addressState.viewFieldValue.isFromUserInput

-        if (isPayIdEnabled() && PayIdManager.isPayId(addressPayId)) {
-            verifyPayId(addressPayId, wallet, isUserInput, dispatch)
-        } else {
-            verifyAddress(
-                address = addressPayId,
-                wallet = wallet,
-                isUserInput = isUserInput,
-                dispatch = dispatch,
-                sourceType = sourceType,
-            )
-        }
-    }
-
-    private fun verifyPayId(payId: String, wallet: Wallet, isUserInput: Boolean, dispatch: DispatchFunction) {
-        val blockchain = wallet.blockchain
-        if (!blockchain.isPayIdSupported()) {
-            dispatch(SetPayIdError(Error.PAY_ID_UNSUPPORTED_BY_BLOCKCHAIN))
-            return
-        }
-
-        scope.launch {
-            val result = PayIdManager().verifyPayId(payId, blockchain)
-            withContext(Dispatchers.Main) {
-                when (result) {
-                    is Result.Success -> {
-                        val addressDetails = result.data.getAddressDetails()
-                        if (addressDetails == null) {
-                            dispatch(SetPayIdError(Error.PAY_ID_NOT_REGISTERED))
-                            return@withContext
-                        }
-
-                        val address = addressDetails.address
-                        val failReason = isValidBlockchainAddressAndNotTheSameAsWallet(wallet, address)
-                        if (failReason == null) {
-                            dispatch(SetPayIdWalletAddress(payId, address, isUserInput))
-                            dispatch(TransactionExtrasAction.Prepare(wallet.blockchain, address, addressDetails.tag))
-                            dispatch(FeeAction.RequestFee)
-                        } else {
-                            dispatch(SetAddressError(failReason))
-                            dispatch(TransactionExtrasAction.Release)
-                        }
-                    }
-                    is Result.Failure -> {
-                        dispatch(SetPayIdError(Error.PAY_ID_REQUEST_FAILED))
-                        dispatch(TransactionExtrasAction.Release)
-                    }
-                }
-            }
-        }
+        verifyAddress(
+            address = address,
+            wallet = wallet,
+            isUserInput = isUserInput,
+            dispatch = dispatch,
+            sourceType = sourceType,
+        )
    }

    private fun verifyAddress(
@ -219,41 +162,33 @@ internal class AddressPayIdMiddleware {
    }

    private fun verifyClipboard(input: String?, appState: AppState?, dispatch: DispatchFunction) {
-        val addressPayId = input ?: return
+        val address = input ?: return
        val wallet = appState?.sendState?.walletManager?.wallet ?: return

        val internalDispatcher: (Action) -> Unit = {
            when (it) {
-                is SetWalletAddress, is SetPayIdWalletAddress -> {
-                    dispatch(AddressPayIdVerifyAction.ChangePasteBtnEnableState(true))
+                is SetWalletAddress -> {
+                    dispatch(AddressVerifyAction.ChangePasteBtnEnableState(true))
                }
-                is SetAddressError, is SetPayIdError -> {
-                    dispatch(AddressPayIdVerifyAction.ChangePasteBtnEnableState(false))
+                is SetAddressError -> {
+                    dispatch(AddressVerifyAction.ChangePasteBtnEnableState(false))
                }
            }
        }

-        if (PayIdManager.isPayId(addressPayId) && isPayIdEnabled()) {
-            verifyPayId(addressPayId, wallet, false, internalDispatcher)
-        } else {
-            verifyAddress(
-                address = addressPayId,
-                wallet = wallet,
-                sourceType = null,
-                isUserInput = false,
-                dispatch = internalDispatcher,
-            )
-        }
-    }
-
-    private fun isPayIdEnabled(): Boolean {
-        return store.state.globalState.configManager?.config?.isSendingToPayIdEnabled ?: false
+        verifyAddress(
+            address = address,
+            wallet = wallet,
+            sourceType = null,
+            isUserInput = false,
+            dispatch = internalDispatcher,
+        )
    }
 }

 fun String.splitToMap(firstDelimiter: String, secondDelimiter: String): Map<String, String> {
-    return this.split(firstDelimiter)
+    return this
+        .split(firstDelimiter)
        .map { it.split(secondDelimiter) }
-        .map { it.first() to it.last().toString() }
-        .toMap()
+        .associate { it.first() to it.last() }
 }
--- a/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/RequestFeeMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/RequestFeeMiddleware.kt
@ -38,7 +38,7 @@ class RequestFeeMiddleware {
        }
        val typedAmount = sendState.amountState.amountToExtract ?: return

-        val destinationAddress = sendState.addressPayIdState.destinationWalletAddress!!
+        val destinationAddress = sendState.addressState.destinationWalletAddress!!
        val destinationAmount = Amount(typedAmount, sendState.amountState.amountToSendCrypto)
        val txSender = if (scanResponse.isDemoCard()) {
            DemoTransactionSender(walletManager)
--- a/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/SendMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/middlewares/SendMiddleware.kt
@ -55,18 +55,17 @@ class SendMiddleware {
        { nextDispatch ->
            { action ->
                when (action) {
-                    is AddressPayIdActionUi -> AddressPayIdMiddleware().handle(action, appState(), dispatch)
+                    is AddressActionUi -> AddressMiddleware().handle(action, appState(), dispatch)
                    is AmountActionUi -> AmountMiddleware().handle(action, appState(), dispatch)
                    is RequestFee -> RequestFeeMiddleware().handle(appState(), dispatch)
                    is SendActionUi.SendAmountToRecipient ->
                        verifyAndSendTransaction(action, appState(), dispatch)
-                    is PrepareSendScreen -> setIfSendingToPayIdEnabled(appState(), dispatch)
                    is SendAction.Warnings.Update -> updateWarnings(dispatch)
                    is SendActionUi.CheckIfTransactionDataWasProvided -> {
                        val transactionData = appState()?.sendState?.externalTransactionData
                        if (transactionData != null) {
                            store.dispatchOnMain(
-                                AddressPayIdVerifyAction.AddressVerification.SetWalletAddress(
+                                AddressVerifyAction.AddressVerification.SetWalletAddress(
                                    address = transactionData.destinationAddress,
                                    isUserInput = false,
                                ),
@ -96,7 +95,7 @@ private fun verifyAndSendTransaction(
    val sendState = appState?.sendState ?: return
    val walletManager = sendState.walletManager ?: return
    val card = appState.globalState.scanResponse?.card ?: return
-    val destinationAddress = sendState.addressPayIdState.destinationWalletAddress ?: return
+    val destinationAddress = sendState.addressState.destinationWalletAddress ?: return
    val typedAmount = sendState.amountState.amountToExtract ?: return
    val feeAmount = sendState.feeState.currentFee ?: return

@ -391,12 +390,6 @@ fun createValidateTransactionError(
    return TapError.ValidateTransactionErrors(tapErrors) { it.joinToString("\r\n") }
 }

-private fun setIfSendingToPayIdEnabled(appState: AppState?, dispatch: (Action) -> Unit) {
-    val isSendingToPayIdEnabled =
-        appState?.globalState?.configManager?.config?.isSendingToPayIdEnabled ?: false
-    dispatch(AddressPayIdActionUi.ChangePayIdState(isSendingToPayIdEnabled))
-}
-
 private fun updateWarnings(dispatch: (Action) -> Unit) {
    val warningsManager = store.state.globalState.warningManager ?: return
    val blockchain = store.state.sendState.walletManager?.wallet?.blockchain ?: return
--- a/app/src/main/java/com/tangem/tap/features/send/redux/reducers/AddressPayIdReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/reducers/AddressPayIdReducer.kt
@ -1,72 +0,0 @@
-package com.tangem.tap.features.send.redux.reducers
-
-import com.tangem.tap.features.send.redux.AddressPayIdActionUi
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction.AddressVerification
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction.PayIdVerification
-import com.tangem.tap.features.send.redux.SendScreenAction
-import com.tangem.tap.features.send.redux.states.AddressPayIdState
-import com.tangem.tap.features.send.redux.states.InputViewValue
-import com.tangem.tap.features.send.redux.states.SendState
-
-/**
-[REDACTED_AUTHOR]
- */
-class AddressPayIdReducer : SendInternalReducer {
-    override fun handle(action: SendScreenAction, sendState: SendState): SendState = when (action) {
-        is AddressPayIdActionUi -> handleUiAction(action, sendState, sendState.addressPayIdState)
-        is AddressPayIdVerifyAction -> handleAction(action, sendState, sendState.addressPayIdState)
-        else -> sendState
-    }
-
-    private fun handleUiAction(
-        action: AddressPayIdActionUi,
-        sendState: SendState,
-        state: AddressPayIdState,
-    ): SendState {
-        val result = when (action) {
-            is AddressPayIdActionUi.HandleUserInput -> state
-            is AddressPayIdActionUi.SetTruncateHandler -> state.copy(truncateHandler = action.handler)
-            is AddressPayIdActionUi.TruncateOrRestore -> {
-                val value = if (action.truncate) state.truncatedFieldValue ?: "" else state.normalFieldValue ?: ""
-                state.copy(viewFieldValue = state.viewFieldValue.copy(value = value))
-            }
-            is AddressPayIdActionUi.PasteAddressPayId -> return sendState
-            is AddressPayIdActionUi.CheckClipboard -> return sendState
-            is AddressPayIdActionUi.CheckAddressPayId -> return sendState
-            is AddressPayIdActionUi.ChangePayIdState -> state.copy(sendingToPayIdEnabled = action.sendingToPayIdEnabled)
-        }
-        return updateLastState(sendState.copy(addressPayIdState = result), result)
-    }
-
-    private fun handleAction(
-        action: AddressPayIdVerifyAction,
-        sendState: SendState,
-        state: AddressPayIdState,
-    ): SendState {
-        val result = when (action) {
-            is PayIdVerification.SetPayIdWalletAddress -> {
-                state.copy(
-                    viewFieldValue = InputViewValue(action.payId, action.isUserInput),
-                    normalFieldValue = action.payId,
-                    truncatedFieldValue = state.truncate(action.payId),
-                    destinationWalletAddress = action.payIdWalletAddress,
-                    error = null,
-                )
-            }
-            is AddressVerification.SetWalletAddress -> {
-                state.copy(
-                    viewFieldValue = InputViewValue(action.address, action.isUserInput),
-                    normalFieldValue = action.address,
-                    truncatedFieldValue = state.truncate(action.address),
-                    destinationWalletAddress = action.address,
-                    error = null,
-                )
-            }
-            is AddressPayIdVerifyAction.ChangePasteBtnEnableState -> state.copy(pasteIsEnabled = action.isEnabled)
-            is AddressVerification.SetAddressError -> state.copy(error = action.error, destinationWalletAddress = null)
-            is PayIdVerification.SetPayIdError -> state.copy(error = action.error, destinationWalletAddress = null)
-        }
-        return updateLastState(sendState.copy(addressPayIdState = result), result)
-    }
-}
--- a/app/src/main/java/com/tangem/tap/features/send/redux/reducers/AddressReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/reducers/AddressReducer.kt
@ -0,0 +1,52 @@
+package com.tangem.tap.features.send.redux.reducers
+
+import com.tangem.tap.features.send.redux.AddressActionUi
+import com.tangem.tap.features.send.redux.AddressVerifyAction
+import com.tangem.tap.features.send.redux.AddressVerifyAction.AddressVerification
+import com.tangem.tap.features.send.redux.SendScreenAction
+import com.tangem.tap.features.send.redux.states.AddressState
+import com.tangem.tap.features.send.redux.states.InputViewValue
+import com.tangem.tap.features.send.redux.states.SendState
+
+/**
+[REDACTED_AUTHOR]
+ */
+class AddressReducer : SendInternalReducer {
+    override fun handle(action: SendScreenAction, sendState: SendState): SendState = when (action) {
+        is AddressActionUi -> handleUiAction(action, sendState, sendState.addressState)
+        is AddressVerifyAction -> handleAction(action, sendState, sendState.addressState)
+        else -> sendState
+    }
+
+    private fun handleUiAction(action: AddressActionUi, sendState: SendState, state: AddressState): SendState {
+        val result = when (action) {
+            is AddressActionUi.HandleUserInput -> state
+            is AddressActionUi.SetTruncateHandler -> state.copy(truncateHandler = action.handler)
+            is AddressActionUi.TruncateOrRestore -> {
+                val value = if (action.truncate) state.truncatedFieldValue ?: "" else state.normalFieldValue ?: ""
+                state.copy(viewFieldValue = state.viewFieldValue.copy(value = value))
+            }
+            is AddressActionUi.PasteAddress -> return sendState
+            is AddressActionUi.CheckClipboard -> return sendState
+            is AddressActionUi.CheckAddress -> return sendState
+        }
+        return updateLastState(sendState.copy(addressState = result), result)
+    }
+
+    private fun handleAction(action: AddressVerifyAction, sendState: SendState, state: AddressState): SendState {
+        val result = when (action) {
+            is AddressVerification.SetWalletAddress -> {
+                state.copy(
+                    viewFieldValue = InputViewValue(action.address, action.isUserInput),
+                    normalFieldValue = action.address,
+                    truncatedFieldValue = state.truncate(action.address),
+                    destinationWalletAddress = action.address,
+                    error = null,
+                )
+            }
+            is AddressVerifyAction.ChangePasteBtnEnableState -> state.copy(pasteIsEnabled = action.isEnabled)
+            is AddressVerification.SetAddressError -> state.copy(error = action.error, destinationWalletAddress = null)
+        }
+        return updateLastState(sendState.copy(addressState = result), result)
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/send/redux/reducers/SendScreenReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/reducers/SendScreenReducer.kt
@ -25,7 +25,7 @@ object SendScreenReducer {

        val reducer: SendInternalReducer = when (action) {
            is PrepareSendScreen -> PrepareSendScreenStatesReducer()
-            is AddressPayIdActionUi, is AddressPayIdVerifyAction -> AddressPayIdReducer()
+            is AddressActionUi, is AddressVerifyAction -> AddressReducer()
            is TransactionExtrasAction -> TransactionExtrasReducer()
            is AmountActionUi, is AmountAction -> AmountReducer()
            is FeeActionUi, is FeeAction -> FeeReducer()
@ -71,7 +71,7 @@ private class SendReducer : SendInternalReducer {
            amountState = state.amountState.copy(
                inputIsEnabled = false,
            ),
-            addressPayIdState = state.addressPayIdState.copy(
+            addressState = state.addressState.copy(
                inputIsEnabled = false,
            ),
        )
--- a/app/src/main/java/com/tangem/tap/features/send/redux/states/AddressPayIdState.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/states/AddressPayIdState.kt
@ -2,17 +2,16 @@ package com.tangem.tap.features.send.redux.states

 import androidx.core.text.isDigitsOnly
 import com.tangem.blockchain.blockchains.stellar.StellarMemo
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction
+import com.tangem.tap.features.send.redux.AddressVerifyAction
 import java.math.BigInteger

-data class AddressPayIdState(
+data class AddressState(
    val viewFieldValue: InputViewValue = InputViewValue(""),
    val normalFieldValue: String? = null,
    val truncatedFieldValue: String? = null,
    val destinationWalletAddress: String? = null,
-    val error: AddressPayIdVerifyAction.Error? = null,
+    val error: AddressVerifyAction.Error? = null,
    val truncateHandler: ((String) -> String)? = null,
-    val sendingToPayIdEnabled: Boolean = false,
    val pasteIsEnabled: Boolean = false,
    val inputIsEnabled: Boolean = true,
 ) : SendScreenState {
@ -22,8 +21,6 @@ data class AddressPayIdState(
    fun truncate(value: String): String = truncateHandler?.invoke(value) ?: value

    fun isReady(): Boolean = error == null && destinationWalletAddress?.isNotEmpty() ?: false
-
-    fun isPayIdState(): Boolean = destinationWalletAddress != null && destinationWalletAddress != normalFieldValue
 }

 data class TransactionExtrasState(
@ -98,11 +95,7 @@ data class BinanceMemoState(
    val viewFieldValue: InputViewValue = InputViewValue(""),
    val memo: BigInteger? = null,
    val error: TransactionExtraError? = null,
-) {
-    companion object {
-        val MAX_NUMBER: BigInteger = BigInteger("FFFFFFFFFFFFFFFF", 16)
-    }
-}
+)

 // tag must contains only digits
 data class XrpDestinationTagState(
--- a/app/src/main/java/com/tangem/tap/features/send/redux/states/SendState.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/states/SendState.kt
@ -34,7 +34,7 @@ data class SendState(
    val coinConverter: CurrencyConverter? = null,
    val tokenConverter: CurrencyConverter? = null,
    val lastChangedStates: LinkedHashSet<StateId> = linkedSetOf(),
-    val addressPayIdState: AddressPayIdState = AddressPayIdState(),
+    val addressState: AddressState = AddressState(),
    val transactionExtrasState: TransactionExtrasState = TransactionExtrasState(),
    val amountState: AmountState = AmountState(),
    val feeState: FeeState = FeeState(),
@ -52,7 +52,7 @@ data class SendState(
        MainCurrencyType.CRYPTO -> amountState.amountToExtract?.decimals ?: 0
    }

-    fun convertFiatToCoin(value: BigDecimal): BigDecimal {
+    private fun convertFiatToCoin(value: BigDecimal): BigDecimal {
        return if (!this.coinIsConvertible()) value else coinConverter!!.toCrypto(value)
    }

@ -60,14 +60,14 @@ data class SendState(
        return if (!this.tokenIsConvertible()) value else tokenConverter!!.toCrypto(value)
    }

-    fun convertCoinToFiat(value: BigDecimal, scaleWithPrecision: Boolean = false): BigDecimal {
+    private fun convertCoinToFiat(value: BigDecimal, scaleWithPrecision: Boolean = false): BigDecimal {
        if (!this.coinIsConvertible()) return value

        val converter = coinConverter!!
        return if (!scaleWithPrecision) converter.toFiat(value) else converter.toFiatWithPrecision(value)
    }

-    fun convertTokenToFiat(value: BigDecimal, scaleWithPrecision: Boolean = false): BigDecimal {
+    private fun convertTokenToFiat(value: BigDecimal, scaleWithPrecision: Boolean = false): BigDecimal {
        if (!this.tokenIsConvertible()) return value

        val converter = tokenConverter!!
@ -107,13 +107,13 @@ data class SendState(
    }

    companion object {
-        fun addressPayIdIsReady(): Boolean = store.state.sendState.addressPayIdState.isReady()
+        private fun addressIsReady(): Boolean = store.state.sendState.addressState.isReady()

-        fun amountIsReady(): Boolean = store.state.sendState.amountState.isReady()
+        private fun amountIsReady(): Boolean = store.state.sendState.amountState.isReady()

-        fun isReadyToRequestFee(): Boolean = addressPayIdIsReady() && amountIsReady()
+        fun isReadyToRequestFee(): Boolean = addressIsReady() && amountIsReady()

-        fun isReadyToSend(): Boolean = addressPayIdIsReady() && amountIsReady() &&
+        fun isReadyToSend(): Boolean = addressIsReady() && amountIsReady() &&
            store.state.sendState.feeState.isReady()
    }
 }
--- a/app/src/main/java/com/tangem/tap/features/send/ui/SendFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/ui/SendFragment.kt
@ -33,7 +33,7 @@ import com.tangem.tap.common.toggleWidget.ViewStateWidget
 import com.tangem.tap.features.BaseStoreFragment
 import com.tangem.tap.features.addBackPressHandler
 import com.tangem.tap.features.send.redux.*
-import com.tangem.tap.features.send.redux.AddressPayIdActionUi.*
+import com.tangem.tap.features.send.redux.AddressActionUi.*
 import com.tangem.tap.features.send.redux.AmountActionUi.*
 import com.tangem.tap.features.send.redux.FeeActionUi.*
 import com.tangem.tap.features.send.redux.states.FeeType
@ -80,7 +80,7 @@ class SendFragment : BaseStoreFragment(R.layout.fragment_send) {
        etAmountToSend = view.findViewById(R.id.etAmountToSend)

        initSendButtonStates()
-        setupAddressOrPayIdLayout()
+        setupAddressLayout()
        setupTransactionExtrasLayout()
        setupAmountLayout()
        setupFeeLayout()
@ -99,14 +99,14 @@ class SendFragment : BaseStoreFragment(R.layout.fragment_send) {
        sendBtn = IndeterminateProgressButtonWidget(btnSend, progress)
    }

-    private fun setupAddressOrPayIdLayout() = with(binding.lSendAddressPayid) {
-        store.dispatch(SetTruncateHandler { etAddressOrPayId.truncateMiddleWith(it, "...") })
+    private fun setupAddressLayout() = with(binding.lSendAddress) {
+        store.dispatch(SetTruncateHandler { etAddress.truncateMiddleWith(it, "...") })
        store.dispatch(CheckClipboard(requireContext().getFromClipboard()?.toString()))

-        etAddressOrPayId.apply {
+        etAddress.apply {
            setOnSystemPasteButtonClickListener {
                store.dispatch(
-                    PasteAddressPayId(
+                    PasteAddress(
                        data = requireContext().getFromClipboard()?.toString() ?: "",
                        sourceType = Token.Send.AddressEntered.SourceType.PastePopup,
                    ),
@ -119,9 +119,9 @@ class SendFragment : BaseStoreFragment(R.layout.fragment_send) {

            inputtedTextAsFlow()
                .debounce(EDIT_TEXT_INPUT_DEBOUNCE)
-                .filter { store.state.sendState.addressPayIdState.viewFieldValue.value != it }
+                .filter { store.state.sendState.addressState.viewFieldValue.value != it }
                .onEach {
-                    store.dispatch(AddressPayIdActionUi.HandleUserInput(it))
+                    store.dispatch(AddressActionUi.HandleUserInput(it))
                }
                .launchIn(mainScope)
        }
@ -129,12 +129,12 @@ class SendFragment : BaseStoreFragment(R.layout.fragment_send) {
        imvPaste.setOnClickListener {
            Analytics.send(Token.Send.ButtonPaste())
            store.dispatch(
-                PasteAddressPayId(
+                PasteAddress(
                    data = requireContext().getFromClipboard()?.toString() ?: "",
                    sourceType = Token.Send.AddressEntered.SourceType.PasteButton,
                ),
            )
-            store.dispatch(TruncateOrRestore(!etAddressOrPayId.isFocused))
+            store.dispatch(TruncateOrRestore(!etAddress.isFocused))
        }
        imvQrCode.setOnClickListener {
            Analytics.send(Token.Send.ButtonQRCode())
@ -145,7 +145,7 @@ class SendFragment : BaseStoreFragment(R.layout.fragment_send) {
        }
    }

-    private fun setupTransactionExtrasLayout() = with(binding.lSendAddressPayid) {
+    private fun setupTransactionExtrasLayout() = with(binding.lSendAddress) {
        // TODO: [REDACTED_TASK_KEY]
        etXlmMemo.inputtedTextAsFlow()
            .debounce(EDIT_TEXT_INPUT_DEBOUNCE)
@ -202,15 +202,15 @@ class SendFragment : BaseStoreFragment(R.layout.fragment_send) {
        // Delayed launch is needed in order for the UI to be drawn and to process the sent events.
        // If do not use the delay, then etAmount error field is not displayed when
        // inserting an incorrect amount by shareUri
-        binding.lSendAddressPayid.imvQrCode.postDelayed(
+        binding.lSendAddress.imvQrCode.postDelayed(
            {
                store.dispatch(
-                    PasteAddressPayId(
+                    PasteAddress(
                        data = scannedCode,
                        sourceType = Token.Send.AddressEntered.SourceType.QRCode,
                    ),
                )
-                store.dispatch(TruncateOrRestore(!binding.lSendAddressPayid.etAddressOrPayId.isFocused))
+                store.dispatch(TruncateOrRestore(!binding.lSendAddress.etAddress.isFocused))
            },
            200,
        )
--- a/app/src/main/java/com/tangem/tap/features/send/ui/stateSubscribers/SendStateSubscriber.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/ui/stateSubscribers/SendStateSubscriber.kt
@ -7,30 +7,15 @@ import android.view.View
 import android.view.ViewGroup
 import androidx.core.text.bold
 import com.tangem.common.extensions.remove
-import com.tangem.tap.common.extensions.beginDelayedTransition
-import com.tangem.tap.common.extensions.enableError
-import com.tangem.tap.common.extensions.getColor
-import com.tangem.tap.common.extensions.getString
-import com.tangem.tap.common.extensions.hide
-import com.tangem.tap.common.extensions.show
-import com.tangem.tap.common.extensions.update
+import com.tangem.tap.common.extensions.*
 import com.tangem.tap.common.redux.getMessageString
 import com.tangem.tap.common.text.DecimalDigitsInputFilter
 import com.tangem.tap.domain.MultiMessageError
 import com.tangem.tap.domain.assembleErrors
 import com.tangem.tap.features.BaseStoreFragment
-import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction.Error
+import com.tangem.tap.features.send.redux.AddressVerifyAction.Error
 import com.tangem.tap.features.send.redux.SendAction
-import com.tangem.tap.features.send.redux.states.AddressPayIdState
-import com.tangem.tap.features.send.redux.states.AmountState
-import com.tangem.tap.features.send.redux.states.FeeState
-import com.tangem.tap.features.send.redux.states.MainCurrencyType
-import com.tangem.tap.features.send.redux.states.ReceiptLayoutType
-import com.tangem.tap.features.send.redux.states.ReceiptState
-import com.tangem.tap.features.send.redux.states.SendState
-import com.tangem.tap.features.send.redux.states.StateId
-import com.tangem.tap.features.send.redux.states.TransactionExtraError
-import com.tangem.tap.features.send.redux.states.TransactionExtrasState
+import com.tangem.tap.features.send.redux.states.*
 import com.tangem.tap.features.send.ui.FeeUiHelper
 import com.tangem.tap.features.send.ui.SendFragment
 import com.tangem.tap.features.send.ui.dialogs.KaspaWarningDialog
@ -61,7 +46,7 @@ class SendStateSubscriber(fragment: BaseStoreFragment) : FragmentStateSubscriber
        lastChangedStates.forEach {
            when (it) {
                StateId.SEND_SCREEN -> handleSendScreen(fg, state)
-                StateId.ADDRESS_PAY_ID -> handleAddressPayIdState(fg, state.addressPayIdState)
+                StateId.ADDRESS_PAY_ID -> handleAddressState(fg, state.addressState)
                StateId.TRANSACTION_EXTRAS -> handleTransactionExtrasState(fg, state.transactionExtrasState)
                StateId.AMOUNT -> handleAmountState(fg, state.amountState)
                StateId.FEE -> handleFeeState(fg, state.feeState)
@ -72,7 +57,7 @@ class SendStateSubscriber(fragment: BaseStoreFragment) : FragmentStateSubscriber

    @Suppress("ComplexMethod")
    private fun handleTransactionExtrasState(fg: SendFragment, infoState: TransactionExtrasState) =
-        with(fg.binding.lSendAddressPayid) {
+        with(fg.binding.lSendAddress) {
            fun showView(view: View, info: Any?) {
                view.show(info != null)
            }
@ -192,13 +177,10 @@ class SendStateSubscriber(fragment: BaseStoreFragment) : FragmentStateSubscriber
        )
    }

-    private fun handleAddressPayIdState(fg: SendFragment, state: AddressPayIdState) =
-        with(fg.binding.lSendAddressPayid) {
+    private fun handleAddressState(fg: SendFragment, state: AddressState) {
+        with(fg.binding.lSendAddress) {
            fun parseError(context: Context, error: Error?): String? {
                val resId = when (error) {
-                    Error.PAY_ID_UNSUPPORTED_BY_BLOCKCHAIN -> R.string.send_error_payid_unsupported_by_blockchain
-                    Error.PAY_ID_NOT_REGISTERED -> R.string.send_error_payid_not_registered
-                    Error.PAY_ID_REQUEST_FAILED -> R.string.send_error_payid_request_failed
                    Error.ADDRESS_INVALID_OR_UNSUPPORTED_BY_BLOCKCHAIN -> R.string.send_validation_invalid_address
                    Error.ADDRESS_SAME_AS_WALLET -> R.string.send_error_address_same_as_wallet
                    else -> null
@ -208,8 +190,8 @@ class SendStateSubscriber(fragment: BaseStoreFragment) : FragmentStateSubscriber

            imvPaste.isEnabled = state.pasteIsEnabled

-            val et = etAddressOrPayId
-            val til = tilAddressOrPayId
+            val et = etAddress
+            val til = tilAddress
            val parsedError = parseError(til.context, state.error)

            til.isEnabled = state.inputIsEnabled
@ -218,19 +200,15 @@ class SendStateSubscriber(fragment: BaseStoreFragment) : FragmentStateSubscriber
            flPaste.show(state.inputIsEnabled)
            flQrCode.show(state.inputIsEnabled)

-            val hintResId = if (state.sendingToPayIdEnabled) {
-                R.string.send_destination_hint_address_payid
-            } else {
-                R.string.send_destination_hint_address
-            }
-            til.hint = til.getString(hintResId)
+            til.hint = til.getString(R.string.send_destination_hint_address)
            til.error = parsedError
            til.isErrorEnabled = parsedError != null
            til.helperText = state.destinationWalletAddress
-            til.isHelperTextEnabled = state.isPayIdState() && parsedError == null
+            til.isHelperTextEnabled = parsedError == null

            if (!state.viewFieldValue.isFromUserInput) et.update(state.viewFieldValue.value)
        }
+    }

    private fun handleAmountState(fg: SendFragment, state: AmountState) = with(fg.binding.lSendAmount) {
        if (state.error != null) {
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/WalletFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/WalletFragment.kt
@ -8,7 +8,9 @@ import android.view.View
 import androidx.activity.OnBackPressedCallback
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.platform.ViewCompositionStrategy
 import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
 import androidx.fragment.app.viewModels
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.flowWithLifecycle
@ -22,12 +24,16 @@ import coil.size.Scale
 import com.badoo.mvicore.modelWatcher
 import com.tangem.core.analytics.Analytics
 import com.tangem.core.ui.fragments.setStatusBarColor
+import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.utils.OneTouchClickListener
 import com.tangem.datasource.connection.NetworkConnectionManager
+import com.tangem.feature.learn2earn.presentation.Learn2earnViewModel
+import com.tangem.feature.learn2earn.presentation.ui.Learn2earnMainPageScreen
 import com.tangem.feature.swap.api.SwapFeatureToggleManager
 import com.tangem.feature.swap.domain.SwapInteractor
 import com.tangem.tap.MainActivity
 import com.tangem.tap.common.analytics.events.Portfolio
+import com.tangem.tap.common.extensions.beginDelayedTransition
 import com.tangem.tap.common.extensions.show
 import com.tangem.tap.common.recyclerView.SpaceItemDecoration
 import com.tangem.tap.common.redux.global.GlobalAction
@ -73,6 +79,7 @@ class WalletFragment : Fragment(R.layout.fragment_wallet), SafeStoreSubscriber<W

    private var walletView: WalletView = MultiWalletView()

+    private val learn2earnViewModel by activityViewModels<Learn2earnViewModel>()
    private val viewModel by viewModels<WalletViewModel>()

    private val totalBalanceWatcher = modelWatcher {
@ -102,6 +109,7 @@ class WalletFragment : Fragment(R.layout.fragment_wallet), SafeStoreSubscriber<W
        val inflater = TransitionInflater.from(requireContext())
        enterTransition = inflater.inflateTransition(R.transition.slide_right)
        exitTransition = inflater.inflateTransition(R.transition.fade)
+        learn2earnViewModel.onMainScreenCreated()
    }

    override fun onStart() {
@ -199,6 +207,27 @@ class WalletFragment : Fragment(R.layout.fragment_wallet), SafeStoreSubscriber<W
        binding.toolbar.setNavigationIcon(
            if (state.canSaveUserWallets) R.drawable.ic_wallet_24 else R.drawable.ic_tap_card_24,
        )
+
+        showLearn2earnView()
+    }
+
+    private fun showLearn2earnView() {
+        val isShowing = learn2earnViewModel.uiState.mainScreenState.isVisible
+        if (!isShowing) return
+
+        binding.composeLearnToEarnContainer.show(true) { binding.llWarnings.beginDelayedTransition() }
+        binding.composeLearnToEarnContainer.apply {
+            setViewCompositionStrategy(
+                strategy = ViewCompositionStrategy.DisposeOnLifecycleDestroyed(
+                    lifecycle = this@WalletFragment.lifecycle,
+                ),
+            )
+            setContent {
+                TangemTheme {
+                    Learn2earnMainPageScreen(learn2earnViewModel.uiState)
+                }
+            }
+        }
    }

    private fun setupPullToRefreshLayout(state: WalletState) {
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/WalletViewModel.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/WalletViewModel.kt
@ -17,16 +17,8 @@ import com.tangem.tap.features.wallet.ui.analytics.WalletAnalyticsEventsMapper
 import com.tangem.tap.store
 import com.tangem.tap.walletStoresManager
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.FlowPreview
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.debounce
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
 import org.rekotlin.StoreSubscriber
 import javax.inject.Inject

@ -71,6 +63,7 @@ internal class WalletViewModel @Inject constructor(
                        currency = currency,
                        batch = scanResponse.card.batchId,
                        signInType = signInType,
+                        walletsCount = store.state.globalState.userWalletsListManager?.walletsCount.toString(),
                    ),
                )
            }
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/utils/WalletDataOperations.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/utils/WalletDataOperations.kt
@ -98,7 +98,7 @@ internal fun WalletDataModel.getAvailableActions(

 internal fun WalletDataModel.shouldShowMultipleAddress(): Boolean {
    val listOfAddresses = walletAddresses?.list.orEmpty()
-    return listOfAddresses.size > 1 && currency.blockchain != Blockchain.BitcoinCash
+    return listOfAddresses.size > 1
 }

 internal fun WalletDataModel.assembleWarnings(
--- a/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeAction.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeAction.kt
@ -15,7 +15,7 @@ internal sealed interface WelcomeAction : Action {
        data class Error(val error: TangemError) : WelcomeAction
    }

-    data class HandleIntentIfNeeded(val intent: Intent?) : WelcomeAction
+    data class SetInitialIntent(val intent: Intent?) : WelcomeAction

    object CloseError : WelcomeAction

--- a/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeMiddleware.kt
@ -1,6 +1,5 @@
 package com.tangem.tap.features.welcome.redux

-import android.content.Intent
 import com.tangem.common.core.TangemSdkError
 import com.tangem.common.doOnFailure
 import com.tangem.common.doOnResult
@ -19,6 +18,7 @@ import com.tangem.tap.common.redux.navigation.NavigationAction
 import com.tangem.tap.domain.model.builders.UserWalletBuilder
 import com.tangem.tap.domain.scanCard.ScanCardProcessor
 import com.tangem.tap.domain.userWalletList.unlockIfLockable
+import com.tangem.tap.features.intentHandler.handlers.WalletConnectLinkIntentHandler
 import com.tangem.tap.features.signin.redux.SignInAction
 import kotlinx.coroutines.launch
 import org.rekotlin.Middleware
@ -39,24 +39,10 @@ internal class WelcomeMiddleware {

    private fun handleAction(action: WelcomeAction, state: WelcomeState) {
        when (action) {
-            is WelcomeAction.ProceedWithBiometrics -> {
-                proceedWithBiometrics(state)
-            }
-            is WelcomeAction.ProceedWithCard -> {
-                proceedWithCard(state)
-            }
-            is WelcomeAction.HandleIntentIfNeeded -> {
-                handleInitialIntent(action.intent)
-            }
-            is WelcomeAction.ClearUserWallets -> {
-                disableUserWalletsSaving()
-            }
-            is WelcomeAction.ProceedWithBiometrics.Error,
-            is WelcomeAction.ProceedWithCard.Error,
-            is WelcomeAction.ProceedWithBiometrics.Success,
-            is WelcomeAction.ProceedWithCard.Success,
-            is WelcomeAction.CloseError,
-            -> Unit
+            is WelcomeAction.ProceedWithBiometrics -> proceedWithBiometrics(state)
+            is WelcomeAction.ProceedWithCard -> proceedWithCard(state)
+            is WelcomeAction.ClearUserWallets -> disableUserWalletsSaving()
+            else -> Unit
        }
    }

@ -85,7 +71,9 @@ internal class WelcomeMiddleware {
                store.dispatchOnMain(WelcomeAction.ProceedWithBiometrics.Success)
                store.onUserWalletSelected(userWallet = selectedUserWallet)

-                intentHandler.handleWalletConnectLink(state.intent)
+                state.intent?.let {
+                    WalletConnectLinkIntentHandler().handleIntent(it)
+                }
            }
    }

@ -104,20 +92,13 @@ internal class WelcomeMiddleware {
                    store.dispatchOnMain(WelcomeAction.ProceedWithCard.Success)
                    store.onUserWalletSelected(userWallet = userWallet)

-                    intentHandler.handleWalletConnectLink(state.intent)
+                    state.intent?.let {
+                        WalletConnectLinkIntentHandler().handleIntent(it)
+                    }
                }
        }
    }

-    private fun handleInitialIntent(intent: Intent?) {
-        val isBackgroundScanNotHandled = !intentHandler.handleBackgroundScan(intent, hasSavedUserWallets = true)
-        val hasNotIncompletedBackup = !backupService.hasIncompletedBackup
-
-        if (isBackgroundScanNotHandled && hasNotIncompletedBackup) {
-            store.dispatchOnMain(WelcomeAction.ProceedWithBiometrics)
-        }
-    }
-
    private suspend inline fun scanCardInternal(crossinline onCardScanned: suspend (ScanResponse) -> Unit) {
        tangemSdkManager.setAccessCodeRequestPolicy(
            useBiometricsForAccessCode = preferencesStorage.shouldSaveAccessCodes,
--- a/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeReducer.kt
@ -14,7 +14,7 @@ internal object WelcomeReducer {

    private fun internalReduce(action: WelcomeAction, state: WelcomeState): WelcomeState {
        return when (action) {
-            is WelcomeAction.HandleIntentIfNeeded -> state.copy(intent = action.intent)
+            is WelcomeAction.SetInitialIntent -> state.copy(intent = action.intent)
            is WelcomeAction.ProceedWithBiometrics -> state.copy(isUnlockWithBiometricsInProgress = true)
            is WelcomeAction.ProceedWithCard -> state.copy(isUnlockWithCardInProgress = true)
            is WelcomeAction.ProceedWithBiometrics.Error -> state.copy(