Updated on 2026-08-14

features/account/impl/src/main/java/com/tangem/features/account/archived/ui/ArchivedAccountListContent.kt

@@ -11,6 +11,7 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.tooling.preview.datasource.CollectionPreviewParameterProvider
@@ -27,6 +28,7 @@ import com.tangem.core.ui.extensions.stringReference
 import com.tangem.core.ui.extensions.stringResourceSafe
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
+import com.tangem.core.ui.test.accounts.ArchivedAccountsScreenTestTags
 import com.tangem.features.account.archived.entity.AccountArchivedUM
 import com.tangem.features.account.archived.entity.ArchivedAccountUM
 import kotlinx.collections.immutable.toImmutableList
@@ -102,7 +104,7 @@ private fun ArchiveAccountError(state: AccountArchivedUM.Error, modifier: Modifi
 
 @Composable
 private fun ArchiveAccountContent(state: AccountArchivedUM.Content, modifier: Modifier = Modifier) {
-    LazyColumn(modifier = modifier) {
+    LazyColumn(modifier = modifier.testTag(ArchivedAccountsScreenTestTags.ARCHIVED_ACCOUNTS_SCREEN_CONTAINER)) {
         itemsIndexed(
             items = state.accounts,
             key = { index, item -> item.accountId },
@@ -127,7 +129,8 @@ private fun ArchivedAccountRow(item: ArchivedAccountUM, modifier: Modifier = Mod
         modifier = modifier
             .fillMaxWidth()
             .clickable(enabled = !item.isLoading, onClick = item.onClick)
-            .padding(all = TangemTheme.dimens.spacing12),
+            .padding(all = TangemTheme.dimens.spacing12)
+            .testTag(ArchivedAccountsScreenTestTags.ARCHIVED_ACCOUNT_ITEM),
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.spacedBy(TangemTheme.dimens.spacing12),
     ) {
@@ -151,6 +154,7 @@ private fun ArchivedAccountRow(item: ArchivedAccountUM, modifier: Modifier = Mod
                 isLoading = item.isLoading,
                 onClick = item.onClick,
             ),
+            modifier = Modifier.testTag(ArchivedAccountsScreenTestTags.RESTORE_BUTTON),
         )
     }
 }

features/account/impl/src/main/java/com/tangem/features/account/createedit/ui/AccountCreateEditContent.kt

@@ -21,6 +21,7 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.vectorResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
@@ -40,6 +41,7 @@ import com.tangem.core.ui.components.fields.AutoSizeTextField
 import com.tangem.core.ui.extensions.*
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
+import com.tangem.core.ui.test.accounts.AccountInfoEditScreenTestTags
 import com.tangem.core.ui.utils.rememberHideKeyboardNestedScrollConnection
 import com.tangem.domain.models.account.CryptoPortfolioIcon
 import com.tangem.features.account.createedit.entity.AccountCreateEditUM
@@ -128,6 +130,8 @@ private fun AccountSummary(account: Account, isCreateMode: Boolean) {
             name = account.name.value,
             icon = account.portfolioIcon,
             size = AccountIconSize.Large,
+            modifier = Modifier
+                .testTag(AccountInfoEditScreenTestTags.SELECTED_ICON),
         )
         Spacer(modifier = Modifier.height(24.dp))
 
@@ -159,7 +163,9 @@ private fun AccountSummary(account: Account, isCreateMode: Boolean) {
 
                 account.onNameChange(newName)
             },
-            textFieldModifier = Modifier.focusRequester(focusRequester),
+            textFieldModifier = Modifier
+                .focusRequester(focusRequester)
+                .testTag(AccountInfoEditScreenTestTags.NAME_FIELD),
         )
         SpacerH(20.dp)
     }

features/account/impl/src/main/java/com/tangem/features/account/details/ui/AccountDetailsContent.kt

@@ -32,7 +32,7 @@ import com.tangem.core.ui.extensions.stringReference
 import com.tangem.core.ui.extensions.stringResourceSafe
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.core.ui.test.AccountDetailsScreenTestTags
+import com.tangem.core.ui.test.accounts.AccountDetailsScreenTestTags
 import com.tangem.features.account.details.entity.AccountDetailsUM
 
 @Composable
@@ -42,7 +42,8 @@ internal fun AccountDetailsContent(state: AccountDetailsUM, modifier: Modifier =
             .background(color = TangemTheme.colors.background.secondary)
             .fillMaxSize()
             .imePadding()
-            .systemBarsPadding(),
+            .systemBarsPadding()
+            .testTag(AccountDetailsScreenTestTags.ACCOUNT_DETAILS_CONTAINER),
         horizontalAlignment = Alignment.CenterHorizontally,
     ) {
         AppBarWithBackButton(
@@ -95,7 +96,8 @@ private fun ArchiveAccountRow(state: AccountDetailsUM.ArchiveMode.Available) {
             .clip(RoundedCornerShape(TangemTheme.dimens.radius12))
             .background(TangemTheme.colors.background.primary)
             .clickable(enabled = !state.isLoading, onClick = state.onArchiveAccountClick)
-            .padding(all = TangemTheme.dimens.spacing12),
+            .padding(all = TangemTheme.dimens.spacing12)
+            .testTag(AccountDetailsScreenTestTags.ARCHIVE_ACCOUNT_BUTTON),
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.spacedBy(TangemTheme.dimens.spacing12),
     ) {
@@ -160,7 +162,8 @@ private fun AccountRow(state: AccountDetailsUM) {
             .clip(RoundedCornerShape(TangemTheme.dimens.radius12))
             .background(TangemTheme.colors.background.primary)
             .clickable(onClick = state.onAccountEditClick)
-            .padding(all = TangemTheme.dimens.spacing12),
+            .padding(all = TangemTheme.dimens.spacing12)
+            .testTag(AccountDetailsScreenTestTags.EDIT_ACCOUNT_BUTTON),
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.spacedBy(TangemTheme.dimens.spacing12),
     ) {

features/account/impl/src/main/java/com/tangem/features/account/di/AccountFeatureModule.kt

@@ -3,15 +3,9 @@ package com.tangem.features.account.di
 import com.tangem.features.account.AccountCreateEditComponent
 import com.tangem.features.account.AccountDetailsComponent
 import com.tangem.features.account.ArchivedAccountListComponent
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.account.PortfolioSelectorComponent
-import com.tangem.features.account.PortfolioSelectorController
 import com.tangem.features.account.archived.DefaultArchivedAccountListComponent
 import com.tangem.features.account.createedit.DefaultAccountCreateEditComponent
 import com.tangem.features.account.details.DefaultAccountDetailsComponent
-import com.tangem.features.account.fetcher.DefaultPortfolioFetcher
-import com.tangem.features.account.selector.DefaultPortfolioSelectorComponent
-import com.tangem.features.account.selector.DefaultPortfolioSelectorController
 import dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn
@@ -21,17 +15,6 @@ import dagger.hilt.components.SingletonComponent
 @InstallIn(SingletonComponent::class)
 internal interface AccountFeatureModule {
 
-    @Binds
-    fun bindPortfolioFetcherFactory(impl: DefaultPortfolioFetcher.Factory): PortfolioFetcher.Factory
-
-    @Binds
-    fun bindPortfolioSelectorController(impl: DefaultPortfolioSelectorController): PortfolioSelectorController
-
-    @Binds
-    fun bindPortfolioSelectorComponentFactory(
-        impl: DefaultPortfolioSelectorComponent.Factory,
-    ): PortfolioSelectorComponent.Factory
-
     @Binds
     fun bindAccountCreateEditComponentFactory(
         impl: DefaultAccountCreateEditComponent.Factory,

features/approval/impl/src/main/java/com/tangem/features/approval/impl/model/GiveApprovalModel.kt

@@ -8,6 +8,7 @@ import com.tangem.blockchain.common.TransactionData
 import com.tangem.blockchain.common.TransactionSender.MultipleTransactionSendMode
 import com.tangem.blockchain.common.transaction.Fee
 import com.tangem.blockchain.common.transaction.TransactionFee
+import com.tangem.common.TangemBlogUrlBuilder
 import com.tangem.common.ui.bottomsheet.permission.state.ApproveType
 import com.tangem.common.ui.userwallet.ext.walletInterationIcon
 import com.tangem.core.analytics.api.AnalyticsEventHandler
@@ -16,10 +17,7 @@ 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.decompose.model.ParamsContainer
-import com.tangem.core.decompose.ui.UiMessageSender
 import com.tangem.core.navigation.url.UrlOpener
-import com.tangem.core.ui.extensions.resourceReference
-import com.tangem.core.ui.message.DialogMessage
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.currency.CryptoCurrencyStatus
 import com.tangem.domain.transaction.error.GetFeeError
@@ -38,7 +36,6 @@ import com.tangem.features.send.v2.api.callbacks.FeeSelectorModelCallback
 import com.tangem.features.send.v2.api.entity.FeeItem
 import com.tangem.features.send.v2.api.entity.FeeSelectorUM
 import com.tangem.features.send.v2.api.subcomponents.feeSelector.FeeSelectorReloadTrigger
-import com.tangem.utils.TangemBlogUrlBuilder.RESOURCE_TO_LEARN_ABOUT_APPROVING_IN_SWAP
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.logging.TangemLogger
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -62,7 +59,6 @@ internal class GiveApprovalModel @Inject constructor(
     private val getFeeForGaslessUseCase: GetFeeForGaslessUseCase,
     private val getFeeForTokenUseCase: GetFeeForTokenUseCase,
     private val createAndSendGaslessTransactionUseCase: CreateAndSendGaslessTransactionUseCase,
-    private val uiMessageSender: UiMessageSender,
     private val urlOpener: UrlOpener,
     private val getUserWalletUseCase: GetUserWalletUseCase,
     private val analyticsEventHandler: AnalyticsEventHandler,
@@ -126,16 +122,9 @@ internal class GiveApprovalModel @Inject constructor(
     }
 
     fun onOpenLearnMoreAboutApproveClick() {
-        urlOpener.openUrl(RESOURCE_TO_LEARN_ABOUT_APPROVING_IN_SWAP)
-    }
-
-    fun showPermissionInfoDialog() {
-        uiMessageSender.send(
-            DialogMessage(
-                message = resourceReference(com.tangem.common.ui.R.string.give_permission_staking_footer),
-                title = resourceReference(com.tangem.common.ui.R.string.common_approve),
-            ),
-        )
+        modelScope.launch {
+            urlOpener.openUrl(TangemBlogUrlBuilder.build(TangemBlogUrlBuilder.Post.GiveRevokePermission))
+        }
     }
 
     suspend fun loadFee(): Either<GetFeeError, TransactionFee> {

features/biometry/impl/src/main/kotlin/com/tangem/features/biometry/impl/ui/AskBiometry.kt

@@ -126,6 +126,16 @@ private fun Footer(state: AskBiometryUM, modifier: Modifier = Modifier) {
             .fillMaxWidth(),
         horizontalAlignment = Alignment.CenterHorizontally,
     ) {
+        Text(
+            modifier = Modifier.fillMaxWidth(fraction = .7f),
+            text = stringResourceSafe(R.string.save_user_wallet_agreement_notice),
+            style = TangemTheme.typography.caption2,
+            color = TangemTheme.colors.text.tertiary,
+            textAlign = TextAlign.Center,
+        )
+
+        SpacerH16()
+
         PrimaryButton(
             modifier = Modifier.fillMaxWidth(),
             showProgress = state.shouldShowProgress,
@@ -142,16 +152,6 @@ private fun Footer(state: AskBiometryUM, modifier: Modifier = Modifier) {
                 onClick = state.onDontAllowClick,
             )
         }
-
-        SpacerH16()
-
-        Text(
-            modifier = Modifier.fillMaxWidth(fraction = .7f),
-            text = stringResourceSafe(R.string.save_user_wallet_agreement_notice),
-            style = TangemTheme.typography.caption2,
-            color = TangemTheme.colors.text.tertiary,
-            textAlign = TextAlign.Center,
-        )
     }
 }
 

features/common-features/api/.gitignore

@@ -0,0 +1 @@
+/build

features/common-features/api/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+    alias(deps.plugins.android.library)
+    alias(deps.plugins.kotlin.android)
+    alias(deps.plugins.kotlin.serialization)
+    id("configuration")
+}
+
+android {
+    namespace = "com.tangem.features.commonfeatures.api"
+}
+
+dependencies {
+
+    /* Project - Domain */
+    implementation(projects.domain.models)
+    implementation(projects.domain.markets)
+    implementation(projects.domain.account)
+
+    /* Project - Core */
+    implementation(projects.core.decompose)
+    implementation(projects.core.ui)
+
+    /* Compose */
+    implementation(deps.compose.runtime)
+    implementation(deps.kotlin.immutable.collections)
+}

features/common-features/api/src/main/java/com/tangem/features/commonfeatures/api/addtoportfolio/AddToPortfolioComponent.kt

@@ -0,0 +1,11 @@
+package com.tangem.features.commonfeatures.api.addtoportfolio
+
+import com.tangem.core.decompose.factory.ComponentFactory
+import com.tangem.core.ui.decompose.ComposableBottomSheetComponent
+
+interface AddToPortfolioComponent : ComposableBottomSheetComponent {
+
+    data class Params(val addToPortfolioManager: AddToPortfolioManager)
+
+    interface Factory : ComponentFactory<Params, AddToPortfolioComponent>
+}

features/common-features/api/src/main/java/com/tangem/features/commonfeatures/api/addtoportfolio/AddToPortfolioManager.kt

@@ -0,0 +1,114 @@
+package com.tangem.features.commonfeatures.api.addtoportfolio
+
+import com.tangem.domain.markets.RawMarketToken
+import com.tangem.domain.markets.TokenMarketInfo
+import com.tangem.domain.markets.TokenMarketParams
+import com.tangem.domain.models.account.AccountStatus
+import com.tangem.domain.models.currency.CryptoCurrencyStatus
+import com.tangem.domain.models.wallet.UserWallet
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager.AnalyticsParams
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioFetcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.serialization.Serializable
+
+interface AddToPortfolioManager : AddToPortfolioManagerInternal {
+
+    val onDismiss: Channel<Unit>
+    val onSuccessAdded: Channel<Result>
+    val onAddedTokenClick: Channel<Result>
+
+    val state: StateFlow<State>
+
+    /**
+     * default is [LaunchMode.DirectAdd]
+     */
+    fun updateLaunchMode(launchMode: LaunchMode)
+
+    fun setTokenNetworks(networks: List<TokenMarketInfo.Network>)
+    fun setTokenParams(token: RawMarketToken)
+    fun setTokenParams(token: TokenMarketParams) = setTokenParams(
+        RawMarketToken(
+            id = token.id,
+            name = token.name,
+            symbol = token.symbol,
+        ),
+    )
+
+    sealed interface State {
+        data object Loading : State
+        data class Ready(val availableToAddData: AvailableToAddData) : State {
+            val isAvailableToAdd: Boolean get() = availableToAddData.isAvailableToAdd
+            val isSinglePortfolio: Boolean get() = availableToAddData.isSinglePortfolio
+        }
+    }
+
+    @Serializable
+    data class AnalyticsParams(
+        val source: String?,
+        val category: String = CategoryDefault,
+    ) {
+        companion object {
+            const val CategoryDefault = "Markets / Chart"
+            const val CategoryEarn = "Earn"
+        }
+    }
+
+    interface Factory {
+        fun create(scope: CoroutineScope, settings: Settings, analyticsParams: AnalyticsParams): AddToPortfolioManager
+    }
+
+    sealed interface LaunchMode {
+        data object DirectAdd : LaunchMode
+        data object Preselected : LaunchMode
+        data object ViaUserPortfolio : LaunchMode
+    }
+
+    /**
+     * Immutable settings
+     */
+    data class Settings(
+        val shouldSkipTokenActionsScreen: Boolean = false,
+    ) {
+        companion object {
+            val DefaultMarket = Settings(shouldSkipTokenActionsScreen = false)
+            val ChooseToken = Settings(shouldSkipTokenActionsScreen = true)
+        }
+    }
+
+    /**
+     * Mutable parameters
+     * Updates may trigger reload [State]
+     */
+    data class Params(
+        val networks: List<TokenMarketInfo.Network>,
+        val token: RawMarketToken,
+        val launchMode: LaunchMode,
+    )
+
+    data class Result(
+        val wallet: UserWallet,
+        val account: AccountStatus.CryptoPortfolio,
+        val addedCurrency: CryptoCurrencyStatus,
+    )
+}
+
+/**
+ * primary for internal impl usage, but you can also use it externally
+ */
+interface AddToPortfolioManagerInternal {
+    val paramsFlow: SharedFlow<AddToPortfolioManager.Params>
+    val settings: AddToPortfolioManager.Settings
+    val analyticsParams: AnalyticsParams
+    val portfolioFetcher: PortfolioFetcher
+
+    suspend fun params(): AddToPortfolioManager.Params = paramsFlow.first()
+    suspend fun token(): RawMarketToken = params().token
+
+    fun onDismiss()
+    fun onSuccessAdded(result: AddToPortfolioManager.Result)
+    fun onAddedTokenClick(result: AddToPortfolioManager.Result)
+}

features/common-features/api/src/main/java/com/tangem/features/commonfeatures/api/addtoportfolio/AddToPortfolioPreselectedDataComponent.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add
+package com.tangem.features.commonfeatures.api.addtoportfolio
 
 import com.tangem.core.decompose.factory.ComponentFactory
 import com.tangem.core.ui.decompose.ComposableBottomSheetComponent

features/common-features/api/src/main/java/com/tangem/features/commonfeatures/api/addtoportfolio/AvailableToAddData.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add
+package com.tangem.features.commonfeatures.api.addtoportfolio
 
 import com.tangem.domain.markets.TokenMarketInfo
 import com.tangem.domain.models.account.AccountId
@@ -36,13 +36,13 @@ data class AvailableToAddAccount(
         get() = availableNetworks.size == 1
 
     val availableToAddNetworks: Set<TokenMarketInfo.Network> = availableNetworks
-        .filter { available -> addedNetworks.none { added -> added.backendId == available.networkId } }
+        .filter { available -> addedNetworks.none { added -> added.rawId == available.networkId } }
         .toSet()
 
     val isAvailableToAdd: Boolean = availableToAddNetworks.isNotEmpty()
 
     val addedMarketNetworks: Set<TokenMarketInfo.Network> = availableNetworks
-        .filter { available -> addedNetworks.any { added -> added.backendId == available.networkId } }
+        .filter { available -> addedNetworks.any { added -> added.rawId == available.networkId } }
         .toSet()
 }
 

features/common-features/api/src/main/java/com/tangem/features/commonfeatures/api/portfolioselector/PortfolioFetcher.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.account
+package com.tangem.features.commonfeatures.api.portfolioselector
 
 import com.tangem.domain.account.models.AccountStatusList
 import com.tangem.domain.appcurrency.model.AppCurrency

features/common-features/api/src/main/java/com/tangem/features/commonfeatures/api/portfolioselector/PortfolioSelectorComponent.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.account
+package com.tangem.features.commonfeatures.api.portfolioselector
 
 import com.tangem.core.decompose.factory.ComponentFactory
 import com.tangem.core.ui.decompose.ComposableBottomSheetComponent

features/common-features/impl/.gitignore

@@ -0,0 +1 @@
+/build

features/common-features/impl/build.gradle.kts

@@ -0,0 +1,94 @@
+plugins {
+    alias(deps.plugins.android.library)
+    alias(deps.plugins.kotlin.android)
+    alias(deps.plugins.kotlin.kapt)
+    alias(deps.plugins.kotlin.serialization)
+    alias(deps.plugins.hilt.android)
+    id("configuration")
+}
+
+android {
+    namespace = "com.tangem.features.commonfeatures.impl"
+}
+
+tasks.withType<Test>().configureEach {
+    useJUnitPlatform()
+}
+
+dependencies {
+    /** Api */
+    implementation(projects.features.commonFeatures.api)
+    // todo swap delete after move portfolio selector
+    implementation(projects.features.account.api)
+    implementation(projects.features.wallet.api)
+    implementation(projects.features.tokenRecieve.api)
+
+    /** Core modules */
+    implementation(projects.core.analytics)
+    implementation(projects.core.analytics.models)
+    implementation(projects.core.utils)
+    implementation(projects.core.ui)
+    implementation(projects.core.error)
+    implementation(projects.core.res)
+    implementation(projects.core.decompose)
+    implementation(projects.core.navigation)
+    implementation(projects.core.datasource)
+
+    /** Domain */
+    implementation(projects.domain.models)
+    implementation(projects.domain.account)
+    implementation(projects.domain.account.status)
+    implementation(projects.domain.core)
+    implementation(projects.domain.appCurrency)
+    implementation(projects.domain.appCurrency.models)
+    implementation(projects.domain.markets)
+    implementation(projects.domain.transaction)
+    implementation(projects.domain.tokens)
+    implementation(projects.domain.tokens.models)
+    implementation(projects.domain.manageTokens)
+    implementation(projects.domain.manageTokens.models)
+    implementation(projects.domain.balanceHiding)
+    implementation(projects.domain.balanceHiding.models)
+    implementation(projects.domain.wallets)
+    implementation(projects.domain.wallets.models)
+
+    /** Tangem libraries */
+    implementation(tangemDeps.card.core)
+
+    /** Common */
+    implementation(projects.common.ui)
+    implementation(projects.common.uiMarkets)
+    implementation(projects.common.routing)
+
+    /** Libs */
+    implementation(projects.libs.blockchainSdk)
+
+    /** AndroidX libraries */
+    implementation(deps.androidx.core.ktx)
+    implementation(deps.lifecycle.runtime.ktx)
+
+    /** Compose libraries */
+    implementation(deps.compose.material3)
+    implementation(deps.compose.animation)
+    implementation(deps.compose.foundation)
+    implementation(deps.compose.ui)
+    implementation(deps.compose.ui.tooling)
+    implementation(deps.compose.coil)
+    implementation(deps.decompose.ext.compose)
+    implementation(deps.androidx.activity.compose)
+
+    /** Other libraries */
+    implementation(deps.arrow.core)
+    implementation(deps.kotlin.immutable.collections)
+    implementation(deps.kotlin.serialization)
+    implementation(deps.firebase.crashlytics)
+
+    /** DI */
+    implementation(deps.hilt.android)
+    kapt(deps.hilt.kapt)
+
+    testRuntimeOnly(deps.test.junit5.engine)
+    testImplementation(projects.common.test)
+    testImplementation(projects.test.core)
+    testImplementation(projects.test.mock)
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/AddToPortfolioBottomSheet.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl
+package com.tangem.features.commonfeatures.impl.addtoportfolio
 
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.foundation.layout.Column
@@ -19,9 +19,9 @@ import com.tangem.core.ui.decompose.ComposableContentComponent
 import com.tangem.core.ui.extensions.TextReference
 import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.core.ui.res.TangemTheme
-import com.tangem.features.account.PortfolioSelectorComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.AddToPortfolioRoutes
-import com.tangem.features.feed.impl.R
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorComponent
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddToPortfolioRoutes
 
 @Composable
 internal fun AddToPortfolioBottomSheet(
@@ -63,7 +63,9 @@ internal fun AddToPortfolioBottomSheet(
                     bottom = 16.dp,
                 )
                 val isScrollableContent = when (animatedStack.active.configuration) {
-                    AddToPortfolioRoutes.PortfolioSelector -> false
+                    AddToPortfolioRoutes.PortfolioSelector,
+                    AddToPortfolioRoutes.UserPortfolio,
+                    -> false
                     AddToPortfolioRoutes.AddToken,
                     AddToPortfolioRoutes.Empty,
                     is AddToPortfolioRoutes.NetworkSelector,
@@ -95,6 +97,7 @@ private fun AddToPortfolioBottomSheetTitle(
         AddToPortfolioRoutes.Empty -> TextReference.EMPTY
         is AddToPortfolioRoutes.NetworkSelector -> resourceReference(R.string.common_choose_network)
         AddToPortfolioRoutes.TokenActions -> resourceReference(R.string.common_get_token)
+        AddToPortfolioRoutes.UserPortfolio -> resourceReference(R.string.markets_portfolio_block_title)
         AddToPortfolioRoutes.PortfolioSelector -> (stack.active.instance as PortfolioSelectorComponent)
             .title.collectAsStateWithLifecycle().value
     }

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/AddTokenComponent.kt

@@ -1,18 +1,20 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl
+package com.tangem.features.commonfeatures.impl.addtoportfolio
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.tangem.common.ui.addtoken.AddTokenContent
+import com.tangem.common.ui.addtoken.AddTokenContentV2
 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.core.ui.res.LocalRedesignEnabled
 import com.tangem.domain.models.currency.CryptoCurrencyStatus
-import com.tangem.features.feed.components.market.details.portfolio.add.SelectedNetwork
-import com.tangem.features.feed.components.market.details.portfolio.add.SelectedPortfolio
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.AddTokenModel
-import com.tangem.features.feed.components.market.details.portfolio.impl.analytics.PortfolioAnalyticsEvent
+import com.tangem.features.commonfeatures.api.addtoportfolio.SelectedNetwork
+import com.tangem.features.commonfeatures.api.addtoportfolio.SelectedPortfolio
+import com.tangem.features.commonfeatures.impl.addtoportfolio.analytics.PortfolioAnalyticsEvent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddTokenModel
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
@@ -29,10 +31,17 @@ internal class AddTokenComponent @AssistedInject constructor(
     override fun Content(modifier: Modifier) {
         val state = model.uiState.collectAsStateWithLifecycle()
         val um = state.value ?: return
-        AddTokenContent(
-            modifier = modifier,
-            state = um,
-        )
+        if (LocalRedesignEnabled.current) {
+            AddTokenContentV2(
+                modifier = modifier,
+                state = um,
+            )
+        } else {
+            AddTokenContent(
+                modifier = modifier,
+                state = um,
+            )
+        }
     }
 
     data class Params(

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/ChooseNetworkComponent.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl
+package com.tangem.features.commonfeatures.impl.addtoportfolio
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
@@ -9,9 +9,9 @@ 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.markets.TokenMarketInfo
-import com.tangem.features.feed.components.market.details.portfolio.add.SelectedPortfolio
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.ChooseNetworkModel
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.ChooseNetworkContent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.ChooseNetworkModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.ChooseNetworkContent
+import com.tangem.features.commonfeatures.api.addtoportfolio.SelectedPortfolio
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/DefaultAddToPortfolioComponent.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl
+package com.tangem.features.commonfeatures.impl.addtoportfolio
 
 import androidx.compose.runtime.Composable
 import com.arkivanov.decompose.ComponentContext
@@ -11,14 +11,16 @@ import com.tangem.core.decompose.context.child
 import com.tangem.core.decompose.context.childByContext
 import com.tangem.core.decompose.model.getOrCreateModel
 import com.tangem.core.ui.decompose.ComposableContentComponent
-import com.tangem.features.account.PortfolioSelectorComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.AddToPortfolioModel
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.AddToPortfolioRoutes
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioComponent
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddToPortfolioModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddToPortfolioRoutes
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.UserPortfolioComponent
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 
+@Suppress("LongParameterList")
 internal class DefaultAddToPortfolioComponent @AssistedInject constructor(
     @Assisted context: AppComponentContext,
     @Assisted private val params: AddToPortfolioComponent.Params,
@@ -26,6 +28,7 @@ internal class DefaultAddToPortfolioComponent @AssistedInject constructor(
     addTokenComponentFactory: AddTokenComponent.Factory,
     tokenActionsComponentFactory: TokenActionsComponent.Factory,
     private val chooseNetworkComponentFactory: ChooseNetworkComponent.Factory,
+    private val userPortfolioComponentFactory: UserPortfolioComponent.Factory,
 ) : AppComponentContext by context, AddToPortfolioComponent {
 
     private val model: AddToPortfolioModel = getOrCreateModel(params)
@@ -33,29 +36,33 @@ internal class DefaultAddToPortfolioComponent @AssistedInject constructor(
     private val portfolioSelectorComponent: PortfolioSelectorComponent = portfolioSelectorComponentFactory.create(
         context = child("portfolioSelectorComponent"),
         params = PortfolioSelectorComponent.Params(
-            portfolioFetcher = model.portfolioFetcher,
+            portfolioFetcher = model.addToPortfolioManager.portfolioFetcher,
             controller = model.portfolioSelectorController,
         ),
     )
 
-    private val addTokenComponent: AddTokenComponent = addTokenComponentFactory.create(
-        context = child("addTokenComponent"),
-        params = AddTokenComponent.Params(
-            eventBuilder = model.eventBuilder,
-            callbacks = model,
-            selectedPortfolio = model.selectedPortfolio,
-            selectedNetwork = model.selectedNetwork,
-        ),
-    )
+    private val addTokenComponent: AddTokenComponent by lazy {
+        addTokenComponentFactory.create(
+            context = child("addTokenComponent"),
+            params = AddTokenComponent.Params(
+                eventBuilder = model.eventBuilder,
+                callbacks = model,
+                selectedPortfolio = model.selectedPortfolio,
+                selectedNetwork = model.selectedNetwork,
+            ),
+        )
+    }
 
-    private val tokenActionsComponent: TokenActionsComponent = tokenActionsComponentFactory.create(
-        context = child("tokenActionsComponent"),
-        params = TokenActionsComponent.Params(
-            eventBuilder = model.eventBuilder,
-            callbacks = model,
-            data = model.tokenActionsData,
-        ),
-    )
+    private val tokenActionsComponent: TokenActionsComponent by lazy {
+        tokenActionsComponentFactory.create(
+            context = child("tokenActionsComponent"),
+            params = TokenActionsComponent.Params(
+                eventBuilder = model.eventBuilder,
+                callbacks = model,
+                data = model.tokenActionsData,
+            ),
+        )
+    }
 
     private val childStack = childStack(
         key = "addToPortfolioStack",
@@ -71,7 +78,7 @@ internal class DefaultAddToPortfolioComponent @AssistedInject constructor(
     }
 
     override fun dismiss() {
-        params.callback.onDismiss()
+        model.addToPortfolioManager.onDismiss()
     }
 
     @Composable
@@ -91,6 +98,7 @@ internal class DefaultAddToPortfolioComponent @AssistedInject constructor(
         AddToPortfolioRoutes.PortfolioSelector -> portfolioSelectorComponent
         AddToPortfolioRoutes.TokenActions -> tokenActionsComponent
         AddToPortfolioRoutes.Empty -> ComposableContentComponent.EMPTY
+        AddToPortfolioRoutes.UserPortfolio -> createUserPortfolioComponent(componentContext)
         is AddToPortfolioRoutes.NetworkSelector -> chooseNetworkComponentFactory.create(
             context = childByContext(componentContext),
             params = ChooseNetworkComponent.Params(
@@ -100,6 +108,16 @@ internal class DefaultAddToPortfolioComponent @AssistedInject constructor(
         )
     }
 
+    private fun createUserPortfolioComponent(componentContext: ComponentContext): ComposableContentComponent {
+        return userPortfolioComponentFactory.create(
+            context = childByContext(componentContext),
+            params = UserPortfolioComponent.Params(
+                uiState = model.userPortfolioStateController.uiState,
+                callbacks = model,
+            ),
+        )
+    }
+
     @AssistedFactory
     interface Factory : AddToPortfolioComponent.Factory {
         override fun create(

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/DefaultAddToPortfolioPreselectedDataComponent.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl
+package com.tangem.features.commonfeatures.impl.addtoportfolio
 
 import androidx.compose.runtime.Composable
 import com.arkivanov.decompose.extensions.compose.subscribeAsState
@@ -9,10 +9,10 @@ import com.tangem.core.decompose.context.AppComponentContext
 import com.tangem.core.decompose.context.child
 import com.tangem.core.decompose.model.getOrCreateModel
 import com.tangem.core.ui.decompose.ComposableContentComponent
-import com.tangem.features.account.PortfolioSelectorComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioPreselectedDataComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.AddToPortfolioPreselectedDataModel
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.AddToPortfolioRoutes
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioPreselectedDataComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddToPortfolioPreselectedDataModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddToPortfolioRoutes
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
@@ -78,6 +78,7 @@ internal class DefaultAddToPortfolioPreselectedDataComponent @AssistedInject con
         AddToPortfolioRoutes.TokenActions -> ComposableContentComponent.EMPTY
         AddToPortfolioRoutes.Empty -> ComposableContentComponent.EMPTY
         is AddToPortfolioRoutes.NetworkSelector -> ComposableContentComponent.EMPTY
+        AddToPortfolioRoutes.UserPortfolio -> ComposableContentComponent.EMPTY
     }
 
     @AssistedFactory

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/TokenActionsComponent.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl
+package com.tangem.features.commonfeatures.impl.addtoportfolio
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
@@ -8,17 +8,19 @@ import com.arkivanov.decompose.ComponentContext
 import com.arkivanov.decompose.extensions.compose.subscribeAsState
 import com.arkivanov.decompose.router.slot.childSlot
 import com.arkivanov.decompose.router.slot.dismiss
+import com.tangem.common.ui.markets.action.CryptoCurrencyData
 import com.tangem.core.decompose.context.AppComponentContext
 import com.tangem.core.decompose.context.childByContext
 import com.tangem.core.decompose.factory.ComponentFactory
 import com.tangem.core.decompose.model.getOrCreateModel
 import com.tangem.core.ui.decompose.ComposableBottomSheetComponent
 import com.tangem.core.ui.decompose.ComposableContentComponent
+import com.tangem.core.ui.res.LocalRedesignEnabled
 import com.tangem.domain.models.TokenReceiveConfig
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.TokenActionsModel
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.TokenActionsContent
-import com.tangem.features.feed.components.market.details.portfolio.impl.analytics.PortfolioAnalyticsEvent
-import com.tangem.features.feed.components.market.details.portfolio.impl.loader.PortfolioData
+import com.tangem.features.commonfeatures.impl.addtoportfolio.analytics.PortfolioAnalyticsEvent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.TokenActionsModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.TokenActionsContent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.TokenActionsContentV2
 import com.tangem.features.tokenreceive.TokenReceiveComponent
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
@@ -44,10 +46,17 @@ internal class TokenActionsComponent @AssistedInject constructor(
         val state = model.uiState.collectAsStateWithLifecycle()
         val bottomSheet by bottomSheetSlot.subscribeAsState()
         val tokenActionsUM = state.value ?: return
-        TokenActionsContent(
-            modifier = modifier,
-            state = tokenActionsUM,
-        )
+        if (LocalRedesignEnabled.current) {
+            TokenActionsContentV2(
+                modifier = modifier,
+                state = tokenActionsUM,
+            )
+        } else {
+            TokenActionsContent(
+                modifier = modifier,
+                state = tokenActionsUM,
+            )
+        }
         bottomSheet.child?.instance?.BottomSheet()
     }
 
@@ -64,7 +73,7 @@ internal class TokenActionsComponent @AssistedInject constructor(
 
     data class Params(
         val eventBuilder: PortfolioAnalyticsEvent.EventBuilder,
-        val data: Flow<PortfolioData.CryptoCurrencyData>,
+        val data: Flow<CryptoCurrencyData>,
         val callbacks: Callbacks,
     )
 

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/analytics/EarnAnalyticsEvent.kt

@@ -0,0 +1,35 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.analytics
+
+import com.tangem.core.analytics.models.AnalyticsEvent
+import com.tangem.core.analytics.models.AnalyticsParam
+
+// todo swap unify with PortfolioAnalyticsEvent, AddToPortfolioFlow
+internal sealed class EarnAnalyticsEvent(
+    event: String,
+    params: Map<String, String> = emptyMap(),
+) : AnalyticsEvent(category = "Earn", event = event, params = params) {
+
+    data class AddTokenScreenOpened(
+        private val tokenSymbol: String,
+        private val blockchain: String,
+        private val source: String,
+    ) : EarnAnalyticsEvent(
+        event = "Add Token Screen Opened",
+        params = mapOf(
+            AnalyticsParam.TOKEN_PARAM to tokenSymbol,
+            AnalyticsParam.BLOCKCHAIN to blockchain,
+            AnalyticsParam.SOURCE to source,
+        ),
+    )
+
+    data class TokenAdded(
+        private val tokenSymbol: String,
+        private val blockchain: String,
+    ) : EarnAnalyticsEvent(
+        event = "Token Added",
+        params = mapOf(
+            AnalyticsParam.TOKEN_PARAM to tokenSymbol,
+            AnalyticsParam.BLOCKCHAIN to blockchain,
+        ),
+    )
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/analytics/PortfolioAnalyticsEvent.kt

@@ -0,0 +1,104 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.analytics
+
+import com.tangem.common.ui.markets.action.TokenActionsBSContentUM
+import com.tangem.core.analytics.models.AnalyticsEvent
+import com.tangem.core.analytics.models.AnalyticsParam
+
+internal class PortfolioAnalyticsEvent(
+    event: String,
+    params: Map<String, String> = emptyMap(),
+    category: String,
+) : AnalyticsEvent(category = category, event = event, params = params) {
+
+    data class EventBuilder(
+        val tokenSymbol: String,
+        val source: String?,
+        val category: String,
+    ) {
+
+        fun popupToChooseAccount() = PortfolioAnalyticsEvent(
+            event = "Choose Account Opened",
+            category = category,
+            params = buildMap {
+                if (source != null) put(AnalyticsParam.SOURCE, source)
+            },
+        )
+
+        fun popupToConfirm(blockchain: String) = PortfolioAnalyticsEvent(
+            event = "Add Token Screen Opened",
+            category = category,
+            params = buildMap {
+                put(AnalyticsParam.TOKEN_PARAM, tokenSymbol)
+                put(AnalyticsParam.BLOCKCHAIN, blockchain)
+                if (source != null) put(AnalyticsParam.SOURCE, source)
+            },
+        )
+
+        fun addToNotMainAccount() = PortfolioAnalyticsEvent(
+            event = "Button - Add To Account",
+            category = category,
+            params = buildMap {
+                if (source != null) put("Source", source)
+            },
+        )
+
+        fun addButtonClick() = PortfolioAnalyticsEvent(
+            event = "Button - Add Token",
+            category = category,
+            params = buildMap {
+                if (source != null) put("Source", source)
+            },
+        )
+
+        fun addToPortfolioWalletChanged() = PortfolioAnalyticsEvent(
+            event = "Wallet Selected",
+            category = category,
+            params = buildMap {
+                if (source != null) put("Source", source)
+            },
+        )
+
+        fun addToPortfolioContinue(blockchainNames: List<String>) = PortfolioAnalyticsEvent(
+            event = "Token Network Selected",
+            category = category,
+            params = buildMap {
+                put("Count", blockchainNames.size.toString())
+                put("Token", tokenSymbol)
+                put("blockchain", blockchainNames.joinToString(separator = ", "))
+                if (source != null) put("Source", source)
+            },
+        )
+
+        fun tokenAdded(blockchainName: String) = PortfolioAnalyticsEvent(
+            event = "Token Added",
+            category = category,
+            params = buildMap {
+                put(AnalyticsParam.TOKEN_PARAM, tokenSymbol)
+                put(AnalyticsParam.BLOCKCHAIN, blockchainName)
+                if (source != null) put("Source", source)
+            },
+        )
+
+        fun getTokenActionClick(actionUM: TokenActionsBSContentUM.Action) = PortfolioAnalyticsEvent(
+            event = when (actionUM) {
+                TokenActionsBSContentUM.Action.Buy -> "Popup Get token - Button Buy"
+                TokenActionsBSContentUM.Action.Receive -> "Popup Get token - Button Receive"
+                TokenActionsBSContentUM.Action.Exchange -> "Popup Get token - Button Exchange"
+                TokenActionsBSContentUM.Action.Stake -> "Popup Get token - Button Stake"
+                else -> "error"
+            },
+            category = category,
+            params = buildMap {
+                if (source != null) put("Source", source)
+            },
+        )
+
+        fun getTokenLater() = PortfolioAnalyticsEvent(
+            event = "Popup Get token - Button Later",
+            category = category,
+            params = buildMap {
+                if (source != null) put("Source", source)
+            },
+        )
+    }
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/converter/AvailableToAddDataConverter.kt

@@ -1,10 +1,10 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.converter
+package com.tangem.features.commonfeatures.impl.addtoportfolio.converter
 
 import com.tangem.domain.account.status.usecase.GetAccountCurrencyStatusUseCase
 import com.tangem.domain.markets.FilterAvailableNetworksForWalletUseCase
 import com.tangem.domain.markets.GetTokenMarketCryptoCurrency
+import com.tangem.domain.markets.RawMarketToken
 import com.tangem.domain.markets.TokenMarketInfo
-import com.tangem.domain.markets.TokenMarketParams
 import com.tangem.domain.models.account.Account
 import com.tangem.domain.models.account.AccountId
 import com.tangem.domain.models.account.AccountStatus
@@ -12,10 +12,10 @@ import com.tangem.domain.models.account.filterCryptoPortfolio
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.feed.components.market.details.portfolio.add.AvailableToAddAccount
-import com.tangem.features.feed.components.market.details.portfolio.add.AvailableToAddData
-import com.tangem.features.feed.components.market.details.portfolio.add.AvailableToAddWallet
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioFetcher
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddAccount
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddData
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddWallet
 import javax.inject.Inject
 
 internal class AvailableToAddDataConverter @Inject constructor(
@@ -27,7 +27,7 @@ internal class AvailableToAddDataConverter @Inject constructor(
     suspend fun convert(
         balances: Map<UserWalletId, PortfolioFetcher.PortfolioBalance>,
         availableNetworks: Set<TokenMarketInfo.Network>,
-        marketParams: TokenMarketParams,
+        marketParams: RawMarketToken,
     ): AvailableToAddData {
         suspend fun AccountStatus.CryptoPortfolio.getAvailableToAddAccount(wallet: UserWallet): AvailableToAddAccount? {
             val currencies = availableNetworks
@@ -103,7 +103,7 @@ internal class AvailableToAddDataConverter @Inject constructor(
     private suspend fun createCryptoCurrency(
         userWallet: UserWallet,
         network: TokenMarketInfo.Network,
-        marketParams: TokenMarketParams,
+        marketParams: RawMarketToken,
         account: Account.CryptoPortfolio,
     ): CryptoCurrency? {
         return getTokenMarketCryptoCurrency(

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/converter/BlockchainRowUMConverter.kt

@@ -1,15 +1,15 @@
-package com.tangem.features.feed.components.market.details.portfolio.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.converter
 
+import com.tangem.common.ui.extensions.greyedOutIconResId
+import com.tangem.common.ui.extensions.iconResId
 import com.tangem.core.ui.components.rows.model.BlockchainRowUM
-import com.tangem.core.ui.extensions.getActiveIconRes
-import com.tangem.core.ui.extensions.getGreyedOutIconRes
 import com.tangem.domain.markets.TokenMarketInfo
-import com.tangem.domain.markets.TokenMarketInfo.Network
+import com.tangem.domain.models.network.Network
 import com.tangem.lib.crypto.BlockchainUtils
 import com.tangem.utils.converter.Converter
 
 /**
- * Converter from [TokenMarketInfo.Network] to [BlockchainRowUM]
+ * Converter from [com.tangem.domain.markets.TokenMarketInfo.Network] to [com.tangem.core.ui.components.rows.model.BlockchainRowUM]
  *
  * @property alreadyAddedNetworks set of already added networks
  *
@@ -17,9 +17,9 @@ import com.tangem.utils.converter.Converter
  */
 internal class BlockchainRowUMConverter(
     private val alreadyAddedNetworks: Set<String>,
-) : Converter<Pair<Network, Boolean>, BlockchainRowUM> {
+) : Converter<Pair<TokenMarketInfo.Network, Boolean>, BlockchainRowUM> {
 
-    override fun convert(value: Pair<Network, Boolean>): BlockchainRowUM {
+    override fun convert(value: Pair<TokenMarketInfo.Network, Boolean>): BlockchainRowUM {
         val (network, isSelected) = value
 
         val blockchainInfo = BlockchainUtils.getNetworkInfo(networkId = network.networkId)
@@ -28,6 +28,7 @@ internal class BlockchainRowUMConverter(
         val isMainNetwork = network.contractAddress == null
 
         val isEnabled = !alreadyAddedNetworks.contains(network.networkId)
+        val networkRawId = Network.RawID(value = network.networkId)
 
         return BlockchainRowUM(
             id = network.networkId,
@@ -35,12 +36,12 @@ internal class BlockchainRowUMConverter(
             type = getNetworkType(network, blockchainInfo),
             iconResId = if (isEnabled) {
                 if (isSelected) {
-                    getActiveIconRes(blockchainInfo.blockchainId)
+                    networkRawId.iconResId
                 } else {
-                    getGreyedOutIconRes(blockchainInfo.blockchainId)
+                    networkRawId.greyedOutIconResId
                 }
             } else {
-                getGreyedOutIconRes(blockchainInfo.blockchainId)
+                networkRawId.greyedOutIconResId
             },
             isMainNetwork = isMainNetwork,
             isSelected = isSelected,
@@ -48,7 +49,10 @@ internal class BlockchainRowUMConverter(
         )
     }
 
-    private fun getNetworkType(network: Network, blockchainInfo: BlockchainUtils.BlockchainInfo): String {
+    private fun getNetworkType(
+        network: TokenMarketInfo.Network,
+        blockchainInfo: BlockchainUtils.BlockchainInfo,
+    ): String {
         val isMainNetwork = network.contractAddress == null
         return when {
             BlockchainUtils.isL2Network(networkId = network.networkId) -> MAIN_NETWORK_L2_TYPE_NAME

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/di/AddToPortfolioComponentModule.kt

@@ -0,0 +1,35 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.di
+
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioPreselectedDataComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.DefaultAddToPortfolioComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.DefaultAddToPortfolioPreselectedDataComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.DefaultAddToPortfolioManager
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.DefaultUserPortfolioComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.UserPortfolioComponent
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal interface AddToPortfolioComponentModule {
+
+    @Binds
+    fun bindAddToPortfolioComponent(factory: DefaultAddToPortfolioComponent.Factory): AddToPortfolioComponent.Factory
+
+    @Binds
+    fun bindAddToPortfolioManagerFactory(factory: DefaultAddToPortfolioManager.Factory): AddToPortfolioManager.Factory
+
+    @Binds
+    fun bindAddToPortfolioPreselectedDataComponent(
+        factory: DefaultAddToPortfolioPreselectedDataComponent.Factory,
+    ): AddToPortfolioPreselectedDataComponent.Factory
+
+    @Binds
+    fun bindUserPortfolioComponentFactory(
+        factory: DefaultUserPortfolioComponent.Factory,
+    ): UserPortfolioComponent.Factory
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/di/AddToPortfolioModelModule.kt

@@ -1,8 +1,13 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.di
+package com.tangem.features.commonfeatures.impl.addtoportfolio.di
 
 import com.tangem.core.decompose.di.ModelComponent
 import com.tangem.core.decompose.model.Model
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.*
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddToPortfolioModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddToPortfolioPreselectedDataModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddTokenModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.ChooseNetworkModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.TokenActionsModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.model.UserPortfolioModel
 import dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn
@@ -37,4 +42,9 @@ internal interface AddToPortfolioModelModule {
     @IntoMap
     @ClassKey(ChooseNetworkModel::class)
     fun chooseNetworkModel(model: ChooseNetworkModel): Model
+
+    @Binds
+    @IntoMap
+    @ClassKey(UserPortfolioModel::class)
+    fun userPortfolioModel(model: UserPortfolioModel): Model
 }

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/AddToPortfolioInitialSelectionResolver.kt

@@ -0,0 +1,114 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
+
+import arrow.core.getOrElse
+import com.tangem.domain.markets.GetTokenMarketCryptoCurrency
+import com.tangem.domain.markets.RawMarketToken
+import com.tangem.domain.markets.TokenMarketInfo
+import com.tangem.domain.models.account.AccountId
+import com.tangem.domain.models.wallet.UserWallet
+import com.tangem.domain.wallets.usecase.NetworkHasDerivationUseCase
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddAccount
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddData
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddWallet
+import javax.inject.Inject
+
+internal class AddToPortfolioInitialSelectionResolver @Inject constructor(
+    private val getTokenMarketCryptoCurrency: GetTokenMarketCryptoCurrency,
+    private val networkHasDerivationUseCase: NetworkHasDerivationUseCase,
+) {
+
+    suspend fun resolve(
+        availableToAddData: AvailableToAddData,
+        orderedNetworks: List<TokenMarketInfo.Network>,
+        selectedWallet: UserWallet?,
+        tokenParams: RawMarketToken,
+        accountToAdd: AvailableToAddAccount? = null,
+    ): InitialSelection? {
+        if (availableToAddData.availableToAddWallets.isEmpty()) return null
+        val fallbackNetwork = orderedNetworks.firstOrNull() ?: return null
+
+        val walletOrder = orderedWallets(availableToAddData, selectedWallet)
+
+        if (accountToAdd != null) {
+            val ownerWallet = walletOrder.firstOrNull { entry ->
+                entry.availableToAddAccounts.values.any { it === accountToAdd }
+            } ?: walletOrder.first()
+            val network = pickAddableNetwork(
+                userWallet = ownerWallet.userWallet,
+                account = accountToAdd,
+                orderedNetworks = orderedNetworks,
+                tokenParams = tokenParams,
+            )
+                ?: fallbackNetwork
+            return InitialSelection(userWallet = ownerWallet.userWallet, account = accountToAdd, network = network)
+        }
+
+        for (walletEntry in walletOrder) {
+            val account = pickAvailableAccount(walletEntry) ?: continue
+            val network = pickAddableNetwork(
+                userWallet = walletEntry.userWallet,
+                account = account,
+                orderedNetworks = orderedNetworks,
+                tokenParams = tokenParams,
+            ) ?: continue
+            return InitialSelection(walletEntry.userWallet, account, network)
+        }
+
+        val fallbackWallet = walletOrder.first()
+        val fallbackAccount = pickFallbackAccount(fallbackWallet) ?: return null
+        return InitialSelection(fallbackWallet.userWallet, fallbackAccount, fallbackNetwork)
+    }
+
+    private fun orderedWallets(data: AvailableToAddData, selectedWallet: UserWallet?): List<AvailableToAddWallet> {
+        val preferred = selectedWallet?.walletId?.let { data.availableToAddWallets[it] }
+        return buildList {
+            preferred?.let(::add)
+            data.availableToAddWallets.values.forEach { entry ->
+                if (entry !== preferred) add(entry)
+            }
+        }
+    }
+
+    private fun pickAvailableAccount(walletEntry: AvailableToAddWallet): AvailableToAddAccount? {
+        val mainId = AccountId.forMainCryptoPortfolio(walletEntry.userWallet.walletId)
+        return walletEntry.availableToAddAccounts[mainId]?.takeIf { it.isAvailableToAdd }
+            ?: walletEntry.availableToAddAccounts.values.firstOrNull { it.isAvailableToAdd }
+    }
+
+    private fun pickFallbackAccount(walletEntry: AvailableToAddWallet): AvailableToAddAccount? {
+        val mainId = AccountId.forMainCryptoPortfolio(walletEntry.userWallet.walletId)
+        return walletEntry.availableToAddAccounts[mainId]
+            ?: walletEntry.availableToAddAccounts.values.firstOrNull()
+    }
+
+    private suspend fun pickAddableNetwork(
+        userWallet: UserWallet,
+        account: AvailableToAddAccount,
+        orderedNetworks: List<TokenMarketInfo.Network>,
+        tokenParams: RawMarketToken,
+    ): TokenMarketInfo.Network? {
+        val availableOrdered = orderedNetworks.filter { candidate ->
+            account.availableToAddNetworks.any { it.networkId == candidate.networkId }
+        }
+        if (availableOrdered.isEmpty()) return null
+
+        val derivationIndex = account.account.account.derivationIndex
+        val withDerivation = availableOrdered.filter { network ->
+            val currency = getTokenMarketCryptoCurrency(
+                userWalletId = userWallet.walletId,
+                tokenMarketParams = tokenParams,
+                network = network,
+                accountIndex = derivationIndex,
+            ) ?: return@filter false
+            networkHasDerivationUseCase(userWallet, currency.network).getOrElse { false }
+        }
+
+        return withDerivation.firstOrNull() ?: availableOrdered.first()
+    }
+
+    data class InitialSelection(
+        val userWallet: UserWallet,
+        val account: AvailableToAddAccount,
+        val network: TokenMarketInfo.Network,
+    )
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/AddToPortfolioModel.kt

@@ -1,31 +1,39 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
 
 import com.arkivanov.decompose.router.stack.StackNavigation
 import com.arkivanov.decompose.router.stack.popToFirst
 import com.arkivanov.decompose.router.stack.pushNew
 import com.arkivanov.decompose.router.stack.replaceAll
+import com.tangem.blockchainsdk.compatibility.getTokenIdIfL2Network
+import com.tangem.common.ui.markets.action.CryptoCurrencyData
+import com.tangem.common.ui.markets.action.QuickActionsConverter.toQuickActions
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 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.DesignFeatureToggles
 import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.core.ui.message.ToastMessage
 import com.tangem.domain.account.status.usecase.GetCryptoCurrencyActionsUseCaseV2
 import com.tangem.domain.markets.GetTokenMarketCryptoCurrency
+import com.tangem.domain.markets.RawMarketToken
 import com.tangem.domain.markets.TokenMarketInfo
+import com.tangem.domain.models.account.filterCryptoPortfolio
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.currency.CryptoCurrencyStatus
 import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.features.account.PortfolioSelectorController
-import com.tangem.features.feed.components.market.details.portfolio.add.*
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.AddTokenComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ChooseNetworkComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.TokenActionsComponent
-import com.tangem.features.feed.components.market.details.portfolio.impl.analytics.PortfolioAnalyticsEvent
-import com.tangem.features.feed.components.market.details.portfolio.impl.loader.PortfolioData
-import com.tangem.features.feed.components.market.details.portfolio.impl.model.PortfolioTokenUMConverter.Companion.toQuickActions
-import com.tangem.features.feed.impl.R
+import com.tangem.domain.models.wallet.isMultiCurrency
+import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
+import com.tangem.features.commonfeatures.api.addtoportfolio.*
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorController
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.addtoportfolio.AddTokenComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ChooseNetworkComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.TokenActionsComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.analytics.PortfolioAnalyticsEvent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.UserPortfolioComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.state.UserPortfolioStateController
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.logging.TangemLogger
 import kotlinx.coroutines.Job
@@ -39,20 +47,25 @@ import javax.inject.Inject
 private const val TOKEN_ACTIONS_DELAY = 500L
 
 @ModelScoped
-@Suppress("LongParameterList")
+@Suppress("LongParameterList", "LargeClass")
 internal class AddToPortfolioModel @Inject constructor(
     paramsContainer: ParamsContainer,
     override val dispatchers: CoroutineDispatcherProvider,
+    val portfolioSelectorController: PortfolioSelectorController,
+    private val designFeatureToggles: DesignFeatureToggles,
     private val callbackDelegate: AddToPortfolioCallbackDelegate,
     private val getCryptoCurrencyActionsUseCase: GetCryptoCurrencyActionsUseCaseV2,
     private val getTokenMarketCryptoCurrency: GetTokenMarketCryptoCurrency,
     private val messageSender: UiMessageSender,
     private val analyticsEventHandler: AnalyticsEventHandler,
-    val portfolioSelectorController: PortfolioSelectorController,
+    private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
+    private val selectionResolver: AddToPortfolioInitialSelectionResolver,
+    userPortfolioStateControllerFactory: UserPortfolioStateController.Factory,
 ) : Model(),
     ChooseNetworkComponent.Callbacks by callbackDelegate,
     TokenActionsComponent.Callbacks by callbackDelegate,
-    AddTokenComponent.Callbacks by callbackDelegate {
+    AddTokenComponent.Callbacks by callbackDelegate,
+    UserPortfolioComponent.Callbacks by callbackDelegate {
 
     private val params = paramsContainer.require<AddToPortfolioComponent.Params>()
     val navigation = StackNavigation<AddToPortfolioRoutes>()
@@ -61,20 +74,40 @@ internal class AddToPortfolioModel @Inject constructor(
     /* Flows that hold state and provide it to child models */
     val selectedNetwork: MutableSharedFlow<SelectedNetwork> = replayMutableSharedFlow()
     val selectedPortfolio: MutableSharedFlow<SelectedPortfolio> = replayMutableSharedFlow()
-    val tokenActionsData: MutableSharedFlow<PortfolioData.CryptoCurrencyData> = replayMutableSharedFlow()
+    val tokenActionsData: MutableSharedFlow<CryptoCurrencyData> = replayMutableSharedFlow()
 
-    private val addToPortfolioManager = params.addToPortfolioManager
-    val portfolioFetcher = addToPortfolioManager.portfolioFetcher
-    val eventBuilder = PortfolioAnalyticsEvent.EventBuilder(
-        tokenSymbol = addToPortfolioManager.token.symbol,
-        source = addToPortfolioManager.analyticsParams?.source,
+    val addToPortfolioManager: AddToPortfolioManager = params.addToPortfolioManager
+
+    val paramsSnapshot: AddToPortfolioManager.Params by lazy {
+        addToPortfolioManager.paramsFlow.replayCache.first()
+    }
+    val eventBuilder: PortfolioAnalyticsEvent.EventBuilder by lazy {
+        val tokenMarketParams = paramsSnapshot.token
+        PortfolioAnalyticsEvent.EventBuilder(
+            tokenSymbol = tokenMarketParams.symbol,
+            source = addToPortfolioManager.analyticsParams.source,
+            category = addToPortfolioManager.analyticsParams.category,
+        )
+    }
+
+    val userPortfolioStateController = userPortfolioStateControllerFactory.create(
+        modelScope = modelScope,
+        onTokenSelected = { result -> addToPortfolioManager.onAddedTokenClick(result) },
     )
 
     val featureData: Flow<AddToPortfolioManager.State> = combineFeatureData()
 
+    private val globalSelectedWallet: UserWallet?
+        get() = getSelectedWalletSyncUseCase().getOrNull()
+            .takeIf { it?.isMultiCurrency == true }
+
     init {
         navigation.subscribe { currentStack = it.transformer.invoke(currentStack) }
-        startAddToPortfolioFlow()
+        if (designFeatureToggles.isRedesignEnabled) {
+            startRedesignAddToPortfolioFlow()
+        } else {
+            startLegacyAddToPortfolioFlow()
+        }
     }
 
     private fun <T> replayMutableSharedFlow() = MutableSharedFlow<T>(
@@ -83,20 +116,15 @@ internal class AddToPortfolioModel @Inject constructor(
     )
 
     @Suppress("LongMethod")
-    private fun startAddToPortfolioFlow() {
+    private fun startLegacyAddToPortfolioFlow() {
         channelFlow<Unit> {
-            fun finishFlow() {
-                params.callback.onDismiss()
-                channel.close()
-            }
-
-            fun finishSuccessFlow(addedToken: CryptoCurrencyStatus) {
-                params.callback.onSuccess(addedToken.currency)
+            fun finishSuccessFlow(result: AddToPortfolioManager.Result) {
+                addToPortfolioManager.onSuccessAdded(result)
                 channel.close()
             }
 
             val featureDataFlow: StateFlow<AvailableToAddData> = featureData
-                .filterIsInstance<AddToPortfolioManager.State.AvailableToAdd>()
+                .filterIsInstance<AddToPortfolioManager.State.Ready>()
                 .map { it.availableToAddData }
                 .distinctUntilChanged()
                 .stateIn(this)
@@ -105,12 +133,6 @@ internal class AddToPortfolioModel @Inject constructor(
             // use snapshot data, looks like we don’t need to remap at runtime
             val data = featureDataFlow.value
 
-            // you must control it via [AddToPortfolioManager.state]
-            if (!data.isAvailableToAdd) {
-                finishFlow()
-                return@channelFlow
-            }
-
             // init data flows, emits on user/code selection, updates state holder
             val firstSelectedPortfolio = setupPortfolioFlow(data)
                 .onEach { selectedPortfolio.emit(it) }
@@ -153,11 +175,12 @@ internal class AddToPortfolioModel @Inject constructor(
             )
 
             // suspend until all required data is selected
-            allRequireForAdd.first()
+            val firstPair = allRequireForAdd.first()
             // line of navigation to AddToken screen is finished; cancel the job, select a new root screen
             firstPartOfNavigation.cancel()
 
-            analyticsEventHandler.send(event = eventBuilder.popupToConfirm())
+            val selectedNetworkName = firstPair.first.cryptoCurrency.network.name
+            analyticsEventHandler.send(event = eventBuilder.popupToConfirm(selectedNetworkName))
             navigation.replaceAll(AddToPortfolioRoutes.AddToken)
 
             var middleNavigationJob: Job? = null
@@ -185,27 +208,156 @@ internal class AddToPortfolioModel @Inject constructor(
             val addedToken = callbackDelegate.onTokenAdded.receiveAsFlow().first()
             middleNavigationJob?.cancel()
             val selectedPortfolio = selectedPortfolio.first()
+            analyticsEventHandler.send(eventBuilder.tokenAdded(addedToken.currency.network.name))
+            if (!selectedPortfolio.account.account.account.isMainAccount) {
+                analyticsEventHandler.send(eventBuilder.addToNotMainAccount())
+            }
+            val result = AddToPortfolioManager.Result(
+                wallet = selectedPortfolio.userWallet,
+                account = selectedPortfolio.account.account,
+                addedCurrency = addedToken,
+            )
 
             messageSender.send(ToastMessage(message = resourceReference(R.string.markets_token_added)))
 
-            if (params.shouldSkipTokenActionsScreen) {
-                finishSuccessFlow(addedToken)
+            if (addToPortfolioManager.settings.shouldSkipTokenActionsScreen) {
+                finishSuccessFlow(result)
             } else {
                 setupTokenActionsFlow(selectedPortfolio, addedToken)
                     .onEach { cryptoCurrencyData ->
                         tokenActionsData.emit(cryptoCurrencyData)
                         navigation.replaceAll(AddToPortfolioRoutes.TokenActions)
                     }
-                    .onEmpty { finishFlow() }
+                    .onEmpty { finishSuccessFlow(result) }
                     .launchIn(this)
             }
 
             callbackDelegate.onLaterClick.receiveAsFlow().first()
-            finishFlow()
+            analyticsEventHandler.send(eventBuilder.getTokenLater())
+            finishSuccessFlow(result)
         }
             .catch { throwable ->
                 TangemLogger.e("Error", throwable)
-                params.callback.onDismiss()
+                addToPortfolioManager.onDismiss()
+            }
+            .launchIn(modelScope)
+    }
+
+    @Suppress("LongMethod")
+    private fun startRedesignAddToPortfolioFlow() {
+        channelFlow<Unit> {
+            fun finishSuccessFlow(result: AddToPortfolioManager.Result) {
+                addToPortfolioManager.onSuccessAdded(result)
+                channel.close()
+            }
+
+            fun finishDismissFlow() {
+                addToPortfolioManager.onDismiss()
+                channel.close()
+            }
+
+            val tokenMarketParams = paramsSnapshot.token
+
+            val launchMode = paramsSnapshot.launchMode
+            val initialData = featureData
+                .filterIsInstance<AddToPortfolioManager.State.Ready>()
+                .map { it.availableToAddData }
+                .first()
+
+            if (launchMode is AddToPortfolioManager.LaunchMode.ViaUserPortfolio &&
+                initialData.hasAnyAddedCurrency(tokenMarketParams.id)
+            ) {
+                // suspend, must prepare UM before navigate to UserPortfolio
+                userPortfolioStateController.updateAndWaitNotNullState(initialData, tokenMarketParams.id)
+                navigation.replaceAll(AddToPortfolioRoutes.UserPortfolio)
+                callbackDelegate.onContinueFromUserPortfolio.receiveAsFlow().first()
+            }
+            val selection = selectionResolver.resolve(
+                availableToAddData = initialData,
+                orderedNetworks = paramsSnapshot.networks,
+                selectedWallet = globalSelectedWallet,
+                tokenParams = tokenMarketParams,
+            ) ?: run {
+                finishDismissFlow()
+                return@channelFlow
+            }
+
+            val isAccountMode = portfolioSelectorController.isAccountModeSync()
+            portfolioSelectorController.selectAccount(selection.account.account.accountId)
+
+            val firstSelectedPortfolio = SelectedPortfolio(
+                isAccountMode = isAccountMode,
+                userWallet = selection.userWallet,
+                account = selection.account,
+                isAvailableMorePortfolio = !initialData.isSinglePortfolio,
+            )
+            val firstSelectedNetwork = selection.toSelectedNetwork() ?: run {
+                finishDismissFlow()
+                return@channelFlow
+            }
+
+            selectedPortfolio.emit(firstSelectedPortfolio)
+            selectedNetwork.emit(firstSelectedNetwork)
+
+            val selectedNetworkName = firstSelectedNetwork.cryptoCurrency.network.name
+            analyticsEventHandler.send(event = eventBuilder.popupToConfirm(selectedNetworkName))
+            navigation.replaceAll(AddToPortfolioRoutes.AddToken)
+
+            var middleNavigationJob: Job? = null
+            callbackDelegate.onChangeNetworkClick.receiveAsFlow()
+                .onEach {
+                    middleNavigationJob?.cancel()
+                    middleNavigationJob = changeNetworkNavigationFlow()
+                        .launchIn(this)
+                    val route = routeToNetworkSelector(selectedPortfolio.first())
+                    navigation.pushNew(route)
+                }
+                .launchIn(this)
+
+            callbackDelegate.onChangePortfolioClick.receiveAsFlow()
+                .onEach {
+                    middleNavigationJob?.cancel()
+                    middleNavigationJob = changePortfolioNavigationNewFlow(
+                        data = initialData,
+                        orderedNetworks = paramsSnapshot.networks,
+                        tokenParams = tokenMarketParams,
+                    ).launchIn(this)
+                    logAccountSelector(isAccountMode)
+                    navigation.pushNew(AddToPortfolioRoutes.PortfolioSelector)
+                }
+                .launchIn(this)
+
+            val addedToken = callbackDelegate.onTokenAdded.receiveAsFlow().first()
+            middleNavigationJob?.cancel()
+            val selectedPortfolioSnapshot = selectedPortfolio.first()
+            val result = AddToPortfolioManager.Result(
+                wallet = selectedPortfolioSnapshot.userWallet,
+                account = selectedPortfolioSnapshot.account.account,
+                addedCurrency = addedToken,
+            )
+
+            messageSender.send(ToastMessage(message = resourceReference(R.string.markets_token_added)))
+
+            if (addToPortfolioManager.settings.shouldSkipTokenActionsScreen) {
+                finishSuccessFlow(result)
+                return@channelFlow
+            }
+
+            setupTokenActionsFlow(selectedPortfolioSnapshot, addedToken)
+                .onEach { cryptoCurrencyData ->
+                    tokenActionsData.emit(cryptoCurrencyData)
+                    navigation.replaceAll(AddToPortfolioRoutes.TokenActions)
+                }
+                .onEmpty { finishSuccessFlow(result) }
+                .launchIn(this)
+
+            callbackDelegate.onLaterClick.receiveAsFlow().first()
+            analyticsEventHandler.send(eventBuilder.getTokenLater())
+            finishSuccessFlow(result)
+        }
+            .catch { throwable ->
+                TangemLogger.e("Error", throwable)
+                addToPortfolioManager.onDismiss()
             }
             .launchIn(modelScope)
     }
@@ -251,17 +403,49 @@ internal class AddToPortfolioModel @Inject constructor(
         ).collect { emit(it) }
     }
 
+    private fun changePortfolioNavigationNewFlow(
+        data: AvailableToAddData,
+        orderedNetworks: List<TokenMarketInfo.Network>,
+        tokenParams: RawMarketToken,
+    ): Flow<Unit> {
+        return setupPortfolioFlow(data)
+            // drop first selected portfolio or any selected before
+            .drop(1)
+            .map { newPortfolio ->
+                val currentNetwork = selectedNetwork.first().selectedNetwork
+                val availableToAddNetworks = newPortfolio.account.availableToAddNetworks
+                val isSelectedNetworkAvailableForNewPortfolio = availableToAddNetworks
+                    .any { it.networkId == currentNetwork.networkId }
+
+                if (!isSelectedNetworkAvailableForNewPortfolio) {
+                    val selection = selectionResolver.resolve(
+                        availableToAddData = data,
+                        orderedNetworks = orderedNetworks,
+                        selectedWallet = globalSelectedWallet,
+                        tokenParams = tokenParams,
+                        accountToAdd = newPortfolio.account,
+                    )
+                    val newNetwork = selection?.toSelectedNetwork()
+                    if (newNetwork != null) {
+                        this.selectedNetwork.tryEmit(newNetwork)
+                    }
+                }
+                selectedPortfolio.tryEmit(newPortfolio)
+                navigation.popToFirst()
+            }
+    }
+
     private fun setupTokenActionsFlow(
         selectedPortfolio: SelectedPortfolio,
         addedToken: CryptoCurrencyStatus,
-    ): Flow<PortfolioData.CryptoCurrencyData> {
+    ): Flow<CryptoCurrencyData> {
         val timeFlow = channelFlow {
             val timerJob = launch { delay(TOKEN_ACTIONS_DELAY) }
             getCryptoCurrencyActionsUseCase(
                 currency = addedToken.currency,
                 accountId = selectedPortfolio.account.account.account.accountId,
             ).onEach { state ->
-                val requestedQuickActions = toQuickActions(state.states)
+                val requestedQuickActions = toQuickActions(state.states, designFeatureToggles.isRedesignEnabled)
                 when {
                     requestedQuickActions.isNotEmpty() -> {
                         timerJob.cancel()
@@ -274,10 +458,12 @@ internal class AddToPortfolioModel @Inject constructor(
             }.collect()
         }
         return timeFlow.map { actionsState ->
-            PortfolioData.CryptoCurrencyData(
+            CryptoCurrencyData(
                 userWallet = selectedPortfolio.userWallet,
                 status = actionsState.cryptoCurrencyStatus,
                 actions = actionsState.states,
+                isAccountMode = selectedPortfolio.isAccountMode,
+                account = selectedPortfolio.account.account,
             )
         }
     }
@@ -327,7 +513,7 @@ internal class AddToPortfolioModel @Inject constructor(
         val accountIndex = account.account.account.derivationIndex
         return getTokenMarketCryptoCurrency(
             userWalletId = userWallet.walletId,
-            tokenMarketParams = addToPortfolioManager.token,
+            tokenMarketParams = addToPortfolioManager.token(),
             network = network,
             accountIndex = accountIndex,
         )
@@ -339,7 +525,7 @@ internal class AddToPortfolioModel @Inject constructor(
 
     private fun combineFeatureData() = addToPortfolioManager.state.onEach { state ->
         when (state) {
-            is AddToPortfolioManager.State.AvailableToAdd ->
+            is AddToPortfolioManager.State.Ready ->
                 portfolioSelectorController.isEnabled.value = isEnabled@{ userWallet, accountStatus ->
                     val availableWallet = state.availableToAddData.availableToAddWallets[userWallet.walletId]
                         ?: return@isEnabled false
@@ -348,24 +534,38 @@ internal class AddToPortfolioModel @Inject constructor(
                             ?.isAvailableToAdd == true
                     return@isEnabled isAvailableAccount
                 }
-            AddToPortfolioManager.State.Init,
-            AddToPortfolioManager.State.NothingToAdd,
+            AddToPortfolioManager.State.Loading,
             -> Unit
         }
     }
+
+    private suspend fun AddToPortfolioInitialSelectionResolver.InitialSelection.toSelectedNetwork(): SelectedNetwork? {
+        val crypto = createCryptoCurrency(
+            userWallet = userWallet,
+            network = network,
+            account = account,
+        ) ?: return null
+        return SelectedNetwork(
+            cryptoCurrency = crypto,
+            selectedNetwork = network,
+            isAvailableMoreNetwork = !account.isSingleNetwork,
+        )
+    }
 }
 
 @ModelScoped
 internal class AddToPortfolioCallbackDelegate @Inject constructor() :
     ChooseNetworkComponent.Callbacks,
     TokenActionsComponent.Callbacks,
-    AddTokenComponent.Callbacks {
+    AddTokenComponent.Callbacks,
+    UserPortfolioComponent.Callbacks {
 
     val onNetworkSelected = Channel<TokenMarketInfo.Network>()
     val onLaterClick = Channel<Unit>()
     val onChangeNetworkClick = Channel<Unit>()
     val onChangePortfolioClick = Channel<Unit>()
     val onTokenAdded = Channel<CryptoCurrencyStatus>()
+    val onContinueFromUserPortfolio = Channel<Unit>()
 
     override fun onNetworkSelected(network: TokenMarketInfo.Network) {
         onNetworkSelected.trySend(network)
@@ -386,4 +586,19 @@ internal class AddToPortfolioCallbackDelegate @Inject constructor() :
     override fun onTokenAdded(status: CryptoCurrencyStatus) {
         onTokenAdded.trySend(status)
     }
+
+    override fun onContinueFromUserPortfolio() {
+        onContinueFromUserPortfolio.trySend(Unit)
+    }
+}
+
+private fun AvailableToAddData.hasAnyAddedCurrency(rawCurrencyId: CryptoCurrency.RawID): Boolean {
+    return availableToAddWallets.values.any { wallet ->
+        wallet.accounts.filterCryptoPortfolio().any { accountStatus ->
+            accountStatus.tokenList.flattenCurrencies().any { status ->
+                val id = status.currency.id.rawCurrencyId ?: return@any false
+                getTokenIdIfL2Network(id.value) == rawCurrencyId.value
+            }
+        }
+    }
 }

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/AddToPortfolioPreselectedDataModel.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
 
 import com.arkivanov.decompose.router.stack.StackNavigation
 import com.arkivanov.decompose.router.stack.replaceAll
@@ -12,27 +12,27 @@ import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.core.ui.message.ToastMessage
 import com.tangem.domain.account.status.usecase.GetAccountCurrencyStatusUseCase
 import com.tangem.domain.markets.GetTokenMarketCryptoCurrency
+import com.tangem.domain.markets.RawMarketToken
 import com.tangem.domain.markets.TokenMarketInfo
-import com.tangem.domain.markets.TokenMarketParams
 import com.tangem.domain.models.account.AccountStatus
 import com.tangem.domain.models.account.filterCryptoPortfolio
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.currency.CryptoCurrencyStatus
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.account.PortfolioSelectorController
-import com.tangem.features.feed.components.market.details.portfolio.add.*
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.AddTokenComponent
-import com.tangem.features.feed.components.market.details.portfolio.impl.analytics.PortfolioAnalyticsEvent
-import com.tangem.features.feed.impl.R
-import com.tangem.features.feed.model.earn.analytics.EarnAnalyticsEvent
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioFetcher
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorController
+import com.tangem.features.commonfeatures.impl.addtoportfolio.AddTokenComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.*
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.addtoportfolio.analytics.EarnAnalyticsEvent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.analytics.PortfolioAnalyticsEvent
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.logging.TangemLogger
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.*
-import java.math.BigDecimal
 import javax.inject.Inject
+import kotlin.collections.mapNotNull
 
 @Suppress("LongParameterList")
 internal class AddToPortfolioPreselectedDataModel @Inject constructor(
@@ -65,6 +65,7 @@ internal class AddToPortfolioPreselectedDataModel @Inject constructor(
     val eventBuilder = PortfolioAnalyticsEvent.EventBuilder(
         tokenSymbol = params.tokenToAdd.symbol,
         source = AnalyticsParam.ScreensSources.Markets.value,
+        category = AnalyticsParam.ScreensSources.Markets.value,
     )
 
     init {
@@ -148,22 +149,15 @@ internal class AddToPortfolioPreselectedDataModel @Inject constructor(
     }
 
     private fun minimalTokenMarketParams() = with(params.tokenToAdd) {
-        TokenMarketParams(
+        RawMarketToken(
             id = id,
             name = name,
             symbol = symbol,
-            tokenQuotes = TokenMarketParams.Quotes(
-                currentPrice = BigDecimal.ZERO,
-                h24Percent = null,
-                weekPercent = null,
-                monthPercent = null,
-            ),
-            imageUrl = null,
         )
     }
 
     /**
-     * Creates [AvailableToAddData] for preselected network when token is already added in all networks.
+     * Creates [com.tangem.features.commonfeatures.api.AvailableToAddData] for preselected network when token is already added in all networks.
      * This allows user to select wallet/account and do smth after it with selected info.
      */
     private suspend fun createAvailableToAddDataForPreselectedNetwork(

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/AddToPortfolioRoutes.kt

@@ -1,8 +1,8 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
 
 import androidx.compose.runtime.Immutable
 import com.tangem.core.decompose.navigation.Route
-import com.tangem.features.feed.components.market.details.portfolio.add.SelectedPortfolio
+import com.tangem.features.commonfeatures.api.addtoportfolio.SelectedPortfolio
 import kotlinx.serialization.Serializable
 
 @Serializable
@@ -23,6 +23,9 @@ internal sealed interface AddToPortfolioRoutes : Route {
     @Serializable
     data object AddToken : AddToPortfolioRoutes
 
+    @Serializable
+    data object UserPortfolio : AddToPortfolioRoutes
+
     @Serializable
     data object TokenActions : AddToPortfolioRoutes
 }

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/AddTokenModel.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
 
 import com.tangem.common.ui.addtoken.AddTokenUM
 import com.tangem.core.analytics.api.AnalyticsEventHandler
@@ -12,11 +12,11 @@ import com.tangem.core.ui.message.ToastMessage
 import com.tangem.domain.account.status.usecase.GetAccountCurrencyStatusUseCase
 import com.tangem.domain.account.status.usecase.ManageCryptoCurrenciesUseCase
 import com.tangem.domain.wallets.usecase.ColdWalletAndHasMissedDerivationsUseCase
-import com.tangem.features.feed.components.market.details.portfolio.add.SelectedNetwork
-import com.tangem.features.feed.components.market.details.portfolio.add.SelectedPortfolio
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.AddTokenComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.model.AddTokenUiBuilder.Companion.toggleProgress
-import com.tangem.features.feed.impl.R
+import com.tangem.features.commonfeatures.api.addtoportfolio.SelectedNetwork
+import com.tangem.features.commonfeatures.api.addtoportfolio.SelectedPortfolio
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.addtoportfolio.AddTokenComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddTokenUiBuilder.Companion.toggleProgress
 import com.tangem.lib.crypto.BlockchainUtils
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.coroutines.JobHolder
@@ -40,7 +40,6 @@ internal class AddTokenModel @Inject constructor(
 ) : Model() {
 
     private val params = paramsContainer.require<AddTokenComponent.Params>()
-    private val analyticsEventBuilder = params.eventBuilder
     private val addTokenJob = JobHolder()
 
     val uiState: StateFlow<AddTokenUM?>
@@ -86,10 +85,11 @@ internal class AddTokenModel @Inject constructor(
             uiState.value = um.toggleProgress(true)
             val blockchainNames = listOf(selectedNetwork.selectedNetwork)
                 .mapNotNull { BlockchainUtils.getNetworkInfo(it.networkId)?.name }
+            val analyticsEventBuilder = params.eventBuilder
             analyticsEventHandler.send(analyticsEventBuilder.addToPortfolioContinue(blockchainNames))
             analyticsEventHandler.send(analyticsEventBuilder.addButtonClick())
 
-            manageCryptoCurrenciesUseCase(accountId = accountId, add = cryptoCurrency)
+            manageCryptoCurrenciesUseCase.invokeAndAwait(accountId = accountId, add = listOf(cryptoCurrency))
                 .onLeft { throwable ->
                     processError(error = throwable)
                     uiState.value = um.toggleProgress(false)
@@ -100,18 +100,11 @@ internal class AddTokenModel @Inject constructor(
                 userWalletId = accountId.userWalletId,
                 currencyId = cryptoCurrency.id,
                 network = cryptoCurrency.network,
-            ).firstOrNull()
+            )
+                .firstOrNull()
             if (status == null) {
                 processError(error = null)
             } else {
-                if (!account.isMainAccount) {
-                    analyticsEventHandler.send(analyticsEventBuilder.addToNotMainAccount())
-                }
-
-                analyticsEventHandler.send(
-                    event = analyticsEventBuilder.tokenAdded(status.status.currency.network.name),
-                )
-
                 params.callbacks.onTokenAdded(status.status)
             }
             uiState.value = um.toggleProgress(false)

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/AddTokenUiBuilder.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
 
 import com.tangem.common.ui.account.AccountIconUM
 import com.tangem.common.ui.account.CryptoPortfolioIconConverter
@@ -7,17 +7,17 @@ import com.tangem.common.ui.account.toUM
 import com.tangem.common.ui.addtoken.AddTokenUM
 import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.ParamsContainer
-import com.tangem.core.ui.components.currency.icon.converter.CryptoCurrencyToIconStateConverter
+import com.tangem.common.ui.components.currency.icon.converter.CryptoCurrencyToIconStateConverter
 import com.tangem.core.ui.components.token.state.TokenItemState
 import com.tangem.core.ui.extensions.TextReference
-import com.tangem.core.ui.extensions.iconResId
+import com.tangem.common.ui.extensions.iconResId
 import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.core.ui.extensions.stringReference
 import com.tangem.domain.models.account.AccountStatus.*
-import com.tangem.features.feed.components.market.details.portfolio.add.SelectedNetwork
-import com.tangem.features.feed.components.market.details.portfolio.add.SelectedPortfolio
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.AddTokenComponent
-import com.tangem.features.feed.impl.R
+import com.tangem.features.commonfeatures.impl.addtoportfolio.AddTokenComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.SelectedNetwork
+import com.tangem.features.commonfeatures.api.addtoportfolio.SelectedPortfolio
+import com.tangem.features.commonfeatures.impl.R
 import javax.inject.Inject
 
 @ModelScoped

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/CheckCurrencyUnsupportedDelegate.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
 
 import arrow.core.getOrElse
 import com.tangem.core.decompose.ui.UiMessageSender
@@ -10,7 +10,7 @@ import com.tangem.core.ui.message.SnackbarMessage
 import com.tangem.domain.managetokens.CheckCurrencyUnsupportedUseCase
 import com.tangem.domain.managetokens.model.CurrencyUnsupportedState
 import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.features.feed.impl.R
+import com.tangem.features.commonfeatures.impl.R
 import com.tangem.utils.logging.TangemLogger
 import javax.inject.Inject
 

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/ChooseNetworkModel.kt

@@ -1,13 +1,13 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
 
 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.ui.components.rows.model.BlockchainRowUM
 import com.tangem.domain.markets.TokenMarketInfo
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ChooseNetworkComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.state.ChooseNetworkUM
-import com.tangem.features.feed.components.market.details.portfolio.impl.model.BlockchainRowUMConverter
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ChooseNetworkComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.converter.BlockchainRowUMConverter
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state.ChooseNetworkUM
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.collections.immutable.toPersistentList
 import kotlinx.coroutines.flow.MutableStateFlow

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/TokenActionsModel.kt

@@ -1,25 +1,24 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
 
 import com.arkivanov.decompose.router.slot.SlotNavigation
 import com.arkivanov.decompose.router.slot.activate
+import com.tangem.common.ui.markets.action.TokenActionsBSContentUM
+import com.tangem.common.ui.markets.action.TokenActionsHandler
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.Model
 import com.tangem.core.decompose.model.ParamsContainer
 import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
 import com.tangem.domain.appcurrency.model.AppCurrency
+import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
 import com.tangem.domain.models.TokenReceiveConfig
 import com.tangem.domain.transaction.usecase.ReceiveAddressesFactory
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.TokenActionsComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.state.TokenActionsUM
-import com.tangem.features.feed.components.market.details.portfolio.impl.model.TokenActionsHandler
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.TokenActionsBSContentUM
+import com.tangem.features.commonfeatures.impl.addtoportfolio.TokenActionsComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state.TokenActionsUM
 import com.tangem.utils.Provider
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.mapLatest
-import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
@@ -28,6 +27,7 @@ import javax.inject.Inject
 internal class TokenActionsModel @Inject constructor(
     paramsContainer: ParamsContainer,
     getSelectedAppCurrencyUseCase: GetSelectedAppCurrencyUseCase,
+    getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
     tokenActionsIntentsFactory: TokenActionsHandler.Factory,
     override val dispatchers: CoroutineDispatcherProvider,
     private val uiBuilder: TokenActionsUiBuilder,
@@ -51,19 +51,34 @@ internal class TokenActionsModel @Inject constructor(
         )
 
     val bottomSheetNavigation: SlotNavigation<TokenReceiveConfig> = SlotNavigation()
-    val uiState: StateFlow<TokenActionsUM?> = params.data
-        .mapLatest { uiBuilder.build(it, tokenActionsHandler) }
-        .stateIn(
-            scope = modelScope,
-            started = SharingStarted.Eagerly,
-            initialValue = null,
-        )
 
-    private fun handledQuickAction(handledAction: TokenActionsHandler.HandledQuickAction) {
+    @OptIn(ExperimentalCoroutinesApi::class)
+    val uiState: StateFlow<TokenActionsUM?> =
+        combine(
+            params.data,
+            getBalanceHidingSettingsUseCase.isBalanceHidden(),
+        ) { cryptoCurrencyData, isBalanceHidden ->
+            cryptoCurrencyData to isBalanceHidden
+        }
+            .mapLatest { (cryptoCurrencyData, isBalanceHidden) ->
+                uiBuilder.build(
+                    cryptoCurrencyData = cryptoCurrencyData,
+                    tokenActionsHandler = tokenActionsHandler,
+                    appCurrency = currentAppCurrency.value,
+                    isBalanceHidden = isBalanceHidden,
+                )
+            }
+            .stateIn(
+                scope = modelScope,
+                started = SharingStarted.Eagerly,
+                initialValue = null,
+            )
+
+    private fun handledQuickAction(handledAction: TokenActionsHandler.HandledQuickAction) = modelScope.launch {
         val event = analyticsEventBuilder.getTokenActionClick(actionUM = handledAction.action)
         analyticsEventHandler.send(event)
         val isReceive = handledAction.action == TokenActionsBSContentUM.Action.Receive
-        if (!isReceive) return
+        if (!isReceive) return@launch
         modelScope.launch {
             val tokenConfig = receiveAddressesFactory.create(
                 status = handledAction.cryptoCurrencyData.status,

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/TokenActionsUiBuilder.kt

@@ -0,0 +1,216 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
+
+import androidx.compose.ui.text.SpanStyle
+import com.tangem.common.getTotalCryptoAmount
+import com.tangem.common.getTotalFiatAmount
+import com.tangem.common.ui.account.*
+import com.tangem.common.ui.components.currency.icon.converter.CryptoCurrencyToIconStateConverter
+import com.tangem.common.ui.markets.action.CryptoCurrencyData
+import com.tangem.common.ui.markets.action.QuickActionsConverter.quickActions
+import com.tangem.common.ui.markets.action.TokenActionsHandler
+import com.tangem.core.decompose.di.ModelScoped
+import com.tangem.core.decompose.model.ParamsContainer
+import com.tangem.core.ui.DesignFeatureToggles
+import com.tangem.core.ui.R
+import com.tangem.core.ui.components.token.state.TokenItemState
+import com.tangem.core.ui.ds.badge.TangemBadgeIconPosition
+import com.tangem.core.ui.ds.badge.TangemBadgeShape
+import com.tangem.core.ui.ds.badge.TangemBadgeSize
+import com.tangem.core.ui.ds.badge.TangemBadgeUM
+import com.tangem.core.ui.ds.image.TangemIconUM
+import com.tangem.core.ui.extensions.stringReference
+import com.tangem.core.ui.format.bigdecimal.*
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.domain.appcurrency.model.AppCurrency
+import com.tangem.domain.models.currency.CryptoCurrencyStatus
+import com.tangem.features.commonfeatures.impl.addtoportfolio.TokenActionsComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state.TokenActionsUM
+import java.math.BigDecimal
+import javax.inject.Inject
+
+@ModelScoped
+internal class TokenActionsUiBuilder @Inject constructor(
+    paramsContainer: ParamsContainer,
+    private val designFeatureToggles: DesignFeatureToggles,
+) {
+    private val params = paramsContainer.require<TokenActionsComponent.Params>()
+
+    fun build(
+        cryptoCurrencyData: CryptoCurrencyData,
+        tokenActionsHandler: TokenActionsHandler,
+        appCurrency: AppCurrency,
+        isBalanceHidden: Boolean,
+    ): TokenActionsUM {
+        return if (designFeatureToggles.isRedesignEnabled) {
+            buildV2(
+                cryptoCurrencyData = cryptoCurrencyData,
+                tokenActionsHandler = tokenActionsHandler,
+                appCurrency = appCurrency,
+                isBalanceHidden = isBalanceHidden,
+            )
+        } else {
+            buildV1(
+                cryptoCurrencyData = cryptoCurrencyData,
+                tokenActionsHandler = tokenActionsHandler,
+            )
+        }
+    }
+
+    private fun buildV1(
+        cryptoCurrencyData: CryptoCurrencyData,
+        tokenActionsHandler: TokenActionsHandler,
+    ): TokenActionsUM {
+        val status = cryptoCurrencyData.status
+        val tokenUM = TokenItemState.Content(
+            id = status.currency.id.value,
+            iconState = CryptoCurrencyToIconStateConverter().convert(status.currency),
+            titleState = TokenItemState.TitleState.Content(stringReference(status.currency.name)),
+            fiatAmountState = null,
+            subtitle2State = null,
+            subtitleState = TokenItemState.SubtitleState.TextContent(stringReference(status.currency.symbol)),
+            onItemClick = null,
+            onItemLongClick = null,
+        )
+        return TokenActionsUM(
+            token = tokenUM,
+            quickActions = quickActions(
+                cryptoData = cryptoCurrencyData,
+                tokenActionsHandler = tokenActionsHandler,
+                isRedesignEnabled = false,
+            ),
+            onLaterClick = {
+                params.callbacks.onLaterClick()
+            },
+        )
+    }
+
+    private fun buildV2(
+        cryptoCurrencyData: CryptoCurrencyData,
+        tokenActionsHandler: TokenActionsHandler,
+        appCurrency: AppCurrency,
+        isBalanceHidden: Boolean,
+    ): TokenActionsUM {
+        val status = cryptoCurrencyData.status
+        val tokenUM = TokenItemState.Content(
+            id = status.currency.id.value,
+            iconState = CryptoCurrencyToIconStateConverter().convert(status.currency),
+            titleState = TokenItemState.TitleState.Content(stringReference(status.currency.name)),
+            fiatAmountState = createFiatAmountState(status, appCurrency),
+            subtitle2State = createSubtitle2State(status),
+            subtitleState = TokenItemState.SubtitleState.TextContent(stringReference(status.currency.symbol)),
+            onItemClick = null,
+            onItemLongClick = null,
+        )
+        return TokenActionsUM(
+            token = tokenUM,
+            quickActions = quickActions(
+                cryptoData = cryptoCurrencyData,
+                tokenActionsHandler = tokenActionsHandler,
+                isRedesignEnabled = true,
+            ),
+            onLaterClick = {
+                params.callbacks.onLaterClick()
+            },
+            isBalancesHidden = isBalanceHidden,
+            portfolioBadge = createPortfolioBadge(cryptoCurrencyData),
+        )
+    }
+
+    private fun createPortfolioBadge(cryptoCurrencyData: CryptoCurrencyData): TangemBadgeUM {
+        val icon: AccountIconUM?
+        val name = if (cryptoCurrencyData.isAccountMode) {
+            icon = CryptoPortfolioIconConverter.convert(cryptoCurrencyData.account.account.icon)
+            cryptoCurrencyData
+                .account
+                .account
+                .accountName
+                .toUM()
+                .value
+        } else {
+            icon = null
+            stringReference(cryptoCurrencyData.userWallet.name)
+        }
+        return TangemBadgeUM(
+            text = name,
+            tangemIconUM = if (icon == null) {
+                TangemIconUM.Icon(
+                    iconRes = R.drawable.ic_key_card_20,
+                    tintReference = { TangemTheme.colors2.graphic.neutral.tertiary },
+                )
+            } else {
+                TangemIconUM.Icon(
+                    iconRes = icon.value.getResId(),
+                    tintReference = { icon.color.getUiColor() },
+                )
+            },
+            size = TangemBadgeSize.X6,
+            shape = TangemBadgeShape.Rounded,
+            iconPosition = if (cryptoCurrencyData.isAccountMode) {
+                TangemBadgeIconPosition.Start
+            } else {
+                TangemBadgeIconPosition.End
+            },
+        )
+    }
+
+    private fun createSubtitle2State(status: CryptoCurrencyStatus): TokenItemState.Subtitle2State? {
+        return when (status.value) {
+            is CryptoCurrencyStatus.Loaded,
+            is CryptoCurrencyStatus.Custom,
+            is CryptoCurrencyStatus.NoQuote,
+            is CryptoCurrencyStatus.NoAccount,
+            -> {
+                TokenItemState.Subtitle2State.TextContent(
+                    text = status.getTotalCryptoAmount().format {
+                        crypto(status.currency)
+                    },
+                )
+            }
+            is CryptoCurrencyStatus.Loading,
+            is CryptoCurrencyStatus.MissedDerivation,
+            is CryptoCurrencyStatus.Unreachable,
+            is CryptoCurrencyStatus.NoAmount,
+            -> TokenItemState.Subtitle2State.TextContent(
+                text = BigDecimal.ZERO.format {
+                    crypto(status.currency)
+                },
+            )
+        }
+    }
+
+    private fun createFiatAmountState(
+        status: CryptoCurrencyStatus,
+        appCurrency: AppCurrency,
+    ): TokenItemState.FiatAmountState? {
+        return when (status.value) {
+            is CryptoCurrencyStatus.Loaded,
+            is CryptoCurrencyStatus.Custom,
+            is CryptoCurrencyStatus.NoQuote,
+            is CryptoCurrencyStatus.NoAccount,
+            -> {
+                TokenItemState.FiatAmountState.AnnotatedContent(
+                    text = status.getTotalFiatAmount().formatStyled {
+                        fiat(
+                            fiatCurrencyCode = appCurrency.code,
+                            fiatCurrencySymbol = appCurrency.symbol,
+                            spanStyleReference = { SpanStyle(color = TangemTheme.colors2.text.neutral.secondary) },
+                        ).price()
+                    },
+                )
+            }
+            is CryptoCurrencyStatus.Unreachable,
+            is CryptoCurrencyStatus.NoAmount,
+            is CryptoCurrencyStatus.MissedDerivation,
+            is CryptoCurrencyStatus.Loading,
+            -> TokenItemState.FiatAmountState.AnnotatedContent(
+                text = BigDecimal.ZERO.formatStyled {
+                    fiat(
+                        fiatCurrencyCode = appCurrency.code,
+                        fiatCurrencySymbol = appCurrency.symbol,
+                        spanStyleReference = { SpanStyle(color = TangemTheme.colors2.text.neutral.secondary) },
+                    ).price()
+                },
+            )
+        }
+    }
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/ui/ChooseNetworkContent.kt

@@ -0,0 +1,268 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.ui
+
+import android.content.res.Configuration
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.key
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.layout.layoutId
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.util.fastForEach
+import com.tangem.core.ui.components.label.Label
+import com.tangem.core.ui.components.label.entity.LabelStyle
+import com.tangem.core.ui.components.label.entity.LabelUM
+import com.tangem.core.ui.components.rows.BlockchainRow
+import com.tangem.core.ui.components.rows.model.BlockchainRowUM
+import com.tangem.core.ui.ds.badge.TangemBadge
+import com.tangem.core.ui.ds.badge.TangemBadgeShape
+import com.tangem.core.ui.ds.badge.TangemBadgeSize
+import com.tangem.core.ui.ds.row.TangemRowContainer
+import com.tangem.core.ui.ds.row.TangemRowLayoutId
+import com.tangem.core.ui.extensions.resourceReference
+import com.tangem.core.ui.extensions.stringResourceSafe
+import com.tangem.core.ui.res.LocalRedesignEnabled
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.core.ui.res.TangemThemePreview
+import com.tangem.core.ui.res.TangemThemePreviewRedesign
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state.ChooseNetworkUM
+import kotlinx.collections.immutable.persistentListOf
+import java.util.UUID
+
+private const val DISABLED_ALPHA = 0.4f
+
+@Composable
+internal fun ChooseNetworkContent(state: ChooseNetworkUM, modifier: Modifier = Modifier) {
+    if (LocalRedesignEnabled.current) {
+        ChooseNetworkContentV2(
+            state = state,
+            modifier = modifier,
+        )
+    } else {
+        ChooseNetworkContentV1(
+            state = state,
+            modifier = modifier,
+        )
+    }
+}
+
+@Composable
+internal fun ChooseNetworkContentV1(state: ChooseNetworkUM, modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .clip(RoundedCornerShape(TangemTheme.dimens.radius14))
+            .background(TangemTheme.colors.background.action),
+    ) {
+        state.networks.fastForEach { model ->
+            key(model.id) {
+                BlockchainRow(
+                    model = model,
+                    itemPadding = PaddingValues(
+                        horizontal = TangemTheme.dimens.spacing12,
+                        vertical = TangemTheme.dimens.spacing14,
+                    ),
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .clickable(enabled = model.isEnabled, onClick = { state.onNetworkClick(model) }),
+                ) {
+                    if (!model.isEnabled) {
+                        Label(
+                            modifier = Modifier.alpha(DISABLED_ALPHA),
+                            state = LabelUM(
+                                text = resourceReference(R.string.common_added),
+                                style = LabelStyle.REGULAR,
+                            ),
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+internal fun ChooseNetworkContentV2(state: ChooseNetworkUM, modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .background(
+                color = TangemTheme.colors2.surface.level3,
+                shape = RoundedCornerShape(34.dp),
+            )
+            .padding(horizontal = TangemTheme.dimens2.x4, vertical = TangemTheme.dimens2.x2),
+    ) {
+        Text(
+            modifier = Modifier.padding(top = TangemTheme.dimens2.x4, bottom = TangemTheme.dimens2.x2),
+            text = stringResourceSafe(R.string.common_choose_network),
+            style = TangemTheme.typography2.subheadlineMedium14,
+            color = TangemTheme.colors2.text.neutral.tertiary,
+        )
+
+        state.networks.fastForEach { model ->
+            key(model.id) {
+                TangemRowContainer(
+                    modifier = Modifier.clickable(
+                        enabled = model.isEnabled,
+                        onClick = { state.onNetworkClick(model) },
+                    ),
+                    contentPadding = PaddingValues(vertical = TangemTheme.dimens2.x3),
+                    content = {
+                        NetworkIcon(
+                            modifier = Modifier
+                                .layoutId(layoutId = TangemRowLayoutId.HEAD)
+                                .padding(end = TangemTheme.dimens2.x3),
+                            model = model,
+                        )
+
+                        NetworkText(
+                            modifier = Modifier.layoutId(layoutId = TangemRowLayoutId.START_TOP),
+                            model = model,
+                        )
+                        if (!model.isEnabled) {
+                            TangemBadge(
+                                modifier = Modifier
+                                    .layoutId(layoutId = TangemRowLayoutId.TAIL)
+                                    .padding(start = TangemTheme.dimens2.x2),
+                                text = resourceReference(R.string.common_added),
+                                size = TangemBadgeSize.X6,
+                                shape = TangemBadgeShape.Rounded,
+                            )
+                        }
+                    },
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun NetworkIcon(model: BlockchainRowUM, modifier: Modifier = Modifier) {
+    if (model.isSelected && model.isEnabled) {
+        Image(
+            modifier = modifier
+                .size(TangemTheme.dimens2.x10),
+            painter = painterResource(id = model.iconResId),
+            contentDescription = null,
+        )
+    } else {
+        Icon(
+            modifier = modifier
+                .background(
+                    color = TangemTheme.colors2.button.backgroundSecondary,
+                    shape = CircleShape,
+                )
+                .size(TangemTheme.dimens2.x10),
+            painter = painterResource(id = model.iconResId),
+            tint = TangemTheme.colors2.graphic.neutral.tertiary,
+            contentDescription = null,
+        )
+    }
+}
+
+@Composable
+private fun NetworkText(model: BlockchainRowUM, modifier: Modifier = Modifier) {
+    Row(
+        modifier = modifier,
+        verticalAlignment = Alignment.Bottom,
+        horizontalArrangement = Arrangement.spacedBy(TangemTheme.dimens2.x1),
+    ) {
+        Text(
+            modifier = Modifier.weight(weight = 10f, fill = false),
+            text = model.name,
+            style = TangemTheme.typography2.bodyMedium16,
+            color = when {
+                model.isEnabled && model.isMainNetwork -> TangemTheme.colors2.text.neutral.primary
+                model.isEnabled -> TangemTheme.colors2.text.neutral.secondary
+                else -> TangemTheme.colors2.text.status.disabled
+            },
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+
+        Text(
+            modifier = Modifier.weight(weight = 5f, fill = false),
+            text = model.type,
+            style = TangemTheme.typography2.captionMedium12,
+            color = if (model.isEnabled) {
+                TangemTheme.colors2.text.neutral.tertiary
+            } else {
+                TangemTheme.colors2.text.status.disabled
+            },
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
+
+@Composable
+@Preview(showBackground = true, widthDp = 360)
+@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
+private fun Preview(@PreviewParameter(ChooseNetworkContentProvider::class) content: ChooseNetworkUM) {
+    TangemThemePreview {
+        ChooseNetworkContent(
+            state = content,
+        )
+    }
+}
+
+@Composable
+@Preview(showBackground = true, widthDp = 360)
+@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
+private fun PreviewV2(@PreviewParameter(ChooseNetworkContentProvider::class) content: ChooseNetworkUM) {
+    TangemThemePreviewRedesign {
+        CompositionLocalProvider(LocalRedesignEnabled provides true) {
+            ChooseNetworkContent(
+                state = content,
+            )
+        }
+    }
+}
+
+internal class ChooseNetworkContentProvider : PreviewParameterProvider<ChooseNetworkUM> {
+
+    private val blockchainRow = BlockchainRowUM(
+        id = UUID.randomUUID().toString(),
+        name = "Etherium 3",
+        type = "TEST",
+        iconResId = R.drawable.img_eth_22,
+        isMainNetwork = false,
+        isSelected = true,
+        isEnabled = true,
+    )
+
+    override val values: Sequence<ChooseNetworkUM>
+        get() = sequenceOf(
+            ChooseNetworkUM(
+                onNetworkClick = {},
+                networks = persistentListOf(
+                    blockchainRow.copy(
+                        type = "MAIN",
+                        isMainNetwork = true,
+                    ),
+                    blockchainRow.copy(
+                        iconResId = R.drawable.ic_bsc_16,
+                        isEnabled = false,
+                    ),
+                    blockchainRow.copy(iconResId = R.drawable.img_polygon_22),
+                    blockchainRow.copy(iconResId = R.drawable.img_optimism_22),
+                ),
+            ),
+        )
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/ui/DefaultAddToPortfolioManager.kt

@@ -0,0 +1,125 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.ui
+
+import com.tangem.domain.markets.RawMarketToken
+import com.tangem.domain.markets.TokenMarketInfo
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager.*
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioFetcher
+import com.tangem.features.commonfeatures.impl.addtoportfolio.converter.AvailableToAddDataConverter
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.*
+
+internal class DefaultAddToPortfolioManager @AssistedInject constructor(
+    private val availableToAddDataConverter: AvailableToAddDataConverter,
+    @Assisted override val settings: Settings,
+    @Assisted override val analyticsParams: AnalyticsParams,
+    @Assisted val scope: CoroutineScope,
+    dispatchers: CoroutineDispatcherProvider,
+    portfolioFetcherFactory: PortfolioFetcher.Factory,
+) : AddToPortfolioManager {
+
+    override val onDismiss: Channel<Unit> = Channel()
+    override val onSuccessAdded: Channel<Result> = Channel()
+    override val onAddedTokenClick: Channel<Result> = Channel()
+
+    override val portfolioFetcher: PortfolioFetcher = portfolioFetcherFactory.create(
+        mode = PortfolioFetcher.Mode.All(isOnlyMultiCurrency = true),
+        scope = scope,
+    )
+
+    private val internalParamsFlow = MutableStateFlow(ParamsInternal())
+
+    override val paramsFlow = internalParamsFlow
+        .transform { internalParams ->
+            val fullParams = Params(
+                networks = internalParams.networks ?: return@transform,
+                token = internalParams.token ?: return@transform,
+                launchMode = internalParams.launchMode,
+            )
+            emit(fullParams)
+        }
+        .distinctUntilChanged()
+        .shareIn(scope = scope, started = SharingStarted.Eagerly, replay = 1)
+
+    override val state: MutableStateFlow<State> = MutableStateFlow(State.Loading)
+
+    init {
+        buildFlow()
+            .onEach { newState -> state.update { newState } }
+            .flowOn(dispatchers.default)
+            .launchIn(scope)
+    }
+
+    override fun onDismiss() {
+        onDismiss.trySend(Unit)
+    }
+
+    override fun onSuccessAdded(result: Result) {
+        onSuccessAdded.trySend(result)
+    }
+
+    override fun onAddedTokenClick(result: Result) {
+        onAddedTokenClick.trySend(result)
+    }
+
+    override fun setTokenNetworks(networks: List<TokenMarketInfo.Network>) {
+        updateInternal(networks = networks)
+    }
+
+    override fun setTokenParams(token: RawMarketToken) {
+        updateInternal(token = token)
+    }
+
+    override fun updateLaunchMode(launchMode: LaunchMode) {
+        updateInternal(launchMode = launchMode)
+    }
+
+    private fun updateInternal(
+        networks: List<TokenMarketInfo.Network>? = null,
+        token: RawMarketToken? = null,
+        launchMode: LaunchMode? = null,
+    ) {
+        internalParamsFlow.update { prev ->
+            val newParams = ParamsInternal(
+                networks = networks ?: prev.networks,
+                token = token ?: prev.token,
+                launchMode = launchMode ?: prev.launchMode,
+            )
+            val shouldReload = newParams != prev
+            if (shouldReload) state.update { State.Loading }
+            return@update newParams
+        }
+    }
+
+    private fun buildFlow(): Flow<State> = combine(
+        flow = portfolioFetcher.data.map { it.balances }.distinctUntilChanged(),
+        flow2 = paramsFlow,
+    ) { balances, (availableNetworks, token) ->
+        val data = availableToAddDataConverter.convert(
+            balances = balances,
+            availableNetworks = availableNetworks.toSet(),
+            marketParams = token,
+        )
+        State.Ready(data)
+    }
+
+    @AssistedFactory
+    interface Factory : AddToPortfolioManager.Factory {
+        override fun create(
+            scope: CoroutineScope,
+            settings: Settings,
+            analyticsParams: AnalyticsParams,
+        ): DefaultAddToPortfolioManager
+    }
+
+    private data class ParamsInternal(
+        val launchMode: LaunchMode = LaunchMode.DirectAdd,
+        val networks: List<TokenMarketInfo.Network>? = null,
+        val token: RawMarketToken? = null,
+    )
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/ui/TokenActionsContent.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.ui
+package com.tangem.features.commonfeatures.impl.addtoportfolio.ui
 
 import android.content.res.Configuration
 import androidx.compose.foundation.ExperimentalFoundationApi
@@ -22,6 +22,8 @@ import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.util.fastForEach
+import com.tangem.common.ui.markets.action.QuickActionUM
+import com.tangem.common.ui.markets.action.QuickActions
 import com.tangem.core.ui.components.SecondaryButton
 import com.tangem.core.ui.components.SpacerH
 import com.tangem.core.ui.components.SpacerH16
@@ -37,10 +39,8 @@ import com.tangem.core.ui.res.LocalHapticManager
 import com.tangem.core.ui.res.TangemColorPalette
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.state.TokenActionsUM
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.PortfolioTokenUM
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.QuickActionUM
-import com.tangem.features.feed.impl.R
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state.TokenActionsUM
 import kotlinx.collections.immutable.persistentListOf
 import java.util.UUID
 
@@ -123,7 +123,7 @@ private fun ActionRow(
                 .size(36.dp)
                 .drawWithContent {
                     drawContent()
-                    if (state is QuickActionUM.Exchange && state.shouldShowBadge) {
+                    if (state is QuickActionUM.V1.Exchange && state.shouldShowBadge) {
                         drawBadge(containerColor = containerColor, offset = 4.dp)
                     }
                 },
@@ -188,11 +188,11 @@ private class TokenActionsContentPreviewProvider : PreviewParameterProvider<Toke
     override val values: Sequence<TokenActionsUM>
         get() = sequenceOf(
             TokenActionsUM(
-                quickActions = PortfolioTokenUM.QuickActions(
+                quickActions = QuickActions(
                     actions = persistentListOf(
-                        QuickActionUM.Buy,
-                        QuickActionUM.Exchange(shouldShowBadge = true),
-                        QuickActionUM.Receive,
+                        QuickActionUM.V1.Buy,
+                        QuickActionUM.V1.Exchange(shouldShowBadge = true),
+                        QuickActionUM.V1.Receive,
                     ),
                     onQuickActionClick = {},
                     onQuickActionLongClick = {},

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/ui/TokenActionsContentV2.kt

@@ -0,0 +1,292 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.ui
+
+import android.content.res.Configuration
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.background
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.key
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.layout.layoutId
+import androidx.compose.ui.res.vectorResource
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.util.fastForEach
+import com.tangem.common.ui.markets.action.QuickActionUM
+import com.tangem.common.ui.markets.action.QuickActions
+import com.tangem.core.ui.components.SpacerH
+import com.tangem.core.ui.components.currency.icon.CurrencyIcon
+import com.tangem.core.ui.components.currency.icon.CurrencyIconState
+import com.tangem.core.ui.components.token.state.TokenItemState
+import com.tangem.core.ui.ds.badge.*
+import com.tangem.core.ui.ds.button.SecondaryTangemButton
+import com.tangem.core.ui.ds.button.TangemButtonShape
+import com.tangem.core.ui.ds.button.TangemButtonSize
+import com.tangem.core.ui.ds.image.TangemIconUM
+import com.tangem.core.ui.ds.row.TangemRowContainer
+import com.tangem.core.ui.ds.row.TangemRowLayoutId
+import com.tangem.core.ui.extensions.*
+import com.tangem.core.ui.format.bigdecimal.fiat
+import com.tangem.core.ui.format.bigdecimal.formatStyled
+import com.tangem.core.ui.format.bigdecimal.price
+import com.tangem.core.ui.haptic.TangemHapticEffect
+import com.tangem.core.ui.res.*
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state.TokenActionsUM
+import kotlinx.collections.immutable.persistentListOf
+import java.math.BigDecimal
+import java.util.UUID
+
+private const val ACTION_BACKGROUND_ALPHA = .1f
+
+@Composable
+internal fun TokenActionsContentV2(state: TokenActionsUM, modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier.fillMaxWidth(),
+    ) {
+        TokenHeader(
+            addedToken = state.token,
+            portfolioBadge = state.portfolioBadge,
+            isBalanceHidden = state.isBalancesHidden,
+        )
+
+        SpacerH(TangemTheme.dimens2.x2)
+
+        Column(
+            verticalArrangement = Arrangement.spacedBy(TangemTheme.dimens2.x2),
+        ) {
+            state.quickActions.actions.fastForEach { actionUM ->
+                key(actionUM.title) {
+                    ActionRow(
+                        state = actionUM,
+                        onClick = { state.quickActions.onQuickActionClick(actionUM) },
+                        onLongClick = { state.quickActions.onQuickActionLongClick(actionUM) },
+                    )
+                }
+            }
+        }
+
+        SpacerH(TangemTheme.dimens2.x2)
+
+        SecondaryTangemButton(
+            modifier = Modifier.fillMaxWidth(),
+            onClick = state.onLaterClick,
+            text = resourceReference(R.string.common_later),
+            size = TangemButtonSize.X12,
+            shape = TangemButtonShape.Rounded,
+        )
+    }
+}
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+private fun ActionRow(
+    state: QuickActionUM,
+    onClick: () -> Unit,
+    onLongClick: (() -> Unit),
+    modifier: Modifier = Modifier,
+) {
+    val hapticManager = LocalHapticManager.current
+    val onLongClickInternal = {
+        hapticManager.perform(TangemHapticEffect.View.LongPress)
+        onLongClick()
+    }
+
+    TangemRowContainer(
+        modifier = modifier
+            .combinedClickable(
+                onLongClick = onLongClickInternal.takeIf { state.isLongClickAvailable },
+                onClick = {
+                    hapticManager.perform(TangemHapticEffect.View.SegmentTick)
+                    onClick()
+                },
+            )
+            .background(
+                color = TangemTheme.colors2.surface.level3,
+                shape = RoundedCornerShape(TangemTheme.dimens2.x5),
+            ),
+    ) {
+        Box(
+            modifier = Modifier
+                .layoutId(TangemRowLayoutId.HEAD)
+                .padding(end = TangemTheme.dimens2.x3)
+                .size(40.dp)
+                .background(
+                    color = TangemTheme.colors2.graphic.status.accent.copy(alpha = ACTION_BACKGROUND_ALPHA),
+                    shape = CircleShape,
+                ),
+            contentAlignment = Alignment.Center,
+        ) {
+            Icon(
+                modifier = Modifier.size(20.dp),
+                imageVector = ImageVector.vectorResource(id = state.icon),
+                contentDescription = null,
+                tint = TangemTheme.colors2.graphic.status.accent,
+            )
+        }
+        Text(
+            modifier = Modifier.layoutId(TangemRowLayoutId.START_TOP),
+            text = state.title.resolveReference(),
+            style = TangemTheme.typography2.bodyMedium16,
+            color = TangemTheme.colors2.text.neutral.primary,
+        )
+        Text(
+            modifier = Modifier.layoutId(TangemRowLayoutId.START_BOTTOM),
+            text = state.description.resolveReference(),
+            style = TangemTheme.typography2.captionMedium12,
+            color = TangemTheme.colors2.text.neutral.secondary,
+        )
+        Icon(
+            modifier = Modifier
+                .layoutId(TangemRowLayoutId.TAIL)
+                .padding(start = TangemTheme.dimens2.x2)
+                .size(24.dp),
+            imageVector = ImageVector.vectorResource(R.drawable.ic_chevron_small_right_24),
+            tint = TangemTheme.colors2.graphic.neutral.tertiary,
+            contentDescription = null,
+        )
+    }
+}
+
+@Composable
+private fun TokenHeader(
+    addedToken: TokenItemState,
+    isBalanceHidden: Boolean,
+    portfolioBadge: TangemBadgeUM?,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .padding(vertical = TangemTheme.dimens2.x8),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        CurrencyIcon(
+            state = addedToken.iconState,
+            iconSize = 70.dp,
+            networkBadgeSize = 24.dp,
+        )
+
+        SpacerH(TangemTheme.dimens2.x5)
+
+        when (val fiat = addedToken.fiatAmountState) {
+            is TokenItemState.FiatAmountState.AnnotatedContent -> {
+                Text(
+                    text = fiat.text.orMaskWithStars(isBalanceHidden).resolveAnnotatedReference(),
+                    style = TangemTheme.typography2.titleRegular44,
+                    color = TangemTheme.colors2.text.neutral.primary,
+                )
+                SpacerH(TangemTheme.dimens2.x2)
+            }
+            else -> Unit
+        }
+
+        when (val cryptoAmount = addedToken.subtitle2State) {
+            is TokenItemState.Subtitle2State.TextContent -> {
+                Text(
+                    text = cryptoAmount.text.orMaskWithStars(isBalanceHidden),
+                    style = TangemTheme.typography2.bodyMedium16,
+                    color = TangemTheme.colors2.text.neutral.secondary,
+                )
+                SpacerH(TangemTheme.dimens2.x2)
+            }
+            else -> Unit
+        }
+
+        SpacerH(TangemTheme.dimens2.x7)
+
+        if (portfolioBadge == null) return
+        TangemBadge(portfolioBadge)
+    }
+}
+
+@Preview(widthDp = 360, showBackground = true)
+@Preview(widthDp = 360, showBackground = true, uiMode = Configuration.UI_MODE_NIGHT_YES)
+@Composable
+private fun Preview(@PreviewParameter(TokenActionsContentPreviewProviderV2::class) state: TokenActionsUM) {
+    TangemThemePreviewRedesign {
+        CompositionLocalProvider(LocalRedesignEnabled provides true) {
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .background(TangemTheme.colors2.surface.level2)
+                    .padding(horizontal = 16.dp),
+            ) {
+                TokenActionsContentV2(
+                    state = state,
+                )
+            }
+        }
+    }
+}
+
+private class TokenActionsContentPreviewProviderV2 : PreviewParameterProvider<TokenActionsUM> {
+    private val tokenState
+        get() = TokenItemState.Content(
+            id = UUID.randomUUID().toString(),
+            iconState = CurrencyIconState.TokenIcon(
+                url = null,
+                topBadgeIconResId = R.drawable.img_eth_22,
+                fallbackTint = TangemColorPalette.Black,
+                fallbackBackground = TangemColorPalette.Meadow,
+                isGrayscale = false,
+                shouldShowCustomBadge = false,
+            ),
+            titleState = TokenItemState.TitleState.Content(
+                text = stringReference(value = "Tether"),
+            ),
+            fiatAmountState = TokenItemState.FiatAmountState.AnnotatedContent(
+                text = BigDecimal.ONE.formatStyled {
+                    fiat(
+                        fiatCurrencyCode = "USD",
+                        fiatCurrencySymbol = "$",
+                        spanStyleReference = { SpanStyle(color = TangemTheme.colors2.text.neutral.secondary) },
+                    ).price()
+                },
+            ),
+            subtitle2State = TokenItemState.Subtitle2State.TextContent(
+                "1.01 USDT",
+            ),
+            subtitleState = TokenItemState.SubtitleState.TextContent(value = stringReference("USDT")),
+            onItemClick = {},
+            onItemLongClick = {},
+        )
+
+    override val values: Sequence<TokenActionsUM>
+        get() = sequenceOf(
+            TokenActionsUM(
+                quickActions = QuickActions(
+                    actions = persistentListOf(
+                        QuickActionUM.V2.Buy,
+                        QuickActionUM.V2.Exchange(shouldShowBadge = true),
+                        QuickActionUM.V2.Receive,
+                    ),
+                    onQuickActionClick = {},
+                    onQuickActionLongClick = {},
+                ),
+                token = tokenState,
+                onLaterClick = {},
+                portfolioBadge = TangemBadgeUM(
+                    text = stringReference("Wallet 2"),
+                    tangemIconUM = TangemIconUM.Icon(
+                        iconRes = R.drawable.ic_key_card_20,
+                        tintReference = { TangemTheme.colors2.graphic.neutral.tertiary },
+                    ),
+                    size = TangemBadgeSize.X6,
+                    shape = TangemBadgeShape.Rounded,
+                    iconPosition = TangemBadgeIconPosition.End,
+                ),
+            ),
+        )
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/ui/state/ChooseNetworkUM.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.state
+package com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state
 
 import com.tangem.core.ui.components.rows.model.BlockchainRowUM
 import kotlinx.collections.immutable.ImmutableList

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/ui/state/TokenActionsUM.kt

@@ -0,0 +1,13 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state
+
+import com.tangem.common.ui.markets.action.QuickActions
+import com.tangem.core.ui.components.token.state.TokenItemState
+import com.tangem.core.ui.ds.badge.TangemBadgeUM
+
+internal data class TokenActionsUM(
+    val token: TokenItemState,
+    val quickActions: QuickActions,
+    val onLaterClick: () -> Unit,
+    val isBalancesHidden: Boolean = false,
+    val portfolioBadge: TangemBadgeUM? = null,
+)

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/userportfolio/DefaultUserPortfolioComponent.kt

@@ -0,0 +1,47 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.tangem.common.ui.markets.tokenselector.StickyFooter
+import com.tangem.common.ui.markets.tokenselector.TokenSelectorEmbeddedContent
+import com.tangem.core.decompose.context.AppComponentContext
+import com.tangem.core.decompose.model.getOrCreateModel
+import com.tangem.core.ui.extensions.resourceReference
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.model.UserPortfolioModel
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+
+internal class DefaultUserPortfolioComponent @AssistedInject constructor(
+    @Assisted context: AppComponentContext,
+    @Assisted params: UserPortfolioComponent.Params,
+) : UserPortfolioComponent, AppComponentContext by context {
+
+    private val model: UserPortfolioModel = getOrCreateModel(params)
+    private val onContinueClick: () -> Unit = params.callbacks::onContinueFromUserPortfolio
+
+    @Composable
+    override fun Content(modifier: Modifier) {
+        val stateFlow = model.state.collectAsStateWithLifecycle()
+        val state = stateFlow.value ?: return
+        TokenSelectorEmbeddedContent(
+            content = state.content,
+            modifier = modifier,
+            stickyFooter = StickyFooter(
+                buttonText = resourceReference(R.string.common_add),
+                isEnabled = state.isAddEnabled,
+                onClick = onContinueClick,
+            ),
+        )
+    }
+
+    @AssistedFactory
+    interface Factory : UserPortfolioComponent.Factory {
+        override fun create(
+            context: AppComponentContext,
+            params: UserPortfolioComponent.Params,
+        ): DefaultUserPortfolioComponent
+    }
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/userportfolio/UserPortfolioComponent.kt

@@ -0,0 +1,20 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio
+
+import com.tangem.core.decompose.factory.ComponentFactory
+import com.tangem.core.ui.decompose.ComposableContentComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.model.UserPortfolioUM
+import kotlinx.coroutines.flow.StateFlow
+
+internal interface UserPortfolioComponent : ComposableContentComponent {
+
+    data class Params(
+        val uiState: StateFlow<UserPortfolioUM?>,
+        val callbacks: Callbacks,
+    )
+
+    interface Callbacks {
+        fun onContinueFromUserPortfolio()
+    }
+
+    interface Factory : ComponentFactory<Params, UserPortfolioComponent>
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/userportfolio/model/UserPortfolioModel.kt

@@ -0,0 +1,20 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.model
+
+import com.tangem.core.decompose.di.ModelScoped
+import com.tangem.core.decompose.model.Model
+import com.tangem.core.decompose.model.ParamsContainer
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.UserPortfolioComponent
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import kotlinx.coroutines.flow.StateFlow
+import javax.inject.Inject
+
+@ModelScoped
+internal class UserPortfolioModel @Inject constructor(
+    override val dispatchers: CoroutineDispatcherProvider,
+    paramsContainer: ParamsContainer,
+) : Model() {
+
+    private val params = paramsContainer.require<UserPortfolioComponent.Params>()
+
+    val state: StateFlow<UserPortfolioUM?> = params.uiState
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/userportfolio/model/UserPortfolioUM.kt

@@ -0,0 +1,10 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.model
+
+import androidx.compose.runtime.Immutable
+import com.tangem.common.ui.markets.tokenselector.TokenSelectorContentUM
+
+@Immutable
+internal data class UserPortfolioUM(
+    val content: TokenSelectorContentUM,
+    val isAddEnabled: Boolean,
+)

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/userportfolio/state/UserPortfolioStateController.kt

@@ -0,0 +1,57 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.state
+
+import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
+import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
+import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddData
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.model.UserPortfolioUM
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.transformer.UserPortfolioSectionsTransformer
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.*
+
+internal class UserPortfolioStateController @AssistedInject constructor(
+    getSelectedAppCurrencyUseCase: GetSelectedAppCurrencyUseCase,
+    getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
+    @Assisted private val modelScope: CoroutineScope,
+    @Assisted private val onTokenSelected: (AddToPortfolioManager.Result) -> Unit,
+) {
+
+    private val requiredDataFlow = MutableSharedFlow<Pair<AvailableToAddData, CryptoCurrency.RawID>>(
+        replay = 1,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
+    )
+
+    val uiState: StateFlow<UserPortfolioUM?> = combine(
+        flow = requiredDataFlow.distinctUntilChanged(),
+        flow2 = getSelectedAppCurrencyUseCase.invokeOrDefault(),
+        flow3 = getBalanceHidingSettingsUseCase.isBalanceHidden(),
+    ) { (allAvailableData, rawCurrencyId), appCurrency, isBalanceHidden ->
+        UserPortfolioSectionsTransformer(
+            availableData = allAvailableData,
+            rawCurrencyId = rawCurrencyId,
+            appCurrency = appCurrency,
+            isBalanceHidden = isBalanceHidden,
+            onTokenSelected = onTokenSelected,
+        ).transform()
+    }
+        .distinctUntilChanged()
+        .stateIn(modelScope, SharingStarted.Lazily, null)
+
+    suspend fun updateAndWaitNotNullState(allAvailableData: AvailableToAddData, rawCurrencyId: CryptoCurrency.RawID) {
+        requiredDataFlow.tryEmit(allAvailableData to rawCurrencyId)
+        uiState.filterNotNull().firstOrNull()
+    }
+
+    @AssistedFactory
+    interface Factory {
+        fun create(
+            modelScope: CoroutineScope,
+            onTokenSelected: (AddToPortfolioManager.Result) -> Unit,
+        ): UserPortfolioStateController
+    }
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/userportfolio/transformer/UserPortfolioSectionsTransformer.kt

@@ -0,0 +1,187 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.transformer
+
+import com.tangem.blockchainsdk.compatibility.getTokenIdIfL2Network
+import com.tangem.common.ui.account.toUM
+import com.tangem.common.ui.components.currency.icon.converter.CryptoCurrencyToIconStateConverter
+import com.tangem.common.ui.markets.tokenselector.*
+import com.tangem.core.ui.components.marketprice.PriceChangeState
+import com.tangem.core.ui.components.marketprice.PriceChangeType
+import com.tangem.core.ui.ds.image.TangemIconUM
+import com.tangem.core.ui.extensions.stringReference
+import com.tangem.core.ui.format.bigdecimal.crypto
+import com.tangem.core.ui.format.bigdecimal.fiat
+import com.tangem.core.ui.format.bigdecimal.format
+import com.tangem.core.ui.format.bigdecimal.percent
+import com.tangem.domain.appcurrency.model.AppCurrency
+import com.tangem.domain.models.account.AccountStatus
+import com.tangem.domain.models.account.filterCryptoPortfolio
+import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.domain.models.currency.CryptoCurrencyStatus
+import com.tangem.domain.models.wallet.UserWallet
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddData
+import com.tangem.features.commonfeatures.impl.addtoportfolio.userportfolio.model.UserPortfolioUM
+import com.tangem.utils.StringsSigns
+import com.tangem.utils.extensions.orZero
+import kotlinx.collections.immutable.toImmutableList
+import java.math.BigDecimal
+
+internal class UserPortfolioSectionsTransformer(
+    private val availableData: AvailableToAddData,
+    private val rawCurrencyId: CryptoCurrency.RawID,
+    private val appCurrency: AppCurrency,
+    private val isBalanceHidden: Boolean,
+    private val onTokenSelected: (AddToPortfolioManager.Result) -> Unit,
+) {
+
+    private val iconConverter = CryptoCurrencyToIconStateConverter()
+
+    fun transform(): UserPortfolioUM {
+        return UserPortfolioUM(
+            content = TokenSelectorContentUM(
+                sections = buildSections(entries = generateEntries(availableData)).toImmutableList(),
+            ),
+            isAddEnabled = availableData.isAvailableToAdd,
+        )
+    }
+
+    private fun generateEntries(data: AvailableToAddData): List<PortfolioEntry> {
+        return data.availableToAddWallets.values.flatMap { wallet ->
+            wallet.accounts.filterCryptoPortfolio().flatMap { accountStatus ->
+                accountStatus.tokenList.flattenCurrencies()
+                    .filter { status -> status.currency.matchesRawId(rawCurrencyId) }
+                    .map { status ->
+                        PortfolioEntry(
+                            wallet = wallet.userWallet,
+                            account = accountStatus,
+                            currencyStatus = status,
+                        )
+                    }
+            }
+        }
+    }
+
+    private fun buildSections(entries: List<PortfolioEntry>): List<TokenSelectorSectionUM> {
+        val sections = mutableListOf<TokenSelectorSectionUM>()
+        val byWallet = entries.groupBy { it.wallet.walletId }
+        val shouldShowWalletHeaders = byWallet.size > 1
+
+        for ((_, walletEntries) in byWallet) {
+            if (shouldShowWalletHeaders) {
+                sections.add(
+                    TokenSelectorSectionUM.WalletHeader(walletName = walletEntries.first().wallet.name),
+                )
+            }
+
+            val byAccount = walletEntries.groupBy { it.account.account.accountId }
+            val shouldShowAccountHeaders = byAccount.size > 1
+
+            for ((_, accountEntries) in byAccount) {
+                val singles = accountEntries.map(::entryToSingle).toImmutableList()
+                val accountHeader = if (shouldShowAccountHeaders) {
+                    val first = accountEntries.first()
+                    AccountHeaderData(
+                        accountName = first
+                            .account
+                            .account
+                            .accountName
+                            .toUM()
+                            .value,
+                        cryptoPortfolioIcon = first.account.account.icon,
+                    )
+                } else {
+                    null
+                }
+                sections.add(
+                    TokenSelectorSectionUM.TokenGroup(accountHeader = accountHeader, items = singles),
+                )
+            }
+        }
+        return sections
+    }
+
+    private fun entryToSingle(entry: PortfolioEntry): UserAssetItemUM.Single {
+        val currency = entry.currencyStatus.currency
+        val value = entry.currencyStatus.value
+        return UserAssetItemUM.Single(
+            id = "${entry.wallet.walletId.stringValue}_${entry.account.account.accountId.value}_${currency.id.value}",
+            icon = TangemIconUM.Currency(currencyIconState = iconConverter.convert(entry.currencyStatus)),
+            tokenName = currency.name,
+            tokenSymbol = currency.symbol,
+            fiatRate = value.fiatRate?.format { fiat(appCurrency.code, appCurrency.symbol) },
+            priceChangeState = when (value) {
+                is CryptoCurrencyStatus.Loading,
+                is CryptoCurrencyStatus.Unreachable,
+                is CryptoCurrencyStatus.MissedDerivation,
+                is CryptoCurrencyStatus.NoAmount,
+                -> PriceChangeState.Unknown
+                else -> PriceChangeState.Content(
+                    type = PriceChangeType.fromBigDecimal(value.priceChange.orZero()),
+                    valueInPercent = value.priceChange.format { percent() },
+                )
+            },
+            balanceState = convertBalanceState(value, currency.symbol, currency.decimals),
+            isBalanceHidden = isBalanceHidden,
+            onClick = {
+                onTokenSelected(
+                    AddToPortfolioManager.Result(
+                        wallet = entry.wallet,
+                        account = entry.account,
+                        addedCurrency = entry.currencyStatus,
+                    ),
+                )
+            },
+            networkName = currency.network.name,
+        )
+    }
+
+    private data class PortfolioEntry(
+        val wallet: UserWallet,
+        val account: AccountStatus.CryptoPortfolio,
+        val currencyStatus: CryptoCurrencyStatus,
+    )
+
+    private fun convertBalanceState(
+        value: CryptoCurrencyStatus.Value,
+        symbol: String,
+        decimals: Int,
+    ): BalanceDisplayState {
+        return when {
+            value is CryptoCurrencyStatus.Loading && value.amount != null ->
+                BalanceDisplayState.Flickering(
+                    cryptoBalance = stringReference(formatCryptoAmount(value.amount, symbol, decimals)),
+                    fiatBalance = stringReference(
+                        value.fiatAmount?.format { fiat(appCurrency.code, appCurrency.symbol) }
+                            ?: StringsSigns.DASH_SIGN,
+                    ),
+                )
+            value is CryptoCurrencyStatus.Loading -> BalanceDisplayState.Loading
+            value is CryptoCurrencyStatus.Unreachable -> BalanceDisplayState.Unreachable
+            value.isError && value.amount != null ->
+                BalanceDisplayState.Stale(
+                    cryptoBalance = stringReference(formatCryptoAmount(value.amount, symbol, decimals)),
+                    fiatBalance = stringReference(
+                        value.fiatAmount?.format { fiat(appCurrency.code, appCurrency.symbol) }
+                            ?: StringsSigns.DASH_SIGN,
+                    ),
+                )
+            value.isError -> BalanceDisplayState.Unreachable
+            else -> BalanceDisplayState.Loaded(
+                cryptoBalance = stringReference(formatCryptoAmount(value.amount, symbol, decimals)),
+                fiatBalance = stringReference(
+                    value.fiatAmount?.format { fiat(appCurrency.code, appCurrency.symbol) }
+                        ?: StringsSigns.DASH_SIGN,
+                ),
+            )
+        }
+    }
+
+    private fun formatCryptoAmount(amount: BigDecimal?, symbol: String, decimals: Int): String {
+        return amount?.format { crypto(symbol, decimals) } ?: StringsSigns.DASH_SIGN
+    }
+
+    private fun CryptoCurrency.matchesRawId(target: CryptoCurrency.RawID): Boolean {
+        val rawId = id.rawCurrencyId ?: return false
+        return getTokenIdIfL2Network(rawId.value) == target.value
+    }
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/portfolioselector/DefaultPortfolioSelectorComponent.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.account.selector
+package com.tangem.features.commonfeatures.impl.portfolioselector
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
@@ -7,9 +7,11 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.tangem.core.decompose.context.AppComponentContext
 import com.tangem.core.decompose.model.getOrCreateModel
 import com.tangem.core.ui.extensions.TextReference
-import com.tangem.features.account.PortfolioSelectorComponent
-import com.tangem.features.account.selector.ui.PortfolioSelectorBS
-import com.tangem.features.account.selector.ui.PortfolioSelectorContent
+import com.tangem.core.ui.res.LocalRedesignEnabled
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorComponent
+import com.tangem.features.commonfeatures.impl.portfolioselector.ui.PortfolioSelectorBS
+import com.tangem.features.commonfeatures.impl.portfolioselector.ui.PortfolioSelectorContent
+import com.tangem.features.commonfeatures.impl.portfolioselector.ui.PortfolioSelectorContentV2
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
@@ -43,10 +45,17 @@ internal class DefaultPortfolioSelectorComponent @AssistedInject constructor(
     @Composable
     override fun Content(modifier: Modifier) {
         val state by model.state.collectAsStateWithLifecycle()
-        PortfolioSelectorContent(
-            state = state,
-            modifier = modifier,
-        )
+        if (LocalRedesignEnabled.current) {
+            PortfolioSelectorContentV2(
+                state = state,
+                modifier = modifier,
+            )
+        } else {
+            PortfolioSelectorContent(
+                state = state,
+                modifier = modifier,
+            )
+        }
     }
 
     @AssistedFactory

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/portfolioselector/DefaultPortfolioSelectorController.kt

@@ -1,12 +1,12 @@
-package com.tangem.features.account.selector
+package com.tangem.features.commonfeatures.impl.portfolioselector
 
 import com.tangem.domain.account.status.usecase.IsAccountsModeEnabledUseCase
 import com.tangem.domain.models.account.AccountId
 import com.tangem.domain.models.account.AccountStatus
 import com.tangem.domain.models.account.filterCryptoPortfolio
 import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.account.PortfolioSelectorController
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioFetcher
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorController
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/portfolioselector/PortfolioSelectorModel.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.account.selector
+package com.tangem.features.commonfeatures.impl.portfolioselector
 
 import com.tangem.common.ui.account.AccountPortfolioItemUMConverter
 import com.tangem.common.ui.userwallet.converter.UserWalletItemUMConverter
@@ -15,11 +15,11 @@ import com.tangem.domain.models.account.AccountStatus
 import com.tangem.domain.models.account.filterCryptoPortfolio
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.account.PortfolioSelectorComponent
-import com.tangem.features.account.impl.R
-import com.tangem.features.account.selector.entity.PortfolioSelectorItemUM
-import com.tangem.features.account.selector.entity.PortfolioSelectorUM
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioFetcher
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorComponent
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.portfolioselector.entity.PortfolioSelectorItemUM
+import com.tangem.features.commonfeatures.impl.portfolioselector.entity.PortfolioSelectorUM
 import com.tangem.features.wallet.utils.UserWalletImageFetcher
 import com.tangem.operations.attestation.ArtworkSize
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/portfolioselector/di/PortfolioSelectorModule.kt

@@ -0,0 +1,43 @@
+package com.tangem.features.commonfeatures.impl.portfolioselector.di
+
+import com.tangem.core.decompose.di.ModelComponent
+import com.tangem.core.decompose.model.Model
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioFetcher
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorComponent
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioSelectorController
+import com.tangem.features.commonfeatures.impl.portfolioselector.DefaultPortfolioSelectorComponent
+import com.tangem.features.commonfeatures.impl.portfolioselector.DefaultPortfolioSelectorController
+import com.tangem.features.commonfeatures.impl.portfolioselector.PortfolioSelectorModel
+import com.tangem.features.commonfeatures.impl.portfolioselector.fetcher.DefaultPortfolioFetcher
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import dagger.multibindings.ClassKey
+import dagger.multibindings.IntoMap
+
+@Module
+@InstallIn(ModelComponent::class)
+internal interface PortfolioSelectorModule {
+
+    @Binds
+    @IntoMap
+    @ClassKey(PortfolioSelectorModel::class)
+    fun portfolioSelectorModel(model: PortfolioSelectorModel): Model
+}
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal interface PortfolioSelectorSingletonModule {
+
+    @Binds
+    fun bindPortfolioFetcherFactory(impl: DefaultPortfolioFetcher.Factory): PortfolioFetcher.Factory
+
+    @Binds
+    fun bindPortfolioSelectorController(impl: DefaultPortfolioSelectorController): PortfolioSelectorController
+
+    @Binds
+    fun bindPortfolioSelectorComponentFactory(
+        impl: DefaultPortfolioSelectorComponent.Factory,
+    ): PortfolioSelectorComponent.Factory
+}

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/portfolioselector/entity/PortfolioSelectorUM.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.account.selector.entity
+package com.tangem.features.commonfeatures.impl.portfolioselector.entity
 
 import androidx.compose.runtime.Immutable
 import com.tangem.common.ui.userwallet.state.UserWalletItemUM

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/portfolioselector/fetcher/DefaultPortfolioFetcher.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.account.fetcher
+package com.tangem.features.commonfeatures.impl.portfolioselector.fetcher
 
 import com.tangem.domain.account.models.AccountStatusList
 import com.tangem.domain.account.status.producer.SingleAccountStatusListProducer
@@ -9,8 +9,8 @@ import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.domain.models.wallet.isMultiCurrency
 import com.tangem.domain.wallets.usecase.GetWalletsUseCase
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.account.PortfolioFetcher.*
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioFetcher
+import com.tangem.features.commonfeatures.api.portfolioselector.PortfolioFetcher.*
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/portfolioselector/ui/PortfolioSelectorBS.kt

@@ -1,9 +1,10 @@
-package com.tangem.features.account.selector.ui
+package com.tangem.features.commonfeatures.impl.portfolioselector.ui
 
 import android.content.res.Configuration
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.padding
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
@@ -12,10 +13,12 @@ import com.tangem.core.ui.components.bottomsheets.TangemBottomSheetConfig
 import com.tangem.core.ui.components.bottomsheets.TangemBottomSheetConfigContent
 import com.tangem.core.ui.components.bottomsheets.modal.TangemModalBottomSheet
 import com.tangem.core.ui.components.bottomsheets.modal.TangemModalBottomSheetTitle
+import com.tangem.core.ui.res.LocalRedesignEnabled
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.features.account.impl.R
-import com.tangem.features.account.selector.entity.PortfolioSelectorUM
+import com.tangem.core.ui.res.TangemThemePreviewRedesign
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.portfolioselector.entity.PortfolioSelectorUM
 
 @Composable
 internal fun PortfolioSelectorBS(
@@ -41,11 +44,19 @@ internal fun PortfolioSelectorBS(
             )
         },
         content = {
-            PortfolioSelectorContent(
-                state = state,
-                contentPadding = PaddingValues(bottom = 16.dp),
-                modifier = modifier.padding(horizontal = 16.dp),
-            )
+            if (LocalRedesignEnabled.current) {
+                PortfolioSelectorContentV2(
+                    state = state,
+                    contentPadding = PaddingValues(bottom = 16.dp),
+                    modifier = modifier.padding(horizontal = 16.dp),
+                )
+            } else {
+                PortfolioSelectorContent(
+                    state = state,
+                    contentPadding = PaddingValues(bottom = 16.dp),
+                    modifier = modifier.padding(horizontal = 16.dp),
+                )
+            }
         },
     )
 }
@@ -62,4 +73,20 @@ private fun Preview(@PreviewParameter(PortfolioSelectorPreviewStateProvider::cla
             onBack = {},
         )
     }
+}
+
+@Preview(showBackground = true, widthDp = 360)
+@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
+@Composable
+private fun PreviewV2(@PreviewParameter(PortfolioSelectorPreviewStateProvider::class) params: PortfolioSelectorUM) {
+    TangemThemePreviewRedesign {
+        CompositionLocalProvider(LocalRedesignEnabled provides true) {
+            PortfolioSelectorBS(
+                state = params,
+                onDismiss = {},
+                modifier = Modifier,
+                onBack = {},
+            )
+        }
+    }
 }

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/portfolioselector/ui/PortfolioSelectorContent.kt

@@ -1,4 +1,4 @@
-package com.tangem.features.account.selector.ui
+package com.tangem.features.commonfeatures.impl.portfolioselector.ui
 
 import android.content.res.Configuration
 import androidx.compose.foundation.BorderStroke
@@ -32,13 +32,9 @@ import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.core.ui.extensions.stringReference
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.features.account.impl.R
-import com.tangem.features.account.selector.entity.PortfolioSelectorItemUM
-import com.tangem.features.account.selector.entity.PortfolioSelectorUM
-import com.tangem.features.account.selector.ui.PortfolioSelectorPreviewData.firstList
-import com.tangem.features.account.selector.ui.PortfolioSelectorPreviewData.lockedWalletList
-import com.tangem.features.account.selector.ui.PortfolioSelectorPreviewData.secondList
-import com.tangem.features.account.selector.ui.PortfolioSelectorPreviewData.walletList
+import com.tangem.features.commonfeatures.impl.R
+import com.tangem.features.commonfeatures.impl.portfolioselector.entity.PortfolioSelectorItemUM
+import com.tangem.features.commonfeatures.impl.portfolioselector.entity.PortfolioSelectorUM
 import kotlinx.collections.immutable.toImmutableList
 import java.util.UUID
 
@@ -207,19 +203,19 @@ internal class PortfolioSelectorPreviewStateProvider : CollectionPreviewParamete
     listOf(
         PortfolioSelectorUM(
             title = resourceReference(R.string.common_choose_account),
-            items = firstList.toImmutableList(),
+            items = PortfolioSelectorPreviewData.firstList.toImmutableList(),
         ),
         PortfolioSelectorUM(
             title = resourceReference(R.string.common_choose_account),
-            items = secondList.toImmutableList(),
+            items = PortfolioSelectorPreviewData.secondList.toImmutableList(),
         ),
         PortfolioSelectorUM(
             title = resourceReference(R.string.common_choose_wallet),
-            items = walletList.toImmutableList(),
+            items = PortfolioSelectorPreviewData.walletList.toImmutableList(),
         ),
         PortfolioSelectorUM(
             title = resourceReference(R.string.common_choose_wallet),
-            items = lockedWalletList.toImmutableList(),
+            items = PortfolioSelectorPreviewData.lockedWalletList.toImmutableList(),
         ),
     ),
 )

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/portfolioselector/ui/PortfolioSelectorContentV2.kt

@@ -0,0 +1,228 @@
+package com.tangem.features.commonfeatures.impl.portfolioselector.ui
+
+import android.content.res.Configuration
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.layout.layoutId
+import androidx.compose.ui.res.vectorResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import com.tangem.common.ui.userwallet.CardImage
+import com.tangem.common.ui.userwallet.getBalanceValueAndFlickerState
+import com.tangem.common.ui.userwallet.getInformationValue
+import com.tangem.common.ui.userwallet.state.UserWalletItemUM
+import com.tangem.core.ui.R
+import com.tangem.core.ui.components.TextShimmer
+import com.tangem.core.ui.components.text.applyBladeBrush
+import com.tangem.core.ui.decorations.roundedShapeItemDecoration
+import com.tangem.core.ui.ds.row.TangemRowContainer
+import com.tangem.core.ui.ds.row.TangemRowLayoutId
+import com.tangem.core.ui.extensions.conditional
+import com.tangem.core.ui.extensions.resolveReference
+import com.tangem.core.ui.res.LocalRedesignEnabled
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.core.ui.res.TangemThemePreviewRedesign
+import com.tangem.features.commonfeatures.impl.portfolioselector.entity.PortfolioSelectorItemUM
+import com.tangem.features.commonfeatures.impl.portfolioselector.entity.PortfolioSelectorUM
+import com.tangem.utils.StringsSigns.DOT
+
+private const val DISABLED_WALLET_ALPHA = 0.5f
+
+@Composable
+internal fun PortfolioSelectorContentV2(
+    state: PortfolioSelectorUM,
+    modifier: Modifier = Modifier,
+    contentPadding: PaddingValues = PaddingValues(),
+) {
+    LazyColumn(
+        modifier = modifier,
+        contentPadding = contentPadding,
+    ) {
+        val items = state.items
+        itemsIndexed(
+            items = items,
+            key = { _, item -> item.id },
+        ) { index, item ->
+            when (item) {
+                is PortfolioSelectorItemUM.Portfolio ->
+                    PortfolioSelectorItem(
+                        state = item.item,
+                        modifier = Modifier
+                            .roundedShapeItemDecoration(
+                                currentIndex = index,
+                                lastIndex = state.items.lastIndex,
+                                backgroundColor = TangemTheme.colors2.surface.level3,
+                                radius = TangemTheme.dimens2.x5,
+                                addDefaultPadding = false,
+                            )
+                            .clickable(enabled = item.item.isEnabled, onClick = item.item.onClick)
+                            .conditional(!item.item.isEnabled) { alpha(DISABLED_WALLET_ALPHA) },
+                    )
+                is PortfolioSelectorItemUM.GroupTitle -> WalletNameRow(
+                    model = item,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .roundedShapeItemDecoration(
+                            currentIndex = index,
+                            lastIndex = state.items.lastIndex,
+                            backgroundColor = TangemTheme.colors2.surface.level3,
+                            radius = TangemTheme.dimens2.x5,
+                            addDefaultPadding = false,
+                        )
+                        .padding(horizontal = TangemTheme.dimens.spacing16),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun PortfolioSelectorItem(state: UserWalletItemUM, modifier: Modifier = Modifier) {
+    TangemRowContainer(modifier = modifier) {
+        Box(
+            modifier = Modifier
+                .layoutId(TangemRowLayoutId.HEAD)
+                .padding(end = TangemTheme.dimens2.x3),
+            contentAlignment = Alignment.Center,
+        ) {
+            CardImage(
+                modifier = Modifier.size(40.dp),
+                imageState = state.imageState,
+            )
+        }
+
+        Text(
+            modifier = Modifier.layoutId(layoutId = TangemRowLayoutId.START_TOP),
+            text = state.name.resolveReference(),
+            style = TangemTheme.typography2.bodyMedium16,
+            color = TangemTheme.colors2.text.neutral.primary,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+
+        InfoRow(
+            modifier = Modifier.layoutId(layoutId = TangemRowLayoutId.START_BOTTOM),
+            information = state.information,
+            balance = state.balance,
+        )
+    }
+}
+
+@Composable
+private fun InfoRow(
+    information: UserWalletItemUM.Information,
+    balance: UserWalletItemUM.Balance,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = modifier,
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        AnimatedContent(
+            targetState = information,
+            label = "Information content",
+        ) { information ->
+            val informationValue = getInformationValue(information)
+
+            if (informationValue == null) {
+                TextShimmer(
+                    style = TangemTheme.typography2.captionMedium12,
+                    text = "aaaaa",
+                )
+            } else {
+                Text(
+                    text = informationValue,
+                    style = TangemTheme.typography2.captionMedium12,
+                    color = TangemTheme.colors2.text.neutral.secondary,
+                    maxLines = 1,
+                )
+            }
+        }
+
+        Row {
+            Text(
+                text = " $DOT ",
+                style = TangemTheme.typography2.captionMedium12,
+                color = TangemTheme.colors2.text.neutral.secondary,
+                maxLines = 1,
+            )
+
+            val (balanceValue, isFlickering) = getBalanceValueAndFlickerState(balance)
+
+            if (balanceValue == null) {
+                TextShimmer(
+                    style = TangemTheme.typography2.captionMedium12,
+                    text = "aaaaa",
+                )
+            } else {
+                Text(
+                    text = balanceValue,
+                    style = TangemTheme.typography2.captionMedium12.applyBladeBrush(
+                        isEnabled = isFlickering,
+                        textColor = TangemTheme.colors2.text.neutral.secondary,
+                    ),
+                    maxLines = 1,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun WalletNameRow(model: PortfolioSelectorItemUM.GroupTitle, modifier: Modifier = Modifier) {
+    Row(
+        modifier = modifier.padding(top = TangemTheme.dimens2.x4, bottom = TangemTheme.dimens2.x2),
+        horizontalArrangement = Arrangement.spacedBy(TangemTheme.dimens2.x1),
+    ) {
+        Text(
+            modifier = Modifier.align(Alignment.CenterVertically),
+            text = model.name.resolveReference(),
+            style = TangemTheme.typography2.subheadlineMedium14,
+            color = TangemTheme.colors2.text.neutral.secondary,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+
+        Icon(
+            imageVector = ImageVector.vectorResource(R.drawable.ic_key_card_20),
+            modifier = Modifier
+                .align(Alignment.Bottom)
+                .size(TangemTheme.dimens2.x5),
+            tint = TangemTheme.colors2.graphic.neutral.tertiary,
+            contentDescription = null,
+        )
+    }
+}
+
+@Preview(showBackground = true, widthDp = 360)
+@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
+@Composable
+private fun Preview(@PreviewParameter(PortfolioSelectorPreviewStateProvider::class) params: PortfolioSelectorUM) {
+    TangemThemePreviewRedesign {
+        CompositionLocalProvider(LocalRedesignEnabled provides true) {
+            Box(
+                modifier = Modifier.fillMaxWidth(),
+                contentAlignment = Alignment.Center,
+            ) {
+                PortfolioSelectorContentV2(
+                    state = params,
+                    modifier = Modifier.background(color = TangemTheme.colors.background.tertiary),
+                )
+            }
+        }
+    }
+}

features/common-features/impl/src/test/java/com/tangem/features/commonfeatures/impl/addtoportfolio/model/AddToPortfolioInitialSelectionResolverTest.kt

@@ -0,0 +1,591 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.model
+
+import arrow.core.left
+import arrow.core.right
+import com.google.common.truth.Truth
+import com.tangem.domain.markets.GetTokenMarketCryptoCurrency
+import com.tangem.domain.markets.RawMarketToken
+import com.tangem.domain.markets.TokenMarketInfo
+import com.tangem.domain.models.account.AccountId
+import com.tangem.domain.models.account.DerivationIndex
+import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.domain.models.network.Network
+import com.tangem.domain.models.wallet.UserWallet
+import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.wallets.usecase.NetworkHasDerivationUseCase
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddAccount
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddData
+import com.tangem.features.commonfeatures.api.addtoportfolio.AvailableToAddWallet
+import io.mockk.clearMocks
+import io.mockk.coEvery
+import io.mockk.every
+import io.mockk.mockk
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class AddToPortfolioInitialSelectionResolverTest {
+
+    private val getTokenMarketCryptoCurrency: GetTokenMarketCryptoCurrency = mockk()
+    private val networkHasDerivationUseCase: NetworkHasDerivationUseCase = mockk()
+
+    private val tokenParams: RawMarketToken = mockk()
+
+    private lateinit var resolver: AddToPortfolioInitialSelectionResolver
+
+    @BeforeEach
+    fun setup() {
+        clearMocks(getTokenMarketCryptoCurrency, networkHasDerivationUseCase)
+        coEvery { getTokenMarketCryptoCurrency(any(), any(), any(), any()) } returns null
+        every { networkHasDerivationUseCase(any(), any()) } returns false.right()
+
+        resolver = AddToPortfolioInitialSelectionResolver(
+            getTokenMarketCryptoCurrency = getTokenMarketCryptoCurrency,
+            networkHasDerivationUseCase = networkHasDerivationUseCase,
+        )
+    }
+
+    @Test
+    fun `GIVEN no wallets in data WHEN resolve THEN return null`() = runTest {
+        val data = availableData(wallets = emptyMap())
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(ETHEREUM),
+            selectedWallet = null,
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result).isNull()
+    }
+
+    @Test
+    fun `GIVEN accountToAdd is provided WHEN resolve THEN use it instead of looking up account`() = runTest {
+        val walletId = UserWalletId(WALLET_ID_A)
+        val userWallet = userWallet(walletId)
+        val mainAccount = availableAccount()
+        val explicitAccount = availableAccount(availableToAddNetworks = setOf(BITCOIN))
+
+        val data = availableData(
+            wallets = mapOf(
+                walletId to walletEntry(
+                    userWallet = userWallet,
+                    accounts = mapOf(AccountId.forMainCryptoPortfolio(walletId) to mainAccount),
+                ),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(BITCOIN),
+            selectedWallet = userWallet,
+            tokenParams = tokenParams,
+            accountToAdd = explicitAccount,
+        )
+
+        Truth.assertThat(result).isNotNull()
+        Truth.assertThat(result!!.account).isSameInstanceAs(explicitAccount)
+        Truth.assertThat(result.network).isEqualTo(BITCOIN)
+    }
+
+    @Test
+    fun `GIVEN accountToAdd is not available to add WHEN resolve THEN still use it`() = runTest {
+        val walletId = UserWalletId(WALLET_ID_A)
+        val userWallet = userWallet(walletId)
+        val explicitAccount = availableAccount(isAvailableToAdd = false, availableToAddNetworks = setOf(ETHEREUM))
+
+        val data = availableData(
+            wallets = mapOf(
+                walletId to walletEntry(
+                    userWallet = userWallet,
+                    accounts = mapOf(AccountId.forMainCryptoPortfolio(walletId) to availableAccount()),
+                ),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(ETHEREUM),
+            selectedWallet = userWallet,
+            tokenParams = tokenParams,
+            accountToAdd = explicitAccount,
+        )
+
+        Truth.assertThat(result).isNotNull()
+        Truth.assertThat(result!!.account).isSameInstanceAs(explicitAccount)
+    }
+
+    @Test
+    fun `GIVEN accountToAdd with no matching ordered networks WHEN resolve THEN fall back to first ordered network`() =
+        runTest {
+            val walletId = UserWalletId(WALLET_ID_A)
+            val userWallet = userWallet(walletId)
+            val explicitAccount = availableAccount(availableToAddNetworks = setOf(ETHEREUM))
+
+            val data = availableData(
+                wallets = mapOf(
+                    walletId to walletEntry(
+                        userWallet = userWallet,
+                        accounts = mapOf(AccountId.forMainCryptoPortfolio(walletId) to availableAccount()),
+                    ),
+                ),
+            )
+
+            val result = resolver.resolve(
+                availableToAddData = data,
+                orderedNetworks = listOf(BITCOIN),
+                selectedWallet = userWallet,
+                tokenParams = tokenParams,
+                accountToAdd = explicitAccount,
+            )
+
+            Truth.assertThat(result).isNotNull()
+            Truth.assertThat(result!!.account).isSameInstanceAs(explicitAccount)
+            Truth.assertThat(result.network).isEqualTo(BITCOIN)
+        }
+
+    @Test
+    fun `GIVEN selected wallet is in data WHEN resolve THEN pick its entry`() = runTest {
+        val selectedWalletId = UserWalletId(WALLET_ID_A)
+        val otherWalletId = UserWalletId(WALLET_ID_B)
+        val selectedUserWallet = userWallet(selectedWalletId)
+        val otherUserWallet = userWallet(otherWalletId)
+
+        val selectedAccount = availableAccount()
+        val otherAccount = availableAccount()
+
+        val data = availableData(
+            wallets = linkedMapOf(
+                otherWalletId to walletEntry(otherUserWallet, mapOf(AccountId.forMainCryptoPortfolio(otherWalletId) to otherAccount)),
+                selectedWalletId to walletEntry(selectedUserWallet, mapOf(AccountId.forMainCryptoPortfolio(selectedWalletId) to selectedAccount)),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(ETHEREUM),
+            selectedWallet = selectedUserWallet,
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result).isNotNull()
+        Truth.assertThat(result!!.userWallet).isSameInstanceAs(selectedUserWallet)
+        Truth.assertThat(result.account).isSameInstanceAs(selectedAccount)
+    }
+
+    @Test
+    fun `GIVEN selected wallet is not in data WHEN resolve THEN fall back to first wallet`() = runTest {
+        val firstWalletId = UserWalletId(WALLET_ID_A)
+        val firstUserWallet = userWallet(firstWalletId)
+        val firstAccount = availableAccount()
+
+        val data = availableData(
+            wallets = mapOf(
+                firstWalletId to walletEntry(firstUserWallet, mapOf(AccountId.forMainCryptoPortfolio(firstWalletId) to firstAccount)),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(ETHEREUM),
+            selectedWallet = userWallet(UserWalletId(WALLET_ID_B)),
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result).isNotNull()
+        Truth.assertThat(result!!.userWallet).isSameInstanceAs(firstUserWallet)
+    }
+
+    @Test
+    fun `GIVEN selected wallet is null WHEN resolve THEN fall back to first wallet`() = runTest {
+        val firstWalletId = UserWalletId(WALLET_ID_A)
+        val firstUserWallet = userWallet(firstWalletId)
+        val firstAccount = availableAccount()
+
+        val data = availableData(
+            wallets = mapOf(
+                firstWalletId to walletEntry(firstUserWallet, mapOf(AccountId.forMainCryptoPortfolio(firstWalletId) to firstAccount)),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(ETHEREUM),
+            selectedWallet = null,
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result).isNotNull()
+        Truth.assertThat(result!!.userWallet).isSameInstanceAs(firstUserWallet)
+    }
+
+    @Test
+    fun `GIVEN main account is available WHEN resolve THEN pick main account`() = runTest {
+        val walletId = UserWalletId(WALLET_ID_A)
+        val userWallet = userWallet(walletId)
+        val mainAccount = availableAccount()
+        val otherAccount = availableAccount()
+
+        val data = availableData(
+            wallets = mapOf(
+                walletId to walletEntry(
+                    userWallet = userWallet,
+                    accounts = linkedMapOf(
+                        AccountId.forPaymentAccount(walletId) to otherAccount,
+                        AccountId.forMainCryptoPortfolio(walletId) to mainAccount,
+                    ),
+                ),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(ETHEREUM),
+            selectedWallet = userWallet,
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result).isNotNull()
+        Truth.assertThat(result!!.account).isSameInstanceAs(mainAccount)
+    }
+
+    @Test
+    fun `GIVEN main account is not available WHEN resolve THEN pick first available account`() = runTest {
+        val walletId = UserWalletId(WALLET_ID_A)
+        val userWallet = userWallet(walletId)
+        val mainAccount = availableAccount(isAvailableToAdd = false, availableToAddNetworks = emptySet())
+        val secondAvailable = availableAccount()
+
+        val data = availableData(
+            wallets = mapOf(
+                walletId to walletEntry(
+                    userWallet = userWallet,
+                    accounts = linkedMapOf(
+                        AccountId.forMainCryptoPortfolio(walletId) to mainAccount,
+                        AccountId.forPaymentAccount(walletId) to secondAvailable,
+                    ),
+                ),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(ETHEREUM),
+            selectedWallet = userWallet,
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result).isNotNull()
+        Truth.assertThat(result!!.account).isSameInstanceAs(secondAvailable)
+    }
+
+    @Test
+    fun `GIVEN no available accounts WHEN resolve THEN fall back to that account with first ordered network`() =
+        runTest {
+            val walletId = UserWalletId(WALLET_ID_A)
+            val userWallet = userWallet(walletId)
+            val unavailable = availableAccount(isAvailableToAdd = false, availableToAddNetworks = emptySet())
+
+            val data = availableData(
+                wallets = mapOf(
+                    walletId to walletEntry(
+                        userWallet = userWallet,
+                        accounts = mapOf(AccountId.forMainCryptoPortfolio(walletId) to unavailable),
+                    ),
+                ),
+            )
+
+            val result = resolver.resolve(
+                availableToAddData = data,
+                orderedNetworks = listOf(ETHEREUM),
+                selectedWallet = userWallet,
+                tokenParams = tokenParams,
+            )
+
+            Truth.assertThat(result).isNotNull()
+            Truth.assertThat(result!!.userWallet).isSameInstanceAs(userWallet)
+            Truth.assertThat(result.account).isSameInstanceAs(unavailable)
+            Truth.assertThat(result.network).isEqualTo(ETHEREUM)
+        }
+
+    @Test
+    fun `GIVEN ordered networks do not match account networks WHEN resolve THEN fall back to first ordered network`() =
+        runTest {
+            val walletId = UserWalletId(WALLET_ID_A)
+            val userWallet = userWallet(walletId)
+            val account = availableAccount(availableToAddNetworks = setOf(ETHEREUM))
+
+            val data = availableData(
+                wallets = mapOf(
+                    walletId to walletEntry(
+                        userWallet = userWallet,
+                        accounts = mapOf(AccountId.forMainCryptoPortfolio(walletId) to account),
+                    ),
+                ),
+            )
+
+            val result = resolver.resolve(
+                availableToAddData = data,
+                orderedNetworks = listOf(BITCOIN),
+                selectedWallet = userWallet,
+                tokenParams = tokenParams,
+            )
+
+            Truth.assertThat(result).isNotNull()
+            Truth.assertThat(result!!.userWallet).isSameInstanceAs(userWallet)
+            Truth.assertThat(result.account).isSameInstanceAs(account)
+            Truth.assertThat(result.network).isEqualTo(BITCOIN)
+        }
+
+    @Test
+    fun `GIVEN preferred wallet has no available accounts but another wallet does WHEN resolve THEN pick the other`() =
+        runTest {
+            val preferredWalletId = UserWalletId(WALLET_ID_A)
+            val otherWalletId = UserWalletId(WALLET_ID_B)
+            val preferredUserWallet = userWallet(preferredWalletId)
+            val otherUserWallet = userWallet(otherWalletId)
+
+            val preferredUnavailable = availableAccount(isAvailableToAdd = false, availableToAddNetworks = emptySet())
+            val otherAvailable = availableAccount(availableToAddNetworks = setOf(ETHEREUM))
+
+            val data = availableData(
+                wallets = linkedMapOf(
+                    preferredWalletId to walletEntry(
+                        userWallet = preferredUserWallet,
+                        accounts = mapOf(AccountId.forMainCryptoPortfolio(preferredWalletId) to preferredUnavailable),
+                    ),
+                    otherWalletId to walletEntry(
+                        userWallet = otherUserWallet,
+                        accounts = mapOf(AccountId.forMainCryptoPortfolio(otherWalletId) to otherAvailable),
+                    ),
+                ),
+            )
+
+            val result = resolver.resolve(
+                availableToAddData = data,
+                orderedNetworks = listOf(ETHEREUM),
+                selectedWallet = preferredUserWallet,
+                tokenParams = tokenParams,
+            )
+
+            Truth.assertThat(result).isNotNull()
+            Truth.assertThat(result!!.userWallet).isSameInstanceAs(otherUserWallet)
+            Truth.assertThat(result.account).isSameInstanceAs(otherAvailable)
+            Truth.assertThat(result.network).isEqualTo(ETHEREUM)
+        }
+
+    @Test
+    fun `GIVEN no wallet has viable combo WHEN resolve THEN fall back to preferred wallet with first ordered network`() =
+        runTest {
+            val preferredWalletId = UserWalletId(WALLET_ID_A)
+            val otherWalletId = UserWalletId(WALLET_ID_B)
+            val preferredUserWallet = userWallet(preferredWalletId)
+            val otherUserWallet = userWallet(otherWalletId)
+
+            val preferredUnavailable = availableAccount(isAvailableToAdd = false, availableToAddNetworks = emptySet())
+            val otherUnavailable = availableAccount(isAvailableToAdd = false, availableToAddNetworks = emptySet())
+
+            val data = availableData(
+                wallets = linkedMapOf(
+                    otherWalletId to walletEntry(
+                        userWallet = otherUserWallet,
+                        accounts = mapOf(AccountId.forMainCryptoPortfolio(otherWalletId) to otherUnavailable),
+                    ),
+                    preferredWalletId to walletEntry(
+                        userWallet = preferredUserWallet,
+                        accounts = mapOf(AccountId.forMainCryptoPortfolio(preferredWalletId) to preferredUnavailable),
+                    ),
+                ),
+            )
+
+            val result = resolver.resolve(
+                availableToAddData = data,
+                orderedNetworks = listOf(ETHEREUM),
+                selectedWallet = preferredUserWallet,
+                tokenParams = tokenParams,
+            )
+
+            Truth.assertThat(result).isNotNull()
+            Truth.assertThat(result!!.userWallet).isSameInstanceAs(preferredUserWallet)
+            Truth.assertThat(result.account).isSameInstanceAs(preferredUnavailable)
+            Truth.assertThat(result.network).isEqualTo(ETHEREUM)
+        }
+
+    @Test
+    fun `GIVEN first ordered network has derivation WHEN resolve THEN pick first`() = runTest {
+        val walletId = UserWalletId(WALLET_ID_A)
+        val userWallet = userWallet(walletId)
+        val account = availableAccount(availableToAddNetworks = setOf(ETHEREUM, BITCOIN))
+
+        val ethereumCurrency = cryptoCurrency()
+        val bitcoinCurrency = cryptoCurrency()
+        coEvery { getTokenMarketCryptoCurrency(any(), any(), ETHEREUM, any()) } returns ethereumCurrency
+        coEvery { getTokenMarketCryptoCurrency(any(), any(), BITCOIN, any()) } returns bitcoinCurrency
+        every { networkHasDerivationUseCase(any(), ethereumCurrency.network) } returns true.right()
+        every { networkHasDerivationUseCase(any(), bitcoinCurrency.network) } returns true.right()
+
+        val data = availableData(
+            wallets = mapOf(
+                walletId to walletEntry(
+                    userWallet = userWallet,
+                    accounts = mapOf(AccountId.forMainCryptoPortfolio(walletId) to account),
+                ),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(ETHEREUM, BITCOIN),
+            selectedWallet = userWallet,
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result?.network).isEqualTo(ETHEREUM)
+    }
+
+    @Test
+    fun `GIVEN only second ordered network has derivation WHEN resolve THEN pick second`() = runTest {
+        val walletId = UserWalletId(WALLET_ID_A)
+        val userWallet = userWallet(walletId)
+        val account = availableAccount(availableToAddNetworks = setOf(ETHEREUM, BITCOIN))
+
+        val ethereumCurrency = cryptoCurrency()
+        val bitcoinCurrency = cryptoCurrency()
+        coEvery { getTokenMarketCryptoCurrency(any(), any(), ETHEREUM, any()) } returns ethereumCurrency
+        coEvery { getTokenMarketCryptoCurrency(any(), any(), BITCOIN, any()) } returns bitcoinCurrency
+        every { networkHasDerivationUseCase(any(), ethereumCurrency.network) } returns false.right()
+        every { networkHasDerivationUseCase(any(), bitcoinCurrency.network) } returns true.right()
+
+        val data = availableData(
+            wallets = mapOf(
+                walletId to walletEntry(
+                    userWallet = userWallet,
+                    accounts = mapOf(AccountId.forMainCryptoPortfolio(walletId) to account),
+                ),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(ETHEREUM, BITCOIN),
+            selectedWallet = userWallet,
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result?.network).isEqualTo(BITCOIN)
+    }
+
+    @Test
+    fun `GIVEN no network has derivation WHEN resolve THEN fall back to first ordered available network`() = runTest {
+        val walletId = UserWalletId(WALLET_ID_A)
+        val userWallet = userWallet(walletId)
+        val account = availableAccount(availableToAddNetworks = setOf(ETHEREUM, BITCOIN))
+
+        val ethereumCurrency = cryptoCurrency()
+        val bitcoinCurrency = cryptoCurrency()
+        coEvery { getTokenMarketCryptoCurrency(any(), any(), ETHEREUM, any()) } returns ethereumCurrency
+        coEvery { getTokenMarketCryptoCurrency(any(), any(), BITCOIN, any()) } returns bitcoinCurrency
+        every { networkHasDerivationUseCase(any(), any()) } returns Throwable().left()
+
+        val data = availableData(
+            wallets = mapOf(
+                walletId to walletEntry(
+                    userWallet = userWallet,
+                    accounts = mapOf(AccountId.forMainCryptoPortfolio(walletId) to account),
+                ),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(BITCOIN, ETHEREUM),
+            selectedWallet = userWallet,
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result?.network).isEqualTo(BITCOIN)
+    }
+
+    @Test
+    fun `GIVEN get token market crypto currency returns null WHEN resolve THEN fall back to first ordered available network`() = runTest {
+        val walletId = UserWalletId(WALLET_ID_A)
+        val userWallet = userWallet(walletId)
+        val account = availableAccount(availableToAddNetworks = setOf(ETHEREUM, BITCOIN))
+
+        coEvery { getTokenMarketCryptoCurrency(any(), any(), any(), any()) } returns null
+
+        val data = availableData(
+            wallets = mapOf(
+                walletId to walletEntry(
+                    userWallet = userWallet,
+                    accounts = mapOf(AccountId.forMainCryptoPortfolio(walletId) to account),
+                ),
+            ),
+        )
+
+        val result = resolver.resolve(
+            availableToAddData = data,
+            orderedNetworks = listOf(BITCOIN, ETHEREUM),
+            selectedWallet = userWallet,
+            tokenParams = tokenParams,
+        )
+
+        Truth.assertThat(result?.network).isEqualTo(BITCOIN)
+    }
+
+    // region Helpers
+
+    private fun availableData(wallets: Map<UserWalletId, AvailableToAddWallet>): AvailableToAddData = mockk {
+        every { isAvailableToAdd } returns true
+        every { availableToAddWallets } returns wallets
+    }
+
+    private fun walletEntry(
+        userWallet: UserWallet,
+        accounts: Map<AccountId, AvailableToAddAccount>,
+    ): AvailableToAddWallet = mockk {
+        every { this@mockk.userWallet } returns userWallet
+        every { availableToAddAccounts } returns accounts
+    }
+
+    private fun availableAccount(
+        isAvailableToAdd: Boolean = true,
+        availableToAddNetworks: Set<TokenMarketInfo.Network> = setOf(ETHEREUM),
+        derivationIndex: DerivationIndex = DerivationIndex.Main,
+    ): AvailableToAddAccount = mockk {
+        every { this@mockk.isAvailableToAdd } returns isAvailableToAdd
+        every { this@mockk.availableToAddNetworks } returns availableToAddNetworks
+        every { account.account.derivationIndex } returns derivationIndex
+    }
+
+    private fun userWallet(walletId: UserWalletId): UserWallet = mockk {
+        every { this@mockk.walletId } returns walletId
+    }
+
+    private fun cryptoCurrency(): CryptoCurrency = mockk {
+        every { network } returns mockk<Network>()
+    }
+
+    // endregion
+
+    private companion object {
+        const val WALLET_ID_A = "011f"
+        const val WALLET_ID_B = "022e"
+
+        val ETHEREUM = TokenMarketInfo.Network(
+            networkId = "ethereum",
+            isExchangeable = true,
+            contractAddress = null,
+            decimalCount = 18,
+        )
+
+        val BITCOIN = TokenMarketInfo.Network(
+            networkId = "bitcoin",
+            isExchangeable = true,
+            contractAddress = null,
+            decimalCount = 8,
+        )
+    }
+}

features/create-wallet-start/impl/build.gradle.kts

@@ -11,10 +11,15 @@ android {
     namespace = "com.tangem.features.createwalletstart.impl"
 }
 
+tasks.withType<Test>().configureEach {
+    useJUnitPlatform()
+}
+
 dependencies {
     /** Api */
     implementation(projects.features.createWalletStart.api)
     implementation(projects.features.hotWallet.api)
+    implementation(projects.features.onboardingV2.api)
 
     /** Project - Domain */
     implementation(projects.domain.card)
@@ -71,4 +76,11 @@ dependencies {
     /** DI */
     implementation(deps.hilt.android)
     kapt(deps.hilt.kapt)
+
+    /** Test */
+    testImplementation(deps.test.junit5)
+    testRuntimeOnly(deps.test.junit5.engine)
+    testImplementation(deps.test.mockk)
+    testImplementation(deps.test.truth)
+    testImplementation(deps.test.coroutine)
 }

features/create-wallet-start/impl/src/main/kotlin/com/tangem/features/createwalletstart/CreateWalletStartModel.kt

@@ -33,14 +33,15 @@ import com.tangem.domain.wallets.builder.ColdUserWalletBuilder
 import com.tangem.domain.wallets.usecase.GenerateBuyTangemCardLinkUseCase
 import com.tangem.domain.wallets.usecase.SaveWalletUseCase
 import com.tangem.features.createwalletstart.entity.CreateWalletStartUM
+import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.utils.logging.TangemLogger
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
-import com.tangem.utils.logging.TangemLogger
 import javax.inject.Inject
 
 private const val HIDE_PROGRESS_DELAY = 400L
@@ -65,6 +66,7 @@ internal class CreateWalletStartModel @Inject constructor(
     private val trackingContextProxy: TrackingContextProxy,
     private val analyticsEventHandler: AnalyticsEventHandler,
     private val appsFlyerStore: AppsFlyerStore,
+    private val onboardingV2FeatureToggles: OnboardingV2FeatureToggles,
 ) : Model() {
 
     private val params = paramsContainer.require<CreateWalletStartComponent.Params>()
@@ -234,7 +236,18 @@ internal class CreateWalletStartModel @Inject constructor(
             },
             ifRight = {
                 setLoading(false)
-                appRouter.replaceAll(AppRoute.Wallet)
+                val route = if (onboardingV2FeatureToggles.isAddressSyncEnabled) {
+                    AppRoute.Onboarding(
+                        scanResponse = scanResponse,
+                        mode = AppRoute.Onboarding.Mode.AddressSync(
+                            userWalletId = userWallet.walletId,
+                            isWalletStarted = false,
+                        ),
+                    )
+                } else {
+                    AppRoute.Wallet
+                }
+                appRouter.replaceAll(route)
             },
         )
     }

features/create-wallet-start/impl/src/test/kotlin/com/tangem/features/createwalletstart/CreateWalletStartModelTest.kt

@@ -0,0 +1,664 @@
+package com.tangem.features.createwalletstart
+
+import arrow.core.left
+import arrow.core.right
+import com.tangem.common.core.TangemError
+import com.tangem.common.core.TangemSdkError
+import com.tangem.common.routing.AppRoute
+import com.tangem.common.routing.AppRouter
+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.analytics.models.event.OnboardingAnalyticsEvent
+import com.tangem.core.analytics.utils.TrackingContextProxy
+import com.tangem.core.decompose.model.MutableParamsContainer
+import com.tangem.core.decompose.model.ParamsContainer
+import com.tangem.core.decompose.navigation.Router
+import com.tangem.core.decompose.ui.UiMessageSender
+import com.tangem.core.navigation.url.UrlOpener
+import com.tangem.core.ui.R
+import com.tangem.core.ui.extensions.resourceReference
+import com.tangem.core.ui.message.DialogMessage
+import com.tangem.datasource.local.appsflyer.AppsFlyerStore
+import com.tangem.domain.card.ScanCardProcessor
+import com.tangem.domain.card.analytics.IntroductionProcess
+import com.tangem.domain.card.repository.CardSdkConfigRepository
+import com.tangem.domain.common.wallets.UserWalletsListRepository
+import com.tangem.domain.common.wallets.error.SaveWalletError
+import com.tangem.domain.hotwallet.IsHotWalletCreationSupported
+import com.tangem.domain.models.scan.ScanResponse
+import com.tangem.domain.models.wallet.UserWallet
+import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.settings.repositories.SettingsRepository
+import com.tangem.domain.wallets.builder.ColdUserWalletBuilder
+import com.tangem.domain.wallets.models.AppsFlyerConversionData
+import com.tangem.domain.wallets.usecase.GenerateBuyTangemCardLinkUseCase
+import com.tangem.domain.wallets.usecase.SaveWalletUseCase
+import com.tangem.features.createwalletstart.entity.CreateWalletStartUM
+import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
+import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider
+import io.mockk.*
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+internal class CreateWalletStartModelTest {
+
+    private val router: Router = mockk(relaxed = true)
+    private val appRouter: AppRouter = mockk(relaxed = true)
+    private val scanCardProcessor: ScanCardProcessor = mockk()
+    private val cardSdkConfigRepository: CardSdkConfigRepository = mockk(relaxed = true)
+    private val settingsRepository: SettingsRepository = mockk()
+    private val coldUserWalletBuilderFactory: ColdUserWalletBuilder.Factory = mockk()
+    private val coldUserWalletBuilder: ColdUserWalletBuilder = mockk()
+    private val saveWalletUseCase: SaveWalletUseCase = mockk()
+    private val isHotWalletCreationSupported: IsHotWalletCreationSupported = mockk()
+    private val userWalletsListRepository: UserWalletsListRepository = mockk()
+    private val uiMessageSender: UiMessageSender = mockk(relaxed = true)
+    private val generateBuyTangemCardLinkUseCase: GenerateBuyTangemCardLinkUseCase = mockk()
+    private val urlOpener: UrlOpener = mockk(relaxed = true)
+    private val trackingContextProxy: TrackingContextProxy = mockk(relaxed = true)
+    private val analyticsEventHandler: AnalyticsEventHandler = mockk(relaxed = true)
+    private val appsFlyerStore: AppsFlyerStore = mockk()
+    private val onboardingV2FeatureToggles: OnboardingV2FeatureToggles = mockk()
+
+    private val testUserWalletId = UserWalletId("1234567890ABCDEF")
+    private val testScanResponse: ScanResponse = mockk(relaxed = true)
+    private val testColdWallet: UserWallet.Cold = mockk(relaxed = true) {
+        every { walletId } returns testUserWalletId
+    }
+
+    @BeforeEach
+    fun setUp() {
+        coEvery { appsFlyerStore.get() } returns null
+        coEvery { settingsRepository.shouldSaveAccessCodes() } returns false
+        every { coldUserWalletBuilderFactory.create(any()) } returns coldUserWalletBuilder
+        every { coldUserWalletBuilder.build() } returns testColdWallet
+        every { onboardingV2FeatureToggles.isAddressSyncEnabled } returns false
+        coEvery {
+            scanCardProcessor.scan(
+                analyticsSource = any(),
+                shouldCheckIsAlreadyActivated = any(),
+                cardId = any(),
+                onProgressStateChange = any(),
+                onWalletNotCreated = any(),
+                disclaimerWillShow = any(),
+                onCancel = any(),
+                onFailure = any(),
+                onSuccess = any()
+            )
+        } just Runs
+    }
+
+    @Test
+    fun `GIVEN ColdWallet mode WHEN onScanClick THEN ButtonScanCard event sent AND scan called`() = runTest {
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.onScanClick.invoke()
+        advanceUntilIdle()
+
+        verify {
+            analyticsEventHandler.send(
+                match<IntroductionProcess.ButtonScanCard> {
+                    it.source == AnalyticsParam.ScreensSources.CreateWalletIntro
+                },
+            )
+        }
+        coVerify {
+            scanCardProcessor.scan(
+                analyticsSource = AnalyticsParam.ScreensSources.Intro,
+                shouldCheckIsAlreadyActivated = true,
+                cardId = null,
+                onProgressStateChange = any(),
+                onWalletNotCreated = any(),
+                disclaimerWillShow = any(),
+                onCancel = any(),
+                onFailure = any(),
+                onSuccess = any()
+            )
+        }
+    }
+
+    @Test
+    fun `GIVEN HotWallet mode WHEN onScanClick THEN ButtonScanCard event sent AND scan called`() = runTest {
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.HotWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.onScanClick.invoke()
+        advanceUntilIdle()
+
+        verify {
+            analyticsEventHandler.send(
+                match<IntroductionProcess.ButtonScanCard> {
+                    it.source == AnalyticsParam.ScreensSources.CreateWalletIntro
+                },
+            )
+        }
+        coVerify {
+            scanCardProcessor.scan(
+                analyticsSource = AnalyticsParam.ScreensSources.Intro,
+                shouldCheckIsAlreadyActivated = true,
+                cardId = null,
+                onProgressStateChange = any(),
+                onWalletNotCreated = any(),
+                disclaimerWillShow = any(),
+                onCancel = any(),
+                onFailure = any(),
+                onSuccess = any()
+            )
+        }
+    }
+
+    @Test
+    fun `GIVEN ColdWallet AND hot wallet not supported WHEN otherMethodClick THEN dialog sent`() = runTest {
+        every { isHotWalletCreationSupported() } returns false
+        every { isHotWalletCreationSupported.getLeastVersionName() } returns "13"
+
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.otherMethodClick.invoke()
+        advanceUntilIdle()
+
+        verify { trackingContextProxy.addHotWalletContext() }
+        verify {
+            analyticsEventHandler.send(
+                match<OnboardingAnalyticsEvent.Onboarding.ButtonMobileWallet> { true },
+            )
+        }
+        verify { uiMessageSender.send(match<DialogMessage> { true }) }
+        verify(exactly = 0) { router.push(any(), any()) }
+    }
+
+    @Test
+    fun `GIVEN HotWallet AND hot wallet supported WHEN onPrimaryButtonClick THEN CreateMobileWallet pushed`() =
+        runTest {
+            every { isHotWalletCreationSupported() } returns true
+
+            val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.HotWallet)
+            advanceUntilIdle()
+
+            model.uiState.value.onPrimaryButtonClick.invoke()
+            advanceUntilIdle()
+
+            verify { trackingContextProxy.addHotWalletContext() }
+            verify {
+                analyticsEventHandler.send(
+                    match<OnboardingAnalyticsEvent.Onboarding.ButtonMobileWallet> { true },
+                )
+            }
+            verify {
+                router.push(
+                    route = AppRoute.CreateMobileWallet(
+                        source = AnalyticsParam.ScreensSources.CreateWalletIntro.value,
+                    ),
+                    onComplete = any(),
+                )
+            }
+            verify(exactly = 0) { uiMessageSender.send(any()) }
+        }
+
+    @Test
+    fun `GIVEN ColdWallet mode WHEN onPrimaryButtonClick THEN buy link opened`() = runTest {
+        val testUrl = "https://buy.tangem.com"
+        coEvery {
+            generateBuyTangemCardLinkUseCase.invoke(GenerateBuyTangemCardLinkUseCase.Source.Creation)
+        } returns testUrl
+
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.onPrimaryButtonClick.invoke()
+        advanceUntilIdle()
+
+        verify {
+            analyticsEventHandler.send(
+                match<Basic.ButtonBuy> { true },
+            )
+        }
+        coVerify { generateBuyTangemCardLinkUseCase.invoke(GenerateBuyTangemCardLinkUseCase.Source.Creation) }
+        verify { urlOpener.openUrl(testUrl) }
+    }
+
+    @Test
+    fun `GIVEN HotWallet mode WHEN onBuyClick THEN buy link opened`() = runTest {
+        val testUrl = "https://buy.tangem.com"
+        coEvery {
+            generateBuyTangemCardLinkUseCase.invoke(GenerateBuyTangemCardLinkUseCase.Source.Creation)
+        } returns testUrl
+
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.HotWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.otherMethodClick.invoke()
+        advanceUntilIdle()
+
+        verify {
+            analyticsEventHandler.send(
+                match<Basic.ButtonBuy> { true },
+            )
+        }
+        coVerify { generateBuyTangemCardLinkUseCase.invoke(GenerateBuyTangemCardLinkUseCase.Source.Creation) }
+        verify { urlOpener.openUrl(testUrl) }
+    }
+
+    @Test
+    fun `WHEN scanCard THEN access code policy set AND scanProcessor called`() = runTest {
+        coEvery { settingsRepository.shouldSaveAccessCodes() } returns true
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.onScanClick.invoke()
+        advanceUntilIdle()
+
+        verify { cardSdkConfigRepository.setAccessCodeRequestPolicy(isBiometricsRequestPolicy = true) }
+        coVerify {
+            scanCardProcessor.scan(
+                analyticsSource = AnalyticsParam.ScreensSources.Intro,
+                shouldCheckIsAlreadyActivated = true,
+                cardId = null,
+                onProgressStateChange = any(),
+                onWalletNotCreated = any(),
+                disclaimerWillShow = any(),
+                onCancel = any(),
+                onFailure = any(),
+                onSuccess = any()
+            )
+        }
+    }
+
+    @Test
+    fun `GIVEN NfcFeatureIsUnavailable WHEN handleScanError THEN nfcFeatureUnavailable dialog sent`() = runTest {
+        val error = TangemSdkError.NfcFeatureIsUnavailable()
+        coEvery {
+            scanCardProcessor.scan(
+                analyticsSource = any(),
+                shouldCheckIsAlreadyActivated = any(),
+                cardId = any(),
+                onProgressStateChange = any(),
+                onWalletNotCreated = any(),
+                disclaimerWillShow = any(),
+                onCancel = any(),
+                onFailure = any(),
+                onSuccess = any()
+            )
+        } coAnswers {
+            val onFailure = arg<suspend (TangemError) -> Unit>(7)
+            onFailure.invoke(error)
+        }
+
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.onScanClick.invoke()
+        advanceUntilIdle()
+
+        verify { uiMessageSender.send(match<DialogMessage> { true }) }
+    }
+
+    @Test
+    fun `GIVEN generic TangemSdkError WHEN handleScanError THEN no dialog sent`() = runTest {
+        val error: TangemSdkError = mockk(relaxed = true)
+        coEvery {
+            scanCardProcessor.scan(
+                analyticsSource = any(),
+                shouldCheckIsAlreadyActivated = any(),
+                cardId = any(),
+                onProgressStateChange = any(),
+                onWalletNotCreated = any(),
+                disclaimerWillShow = any(),
+                onCancel = any(),
+                onFailure = any(),
+                onSuccess = any()
+            )
+        } coAnswers {
+            val onFailure = arg<suspend (TangemError) -> Unit>(7)
+            onFailure.invoke(error)
+        }
+
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.onScanClick.invoke()
+        advanceUntilIdle()
+
+        verify(exactly = 0) { uiMessageSender.send(any()) }
+    }
+
+    @Test
+    fun `GIVEN non-sdk TangemError WHEN handleScanError THEN no dialog sent`() = runTest {
+        val error: TangemError = mockk(relaxed = true)
+        coEvery {
+            scanCardProcessor.scan(
+                analyticsSource = any(),
+                shouldCheckIsAlreadyActivated = any(),
+                cardId = any(),
+                onProgressStateChange = any(),
+                onWalletNotCreated = any(),
+                disclaimerWillShow = any(),
+                onCancel = any(),
+                onFailure = any(),
+                onSuccess = any()
+            )
+        } coAnswers {
+            val onFailure = arg<suspend (TangemError) -> Unit>(7)
+            onFailure.invoke(error)
+        }
+
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.onScanClick.invoke()
+        advanceUntilIdle()
+
+        verify(exactly = 0) { uiMessageSender.send(any()) }
+    }
+
+    @Test
+    fun `GIVEN builder returns null WHEN proceedWithScanResponse THEN saveWalletUseCase not called`() = runTest {
+        every { coldUserWalletBuilder.build() } returns null
+        coEvery {
+            scanCardProcessor.scan(
+                analyticsSource = any(),
+                shouldCheckIsAlreadyActivated = any(),
+                cardId = any(),
+                onProgressStateChange = any(),
+                onWalletNotCreated = any(),
+                disclaimerWillShow = any(),
+                onCancel = any(),
+                onFailure = any(),
+                onSuccess = any()
+            )
+        } coAnswers {
+            val onSuccess = arg<suspend (ScanResponse) -> Unit>(8)
+            onSuccess.invoke(testScanResponse)
+        }
+
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.onScanClick.invoke()
+        advanceUntilIdle()
+
+        verify { coldUserWalletBuilderFactory.create(scanResponse = testScanResponse) }
+        coVerify(exactly = 0) { saveWalletUseCase(userWallet = any(), canOverride = any(), analyticsSource = any()) }
+        verify(exactly = 0) { appRouter.replaceAll(routes = anyVararg(), onComplete = any()) }
+    }
+
+    @Test
+    fun `GIVEN save returns WalletAlreadySaved WHEN proceedWithScanResponse THEN unlock called AND Wallet replaced`() =
+        runTest {
+            coEvery {
+                saveWalletUseCase(userWallet = any(), canOverride = any(), analyticsSource = any())
+            } returns SaveWalletError.WalletAlreadySaved(messageId = 0).left()
+            coEvery {
+                userWalletsListRepository.unlock(
+                    userWalletId = testUserWalletId,
+                    unlockMethod = any(),
+                )
+            } returns Unit.right()
+            coEvery {
+                scanCardProcessor.scan(
+                    analyticsSource = any(),
+                    shouldCheckIsAlreadyActivated = any(),
+                    cardId = any(),
+                    onProgressStateChange = any(),
+                    onWalletNotCreated = any(),
+                    disclaimerWillShow = any(),
+                    onCancel = any(),
+                    onFailure = any(),
+                    onSuccess = any()
+                )
+            } coAnswers {
+                val onSuccess = arg<suspend (ScanResponse) -> Unit>(8)
+                onSuccess.invoke(testScanResponse)
+            }
+
+            val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+            advanceUntilIdle()
+
+            model.uiState.value.onScanClick.invoke()
+            advanceUntilIdle()
+
+            coVerify {
+                userWalletsListRepository.unlock(
+                    userWalletId = testUserWalletId,
+                    unlockMethod = UserWalletsListRepository.UnlockMethod.Scan(testScanResponse),
+                )
+            }
+            verify { appRouter.replaceAll(routes = arrayOf(AppRoute.Wallet), onComplete = any()) }
+        }
+
+    @Test
+    fun `GIVEN save returns DataError WHEN proceedWithScanResponse THEN no unlock AND no replace`() = runTest {
+        coEvery {
+            saveWalletUseCase(userWallet = any(), canOverride = any(), analyticsSource = any())
+        } returns SaveWalletError.DataError(messageId = 0).left()
+        coEvery {
+            scanCardProcessor.scan(
+                analyticsSource = any(),
+                shouldCheckIsAlreadyActivated = any(),
+                cardId = any(),
+                onProgressStateChange = any(),
+                onWalletNotCreated = any(),
+                disclaimerWillShow = any(),
+                onCancel = any(),
+                onFailure = any(),
+                onSuccess = any()
+            )
+        } coAnswers {
+            val onSuccess = arg<suspend (ScanResponse) -> Unit>(8)
+            onSuccess.invoke(testScanResponse)
+        }
+
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        model.uiState.value.onScanClick.invoke()
+        advanceUntilIdle()
+
+        coVerify(exactly = 0) { userWalletsListRepository.unlock(any(), any()) }
+        verify(exactly = 0) { appRouter.replaceAll(routes = anyVararg(), onComplete = any()) }
+    }
+
+    @Test
+    fun `GIVEN save success AND isAddressSyncEnabled disabled WHEN proceedWithScanResponse THEN Wallet replaced`() =
+        runTest {
+            every { onboardingV2FeatureToggles.isAddressSyncEnabled } returns false
+            coEvery {
+                saveWalletUseCase(userWallet = any(), canOverride = any(), analyticsSource = any())
+            } returns Unit.right()
+            coEvery {
+                scanCardProcessor.scan(
+                    analyticsSource = any(),
+                    shouldCheckIsAlreadyActivated = any(),
+                    cardId = any(),
+                    onProgressStateChange = any(),
+                    onWalletNotCreated = any(),
+                    disclaimerWillShow = any(),
+                    onCancel = any(),
+                    onFailure = any(),
+                    onSuccess = any()
+                )
+            } coAnswers {
+                val onSuccess = arg<suspend (ScanResponse) -> Unit>(8)
+                onSuccess.invoke(testScanResponse)
+            }
+
+            val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+            advanceUntilIdle()
+
+            model.uiState.value.onScanClick.invoke()
+            advanceUntilIdle()
+
+            verify { appRouter.replaceAll(routes = arrayOf(AppRoute.Wallet), onComplete = any()) }
+        }
+
+    @Test
+    fun `GIVEN save success AND isAddressSyncEnabled WHEN proceedWithScanResponse THEN AddressSync replaced`() =
+        runTest {
+            every { onboardingV2FeatureToggles.isAddressSyncEnabled } returns true
+            coEvery {
+                saveWalletUseCase(userWallet = any(), canOverride = any(), analyticsSource = any())
+            } returns Unit.right()
+            coEvery {
+                scanCardProcessor.scan(
+                    analyticsSource = any(),
+                    shouldCheckIsAlreadyActivated = any(),
+                    cardId = any(),
+                    onProgressStateChange = any(),
+                    onWalletNotCreated = any(),
+                    disclaimerWillShow = any(),
+                    onCancel = any(),
+                    onFailure = any(),
+                    onSuccess = any()
+                )
+            } coAnswers {
+                val onSuccess = arg<suspend (ScanResponse) -> Unit>(8)
+                onSuccess.invoke(testScanResponse)
+            }
+
+            val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+            advanceUntilIdle()
+
+            model.uiState.value.onScanClick.invoke()
+            advanceUntilIdle()
+
+            verify {
+                appRouter.replaceAll(
+                    routes = arrayOf(
+                        AppRoute.Onboarding(
+                            scanResponse = testScanResponse,
+                            mode = AppRoute.Onboarding.Mode.AddressSync(
+                                userWalletId = testUserWalletId,
+                                isWalletStarted = false,
+                            ),
+                        )
+                    ),
+                    onComplete = any()
+                )
+            }
+        }
+
+    @Test
+    fun `WHEN model initialized THEN CreateWalletIntroScreenOpened event sent with referral id`() = runTest {
+        val refcode = "referralCode"
+        coEvery { appsFlyerStore.get() } returns AppsFlyerConversionData(refcode = refcode, campaign = null)
+
+        createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        advanceUntilIdle()
+
+        verify {
+            analyticsEventHandler.send(
+                match<IntroductionProcess.CreateWalletIntroScreenOpened> { true },
+            )
+        }
+    }
+
+    @Test
+    fun `WHEN ColdWallet WHEN get model THEN correct resources`() = runTest {
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.ColdWallet)
+        val state = model.uiState.value
+        assert(state.title == resourceReference(R.string.common_tangem_wallet))
+        assert(state.description == resourceReference(R.string.welcome_create_wallet_hardware_description))
+        assert(
+            state.featureItems == persistentListOf(
+                CreateWalletStartUM.FeatureItem(
+                    iconResId = R.drawable.ic_shield_check_16,
+                    text = resourceReference(R.string.welcome_create_wallet_feature_class),
+                ),
+                CreateWalletStartUM.FeatureItem(
+                    iconResId = R.drawable.ic_flash_16,
+                    text = resourceReference(R.string.welcome_create_wallet_feature_delivery),
+                ),
+                CreateWalletStartUM.FeatureItem(
+                    iconResId = R.drawable.ic_sparkles_16,
+                    text = resourceReference(R.string.welcome_create_wallet_feature_use),
+                )
+            )
+        )
+        assert(state.imageResId == R.drawable.img_hardware_wallet)
+        assert(state.shouldShowScanSecondaryButton)
+        assert(state.primaryButtonText == resourceReference(R.string.details_buy_wallet))
+        assert(state.otherMethodTitle == resourceReference(R.string.welcome_create_wallet_mobile_title))
+        assert(state.otherMethodDescription == null)
+        assert(state.isScanInProgress.not())
+    }
+
+    @Test
+    fun `WHEN HotWallet WHEN get model THEN correct resources`() = runTest {
+        val model = createModel(testScope = this, mode = CreateWalletStartComponent.Mode.HotWallet)
+        val state = model.uiState.value
+        assert(state.title == resourceReference(R.string.hw_mobile_wallet))
+        assert(state.description == resourceReference(R.string.welcome_create_wallet_mobile_description_full))
+        assert(
+            state.featureItems == persistentListOf(
+                CreateWalletStartUM.FeatureItem(
+                    iconResId = R.drawable.ic_shield_check_16,
+                    text = resourceReference(R.string.welcome_create_wallet_feature_seamless),
+                ),
+                CreateWalletStartUM.FeatureItem(
+                    iconResId = R.drawable.ic_flash_16,
+                    text = resourceReference(R.string.welcome_create_wallet_feature_one_tap),
+                ),
+                CreateWalletStartUM.FeatureItem(
+                    iconResId = R.drawable.ic_stack_fill_new_16,
+                    text = resourceReference(R.string.welcome_create_wallet_feature_assets),
+                ),
+            )
+        )
+        assert(state.imageResId == R.drawable.img_mobile_wallet)
+        assert(state.shouldShowScanSecondaryButton.not())
+        assert(state.primaryButtonText == resourceReference(R.string.welcome_create_wallet_mobile_title))
+        assert(state.otherMethodTitle == resourceReference(R.string.welcome_create_wallet_use_hardware_title))
+        assert(state.otherMethodDescription == resourceReference(R.string.welcome_create_wallet_use_hardware_description))
+        assert(state.isScanInProgress.not())
+    }
+
+    private fun createModel(
+        testScope: TestScope,
+        mode: CreateWalletStartComponent.Mode,
+        paramsContainer: ParamsContainer = MutableParamsContainer(
+            value = CreateWalletStartComponent.Params(mode = mode)
+        ),
+    ): CreateWalletStartModel {
+        return CreateWalletStartModel(
+            paramsContainer = paramsContainer,
+            dispatchers = testScope.createTestingCoroutineDispatcherProvider(),
+            router = router,
+            scanCardProcessor = scanCardProcessor,
+            cardSdkConfigRepository = cardSdkConfigRepository,
+            settingsRepository = settingsRepository,
+            appRouter = appRouter,
+            coldUserWalletBuilderFactory = coldUserWalletBuilderFactory,
+            saveWalletUseCase = saveWalletUseCase,
+            isHotWalletCreationSupported = isHotWalletCreationSupported,
+            userWalletsListRepository = userWalletsListRepository,
+            uiMessageSender = uiMessageSender,
+            generateBuyTangemCardLinkUseCase = generateBuyTangemCardLinkUseCase,
+            urlOpener = urlOpener,
+            trackingContextProxy = trackingContextProxy,
+            analyticsEventHandler = analyticsEventHandler,
+            appsFlyerStore = appsFlyerStore,
+            onboardingV2FeatureToggles = onboardingV2FeatureToggles,
+        )
+    }
+
+    private fun TestScope.createTestingCoroutineDispatcherProvider(): TestingCoroutineDispatcherProvider {
+        val testDispatcher = StandardTestDispatcher(testScheduler)
+        return TestingCoroutineDispatcherProvider(
+            main = testDispatcher,
+            mainImmediate = testDispatcher,
+            io = testDispatcher,
+            default = testDispatcher,
+            single = testDispatcher,
+        )
+    }
+}

features/details/impl/build.gradle.kts

@@ -19,8 +19,8 @@ dependencies {
     implementation(projects.features.disclaimer.api)
     implementation(projects.features.tester.api)
     implementation(projects.features.createWalletSelection.api)
-    implementation(projects.features.hotWallet.api)
     implementation(projects.features.tangempay.details.api)
+    implementation(projects.features.onboardingV2.api)
 
     /* Project - Core */
     implementation(projects.core.decompose)
@@ -49,6 +49,7 @@ dependencies {
     implementation(projects.domain.balanceHiding)
     implementation(projects.domain.balanceHiding.models)
     implementation(projects.domain.legacy)
+    implementation(projects.domain.settings)
     implementation(projects.domain.visa)
 
     /* SDK */
@@ -78,7 +79,6 @@ dependencies {
 
     /* Other */
     implementation(deps.kotlin.immutable.collections)
-    implementation(deps.reKotlin)
     implementation(deps.arrow.core)
     implementation(deps.arrow.fx)
 }

features/details/impl/src/main/kotlin/com/tangem/features/details/component/preview/PreviewDetailsComponent.kt

@@ -6,13 +6,15 @@ import com.tangem.core.decompose.navigation.DummyRouter
 import com.tangem.core.navigation.url.DummyUrlOpener
 import com.tangem.core.ui.components.bottomsheets.TangemBottomSheetConfig
 import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.settings.HotWalletRestrictionManager
 import com.tangem.features.details.component.DetailsComponent
 import com.tangem.features.details.entity.DetailsFooterUM
 import com.tangem.features.details.entity.DetailsUM
 import com.tangem.features.details.ui.DetailsScreen
 import com.tangem.features.details.utils.ItemsBuilder
 import com.tangem.features.details.utils.SocialsBuilder
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.runBlocking
 
 internal class PreviewDetailsComponent : DetailsComponent {
@@ -20,9 +22,10 @@ internal class PreviewDetailsComponent : DetailsComponent {
     private val previewBlocks = runBlocking {
         ItemsBuilder(
             router = DummyRouter(),
-            hotWalletFeatureToggles = object : HotWalletFeatureToggles {
-                override val isWalletCreationRestrictionEnabled: Boolean = true
-                override val isTokenSyncEnabled: Boolean = true
+            hotWalletRestrictionManager = object : HotWalletRestrictionManager {
+                override fun isCreationEnabled(): StateFlow<Boolean> = MutableStateFlow(true)
+                override fun isCreationEnabledSync(): Boolean = true
+                override suspend fun toggleCreationEnabled() = Unit
             },
         ).buildAll(
             isWalletConnectAvailable = true,

features/details/impl/src/main/kotlin/com/tangem/features/details/model/DetailsModel.kt

@@ -1,8 +1,6 @@
 package com.tangem.features.details.model
 
-import android.content.res.Resources
 import arrow.core.getOrElse
-import com.tangem.utils.logging.TangemLogger
 import com.tangem.common.routing.AppRoute
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.analytics.models.AnalyticsParam
@@ -22,8 +20,6 @@ import com.tangem.domain.feedback.repository.FeedbackFeatureToggles
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.pay.TangemPayEligibilityManager
 import com.tangem.domain.pay.model.TangemPayEntryPoint
-import com.tangem.domain.redux.LegacyAction
-import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.tangempay.GetTangemPayCustomerIdUseCase
 import com.tangem.domain.tangempay.TangemPayAnalyticsEvents
 import com.tangem.domain.walletconnect.CheckIsWalletConnectAvailableUseCase
@@ -38,7 +34,8 @@ import com.tangem.features.details.entity.SelectEmailFeedbackTypeBS
 import com.tangem.features.details.utils.ItemsBuilder
 import com.tangem.features.details.utils.SocialsBuilder
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import com.tangem.utils.version.AppVersionProvider
+import com.tangem.utils.info.AppInfoProvider
+import com.tangem.utils.logging.TangemLogger
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.launchIn
@@ -46,7 +43,6 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
-import java.util.Locale
 import javax.inject.Inject
 
 @ModelScoped
@@ -56,12 +52,11 @@ internal class DetailsModel @Inject constructor(
     paramsContainer: ParamsContainer,
     feedbackFeatureToggles: FeedbackFeatureToggles,
     private val itemsBuilder: ItemsBuilder,
-    private val appVersionProvider: AppVersionProvider,
+    private val appInfoProvider: AppInfoProvider,
     private val checkIsWalletConnectAvailableUseCase: CheckIsWalletConnectAvailableUseCase,
     private val router: Router,
     private val urlOpener: UrlOpener,
     private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
-    private val appStateHolder: ReduxStateHolder,
     private val getWalletMetaInfoUseCase: GetWalletMetaInfoUseCase,
     private val getTangemPayCustomerIdUseCase: GetTangemPayCustomerIdUseCase,
     private val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
@@ -79,9 +74,6 @@ internal class DetailsModel @Inject constructor(
     val state: MutableStateFlow<DetailsUM>
 
     init {
-        // Use to save compatibility with screens that using Redux states
-        bootstrapScreenState()
-
         val isWalletConnectAvailable = runBlocking {
             // danger region, this works immediately, but will be refactored later with WC
             checkIsWalletConnectAvailableUseCase(params.userWalletId).getOrElse { throwable ->
@@ -122,10 +114,6 @@ internal class DetailsModel @Inject constructor(
             .launchIn(modelScope)
     }
 
-    private fun bootstrapScreenState() {
-        appStateHolder.dispatch(LegacyAction.PrepareDetailsScreen)
-    }
-
     private fun sendFeedback() {
         modelScope.launch {
             val userWallets = getWalletsUseCase.invokeSync()
@@ -279,14 +267,5 @@ internal class DetailsModel @Inject constructor(
         }
     }
 
-    private fun getAppVersion(): String = "${appVersionProvider.versionName} (${appVersionProvider.versionCode})"
-
-    private companion object {
-        val SYSTEM_LANGUAGE = runCatching { Resources.getSystem().configuration.locales[0].language }.getOrElse { "" }
-        val APP_LANGUAGE = Locale.getDefault().language
-        val UTM_MARKS = "utm_source=tangem-app" +
-            "&utm_medium=app" +
-            "&utm_campaign=users-$SYSTEM_LANGUAGE" +
-            "&utm_content=devicelang-$APP_LANGUAGE"
-    }
+    private fun getAppVersion(): String = "${appInfoProvider.appVersion} (${appInfoProvider.appVersionCode})"
 }

features/details/impl/src/main/kotlin/com/tangem/features/details/model/UserWalletListModel.kt

@@ -19,9 +19,8 @@ import com.tangem.domain.wallets.usecase.UnlockWalletUseCase
 import com.tangem.features.details.entity.UserWalletListUM
 import com.tangem.features.details.entity.WalletReorderUM
 import com.tangem.features.details.impl.R
+import com.tangem.domain.settings.HotWalletRestrictionManager
 import com.tangem.features.details.utils.UserWalletSaver
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
-import com.tangem.features.wallet.featuretoggles.WalletFeatureToggles
 import com.tangem.features.wallet.utils.UserWalletsFetcher
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.collections.immutable.ImmutableList
@@ -40,14 +39,15 @@ internal class UserWalletListModel @Inject constructor(
     private val messageSender: UiMessageSender,
     override val dispatchers: CoroutineDispatcherProvider,
     private val userWalletSaver: UserWalletSaver,
-    private val hotWalletFeatureToggles: HotWalletFeatureToggles,
+    private val hotWalletRestrictionManager: HotWalletRestrictionManager,
     private val unlockWalletUseCase: UnlockWalletUseCase,
     private val analyticsEventHandler: AnalyticsEventHandler,
-    private val walletFeatureToggles: WalletFeatureToggles,
     private val applyUserWalletListSortingUseCase: ApplyUserWalletListSortingUseCase,
 ) : Model() {
 
     private val isWalletSavingInProgress: MutableStateFlow<Boolean> = MutableStateFlow(value = false)
+    private val isWalletCreationRestrictionEnabled: StateFlow<Boolean> =
+        hotWalletRestrictionManager.isCreationEnabled()
     private val userWalletsFetcher = userWalletsFetcherFactory.create(
         messageSender = messageSender,
         onlyMultiCurrency = false,
@@ -91,7 +91,7 @@ internal class UserWalletListModel @Inject constructor(
                 isWalletSavingInProgress = isWalletSavingInProgress,
                 addNewWalletText = resourceReference(R.string.user_wallet_list_add_button),
                 walletReorderUM = WalletReorderUM(
-                    isDragEnabled = walletFeatureToggles.isWalletReorderFeatureEnabled && userWallets.size > 1,
+                    isDragEnabled = userWallets.size > 1,
                     onMove = ::onWalletReorder,
                     onDragStopped = ::onWalletDragStopped,
                 ),
@@ -101,7 +101,7 @@ internal class UserWalletListModel @Inject constructor(
     private fun onAddNewWalletClick() {
         analyticsEventHandler.send(SignIn.ButtonAddWallet(AnalyticsParam.ScreensSources.Settings))
 
-        if (hotWalletFeatureToggles.isWalletCreationRestrictionEnabled) {
+        if (isWalletCreationRestrictionEnabled.value) {
             withProgress(isWalletSavingInProgress) {
                 userWalletSaver.scanAndSaveUserWallet(modelScope)
             }

features/details/impl/src/main/kotlin/com/tangem/features/details/utils/ItemsBuilder.kt

@@ -6,9 +6,9 @@ import com.tangem.core.decompose.navigation.Router
 import com.tangem.core.ui.components.block.model.BlockUM
 import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.settings.HotWalletRestrictionManager
 import com.tangem.features.details.entity.DetailsItemUM
 import com.tangem.features.details.impl.R
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toImmutableList
@@ -20,7 +20,7 @@ private const val TANGEM_PAY_ITEM_ID = "get_tangem_pay"
 @ModelScoped
 internal class ItemsBuilder @Inject constructor(
     private val router: Router,
-    private val hotWalletFeatureToggles: HotWalletFeatureToggles,
+    private val hotWalletRestrictionManager: HotWalletRestrictionManager,
 ) {
 
     @Suppress("LongParameterList")
@@ -36,7 +36,7 @@ internal class ItemsBuilder @Inject constructor(
         buildWalletConnectBlock(isWalletConnectAvailable, userWalletId)?.let(::add)
         buildUserWalletListBlock().let(::add)
 
-        if (hotWalletFeatureToggles.isWalletCreationRestrictionEnabled && hasAnyMobileWallet) {
+        if (hotWalletRestrictionManager.isCreationEnabledSync() && hasAnyMobileWallet) {
             DetailsItemUM.UnderSectionText(
                 id = "only_one_mobile_wallet_explanation",
                 text = resourceReference(R.string.only_one_mobile_wallet_explanation),

features/details/impl/src/main/kotlin/com/tangem/features/details/utils/UserWalletSaver.kt

@@ -21,10 +21,10 @@ import com.tangem.domain.card.ScanCardProcessor
 import com.tangem.domain.common.wallets.error.SaveWalletError
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.wallets.builder.ColdUserWalletBuilder
 import com.tangem.domain.wallets.usecase.SaveWalletUseCase
 import com.tangem.features.details.impl.R
+import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
@@ -37,9 +37,9 @@ internal class UserWalletSaver @Inject constructor(
     private val scanCardProcessor: ScanCardProcessor,
     private val saveWalletUseCase: SaveWalletUseCase,
     private val coldUserWalletBuilderFactory: ColdUserWalletBuilder.Factory,
-    private val reduxStateHolder: ReduxStateHolder,
     private val messageSender: UiMessageSender,
     private val router: Router,
+    private val onboardingV2FeatureToggles: OnboardingV2FeatureToggles,
 ) {
 
     suspend fun scanAndSaveUserWallet(scope: CoroutineScope) {
@@ -57,7 +57,7 @@ internal class UserWalletSaver @Inject constructor(
                     block = {
                         scanResponse ?: return
                         val userWallet = createUserWallet(scanResponse)
-                        saveWallet(userWallet)
+                        saveWallet(userWallet, scanResponse)
                     },
                     recover = {
                         val message = it.message
@@ -71,7 +71,7 @@ internal class UserWalletSaver @Inject constructor(
         )
     }
 
-    private suspend fun Raise<Error>.saveWallet(userWallet: UserWallet) {
+    private suspend fun Raise<Error>.saveWallet(userWallet: UserWallet, scanResponse: ScanResponse) {
         fold(
             block = {
                 saveWalletUseCase(
@@ -94,10 +94,19 @@ internal class UserWalletSaver @Inject constructor(
                 }
             },
             transform = {
-                // call only if wallet is successfully saved
-                reduxStateHolder.onUserWalletSelected(userWallet)
-
-                router.popTo<AppRoute.Wallet>()
+                if (onboardingV2FeatureToggles.isAddressSyncEnabled) {
+                    router.push(
+                        AppRoute.Onboarding(
+                            scanResponse = scanResponse,
+                            mode = AppRoute.Onboarding.Mode.AddressSync(
+                                userWalletId = userWallet.walletId,
+                                isWalletStarted = true,
+                            ),
+                        ),
+                    )
+                } else {
+                    router.popTo<AppRoute.Wallet>()
+                }
             },
         )
     }

features/feed/api/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/add/AddToPortfolioComponent.kt

@@ -1,22 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.add
-
-import com.tangem.core.decompose.factory.ComponentFactory
-import com.tangem.core.ui.decompose.ComposableBottomSheetComponent
-import com.tangem.domain.models.currency.CryptoCurrency
-
-interface AddToPortfolioComponent : ComposableBottomSheetComponent {
-
-    data class Params(
-        val addToPortfolioManager: AddToPortfolioManager,
-        val callback: Callback,
-        val shouldSkipTokenActionsScreen: Boolean = false,
-    )
-
-    interface Callback {
-        fun onDismiss()
-        // todo swap add new onSuccess with full data of added token
-        fun onSuccess(addedToken: CryptoCurrency)
-    }
-
-    interface Factory : ComponentFactory<Params, AddToPortfolioComponent>
-}

features/feed/api/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/add/AddToPortfolioManager.kt

@@ -1,44 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.add
-
-import com.tangem.domain.markets.TokenMarketInfo
-import com.tangem.domain.markets.TokenMarketParams
-import com.tangem.features.account.PortfolioFetcher
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.serialization.Serializable
-
-interface AddToPortfolioManager {
-
-    // todo swap make updatable
-    val token: TokenMarketParams
-    val analyticsParams: AnalyticsParams?
-    val portfolioFetcher: PortfolioFetcher
-
-    val state: StateFlow<State>
-
-    val allAvailableNetworks: Flow<List<TokenMarketInfo.Network>>
-    fun setTokenNetworks(networks: List<TokenMarketInfo.Network>)
-
-    sealed interface State {
-        data object Init : State
-        data class AvailableToAdd(
-            val availableToAddData: AvailableToAddData,
-        ) : State
-
-        data object NothingToAdd : State
-    }
-
-    @Serializable
-    data class AnalyticsParams(
-        val source: String,
-    )
-
-    interface Factory {
-        fun create(
-            scope: CoroutineScope,
-            token: TokenMarketParams,
-            analyticsParams: AnalyticsParams?,
-        ): AddToPortfolioManager
-    }
-}

features/feed/api/src/main/kotlin/com/tangem/features/feed/entry/components/FeedEntryRoute.kt

@@ -1,6 +1,9 @@
 package com.tangem.features.feed.entry.components
 
 import com.tangem.domain.appcurrency.model.AppCurrency
+import com.tangem.domain.markets.PreselectedMarketsInterval
+import com.tangem.domain.markets.PreselectedMarketsOrder
+import com.tangem.domain.markets.PreselectedTokenDetailsSection
 import com.tangem.domain.markets.TokenMarketParams
 import kotlinx.serialization.Serializable
 
@@ -13,6 +16,9 @@ sealed interface FeedEntryRoute {
         val appCurrency: AppCurrency,
         val shouldShowPortfolio: Boolean,
         val analyticsParams: AnalyticsParams? = null,
+        val preselectedSection: PreselectedTokenDetailsSection? = null,
+        val shouldOpenExchanges: Boolean = false,
+        val exchangesCount: Int? = null,
     ) : FeedEntryRoute {
 
         @Serializable
@@ -23,7 +29,10 @@ sealed interface FeedEntryRoute {
     }
 
     @Serializable
-    data object MarketTokenList : FeedEntryRoute
+    data class MarketTokenList(
+        val preselectedOrder: PreselectedMarketsOrder? = null,
+        val preselectedInterval: PreselectedMarketsInterval? = null,
+    ) : FeedEntryRoute
 
     @Serializable
     data class NewsDetail(val articleId: Int, val preselectedArticlesId: List<Int>) : FeedEntryRoute

features/feed/api/src/main/kotlin/com/tangem/features/feed/entry/deeplink/MarketsDeepLinkHandler.kt

@@ -3,6 +3,6 @@ package com.tangem.features.feed.entry.deeplink
 interface MarketsDeepLinkHandler {
 
     interface Factory {
-        fun create(): MarketsDeepLinkHandler
+        fun create(params: Map<String, String>): MarketsDeepLinkHandler
     }
 }

features/feed/api/src/main/kotlin/com/tangem/features/feed/entry/deeplink/MarketsTokenExchangesDeepLinkHandler.kt

@@ -0,0 +1,10 @@
+package com.tangem.features.feed.entry.deeplink
+
+import kotlinx.coroutines.CoroutineScope
+
+interface MarketsTokenExchangesDeepLinkHandler {
+
+    interface Factory {
+        fun create(coroutineScope: CoroutineScope, params: Map<String, String>): MarketsTokenExchangesDeepLinkHandler
+    }
+}

features/feed/api/src/main/kotlin/com/tangem/features/feed/entry/featuretoggle/FeedFeatureToggle.kt

@@ -1,5 +0,0 @@
-package com.tangem.features.feed.entry.featuretoggle
-
-interface FeedFeatureToggle {
-    val isEarnBlockEnabled: Boolean
-}

features/feed/impl/build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
 
 android {
     namespace = "com.tangem.features.feed.impl"
-    
+
     packaging {
         resources {
             merges += "paymentrequest.proto"
@@ -17,6 +17,10 @@ android {
     }
 }
 
+tasks.withType<Test>().configureEach {
+    useJUnitPlatform()
+}
+
 dependencies {
     /* Project - API */
     api(projects.features.feed.api)
@@ -25,6 +29,7 @@ dependencies {
     api(projects.features.tokenRecieve.api)
     api(projects.features.wallet.api)
     api(projects.features.account.api)
+    api(projects.features.commonFeatures.api)
     implementation(projects.features.promoBanners.api)
 
     /* Data */
@@ -101,4 +106,10 @@ dependencies {
     /** Tangem libraries */
     implementation(tangemDeps.card.core)
     implementation(tangemDeps.blockchain)
+
+    /** Tests */
+    testImplementation(deps.test.junit5)
+    testRuntimeOnly(deps.test.junit5.engine)
+    testImplementation(deps.test.mockk)
+    testImplementation(deps.test.truth)
 }

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/DefaultFeedEntryComponent.kt

@@ -29,6 +29,9 @@ import com.tangem.features.feed.entry.components.FeedEntryComponent
 import com.tangem.features.feed.entry.components.FeedEntryRoute
 import com.tangem.features.feed.model.FeedEntryModel
 import com.tangem.features.feed.model.feed.FeedModelClickIntents
+import com.tangem.domain.markets.PreselectedMarketsInterval
+import com.tangem.domain.markets.PreselectedMarketsOrder
+import com.tangem.features.feed.model.market.list.state.MarketsListUM
 import com.tangem.features.feed.model.market.list.state.SortByTypeUM
 import com.tangem.features.feed.ui.EntryContent
 import dagger.assisted.Assisted
@@ -87,6 +90,7 @@ internal class DefaultFeedEntryComponent @AssistedInject constructor(
                 route = FeedEntryChildFactory.Child.TokenList(
                     params = DefaultMarketsTokenListComponent.Params(
                         preselectedSortType = sortBy ?: SortByTypeUM.Rating,
+                        preselectedInterval = MarketsListUM.TrendInterval.H24,
                         shouldAlwaysShowSearchBar = sortBy == null,
                     ),
                 ),
@@ -128,8 +132,8 @@ internal class DefaultFeedEntryComponent @AssistedInject constructor(
             innerRouter.push(FeedEntryChildFactory.Child.Earn)
         }
 
-        override fun openSearch() {
-            innerRouter.push(FeedEntryChildFactory.Child.Search)
+        override fun openSearch(source: String) {
+            innerRouter.push(FeedEntryChildFactory.Child.Search(source))
         }
     }
 
@@ -231,11 +235,15 @@ internal class DefaultFeedEntryComponent @AssistedInject constructor(
                             paginationConfig = null,
                         )
                     },
+                    preselectedSection = entryRoute.preselectedSection,
+                    shouldOpenExchanges = entryRoute.shouldOpenExchanges,
+                    exchangesCount = entryRoute.exchangesCount,
                 ),
             )
-            FeedEntryRoute.MarketTokenList -> FeedEntryChildFactory.Child.TokenList(
+            is FeedEntryRoute.MarketTokenList -> FeedEntryChildFactory.Child.TokenList(
                 DefaultMarketsTokenListComponent.Params(
-                    preselectedSortType = SortByTypeUM.Rating,
+                    preselectedSortType = mapOrderToSortType(entryRoute.preselectedOrder),
+                    preselectedInterval = mapIntervalToTrendInterval(entryRoute.preselectedInterval),
                     shouldAlwaysShowSearchBar = false,
                 ),
             )
@@ -265,4 +273,24 @@ internal class DefaultFeedEntryComponent @AssistedInject constructor(
     }
 }
 
+private fun mapOrderToSortType(order: PreselectedMarketsOrder?): SortByTypeUM {
+    return when (order) {
+        PreselectedMarketsOrder.Rating -> SortByTypeUM.Rating
+        PreselectedMarketsOrder.Trending -> SortByTypeUM.Trending
+        PreselectedMarketsOrder.Buyers -> SortByTypeUM.ExperiencedBuyers
+        PreselectedMarketsOrder.Gainers -> SortByTypeUM.TopGainers
+        PreselectedMarketsOrder.Losers -> SortByTypeUM.TopLosers
+        null -> SortByTypeUM.Rating
+    }
+}
+
+private fun mapIntervalToTrendInterval(interval: PreselectedMarketsInterval?): MarketsListUM.TrendInterval {
+    return when (interval) {
+        PreselectedMarketsInterval.H24 -> MarketsListUM.TrendInterval.H24
+        PreselectedMarketsInterval.W1 -> MarketsListUM.TrendInterval.D7
+        PreselectedMarketsInterval.D30 -> MarketsListUM.TrendInterval.M1
+        null -> MarketsListUM.TrendInterval.H24
+    }
+}
+
 internal interface FeedEntryClickIntents : FeedModelClickIntents

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/FeedEntryChildFactory.kt

@@ -11,7 +11,8 @@ import com.tangem.features.feed.components.earn.DefaultEarnComponent
 import com.tangem.features.feed.components.feed.DefaultFeedComponent
 import com.tangem.features.feed.components.feed.DefaultFeedComponent.FeedParams
 import com.tangem.features.feed.components.market.details.DefaultMarketsTokenDetailsComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioPreselectedDataComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioPreselectedDataComponent
 import com.tangem.features.feed.components.market.details.portfolio.api.MarketsPortfolioComponent
 import com.tangem.features.feed.components.market.details.portfolioblock.PortfolioBlockComponent
 import com.tangem.features.feed.components.market.list.DefaultMarketsTokenListComponent
@@ -29,6 +30,7 @@ internal class FeedEntryChildFactory @Inject constructor(
     private val analyticsEventHandler: AnalyticsEventHandler,
     private val portfolioComponentFactory: MarketsPortfolioComponent.Factory,
     private val portfolioBlockComponentFactory: PortfolioBlockComponent.Factory,
+    private val addToPortfolioComponentFactory: AddToPortfolioComponent.Factory,
     private val addToPortfolioPreselectedDataComponent: AddToPortfolioPreselectedDataComponent.Factory,
     private val promoBannersBlockComponentFactory: PromoBannersBlockComponent.Factory,
     private val newPromoBannersFeatureToggles: NewPromoBannersFeatureToggles,
@@ -65,7 +67,7 @@ internal class FeedEntryChildFactory @Inject constructor(
 
         @Serializable
         @Immutable
-        data object Search : Child
+        data class Search(val source: String) : Child
     }
 
     @Suppress("LongMethod")
@@ -84,6 +86,7 @@ internal class FeedEntryChildFactory @Inject constructor(
                     portfolioComponentFactory = portfolioComponentFactory,
                     portfolioBlockComponentFactory = portfolioBlockComponentFactory,
                     designFeatureToggles = designFeatureToggles,
+                    addToPortfolioComponentFactory = addToPortfolioComponentFactory,
                 )
             }
             is Child.TokenList -> {
@@ -144,10 +147,18 @@ internal class FeedEntryChildFactory @Inject constructor(
                     addToPortfolioComponentFactory = addToPortfolioPreselectedDataComponent,
                 )
             }
-            Child.Search -> DefaultSearchComponent(
+            is Child.Search -> DefaultSearchComponent(
                 appComponentContext = appComponentContext,
                 params = DefaultSearchComponent.Params(
                     onBackClick = onBackClicked,
+                    onMarketTokenClick = { token, currency ->
+                        feedEntryClickIntents.onMarketItemClick(
+                            token = token,
+                            appCurrency = currency,
+                            source = AnalyticsParam.ScreensSources.Market.value,
+                        )
+                    },
+                    sourceParams = child.source,
                 ),
             )
         }

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/earn/DefaultEarnComponent.kt

@@ -34,7 +34,7 @@ import com.tangem.core.ui.res.LocalMainBottomSheetColor
 import com.tangem.core.ui.res.LocalRedesignEnabled
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.features.feed.components.feed.FeedBottomSheetRoute
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioPreselectedDataComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioPreselectedDataComponent
 import com.tangem.features.feed.model.earn.EarnModel
 import com.tangem.features.feed.ui.components.FeedSearchBar
 import com.tangem.features.feed.ui.earn.EarnContent
@@ -148,6 +148,6 @@ internal class DefaultEarnComponent(
 
     data class Params(
         val onBackClick: () -> Unit,
-        val onSearchClicked: () -> Unit,
+        val onSearchClicked: (source: String) -> Unit,
     )
 }

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/feed/DefaultFeedComponent.kt

@@ -20,8 +20,8 @@ import com.tangem.core.ui.components.bottomsheets.state.BottomSheetState
 import com.tangem.core.ui.decompose.ComposableBottomSheetComponent
 import com.tangem.core.ui.decompose.ComposableModularBottomSheetContentComponent
 import com.tangem.core.ui.decompose.EmptyComposableBottomSheetComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioPreselectedDataComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioPreselectedDataComponent.Params
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioPreselectedDataComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioPreselectedDataComponent.Params
 import com.tangem.features.feed.model.feed.FeedComponentModel
 import com.tangem.features.feed.model.feed.FeedModelClickIntents
 import com.tangem.features.feed.ui.feed.FeedList

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/feed/FeedBottomSheetRoute.kt

@@ -2,7 +2,7 @@ package com.tangem.features.feed.components.feed
 
 import com.tangem.features.feed.components.earn.EarnNetworkFilterComponent
 import com.tangem.features.feed.components.earn.EarnTypeFilterComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioPreselectedDataComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioPreselectedDataComponent
 
 internal sealed interface FeedBottomSheetRoute {
 

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/AddToPortfolioSlotRoute.kt

@@ -0,0 +1,7 @@
+package com.tangem.features.feed.components.market.details
+
+import com.tangem.core.decompose.navigation.Route
+import kotlinx.serialization.Serializable
+
+@Serializable
+internal data object AddToPortfolioSlotRoute : Route

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/DefaultMarketsTokenDetailsComponent.kt

@@ -16,15 +16,20 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.vectorResource
 import androidx.lifecycle.compose.LifecycleStartEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.arkivanov.decompose.ComponentContext
+import com.arkivanov.decompose.extensions.compose.subscribeAsState
+import com.arkivanov.decompose.router.slot.childSlot
 import com.tangem.blockchainsdk.compatibility.getTokenIdIfL2Network
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.decompose.context.AppComponentContext
 import com.tangem.core.decompose.context.child
+import com.tangem.core.decompose.context.childByContext
 import com.tangem.core.decompose.model.getOrCreateModel
 import com.tangem.core.ui.DesignFeatureToggles
 import com.tangem.core.ui.R
 import com.tangem.core.ui.components.bottomsheets.state.BottomSheetState
 import com.tangem.core.ui.components.haze.hazeEffectTangem
+import com.tangem.core.ui.decompose.ComposableBottomSheetComponent
 import com.tangem.core.ui.decompose.ComposableModularBottomSheetContentComponent
 import com.tangem.core.ui.ds.topbar.TangemTopBar
 import com.tangem.core.ui.ds.topbar.TangemTopBarType
@@ -33,10 +38,13 @@ import com.tangem.core.ui.res.LocalMainBottomSheetColor
 import com.tangem.core.ui.res.LocalRedesignEnabled
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.domain.appcurrency.model.AppCurrency
+import com.tangem.domain.markets.PreselectedTokenDetailsSection
 import com.tangem.domain.markets.TokenMarketParams
 import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioComponent
 import com.tangem.features.feed.components.market.details.portfolio.api.MarketsPortfolioComponent
 import com.tangem.features.feed.components.market.details.portfolioblock.PortfolioBlockComponent
+import com.tangem.features.feed.components.market.details.portfolioblock.PortfolioBlockParentClickIntents
 import com.tangem.features.feed.model.market.details.MarketsTokenDetailsModel
 import com.tangem.features.feed.model.market.details.analytics.MarketDetailsAnalyticsEvent
 import com.tangem.features.feed.model.market.details.state.TokenNetworksState
@@ -47,13 +55,15 @@ import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
 import kotlinx.serialization.Serializable
 
+@Suppress("LongParameterList")
 internal class DefaultMarketsTokenDetailsComponent(
     appComponentContext: AppComponentContext,
-    val params: Params,
     analyticsEventHandler: AnalyticsEventHandler,
     designFeatureToggles: DesignFeatureToggles,
     portfolioComponentFactory: MarketsPortfolioComponent.Factory,
     portfolioBlockComponentFactory: PortfolioBlockComponent.Factory,
+    val params: Params,
+    private val addToPortfolioComponentFactory: AddToPortfolioComponent.Factory,
 ) : ComposableModularBottomSheetContentComponent, AppComponentContext by appComponentContext {
 
     // applying l2 compatibility
@@ -82,12 +92,28 @@ internal class DefaultMarketsTokenDetailsComponent(
         if (updatedParams.shouldShowPortfolio && designFeatureToggles.isRedesignEnabled) {
             portfolioBlockComponentFactory.create(
                 context = child("portfolio_block"),
-                params = PortfolioBlockComponent.Params(updatedParams.token),
+                params = PortfolioBlockComponent.Params(token = updatedParams.token),
+                parentRouter = object : PortfolioBlockParentClickIntents {
+                    override fun openAddToPortfolioDirect() {
+                        model.openAddToPortfolio()
+                    }
+
+                    override fun openAddToPortfolioViaUserPortfolio(rawCurrencyId: CryptoCurrency.RawID) {
+                        model.openAddToPortfolioViaUserPortfolio()
+                    }
+                },
             )
         } else {
             null
         }
 
+    private val addToPortfolioSlot = childSlot(
+        source = model.addToPortfolioSheetNavigation,
+        serializer = AddToPortfolioSlotRoute.serializer(),
+        handleBackButton = false,
+        childFactory = ::addToPortfolioChild,
+    )
+
     init {
         componentScope.launch(dispatchers.default) {
             model.networksState.collectLatest { state ->
@@ -119,6 +145,16 @@ internal class DefaultMarketsTokenDetailsComponent(
         }
     }
 
+    private fun addToPortfolioChild(
+        @Suppress("UNUSED_PARAMETER") config: AddToPortfolioSlotRoute,
+        componentContext: ComponentContext,
+    ): ComposableBottomSheetComponent {
+        return addToPortfolioComponentFactory.create(
+            context = childByContext(componentContext),
+            params = AddToPortfolioComponent.Params(addToPortfolioManager = model.addToPortfolioManager),
+        )
+    }
+
     @Composable
     override fun Title(bottomSheetState: State<BottomSheetState>) {
         val state by model.state.collectAsStateWithLifecycle()
@@ -197,6 +233,7 @@ internal class DefaultMarketsTokenDetailsComponent(
             }
         }
         val state by model.state.collectAsStateWithLifecycle()
+        val bottomSheet by addToPortfolioSlot.subscribeAsState()
         val bsState by bottomSheetState
         LaunchedEffect(bsState) {
             model.isVisibleOnScreen.value = bsState == BottomSheetState.EXPANDED
@@ -218,6 +255,7 @@ internal class DefaultMarketsTokenDetailsComponent(
                 }
             },
         )
+        bottomSheet.child?.instance?.BottomSheet()
     }
 
     @Serializable
@@ -228,6 +266,9 @@ internal class DefaultMarketsTokenDetailsComponent(
         val analyticsParams: AnalyticsParams?,
         val onBackClicked: () -> Unit,
         val onArticleClick: (articleId: Int, preselectedArticlesId: List<Int>) -> Unit,
+        val preselectedSection: PreselectedTokenDetailsSection? = null,
+        val shouldOpenExchanges: Boolean = false,
+        val exchangesCount: Int? = null,
     )
 
     @Serializable

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/add/impl/di/AddToPortfolioComponentModule.kt

@@ -1,28 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.di
-
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioManager
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioPreselectedDataComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.DefaultAddToPortfolioComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.DefaultAddToPortfolioPreselectedDataComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.DefaultAddToPortfolioManager
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-
-@Module
-@InstallIn(SingletonComponent::class)
-internal interface AddToPortfolioComponentModule {
-
-    @Binds
-    fun bindAddToPortfolioComponent(factory: DefaultAddToPortfolioComponent.Factory): AddToPortfolioComponent.Factory
-
-    @Binds
-    fun bindAddToPortfolioManagerFactory(factory: DefaultAddToPortfolioManager.Factory): AddToPortfolioManager.Factory
-
-    @Binds
-    fun bindAddToPortfolioPreselectedDataComponent(
-        factory: DefaultAddToPortfolioPreselectedDataComponent.Factory,
-    ): AddToPortfolioPreselectedDataComponent.Factory
-}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/add/impl/model/TokenActionsUiBuilder.kt

@@ -1,44 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.model
-
-import com.tangem.core.analytics.api.AnalyticsEventHandler
-import com.tangem.core.decompose.di.ModelScoped
-import com.tangem.core.decompose.model.ParamsContainer
-import com.tangem.core.ui.components.currency.icon.converter.CryptoCurrencyToIconStateConverter
-import com.tangem.core.ui.components.token.state.TokenItemState
-import com.tangem.core.ui.extensions.stringReference
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.TokenActionsComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.state.TokenActionsUM
-import com.tangem.features.feed.components.market.details.portfolio.impl.loader.PortfolioData
-import com.tangem.features.feed.components.market.details.portfolio.impl.model.PortfolioTokenUMConverter
-import com.tangem.features.feed.components.market.details.portfolio.impl.model.TokenActionsHandler
-import javax.inject.Inject
-
-@ModelScoped
-internal class TokenActionsUiBuilder @Inject constructor(
-    paramsContainer: ParamsContainer,
-    private val analyticsEventHandler: AnalyticsEventHandler,
-) {
-    private val params = paramsContainer.require<TokenActionsComponent.Params>()
-
-    fun build(data: PortfolioData.CryptoCurrencyData, tokenActionsHandler: TokenActionsHandler): TokenActionsUM {
-        val status = data.status
-        val tokenUM = TokenItemState.Content(
-            id = status.currency.id.value,
-            iconState = CryptoCurrencyToIconStateConverter().convert(status.currency),
-            titleState = TokenItemState.TitleState.Content(stringReference(status.currency.name)),
-            fiatAmountState = null,
-            subtitle2State = null,
-            subtitleState = TokenItemState.SubtitleState.TextContent(stringReference(status.currency.symbol)),
-            onItemClick = null,
-            onItemLongClick = null,
-        )
-        return TokenActionsUM(
-            token = tokenUM,
-            onLaterClick = {
-                analyticsEventHandler.send(params.eventBuilder.getTokenLater())
-                params.callbacks.onLaterClick()
-            },
-            quickActions = PortfolioTokenUMConverter.quickActions(data, tokenActionsHandler),
-        )
-    }
-}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/add/impl/ui/ChooseNetworkContent.kt

@@ -1,110 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.ui
-
-import android.content.res.Configuration
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.key
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.tooling.preview.PreviewParameter
-import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import androidx.compose.ui.util.fastForEachIndexed
-import com.tangem.core.ui.components.label.Label
-import com.tangem.core.ui.components.label.entity.LabelStyle
-import com.tangem.core.ui.components.label.entity.LabelUM
-import com.tangem.core.ui.components.rows.BlockchainRow
-import com.tangem.core.ui.components.rows.model.BlockchainRowUM
-import com.tangem.core.ui.extensions.resourceReference
-import com.tangem.core.ui.res.TangemTheme
-import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.state.ChooseNetworkUM
-import com.tangem.features.feed.impl.R
-import kotlinx.collections.immutable.persistentListOf
-import java.util.UUID
-
-private const val DISABLED_ALPHA = 0.4f
-
-@Composable
-internal fun ChooseNetworkContent(state: ChooseNetworkUM, modifier: Modifier = Modifier) {
-    Column(
-        modifier = modifier
-            .fillMaxWidth()
-            .clip(RoundedCornerShape(TangemTheme.dimens.radius14))
-            .background(TangemTheme.colors.background.action),
-    ) {
-        state.networks.fastForEachIndexed { index, model ->
-            key(model.id) {
-                BlockchainRow(
-                    model = model,
-                    itemPadding = PaddingValues(
-                        horizontal = TangemTheme.dimens.spacing12,
-                        vertical = TangemTheme.dimens.spacing14,
-                    ),
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .clickable(enabled = model.isEnabled, onClick = { state.onNetworkClick(model) }),
-                ) {
-                    if (!model.isEnabled) {
-                        Label(
-                            modifier = Modifier.alpha(DISABLED_ALPHA),
-                            state = LabelUM(
-                                text = resourceReference(R.string.common_added),
-                                style = LabelStyle.REGULAR,
-                            ),
-                        )
-                    }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-@Preview(showBackground = true, widthDp = 360)
-@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
-private fun Preview(@PreviewParameter(ChooseNetworkContentProvider::class) content: ChooseNetworkUM) {
-    TangemThemePreview {
-        ChooseNetworkContent(
-            state = content,
-        )
-    }
-}
-
-internal class ChooseNetworkContentProvider : PreviewParameterProvider<ChooseNetworkUM> {
-
-    private val blockchainRow = BlockchainRowUM(
-        id = UUID.randomUUID().toString(),
-        name = "Etherium 3",
-        type = "TEST",
-        iconResId = R.drawable.img_eth_22,
-        isMainNetwork = false,
-        isSelected = true,
-        isEnabled = true,
-    )
-
-    override val values: Sequence<ChooseNetworkUM>
-        get() = sequenceOf(
-            ChooseNetworkUM(
-                onNetworkClick = {},
-                networks = persistentListOf(
-                    blockchainRow.copy(
-                        type = "MAIN",
-                        isMainNetwork = true,
-                    ),
-                    blockchainRow.copy(
-                        iconResId = R.drawable.ic_bsc_16,
-                        isEnabled = false,
-                    ),
-                    blockchainRow.copy(iconResId = R.drawable.img_polygon_22),
-                    blockchainRow.copy(iconResId = R.drawable.img_optimism_22),
-                ),
-            ),
-        )
-}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/add/impl/ui/DefaultAddToPortfolioManager.kt

@@ -1,71 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.ui
-
-import com.tangem.domain.markets.TokenMarketInfo
-import com.tangem.domain.markets.TokenMarketParams
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioManager
-import com.tangem.features.feed.components.market.details.portfolio.add.impl.converter.AvailableToAddDataConverter
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.channels.BufferOverflow
-import kotlinx.coroutines.flow.*
-
-internal class DefaultAddToPortfolioManager @AssistedInject constructor(
-    private val availableToAddDataConverter: AvailableToAddDataConverter,
-    @Assisted override val token: TokenMarketParams,
-    @Assisted override val analyticsParams: AddToPortfolioManager.AnalyticsParams?,
-    @Assisted val scope: CoroutineScope,
-    dispatchers: CoroutineDispatcherProvider,
-    portfolioFetcherFactory: PortfolioFetcher.Factory,
-) : AddToPortfolioManager {
-
-    private val _allAvailableNetworks = MutableSharedFlow<List<TokenMarketInfo.Network>>(
-        replay = 1,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST,
-    )
-
-    override val allAvailableNetworks: Flow<List<TokenMarketInfo.Network>> = _allAvailableNetworks.asSharedFlow()
-    override val portfolioFetcher: PortfolioFetcher = portfolioFetcherFactory.create(
-        mode = PortfolioFetcher.Mode.All(isOnlyMultiCurrency = true),
-        scope = scope,
-    )
-
-    override val state: StateFlow<AddToPortfolioManager.State> =
-        combine(
-            flow = portfolioFetcher.data.map { it.balances }.distinctUntilChanged(),
-            flow2 = allAvailableNetworks.map { it.toSet() }.distinctUntilChanged(),
-        ) { balances, availableNetworks ->
-            val data = availableToAddDataConverter.convert(
-                balances = balances,
-                availableNetworks = availableNetworks,
-                marketParams = token,
-            )
-            if (data.isAvailableToAdd) {
-                AddToPortfolioManager.State.AvailableToAdd(data)
-            } else {
-                AddToPortfolioManager.State.NothingToAdd
-            }
-        }
-            .flowOn(dispatchers.default)
-            .stateIn(
-                scope = scope,
-                started = SharingStarted.Eagerly,
-                initialValue = AddToPortfolioManager.State.Init,
-            )
-
-    override fun setTokenNetworks(networks: List<TokenMarketInfo.Network>) {
-        _allAvailableNetworks.tryEmit(networks)
-    }
-
-    @AssistedFactory
-    interface Factory : AddToPortfolioManager.Factory {
-        override fun create(
-            scope: CoroutineScope,
-            token: TokenMarketParams,
-            analyticsParams: AddToPortfolioManager.AnalyticsParams?,
-        ): DefaultAddToPortfolioManager
-    }
-}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/add/impl/ui/state/TokenActionsUM.kt

@@ -1,10 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.ui.state
-
-import com.tangem.core.ui.components.token.state.TokenItemState
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.PortfolioTokenUM
-
-internal data class TokenActionsUM(
-    val token: TokenItemState,
-    val quickActions: PortfolioTokenUM.QuickActions,
-    val onLaterClick: () -> Unit,
-)

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/DefaultMarketsPortfolioComponent.kt

@@ -14,7 +14,7 @@ import com.tangem.core.decompose.context.childByContext
 import com.tangem.core.decompose.model.getOrCreateModel
 import com.tangem.core.ui.decompose.ComposableBottomSheetComponent
 import com.tangem.domain.markets.TokenMarketInfo
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioComponent
 import com.tangem.features.feed.components.market.details.portfolio.api.MarketsPortfolioComponent
 import com.tangem.features.feed.components.market.details.portfolio.impl.model.MarketsPortfolioModel
 import com.tangem.features.feed.components.market.details.portfolio.impl.model.MarketsPortfolioRoute
@@ -66,7 +66,6 @@ internal class DefaultMarketsPortfolioComponent @AssistedInject constructor(
             context = childByContext(componentContext),
             params = AddToPortfolioComponent.Params(
                 addToPortfolioManager = model.addToPortfolioManager,
-                callback = model.addToPortfolioCallback,
             ),
         )
         is MarketsPortfolioRoute.TokenReceive -> tokenReceiveComponentFactory.create(

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/analytics/PortfolioAnalyticsEvent.kt

@@ -1,7 +1,7 @@
 package com.tangem.features.feed.components.market.details.portfolio.impl.analytics
 
+import com.tangem.common.ui.markets.action.TokenActionsBSContentUM
 import com.tangem.core.analytics.models.AnalyticsEvent
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.TokenActionsBSContentUM
 
 internal class PortfolioAnalyticsEvent(
     event: String,
@@ -21,60 +21,6 @@ internal class PortfolioAnalyticsEvent(
             },
         )
 
-        fun popupToChooseAccount() = PortfolioAnalyticsEvent(
-            event = "Choose Account Opened",
-            params = buildMap {
-                if (source != null) put("Source", source)
-            },
-        )
-
-        fun popupToConfirm() = PortfolioAnalyticsEvent(
-            event = "Add Token Screen Opened",
-            params = buildMap {
-                if (source != null) put("Source", source)
-            },
-        )
-
-        fun addToNotMainAccount() = PortfolioAnalyticsEvent(
-            event = "Button - Add To Account",
-            params = buildMap {
-                if (source != null) put("Source", source)
-            },
-        )
-
-        fun addButtonClick() = PortfolioAnalyticsEvent(
-            event = "Button - Add Token",
-            params = buildMap {
-                if (source != null) put("Source", source)
-            },
-        )
-
-        fun addToPortfolioWalletChanged() = PortfolioAnalyticsEvent(
-            event = "Wallet Selected",
-            params = buildMap {
-                if (source != null) put("Source", source)
-            },
-        )
-
-        fun addToPortfolioContinue(blockchainNames: List<String>) = PortfolioAnalyticsEvent(
-            event = "Token Network Selected",
-            params = buildMap {
-                put("Count", blockchainNames.size.toString())
-                put("Token", tokenSymbol)
-                put("blockchain", blockchainNames.joinToString(separator = ", "))
-                if (source != null) put("Source", source)
-            },
-        )
-
-        fun tokenAdded(blockchainName: String) = PortfolioAnalyticsEvent(
-            event = "Token Added",
-            params = buildMap {
-                put("Token", tokenSymbol)
-                put("Blockchain", blockchainName)
-                if (source != null) put("Source", source)
-            },
-        )
-
         fun quickActionClick(actionUM: TokenActionsBSContentUM.Action, blockchainName: String) =
             PortfolioAnalyticsEvent(
                 event = when (actionUM) {
@@ -91,25 +37,5 @@ internal class PortfolioAnalyticsEvent(
                     put("blockchain", blockchainName)
                 },
             )
-
-        fun getTokenActionClick(actionUM: TokenActionsBSContentUM.Action) = PortfolioAnalyticsEvent(
-            event = when (actionUM) {
-                TokenActionsBSContentUM.Action.Buy -> "Popup Get token - Button Buy"
-                TokenActionsBSContentUM.Action.Receive -> "Popup Get token - Button Receive"
-                TokenActionsBSContentUM.Action.Exchange -> "Popup Get token - Button Exchange"
-                TokenActionsBSContentUM.Action.Stake -> "Popup Get token - Button Stake"
-                else -> "error"
-            },
-            params = buildMap {
-                if (source != null) put("Source", source)
-            },
-        )
-
-        fun getTokenLater() = PortfolioAnalyticsEvent(
-            event = "Popup Get token - Button Later",
-            params = buildMap {
-                if (source != null) put("Source", source)
-            },
-        )
     }
 }

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/loader/PortfolioData.kt

@@ -1,33 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.impl.loader
-
-import com.tangem.domain.appcurrency.model.AppCurrency
-import com.tangem.domain.core.lce.Lce
-import com.tangem.domain.models.TotalFiatBalance
-import com.tangem.domain.models.currency.CryptoCurrencyStatus
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.tokens.error.TokenListError
-import com.tangem.domain.tokens.model.TokenActionsState
-
-/**
- * Portfolio data. Combined data from all flows that required to setup portfolio
- *
- * @property walletsWithCurrencies wallets with crypto currency statuses
- * @property appCurrency                 app currency
- * @property isBalanceHidden             flag that indicates if balance should be hidden
- * @property walletsWithBalance          wallets with total balance
- *
-[REDACTED_AUTHOR]
- */
-internal data class PortfolioData(
-    val walletsWithCurrencies: Map<UserWallet, List<CryptoCurrencyData>>,
-    val appCurrency: AppCurrency,
-    val isBalanceHidden: Boolean,
-    val walletsWithBalance: Map<UserWalletId, Lce<TokenListError, TotalFiatBalance>>,
-) {
-    data class CryptoCurrencyData(
-        val userWallet: UserWallet,
-        val status: CryptoCurrencyStatus,
-        val actions: List<TokenActionsState.ActionState>,
-    )
-}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/model/MarketsPortfolioDelegate.kt

@@ -5,6 +5,9 @@ import com.tangem.blockchainsdk.compatibility.getTokenIdIfL2Network
 import com.tangem.common.ui.account.AccountTitleUM
 import com.tangem.common.ui.account.CryptoPortfolioIconConverter
 import com.tangem.common.ui.account.toUM
+import com.tangem.common.ui.markets.action.CryptoCurrencyData
+import com.tangem.common.ui.markets.action.TokenActionsHandler
+import com.tangem.core.ui.DesignFeatureToggles
 import com.tangem.core.ui.extensions.TextReference
 import com.tangem.core.ui.extensions.stringReference
 import com.tangem.domain.account.models.AccountStatusList
@@ -28,7 +31,6 @@ import com.tangem.domain.tokens.model.TokenActionsState
 import com.tangem.domain.wallets.usecase.GetUserWalletUseCase
 import com.tangem.domain.yield.supply.models.YieldSupplyAvailability
 import com.tangem.domain.yield.supply.usecase.YieldSupplyGetAvailabilityUseCase
-import com.tangem.features.feed.components.market.details.portfolio.impl.loader.PortfolioData
 import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.MyPortfolioUM
 import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.PortfolioHeader
 import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.PortfolioListItem
@@ -52,6 +54,7 @@ internal class MarketsPortfolioDelegate @AssistedInject constructor(
     private val getCryptoCurrencyActionsUseCase: GetCryptoCurrencyActionsUseCaseV2,
     private val getUserWalletUseCase: GetUserWalletUseCase,
     private val yieldSupplyGetAvailabilityUseCase: YieldSupplyGetAvailabilityUseCase,
+    private val designFeatureToggles: DesignFeatureToggles,
     isAccountsModeEnabledUseCase: IsAccountsModeEnabledUseCase,
     @Assisted private val scope: CoroutineScope,
     @Assisted private val token: TokenMarketParams,
@@ -228,6 +231,7 @@ internal class MarketsPortfolioDelegate @AssistedInject constructor(
             isBalanceHidden = isBalanceHidden,
             onTokenItemClick = { },
             tokenActionsHandler = tokenActionsHandler,
+            isRedesignEnabled = designFeatureToggles.isRedesignEnabled,
         )
 
         portfolio.portfolios.forEach { portfolioItem ->
@@ -248,10 +252,12 @@ internal class MarketsPortfolioDelegate @AssistedInject constructor(
 
                 accountWithAdded.addedCurrency.forEach { currencyStatus ->
                     val actions = allActions[currencyStatus.currency]?.states.orEmpty()
-                    val value = PortfolioData.CryptoCurrencyData(
+                    val value = CryptoCurrencyData(
                         userWallet = userWallet,
                         status = currencyStatus,
                         actions = actions,
+                        isAccountMode = isAccountMode,
+                        account = accountWithAdded.accountStatus,
                     )
                     val expandedKey = portfolioItem.userWallet.walletId to currencyStatus.currency.id
                     val isExpand = expanded.contains(expandedKey)

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/model/MarketsPortfolioModel.kt

@@ -5,6 +5,8 @@ import arrow.core.getOrElse
 import com.arkivanov.decompose.router.slot.SlotNavigation
 import com.arkivanov.decompose.router.slot.activate
 import com.arkivanov.decompose.router.slot.dismiss
+import com.tangem.common.ui.markets.action.TokenActionsBSContentUM
+import com.tangem.common.ui.markets.action.TokenActionsHandler
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.Model
@@ -12,14 +14,11 @@ import com.tangem.core.decompose.model.ParamsContainer
 import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.markets.TokenMarketInfo
-import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.transaction.usecase.ReceiveAddressesFactory
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioManager
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager
 import com.tangem.features.feed.components.market.details.portfolio.api.MarketsPortfolioComponent
 import com.tangem.features.feed.components.market.details.portfolio.impl.analytics.PortfolioAnalyticsEvent
 import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.MyPortfolioUM
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.TokenActionsBSContentUM
 import com.tangem.utils.Provider
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.coroutines.flow.*
@@ -57,16 +56,18 @@ internal class MarketsPortfolioModel @Inject constructor(
     private val marketsPortfolioDelegate: MarketsPortfolioDelegate = createMarketsPortfolioDelegate()
 
     val bottomSheetNavigation: SlotNavigation<MarketsPortfolioRoute> = SlotNavigation()
-    val addToPortfolioCallback = object : AddToPortfolioComponent.Callback {
-        override fun onDismiss() = bottomSheetNavigation.dismiss()
-        override fun onSuccess(addedToken: CryptoCurrency) = bottomSheetNavigation.dismiss()
-    }
 
     init {
         marketsPortfolioDelegate.combineData()
             .onEach { state.value = it }
             .flowOn(dispatchers.default)
             .launchIn(modelScope)
+        addToPortfolioManager.onDismiss.receiveAsFlow()
+            .onEach { bottomSheetNavigation.dismiss() }
+            .launchIn(modelScope)
+        addToPortfolioManager.onSuccessAdded.receiveAsFlow()
+            .onEach { bottomSheetNavigation.dismiss() }
+            .launchIn(modelScope)
     }
 
     fun setTokenNetworks(networks: List<TokenMarketInfo.Network>) {
@@ -82,9 +83,9 @@ internal class MarketsPortfolioModel @Inject constructor(
     private fun createAddToPortfolioManager(): AddToPortfolioManager {
         return addToPortfolioManagerFactory.create(
             scope = modelScope,
-            token = params.token,
-            analyticsParams = params.analyticsParams?.source?.let { AddToPortfolioManager.AnalyticsParams(it) },
-        )
+            settings = AddToPortfolioManager.Settings.DefaultMarket,
+            analyticsParams = AddToPortfolioManager.AnalyticsParams(params.analyticsParams?.source),
+        ).also { addToPortfolioManager -> addToPortfolioManager.setTokenParams(params.token) }
     }
 
     private fun createMarketsPortfolioDelegate(): MarketsPortfolioDelegate {
@@ -94,11 +95,14 @@ internal class MarketsPortfolioModel @Inject constructor(
             tokenActionsHandler = tokenActionsHandler,
             buttonState = addToPortfolioManager.state.map { state ->
                 when (state) {
-                    is AddToPortfolioManager.State.AvailableToAdd -> {
-                        MyPortfolioUM.Tokens.AddButtonState.Available
+                    is AddToPortfolioManager.State.Ready -> {
+                        if (state.isAvailableToAdd) {
+                            MyPortfolioUM.Tokens.AddButtonState.Available
+                        } else {
+                            MyPortfolioUM.Tokens.AddButtonState.Unavailable
+                        }
                     }
-                    AddToPortfolioManager.State.Init -> MyPortfolioUM.Tokens.AddButtonState.Loading
-                    AddToPortfolioManager.State.NothingToAdd -> MyPortfolioUM.Tokens.AddButtonState.Unavailable
+                    AddToPortfolioManager.State.Loading -> MyPortfolioUM.Tokens.AddButtonState.Loading
                 }
             },
             onAddClick = {

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/model/PortfolioTokenUMConverter.kt

@@ -1,19 +1,16 @@
 package com.tangem.features.feed.components.market.details.portfolio.impl.model
 
+import com.tangem.common.ui.markets.action.CryptoCurrencyData
+import com.tangem.common.ui.markets.action.QuickActionsConverter.quickActions
+import com.tangem.common.ui.markets.action.TokenActionsHandler
 import com.tangem.common.ui.tokens.TokenItemStateConverter
 import com.tangem.core.ui.components.token.state.TokenItemState
 import com.tangem.core.ui.extensions.stringReference
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.models.currency.CryptoCurrencyStatus
 import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.tokens.model.ScenarioUnavailabilityReason
-import com.tangem.domain.tokens.model.TokenActionsState
-import com.tangem.features.feed.components.market.details.portfolio.impl.loader.PortfolioData
 import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.PortfolioTokenUM
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.QuickActionUM
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.TokenActionsBSContentUM
 import com.tangem.utils.converter.Converter
-import kotlinx.collections.immutable.toImmutableList
 
 /**
  * Converter from [UserWallet] and [CryptoCurrencyStatus] to [PortfolioTokenUM]
@@ -25,10 +22,11 @@ internal class PortfolioTokenUMConverter(
     private val isBalanceHidden: Boolean,
     private val onTokenItemClick: (CryptoCurrencyStatus) -> Unit,
     private val tokenActionsHandler: TokenActionsHandler,
-) : Converter<PortfolioData.CryptoCurrencyData, PortfolioTokenUM> {
+    private val isRedesignEnabled: Boolean,
+) : Converter<CryptoCurrencyData, PortfolioTokenUM> {
 
     fun convertV2(
-        value: PortfolioData.CryptoCurrencyData,
+        value: CryptoCurrencyData,
         isQuickActionsShown: Boolean,
         onTokenItemClick: (UserWallet, CryptoCurrencyStatus) -> Unit,
     ): PortfolioTokenUM {
@@ -41,11 +39,15 @@ internal class PortfolioTokenUMConverter(
             walletId = value.userWallet.walletId,
             isBalanceHidden = isBalanceHidden,
             isQuickActionsShown = isQuickActionsShown,
-            quickActions = quickActions(cryptoData = value, tokenActionsHandler = tokenActionsHandler),
+            quickActions = quickActions(
+                cryptoData = value,
+                tokenActionsHandler = tokenActionsHandler,
+                isRedesignEnabled = isRedesignEnabled,
+            ),
         )
     }
 
-    override fun convert(value: PortfolioData.CryptoCurrencyData): PortfolioTokenUM {
+    override fun convert(value: CryptoCurrencyData): PortfolioTokenUM {
         val tokenItemStateConverter = TokenItemStateConverter(
             appCurrency = appCurrency,
             titleStateProvider = { TokenItemState.TitleState.Content(text = stringReference(value.userWallet.name)) },
@@ -60,65 +62,11 @@ internal class PortfolioTokenUMConverter(
             walletId = value.userWallet.walletId,
             isBalanceHidden = isBalanceHidden,
             isQuickActionsShown = false,
-            quickActions = quickActions(cryptoData = value, tokenActionsHandler = tokenActionsHandler),
+            quickActions = quickActions(
+                cryptoData = value,
+                tokenActionsHandler = tokenActionsHandler,
+                isRedesignEnabled = isRedesignEnabled,
+            ),
         )
     }
-
-    companion object {
-        fun quickActions(
-            cryptoData: PortfolioData.CryptoCurrencyData,
-            tokenActionsHandler: TokenActionsHandler,
-        ): PortfolioTokenUM.QuickActions {
-            return PortfolioTokenUM.QuickActions(
-                actions = toQuickActions(cryptoData.actions),
-                onQuickActionClick = { quickActionUM ->
-                    when (quickActionUM) {
-                        QuickActionUM.Buy -> tokenActionsHandler.handle(
-                            action = TokenActionsBSContentUM.Action.Buy,
-                            cryptoCurrencyData = cryptoData,
-                        )
-                        is QuickActionUM.Exchange -> tokenActionsHandler.handle(
-                            action = TokenActionsBSContentUM.Action.Exchange,
-                            cryptoCurrencyData = cryptoData,
-                        )
-                        QuickActionUM.Receive -> tokenActionsHandler.handle(
-                            action = TokenActionsBSContentUM.Action.Receive,
-                            cryptoCurrencyData = cryptoData,
-                        )
-                        QuickActionUM.Stake -> tokenActionsHandler.handle(
-                            action = TokenActionsBSContentUM.Action.Stake,
-                            cryptoCurrencyData = cryptoData,
-                        )
-                        is QuickActionUM.YieldMode -> tokenActionsHandler.handle(
-                            action = TokenActionsBSContentUM.Action.YieldMode,
-                            cryptoCurrencyData = cryptoData,
-                        )
-                    }
-                },
-                onQuickActionLongClick = { actionUM ->
-                    if (actionUM == QuickActionUM.Receive) {
-                        tokenActionsHandler.handle(
-                            action = TokenActionsBSContentUM.Action.CopyAddress,
-                            cryptoCurrencyData = cryptoData,
-                        )
-                    }
-                },
-            )
-        }
-
-        fun toQuickActions(actions: List<TokenActionsState.ActionState>) = buildList {
-            actions.forEach { action ->
-                if (action.unavailabilityReason == ScenarioUnavailabilityReason.None) {
-                    when (action) {
-                        is TokenActionsState.ActionState.Buy -> QuickActionUM.Buy
-                        is TokenActionsState.ActionState.Swap -> QuickActionUM.Exchange(action.shouldShowBadge)
-                        is TokenActionsState.ActionState.Receive -> QuickActionUM.Receive
-                        is TokenActionsState.ActionState.Stake -> QuickActionUM.Stake
-                        is TokenActionsState.ActionState.YieldMode -> QuickActionUM.YieldMode(action.apy)
-                        else -> null
-                    }?.let(::add)
-                }
-            }
-        }.toImmutableList()
-    }
 }

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/model/TokenActionsHandler.kt

@@ -1,178 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.impl.model
-
-import com.tangem.common.routing.AppRoute
-import com.tangem.common.ui.bottomsheet.receive.mapToAddressModels
-import com.tangem.core.analytics.api.AnalyticsEventHandler
-import com.tangem.core.analytics.models.AnalyticsParam
-import com.tangem.core.analytics.models.event.OfframpAnalyticsEvent
-import com.tangem.core.decompose.navigation.Router
-import com.tangem.core.decompose.ui.UiMessageSender
-import com.tangem.core.navigation.url.UrlOpener
-import com.tangem.core.ui.clipboard.ClipboardManager
-import com.tangem.core.ui.extensions.resourceReference
-import com.tangem.core.ui.message.DialogMessage
-import com.tangem.core.ui.message.SnackbarMessage
-import com.tangem.domain.appcurrency.model.AppCurrency
-import com.tangem.domain.demo.IsDemoCardUseCase
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.offramp.GetOfframpUrlUseCase
-import com.tangem.domain.onramp.model.OnrampSource
-import com.tangem.domain.tokens.model.TokenActionsState
-import com.tangem.features.feed.components.market.details.portfolio.impl.loader.PortfolioData
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.TokenActionsBSContentUM
-import com.tangem.features.feed.impl.R
-import com.tangem.utils.Provider
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-import kotlinx.collections.immutable.toImmutableList
-
-@Suppress("LongParameterList")
-internal class TokenActionsHandler @AssistedInject constructor(
-    private val router: Router,
-    private val clipboardManager: ClipboardManager,
-    private val uiMessageSender: UiMessageSender,
-    private val getOfframpUrlUseCase: GetOfframpUrlUseCase,
-    private val urlOpener: UrlOpener,
-    private val analyticsEventHandler: AnalyticsEventHandler,
-    @Assisted private val currentAppCurrency: Provider<AppCurrency>,
-    @Assisted private val onHandleQuickAction: (HandledQuickAction) -> Unit,
-    private val isDemoCardUseCase: IsDemoCardUseCase,
-    private val messageSender: UiMessageSender,
-) {
-
-    private val disabledActionsInDemoMode = buildSet {
-        add(TokenActionsBSContentUM.Action.Sell)
-    }
-
-    fun handle(action: TokenActionsBSContentUM.Action, cryptoCurrencyData: PortfolioData.CryptoCurrencyData) {
-        onHandleQuickAction(
-            HandledQuickAction(
-                action = action,
-                cryptoCurrencyData = cryptoCurrencyData,
-            ),
-        )
-        val userWallet = cryptoCurrencyData.userWallet
-        if (userWallet is UserWallet.Cold && handleDemoMode(action, userWallet)) return
-
-        when (action) {
-            TokenActionsBSContentUM.Action.Buy -> onBuyClick(cryptoCurrencyData)
-            TokenActionsBSContentUM.Action.Exchange -> onExchangeClick(cryptoCurrencyData)
-            TokenActionsBSContentUM.Action.Receive -> Unit
-            TokenActionsBSContentUM.Action.CopyAddress -> onCopyAddress(cryptoCurrencyData)
-            TokenActionsBSContentUM.Action.Sell -> onSellClick(cryptoCurrencyData)
-            TokenActionsBSContentUM.Action.Send -> onSendClick(cryptoCurrencyData)
-            TokenActionsBSContentUM.Action.Stake -> onStakeClick(cryptoCurrencyData)
-            TokenActionsBSContentUM.Action.YieldMode -> onYieldModeClick(cryptoCurrencyData)
-        }
-    }
-
-    private fun handleDemoMode(action: TokenActionsBSContentUM.Action, userWallet: UserWallet.Cold): Boolean {
-        val isDemoCard = isDemoCardUseCase.invoke(userWallet.cardId)
-        val isNeededShowDemoWarning = isDemoCard && disabledActionsInDemoMode.contains(action)
-
-        if (isNeededShowDemoWarning) {
-            showDemoModeWarning()
-        }
-
-        return isNeededShowDemoWarning
-    }
-
-    private fun showDemoModeWarning() {
-        val message = DialogMessage(
-            message = resourceReference(R.string.alert_demo_feature_disabled),
-        )
-        messageSender.send(message)
-    }
-
-    private fun onCopyAddress(cryptoCurrencyData: PortfolioData.CryptoCurrencyData) {
-        val cryptoCurrencyStatus = cryptoCurrencyData.status
-        val networkAddress = cryptoCurrencyStatus.value.networkAddress ?: return
-        val addresses = networkAddress.availableAddresses
-            .mapToAddressModels(cryptoCurrencyStatus.currency)
-            .toImmutableList()
-        val defaultAddress = addresses.firstOrNull()?.value ?: return
-
-        clipboardManager.setText(text = defaultAddress, isSensitive = true)
-        uiMessageSender.send(SnackbarMessage(resourceReference(R.string.wallet_notification_address_copied)))
-    }
-
-    private fun onBuyClick(cryptoCurrencyData: PortfolioData.CryptoCurrencyData) {
-        router.push(
-            AppRoute.Onramp(
-                userWalletId = cryptoCurrencyData.userWallet.walletId,
-                currency = cryptoCurrencyData.status.currency,
-                source = OnrampSource.MARKETS,
-            ),
-        )
-    }
-
-    private fun onSellClick(cryptoCurrencyData: PortfolioData.CryptoCurrencyData) {
-        getOfframpUrlUseCase(
-            cryptoCurrencyStatus = cryptoCurrencyData.status,
-            appCurrencyCode = currentAppCurrency().code,
-        ).onRight { url ->
-            urlOpener.openUrl(url)
-            analyticsEventHandler.send(OfframpAnalyticsEvent.ScreenOpened)
-        }
-    }
-
-    private fun onExchangeClick(cryptoCurrencyData: PortfolioData.CryptoCurrencyData) {
-        router.push(
-            AppRoute.Swap(
-                currencyFrom = cryptoCurrencyData.status.currency,
-                userWalletId = cryptoCurrencyData.userWallet.walletId,
-                isInitialReverseOrder = true,
-                screenSource = AnalyticsParam.ScreensSources.Markets.value,
-            ),
-        )
-    }
-
-    private fun onSendClick(cryptoCurrencyData: PortfolioData.CryptoCurrencyData) {
-        val route = AppRoute.SendEntryPoint(
-            userWalletId = cryptoCurrencyData.userWallet.walletId,
-            currency = cryptoCurrencyData.status.currency,
-        )
-        router.push(route)
-    }
-
-    private fun onStakeClick(cryptoCurrencyData: PortfolioData.CryptoCurrencyData) {
-        val option = cryptoCurrencyData.actions.firstOrNull { it is TokenActionsState.ActionState.Stake }
-            ?.let { it as TokenActionsState.ActionState.Stake }
-            ?.option ?: return
-
-        router.push(
-            AppRoute.Staking(
-                userWalletId = cryptoCurrencyData.userWallet.walletId,
-                cryptoCurrency = cryptoCurrencyData.status.currency,
-                integrationId = option.integrationId,
-            ),
-        )
-    }
-
-    private fun onYieldModeClick(cryptoCurrencyData: PortfolioData.CryptoCurrencyData) {
-        val yieldSupplyApy = cryptoCurrencyData.actions.filterIsInstance<TokenActionsState.ActionState.YieldMode>()
-            .firstOrNull()?.apy ?: return
-
-        router.push(
-            AppRoute.YieldSupplyEntry(
-                userWalletId = cryptoCurrencyData.userWallet.walletId,
-                cryptoCurrency = cryptoCurrencyData.status.currency,
-                apy = yieldSupplyApy,
-            ),
-        )
-    }
-
-    @AssistedFactory
-    interface Factory {
-        fun create(
-            currentAppCurrency: Provider<AppCurrency>,
-            onHandleQuickAction: (HandledQuickAction) -> Unit,
-        ): TokenActionsHandler
-    }
-
-    data class HandledQuickAction(
-        val action: TokenActionsBSContentUM.Action,
-        val cryptoCurrencyData: PortfolioData.CryptoCurrencyData,
-    )
-}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/ui/PortfolioQuickActions.kt

@@ -28,6 +28,7 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.util.fastForEach
+import com.tangem.common.ui.markets.action.QuickActionUM
 import com.tangem.core.ui.components.SpacerH4
 import com.tangem.core.ui.components.icons.badge.drawBadge
 import com.tangem.core.ui.extensions.resolveReference
@@ -36,7 +37,6 @@ import com.tangem.core.ui.res.LocalHapticManager
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
 import com.tangem.core.ui.test.MarketTokenDetailsBottomSheetTestTags
-import com.tangem.features.feed.components.market.details.portfolio.impl.ui.state.QuickActionUM
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
 
@@ -180,7 +180,7 @@ private fun AnimatedVisibilityScope.QuickActionIcon(state: QuickActionUM) {
             )
             .size(TangemTheme.dimens.size32)
             .semantics {
-                contentDescription = if (state is QuickActionUM.Exchange && state.shouldShowBadge) {
+                contentDescription = if (state is QuickActionUM.V1.Exchange && state.shouldShowBadge) {
                     "Badge shown"
                 } else {
                     "Badge hidden"
@@ -188,7 +188,7 @@ private fun AnimatedVisibilityScope.QuickActionIcon(state: QuickActionUM) {
             }
             .drawWithContent {
                 drawContent()
-                if (state is QuickActionUM.Exchange && state.shouldShowBadge) {
+                if (state is QuickActionUM.V1.Exchange && state.shouldShowBadge) {
                     drawBadge(containerColor = containerColor, offset = 4.dp)
                 }
             },
@@ -229,9 +229,9 @@ private fun Preview() {
             ) {
                 PortfolioQuickActions(
                     actions = persistentListOf(
-                        QuickActionUM.Buy,
-                        QuickActionUM.Exchange(shouldShowBadge = true),
-                        QuickActionUM.Receive,
+                        QuickActionUM.V1.Buy,
+                        QuickActionUM.V1.Exchange(shouldShowBadge = true),
+                        QuickActionUM.V1.Receive,
                     ),
                     isVisible = isVisible,
                     onActionClick = {},
@@ -250,9 +250,9 @@ private fun PreviewRtl() {
         Box(modifier = Modifier.background(color = TangemTheme.colors.background.action)) {
             PortfolioQuickActions(
                 actions = persistentListOf(
-                    QuickActionUM.Buy,
-                    QuickActionUM.Exchange(shouldShowBadge = true),
-                    QuickActionUM.Receive,
+                    QuickActionUM.V1.Buy,
+                    QuickActionUM.V1.Exchange(shouldShowBadge = true),
+                    QuickActionUM.V1.Receive,
                 ),
                 isVisible = true,
                 onActionClick = {},

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/ui/preview/PreviewMyPortfolioUMProvider.kt

@@ -3,6 +3,8 @@ package com.tangem.features.feed.components.market.details.portfolio.impl.ui.pre
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import com.tangem.common.ui.account.AccountIconPreviewData
 import com.tangem.common.ui.account.AccountTitleUM
+import com.tangem.common.ui.markets.action.QuickActionUM
+import com.tangem.common.ui.markets.action.QuickActions
 import com.tangem.core.ui.components.currency.icon.CurrencyIconState
 import com.tangem.core.ui.components.token.state.TokenItemState
 import com.tangem.core.ui.components.token.state.TokenItemState.FiatAmountState
@@ -125,11 +127,11 @@ internal class PreviewMyPortfolioUMProvider : PreviewParameterProvider<MyPortfol
                 onItemLongClick = {},
             ),
             isQuickActionsShown = false,
-            quickActions = PortfolioTokenUM.QuickActions(
+            quickActions = QuickActions(
                 actions = persistentListOf(
-                    QuickActionUM.Buy,
-                    QuickActionUM.Exchange(shouldShowBadge = true),
-                    QuickActionUM.Receive,
+                    QuickActionUM.V1.Buy,
+                    QuickActionUM.V1.Exchange(shouldShowBadge = true),
+                    QuickActionUM.V1.Receive,
                 ),
                 onQuickActionClick = {},
                 onQuickActionLongClick = {},

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/ui/state/PortfolioTokenUM.kt

@@ -2,10 +2,10 @@ package com.tangem.features.feed.components.market.details.portfolio.impl.ui.sta
 
 import androidx.compose.runtime.Immutable
 import com.tangem.common.ui.account.AccountTitleUM
+import com.tangem.common.ui.markets.action.QuickActions
 import com.tangem.core.ui.components.token.state.TokenItemState
 import com.tangem.core.ui.extensions.TextReference
 import com.tangem.domain.models.wallet.UserWalletId
-import kotlinx.collections.immutable.ImmutableList
 
 @Immutable
 internal sealed interface PortfolioListItem {
@@ -30,10 +30,4 @@ internal data class PortfolioTokenUM(
     val quickActions: QuickActions,
 ) : PortfolioListItem {
     override val id: String = tokenItemState.id
-
-    data class QuickActions(
-        val actions: ImmutableList<QuickActionUM>,
-        val onQuickActionClick: (QuickActionUM) -> Unit,
-        val onQuickActionLongClick: (QuickActionUM) -> Unit,
-    )
 }

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/ui/state/QuickActionUM.kt

@@ -1,51 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.impl.ui.state
-
-import androidx.annotation.DrawableRes
-import androidx.compose.runtime.Immutable
-import com.tangem.core.ui.extensions.TextReference
-import com.tangem.core.ui.extensions.resourceReference
-import com.tangem.core.ui.extensions.wrappedList
-import com.tangem.features.feed.impl.R
-
-@Immutable
-internal sealed class QuickActionUM(
-    val title: TextReference,
-    val description: TextReference,
-    @DrawableRes val icon: Int,
-    val isLongClickAvailable: Boolean = false,
-) {
-    data object Buy : QuickActionUM(
-        title = resourceReference(R.string.common_buy),
-        description = resourceReference(R.string.buy_token_description),
-        icon = R.drawable.ic_plus_24,
-    )
-
-    data class Exchange(
-        val shouldShowBadge: Boolean,
-    ) : QuickActionUM(
-        title = resourceReference(R.string.common_exchange),
-        description = resourceReference(R.string.exсhange_token_description),
-        icon = R.drawable.ic_exchange_vertical_24,
-    )
-
-    data object Receive : QuickActionUM(
-        title = resourceReference(R.string.common_receive),
-        description = resourceReference(R.string.receive_token_description),
-        icon = R.drawable.ic_arrow_down_24,
-        isLongClickAvailable = true,
-    )
-
-    data object Stake : QuickActionUM(
-        title = resourceReference(R.string.common_stake),
-        description = resourceReference(R.string.stake_token_description),
-        icon = R.drawable.ic_staking_24,
-    )
-
-    data class YieldMode(
-        private val apy: String,
-    ) : QuickActionUM(
-        title = resourceReference(R.string.common_yield_mode),
-        description = resourceReference(R.string.yield_module_main_screen_promo_banner_message, wrappedList(apy)),
-        icon = R.drawable.ic_analytics_up_mini_24,
-    )
-}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/components/market/details/portfolio/impl/ui/state/TokenActionsBSContentUM.kt

@@ -1,58 +0,0 @@
-package com.tangem.features.feed.components.market.details.portfolio.impl.ui.state
-
-import androidx.annotation.DrawableRes
-import androidx.compose.runtime.Immutable
-import com.tangem.core.ui.components.bottomsheets.TangemBottomSheetConfigContent
-import com.tangem.core.ui.extensions.TextReference
-import com.tangem.core.ui.extensions.resourceReference
-import com.tangem.features.feed.impl.R
-import kotlinx.collections.immutable.ImmutableList
-
-internal data class TokenActionsBSContentUM(
-    val title: String,
-    val actions: ImmutableList<Action>,
-    val onActionClick: (Action) -> Unit,
-) : TangemBottomSheetConfigContent {
-
-    @Immutable
-    enum class Action(
-        val text: TextReference,
-        @DrawableRes val iconRes: Int,
-    ) {
-        CopyAddress(
-            text = resourceReference(R.string.common_copy_address),
-            iconRes = R.drawable.ic_copy_24,
-        ),
-        Send(
-            text = resourceReference(R.string.common_send),
-            iconRes = R.drawable.ic_arrow_up_24,
-        ),
-        Receive(
-            text = resourceReference(R.string.common_receive),
-            iconRes = R.drawable.ic_arrow_down_24,
-        ),
-        Buy(
-            text = resourceReference(R.string.common_buy),
-            iconRes = R.drawable.ic_plus_24,
-        ),
-        Sell(
-            text = resourceReference(R.string.common_sell),
-            iconRes = R.drawable.ic_currency_24,
-        ),
-        Exchange(
-            text = resourceReference(R.string.common_exchange),
-            iconRes = R.drawable.ic_exchange_horizontal_24,
-        ),
-        Stake(
-            text = resourceReference(R.string.common_stake),
-            iconRes = R.drawable.ic_staking_24,
-        ),
-        YieldMode(
-            text = resourceReference(R.string.common_yield_mode),
-            iconRes = R.drawable.ic_analytics_up_mini_24,
-        ),
-        ;
-
-        val order: Int = ordinal
-    }
-}