Updated on 2026-08-14

features/common-features/api/.gitignore

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

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

@@ -0,0 +1,27 @@
+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 {
+    /** Api */ // todo swap delete after move portfolio selector
+    implementation(projects.features.account.api)
+
+    /* Project - Domain */
+    implementation(projects.domain.models)
+    implementation(projects.domain.markets)
+
+    /* 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

@@ -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/AddToPortfolioManager.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.markets.TokenMarketParams

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/impl/.gitignore

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

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

@@ -0,0 +1,81 @@
+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"
+}
+
+dependencies {
+    /** Api */
+    implementation(projects.features.commonFeatures.api)
+    // todo swap delete after move portfolio selector
+    implementation(projects.features.account.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)
+
+    /** 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)
+}

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
@@ -9,6 +9,7 @@ import androidx.compose.foundation.verticalScroll
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
+import com.tangem.features.commonfeatures.impl.R
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.arkivanov.decompose.router.stack.ChildStack
 import com.tangem.core.ui.components.bottomsheets.TangemBottomSheetConfig
@@ -20,8 +21,7 @@ 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.impl.addtoportfolio.model.AddToPortfolioRoutes
 
 @Composable
 internal fun AddToPortfolioBottomSheet(

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/AddTokenComponent.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.ui.Modifier
@@ -9,10 +9,10 @@ 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.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.impl.addtoportfolio.model.AddTokenModel
+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 dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject

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
@@ -12,9 +12,9 @@ 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.impl.addtoportfolio.model.AddToPortfolioModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddToPortfolioRoutes
 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/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
@@ -10,9 +10,9 @@ 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.impl.addtoportfolio.model.AddToPortfolioPreselectedDataModel
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddToPortfolioRoutes
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioPreselectedDataComponent
 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/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,6 +8,7 @@ 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
@@ -15,10 +16,9 @@ import com.tangem.core.decompose.model.getOrCreateModel
 import com.tangem.core.ui.decompose.ComposableBottomSheetComponent
 import com.tangem.core.ui.decompose.ComposableContentComponent
 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.tokenreceive.TokenReceiveComponent
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
@@ -64,7 +64,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,91 @@
+package com.tangem.features.commonfeatures.impl.addtoportfolio.analytics
+
+import com.tangem.common.ui.markets.action.TokenActionsBSContentUM
+import com.tangem.core.analytics.models.AnalyticsEvent
+
+// todo swap unify with EarnAnalyticsEvent, AddToPortfolioFlow
+internal class PortfolioAnalyticsEvent(
+    event: String,
+    params: Map<String, String> = emptyMap(),
+) : AnalyticsEvent(category = "Markets / Chart", event = event, params = params) {
+
+    data class EventBuilder(
+        val tokenSymbol: String,
+        val source: String?,
+    ) {
+
+        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 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/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/converter/AvailableToAddDataConverter.kt

@@ -1,4 +1,4 @@
-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
@@ -13,9 +13,9 @@ 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.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(

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

@@ -1,15 +1,14 @@
-package com.tangem.features.feed.components.market.details.portfolio.impl.model
+package com.tangem.features.commonfeatures.impl.addtoportfolio.converter
 
 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.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 +16,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)
@@ -48,7 +47,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,28 @@
+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 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/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/di/AddToPortfolioModelModule.kt

@@ -1,8 +1,12 @@
-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 dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn

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

@@ -1,9 +1,11 @@
-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.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
@@ -18,14 +20,12 @@ 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.features.commonfeatures.api.addtoportfolio.*
+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.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.logging.TangemLogger
 import kotlinx.coroutines.Job
@@ -61,7 +61,7 @@ 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
@@ -254,7 +254,7 @@ internal class AddToPortfolioModel @Inject constructor(
     private fun setupTokenActionsFlow(
         selectedPortfolio: SelectedPortfolio,
         addedToken: CryptoCurrencyStatus,
-    ): Flow<PortfolioData.CryptoCurrencyData> {
+    ): Flow<CryptoCurrencyData> {
         val timeFlow = channelFlow {
             val timerJob = launch { delay(TOKEN_ACTIONS_DELAY) }
             getCryptoCurrencyActionsUseCase(
@@ -274,7 +274,7 @@ internal class AddToPortfolioModel @Inject constructor(
             }.collect()
         }
         return timeFlow.map { actionsState ->
-            PortfolioData.CryptoCurrencyData(
+            CryptoCurrencyData(
                 userWallet = selectedPortfolio.userWallet,
                 status = actionsState.cryptoCurrencyStatus,
                 actions = actionsState.states,

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
@@ -22,17 +22,19 @@ 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.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.get
+import kotlin.collections.mapNotNull
 
 @Suppress("LongParameterList")
 internal class AddToPortfolioPreselectedDataModel @Inject constructor(
@@ -163,7 +165,7 @@ internal class AddToPortfolioPreselectedDataModel @Inject constructor(
     }
 
     /**
-     * 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

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.impl.addtoportfolio.AddTokenComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.model.AddTokenUiBuilder.Companion.toggleProgress
+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.lib.crypto.BlockchainUtils
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.coroutines.JobHolder

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
@@ -14,10 +14,10 @@ import com.tangem.core.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,7 +1,9 @@
-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
@@ -10,10 +12,8 @@ import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
 import com.tangem.domain.appcurrency.model.AppCurrency
 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

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

@@ -1,16 +1,16 @@
-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.markets.action.CryptoCurrencyData
+import com.tangem.common.ui.markets.action.QuickActionsConverter.quickActions
+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.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 com.tangem.features.commonfeatures.impl.addtoportfolio.TokenActionsComponent
+import com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state.TokenActionsUM
 import javax.inject.Inject
 
 @ModelScoped
@@ -20,7 +20,7 @@ internal class TokenActionsUiBuilder @Inject constructor(
 ) {
     private val params = paramsContainer.require<TokenActionsComponent.Params>()
 
-    fun build(data: PortfolioData.CryptoCurrencyData, tokenActionsHandler: TokenActionsHandler): TokenActionsUM {
+    fun build(data: CryptoCurrencyData, tokenActionsHandler: TokenActionsHandler): TokenActionsUM {
         val status = data.status
         val tokenUM = TokenItemState.Content(
             id = status.currency.id.value,
@@ -38,7 +38,7 @@ internal class TokenActionsUiBuilder @Inject constructor(
                 analyticsEventHandler.send(params.eventBuilder.getTokenLater())
                 params.callbacks.onLaterClick()
             },
-            quickActions = PortfolioTokenUMConverter.quickActions(data, tokenActionsHandler),
+            quickActions = quickActions(data, tokenActionsHandler),
         )
     }
 }

features/common-features/impl/src/main/java/com/tangem/features/commonfeatures/impl/addtoportfolio/ui/ChooseNetworkContent.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.background
@@ -24,8 +24,8 @@ 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 com.tangem.features.commonfeatures.impl.addtoportfolio.ui.state.ChooseNetworkUM
+import com.tangem.features.commonfeatures.impl.R
 import kotlinx.collections.immutable.persistentListOf
 import java.util.UUID
 

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

@@ -1,10 +1,10 @@
-package com.tangem.features.feed.components.market.details.portfolio.add.impl.ui
+package com.tangem.features.commonfeatures.impl.addtoportfolio.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.features.commonfeatures.impl.addtoportfolio.converter.AvailableToAddDataConverter
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager
 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/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
 
@@ -188,7 +188,7 @@ 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),

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,10 @@
+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
+
+internal data class TokenActionsUM(
+    val token: TokenItemState,
+    val quickActions: QuickActions,
+    val onLaterClick: () -> Unit,
+)

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

@@ -22,7 +22,7 @@ internal class PreviewDetailsComponent : DetailsComponent {
             router = DummyRouter(),
             hotWalletFeatureToggles = object : HotWalletFeatureToggles {
                 override val isWalletCreationRestrictionEnabled: Boolean = true
-                override val isTokenSyncEnabled: Boolean = true
+                override val isAssetsDiscoveryEnabled: Boolean = true
             },
         ).buildAll(
             isWalletConnectAvailable = true,

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

@@ -22,8 +22,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
@@ -61,7 +59,6 @@ internal class DetailsModel @Inject constructor(
     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 +76,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 +116,6 @@ internal class DetailsModel @Inject constructor(
             .launchIn(modelScope)
     }
 
-    private fun bootstrapScreenState() {
-        appStateHolder.dispatch(LegacyAction.PrepareDetailsScreen)
-    }
-
     private fun sendFeedback() {
         modelScope.launch {
             val userWallets = getWalletsUseCase.invokeSync()

features/feed/impl/build.gradle.kts

@@ -25,6 +25,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 */

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

@@ -11,7 +11,7 @@ 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.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
@@ -148,6 +148,13 @@ internal class FeedEntryChildFactory @Inject constructor(
                 appComponentContext = appComponentContext,
                 params = DefaultSearchComponent.Params(
                     onBackClick = onBackClicked,
+                    onMarketTokenClick = { token, currency ->
+                        feedEntryClickIntents.onMarketItemClick(
+                            token = token,
+                            appCurrency = currency,
+                            source = AnalyticsParam.ScreensSources.Market.value,
+                        )
+                    },
                 ),
             )
         }

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

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

@@ -19,8 +19,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/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/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

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,8 @@ 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.extensions.TextReference
 import com.tangem.core.ui.extensions.stringReference
 import com.tangem.domain.account.models.AccountStatusList
@@ -28,7 +30,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
@@ -248,7 +249,7 @@ 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,

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
@@ -14,12 +16,11 @@ 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.AddToPortfolioComponent
+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.*

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,10 @@ internal class PortfolioTokenUMConverter(
     private val isBalanceHidden: Boolean,
     private val onTokenItemClick: (CryptoCurrencyStatus) -> Unit,
     private val tokenActionsHandler: TokenActionsHandler,
-) : Converter<PortfolioData.CryptoCurrencyData, PortfolioTokenUM> {
+) : Converter<CryptoCurrencyData, PortfolioTokenUM> {
 
     fun convertV2(
-        value: PortfolioData.CryptoCurrencyData,
+        value: CryptoCurrencyData,
         isQuickActionsShown: Boolean,
         onTokenItemClick: (UserWallet, CryptoCurrencyStatus) -> Unit,
     ): PortfolioTokenUM {
@@ -45,7 +42,7 @@ internal class PortfolioTokenUMConverter(
         )
     }
 
-    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)) },
@@ -63,62 +60,4 @@ internal class PortfolioTokenUMConverter(
             quickActions = quickActions(cryptoData = value, tokenActionsHandler = tokenActionsHandler),
         )
     }
-
-    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
 

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,7 +127,7 @@ internal class PreviewMyPortfolioUMProvider : PreviewParameterProvider<MyPortfol
                 onItemLongClick = {},
             ),
             isQuickActionsShown = false,
-            quickActions = PortfolioTokenUM.QuickActions(
+            quickActions = QuickActions(
                 actions = persistentListOf(
                     QuickActionUM.Buy,
                     QuickActionUM.Exchange(shouldShowBadge = true),

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
-    }
-}

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

@@ -15,6 +15,8 @@ import com.tangem.core.ui.ds.field.search.TangemFieldShape
 import com.tangem.core.ui.ds.field.search.TangemSearchField
 import com.tangem.core.ui.ds.topbar.TangemTopBar
 import com.tangem.core.ui.ds.topbar.TangemTopBarType
+import com.tangem.domain.appcurrency.model.AppCurrency
+import com.tangem.domain.markets.TokenMarketParams
 import com.tangem.features.feed.model.search.SearchModel
 import com.tangem.features.feed.ui.search.SearchContent
 import com.tangem.features.feed.ui.search.state.SearchCallbacks
@@ -74,6 +76,7 @@ internal class DefaultSearchComponent(
                 onClearHintsClick = model::clearSearchHistory,
                 onTextHintClick = model::onTextHintClick,
                 onResultMarketTokenClick = model::onResultMarketTokenClick,
+                onHistoryTokenClick = model::onHistoryTokenClick,
             )
         }
         SearchContent(
@@ -86,5 +89,6 @@ internal class DefaultSearchComponent(
 
     data class Params(
         val onBackClick: () -> Unit,
+        val onMarketTokenClick: ((TokenMarketParams, AppCurrency) -> Unit),
     )
 }

features/feed/impl/src/main/kotlin/com/tangem/features/feed/model/earn/EarnModel.kt

@@ -25,7 +25,7 @@ import com.tangem.features.feed.components.earn.DefaultEarnComponent
 import com.tangem.features.feed.components.earn.EarnNetworkFilterComponent
 import com.tangem.features.feed.components.earn.EarnTypeFilterComponent
 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.analytics.EarnAnalyticsEvent
 import com.tangem.features.feed.model.earn.filters.state.EarnFilterNetworkConverter
 import com.tangem.features.feed.model.earn.filters.state.EarnFilterNetworkUMConverter

features/feed/impl/src/main/kotlin/com/tangem/features/feed/model/earn/analytics/EarnAnalyticsEvent.kt

@@ -50,30 +50,6 @@ internal sealed class EarnAnalyticsEvent(
         ),
     )
 
-    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,
-        ),
-    )
-
     data class BestOpportunitiesLoadError(
         private val code: Int?,
         private val message: String,

features/feed/impl/src/main/kotlin/com/tangem/features/feed/model/feed/FeedComponentModel.kt

@@ -31,7 +31,7 @@ import com.tangem.domain.news.usecase.FetchTrendingNewsUseCase
 import com.tangem.domain.news.usecase.ManageTrendingNewsUseCase
 import com.tangem.features.feed.components.feed.DefaultFeedComponent
 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.entry.featuretoggle.FeedFeatureToggle
 import com.tangem.features.feed.impl.R
 import com.tangem.features.feed.model.earn.analytics.EarnAnalyticsEvent

features/feed/impl/src/main/kotlin/com/tangem/features/feed/model/market/details/MarketsTokenDetailsModel.kt

@@ -526,7 +526,7 @@ internal class MarketsTokenDetailsModel @Inject constructor(
 
         val networks = newInfo.networks?.filter { network ->
             BlockchainUtils.isSupportedNetworkId(
-                blockchainId = network.networkId,
+                networkId = network.networkId,
                 excludedBlockchains = excludedBlockchains,
                 hotExcludedBlockchains = hotWalletExcludedBlockchains,
                 hasOnlyHotWallets = isAllWalletsIsHot,

features/feed/impl/src/main/kotlin/com/tangem/features/feed/model/search/SearchModel.kt

@@ -1,22 +1,27 @@
 package com.tangem.features.feed.model.search
 
 import arrow.core.getOrElse
+import com.tangem.common.routing.AppRoute
+import com.tangem.common.routing.AppRouter
+import com.tangem.common.ui.charts.state.MarketChartData
+import com.tangem.common.ui.charts.state.converter.PriceAndTimePointValuesConverter
+import com.tangem.common.ui.charts.state.sorted
 import com.tangem.common.ui.markets.models.MarketsListItemUM
 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.common.ui.charts.state.MarketChartData
-import com.tangem.common.ui.charts.state.converter.PriceAndTimePointValuesConverter
-import com.tangem.common.ui.charts.state.sorted
+import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
 import com.tangem.domain.markets.GetMarketsTokenListFlowUseCase
 import com.tangem.domain.markets.GetTokenPriceChartUseCase
 import com.tangem.domain.markets.PriceChangeInterval
-import com.tangem.domain.models.account.AccountName
+import com.tangem.domain.markets.TokenMarketParams
+import com.tangem.domain.markets.toSerializableParam
 import com.tangem.domain.search.usecase.ClearSearchHistoryUseCase
 import com.tangem.domain.search.usecase.GetSearchResultsUseCase
 import com.tangem.domain.search.usecase.SaveRecentSearchTokenUseCase
+import com.tangem.domain.search.model.UserAssetSearchEntry
 import com.tangem.domain.search.usecase.SaveSearchQueryUseCase
 import com.tangem.features.feed.components.search.DefaultSearchComponent
 import com.tangem.features.feed.model.market.list.state.MarketsListUM
@@ -26,6 +31,7 @@ import com.tangem.features.feed.model.search.converter.MarketsListItemUMToRecent
 import com.tangem.features.feed.model.search.converter.MarketsListItemUMWithAppCurrency
 import com.tangem.features.feed.model.search.converter.RecentSearchTokenToMarketsListItemUMConverter
 import com.tangem.features.feed.model.search.converter.RecentSearchTokenWithAppCurrency
+import com.tangem.features.feed.model.search.converter.UserAssetSearchItemConverter
 import com.tangem.features.feed.model.search.state.SearchStateController
 import com.tangem.features.feed.model.search.state.transformers.*
 import com.tangem.features.feed.ui.search.state.*
@@ -35,13 +41,8 @@ import com.tangem.utils.coroutines.JobHolder
 import com.tangem.utils.coroutines.saveIn
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.toImmutableList
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.delay
+import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 private const val UPDATE_QUOTES_TIMER_MILLIS = 60000L
@@ -54,11 +55,13 @@ internal class SearchModel @Inject constructor(
     paramsContainer: ParamsContainer,
     getMarketsTokenListFlowUseCase: GetMarketsTokenListFlowUseCase,
     getSelectedAppCurrencyUseCase: GetSelectedAppCurrencyUseCase,
+    getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
     private val getSearchResultsUseCase: GetSearchResultsUseCase,
     private val saveSearchQueryUseCase: SaveSearchQueryUseCase,
     private val saveRecentSearchTokenUseCase: SaveRecentSearchTokenUseCase,
     private val clearSearchHistoryUseCase: ClearSearchHistoryUseCase,
     private val getTokenPriceChartUseCase: GetTokenPriceChartUseCase,
+    private val appRouter: AppRouter,
     private val stateController: SearchStateController,
 ) : Model() {
 
@@ -77,6 +80,13 @@ internal class SearchModel @Inject constructor(
         initialValue = AppCurrency.Default,
     )
 
+    private val isBalanceHidden = getBalanceHidingSettingsUseCase.isBalanceHidden()
+        .stateIn(
+            scope = modelScope,
+            started = SharingStarted.Eagerly,
+            initialValue = false,
+        )
+
     private val marketsListItemToRecentSearchTokenConverter by lazy {
         MarketsListItemUMToRecentSearchTokenConverter()
     }
@@ -143,17 +153,38 @@ internal class SearchModel @Inject constructor(
             )
             saveRecentSearchTokenUseCase(marketsListItemToRecentSearchTokenConverter.convert(input))
             saveSearchQueryUseCase(stateController.value.searchBar.query)
+            withContext(dispatchers.mainImmediate) {
+                searchMarketsListManager.getTokenById(item.id)?.let { found ->
+                    params.onMarketTokenClick(found.toSerializableParam(), appCurrency)
+                }
+            }
         }
     }
 
+    fun onHistoryTokenClick(item: MarketsListItemUM) {
+        val tokenMarketParams = TokenMarketParams(
+            id = item.id,
+            name = item.name,
+            symbol = item.currencySymbol,
+            tokenQuotes = TokenMarketParams.Quotes(
+                currentPrice = item.price.fiatPrice,
+                h24Percent = null,
+                weekPercent = null,
+                monthPercent = null,
+            ),
+            imageUrl = item.iconUrl,
+        )
+        params.onMarketTokenClick(tokenMarketParams, currentAppCurrency.value)
+    }
+
     private fun initCallbacks() {
         stateController.update(object : SearchUMTransformer {
             override fun transform(prevState: SearchUM): SearchUM {
                 return prevState.copy(
                     searchBar = prevState.searchBar.copy(
                         onQueryChange = ::onQueryChange,
-                        onActiveChange = ::onActiveChange,
                         onClearClick = ::onClearClick,
+                        onCancelClick = params.onBackClick,
                     ),
                 )
             }
@@ -164,14 +195,19 @@ internal class SearchModel @Inject constructor(
         stateController.update(UpdateSearchBarQueryTransformer(query))
     }
 
-    private fun onActiveChange(isActive: Boolean) {
-        if (!isActive) params.onBackClick()
-    }
-
     private fun onClearClick() {
         stateController.update(UpdateSearchBarQueryTransformer(""))
     }
 
+    private fun onSingleUserAssetClick(entry: UserAssetSearchEntry) {
+        appRouter.push(
+            AppRoute.CurrencyDetails(
+                userWalletId = entry.userWalletId,
+                currency = entry.currencyStatus.currency,
+            ),
+        )
+    }
+
     private fun subscribeToQueryChanges() {
         stateController.uiState
             .map { it.searchBar.query.trim() }
@@ -200,20 +236,20 @@ internal class SearchModel @Inject constructor(
 
     private fun subscribeToSearchResults(query: String) {
         modelScope.launch {
-            getSearchResultsUseCase(query = query).collectLatest { searchResult ->
-                val userAssets = searchResult.userAssets.map { entry ->
-                    UserAssetItemUM(
-                        id = "${entry.userWalletId.stringValue}_${entry.accountId.value}" +
-                            "_${entry.currencyStatus.currency.id.value}",
-                        tokenIconUrl = entry.currencyStatus.currency.iconUrl,
-                        tokenName = entry.currencyStatus.currency.name,
-                        tokenSymbol = entry.currencyStatus.currency.symbol,
-                        accountName = entry.accountName.toDisplayString(),
-                        onClick = {
-                            // TODO in [REDACTED_TASK_KEY] while just a stub item. Will be handled in next task.
-                        },
-                    )
-                }.toImmutableList()
+            combine(
+                getSearchResultsUseCase(query = query),
+                currentAppCurrency,
+                isBalanceHidden,
+            ) { searchResult, appCurrency, balanceHidden ->
+                val converter = UserAssetSearchItemConverter(
+                    appCurrency = appCurrency,
+                    isBalanceHidden = balanceHidden,
+                    onSingleClick = ::onSingleUserAssetClick,
+                )
+                searchResult.userAssets
+                    .map(converter::convert)
+                    .toImmutableList()
+            }.collectLatest { userAssets ->
                 stateController.update(UpdateUserAssetsTransformer(userAssets))
             }
         }.saveIn(searchResultsJob)
@@ -334,13 +370,6 @@ internal class SearchModel @Inject constructor(
         }
     }
 
-    private fun AccountName.toDisplayString(): String {
-        return when (this) {
-            is AccountName.DefaultMain -> "Main" // TODO [REDACTED_TASK_KEY] localize
-            is AccountName.Custom -> value
-        }
-    }
-
     private fun CoroutineScope.loadQuotesWithTimer(timeMillis: Long) {
         launch {
             while (true) {

features/feed/impl/src/main/kotlin/com/tangem/features/feed/model/search/converter/UserAssetSearchItemConverter.kt

@@ -0,0 +1,184 @@
+package com.tangem.features.feed.model.search.converter
+
+import com.tangem.common.ui.account.toUM
+import com.tangem.common.ui.markets.toMarketsListItemPriceAnnotated
+import com.tangem.core.ui.components.currency.icon.CurrencyIconState
+import com.tangem.core.ui.components.currency.icon.converter.CryptoCurrencyToIconStateConverter
+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.networkIconResId
+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.currency.CryptoCurrencyStatus
+import com.tangem.domain.search.model.UserAssetSearchEntry
+import com.tangem.domain.search.model.UserAssetSearchItem
+import com.tangem.features.feed.ui.search.state.BalanceDisplayState
+import com.tangem.features.feed.ui.search.state.UserAssetItemUM
+import com.tangem.utils.StringsSigns
+import com.tangem.utils.converter.Converter
+import com.tangem.utils.extensions.orZero
+import kotlinx.collections.immutable.toImmutableList
+import java.math.BigDecimal
+
+internal class UserAssetSearchItemConverter(
+    private val appCurrency: AppCurrency,
+    private val isBalanceHidden: Boolean,
+    private val onSingleClick: (UserAssetSearchEntry) -> Unit,
+) : Converter<UserAssetSearchItem, UserAssetItemUM> {
+
+    override fun convert(value: UserAssetSearchItem): UserAssetItemUM {
+        return when (value) {
+            is UserAssetSearchItem.Single -> convertSingle(value.entry)
+            is UserAssetSearchItem.Grouped -> convertGrouped(value)
+        }
+    }
+
+    private fun convertSingle(entry: UserAssetSearchEntry): UserAssetItemUM.Single {
+        val currency = entry.currencyStatus.currency
+        val value = entry.currencyStatus.value
+
+        return UserAssetItemUM.Single(
+            id = "${entry.userWalletId.stringValue}_${entry.accountId.value}_${currency.id.value}",
+            icon = TangemIconUM.Currency(
+                currencyIconState = CryptoCurrencyToIconStateConverter().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 = convertSingleBalanceState(value, currency.symbol, currency.decimals),
+            isBalanceHidden = isBalanceHidden,
+            onClick = { onSingleClick(entry) },
+        )
+    }
+
+    private fun convertSingleBalanceState(
+        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 = value.fiatAmount?.toMarketsListItemPriceAnnotated(
+                        appCurrencyCode = appCurrency.code, appCurrencySymbol = appCurrency.symbol,
+                    ) ?: stringReference(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 = value.fiatAmount?.toMarketsListItemPriceAnnotated(
+                        appCurrencyCode = appCurrency.code, appCurrencySymbol = appCurrency.symbol,
+                    ) ?: stringReference(StringsSigns.DASH_SIGN),
+                )
+            value.isError -> BalanceDisplayState.Unreachable
+            else -> BalanceDisplayState.Loaded(
+                cryptoBalance = stringReference(formatCryptoAmount(value.amount, symbol, decimals)),
+                fiatBalance = value.fiatAmount?.toMarketsListItemPriceAnnotated(
+                    appCurrencyCode = appCurrency.code, appCurrencySymbol = appCurrency.symbol,
+                ) ?: stringReference(StringsSigns.DASH_SIGN),
+            )
+        }
+    }
+
+    private fun convertGrouped(item: UserAssetSearchItem.Grouped): UserAssetItemUM.Grouped {
+        val firstCurrency = item.entries.first().currencyStatus.currency
+        val children = item.entries.map { entry ->
+            UserAssetItemUM.GroupedChild(
+                walletName = entry.userWalletName,
+                accountName = entry.accountName.toUM(),
+                accountIcon = entry.accountIcon.value,
+                accountColor = entry.accountIcon.color,
+                currencyStatus = entry.currencyStatus,
+            )
+        }.toImmutableList()
+
+        val entryCurrencyStatus = item.entries.first().currencyStatus
+
+        return UserAssetItemUM.Grouped(
+            id = "grouped_${item.tokenName}_${item.tokenSymbol}",
+            icon = TangemIconUM.Currency(
+                currencyIconState = CurrencyIconState.CoinIcon(
+                    url = entryCurrencyStatus.currency.iconUrl,
+                    fallbackResId = entryCurrencyStatus.currency.networkIconResId,
+                    isGrayscale = entryCurrencyStatus.currency.network.isTestnet || entryCurrencyStatus.value.isError,
+                    shouldShowCustomBadge = entryCurrencyStatus.currency.isCustom,
+                ),
+            ),
+            tokenName = item.tokenName,
+            tokenSymbol = item.tokenSymbol,
+            tokensCount = item.entries.size,
+            balanceState = convertGroupedBalanceState(item.entries, firstCurrency.symbol, firstCurrency.decimals),
+            isBalanceHidden = isBalanceHidden,
+            children = children,
+            onClick = {},
+        )
+    }
+
+    private fun convertGroupedBalanceState(
+        entries: List<UserAssetSearchEntry>,
+        symbol: String,
+        decimals: Int,
+    ): BalanceDisplayState {
+        val hasAnyLoading = entries.any { it.currencyStatus.value is CryptoCurrencyStatus.Loading }
+        val hasAnyError = entries.any { it.currencyStatus.value.isError }
+        val hasAnyAmount = entries.any { it.currencyStatus.value.amount != null }
+
+        val balance = when {
+            hasAnyLoading && !hasAnyAmount -> BalanceDisplayState.Loading
+            hasAnyLoading && hasAnyAmount -> computeGroupBalanceFlickering(entries, symbol, decimals)
+            hasAnyError && entries.size == 1 && !hasAnyAmount -> BalanceDisplayState.Unreachable
+            hasAnyError && entries.size > 1 -> computeGroupBalance(entries, symbol, decimals)
+            else -> computeGroupBalance(entries, symbol, decimals)
+        }
+        return balance
+    }
+
+    private fun computeGroupBalance(
+        entries: List<UserAssetSearchEntry>,
+        symbol: String,
+        decimals: Int,
+    ): BalanceDisplayState.Loaded {
+        val totalFiat = entries.sumOf { it.currencyStatus.value.fiatAmount ?: BigDecimal.ZERO }
+        val totalCrypto = entries.sumOf { it.currencyStatus.value.amount ?: BigDecimal.ZERO }
+        return BalanceDisplayState.Loaded(
+            cryptoBalance = stringReference(formatCryptoAmount(totalCrypto, symbol, decimals)),
+            fiatBalance = totalFiat.toMarketsListItemPriceAnnotated(appCurrency.code, appCurrency.symbol),
+        )
+    }
+
+    private fun computeGroupBalanceFlickering(
+        entries: List<UserAssetSearchEntry>,
+        symbol: String,
+        decimals: Int,
+    ): BalanceDisplayState.Flickering {
+        val totalFiat = entries.sumOf { it.currencyStatus.value.fiatAmount ?: BigDecimal.ZERO }
+        val totalCrypto = entries.sumOf { it.currencyStatus.value.amount ?: BigDecimal.ZERO }
+        return BalanceDisplayState.Flickering(
+            cryptoBalance = stringReference(formatCryptoAmount(totalCrypto, symbol, decimals)),
+            fiatBalance = totalFiat.toMarketsListItemPriceAnnotated(appCurrency.code, appCurrency.symbol),
+        )
+    }
+
+    private fun formatCryptoAmount(amount: BigDecimal?, symbol: String, decimals: Int): String {
+        return amount?.format { crypto(symbol, decimals) } ?: StringsSigns.DASH_SIGN
+    }
+}

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

@@ -0,0 +1,99 @@
+package com.tangem.features.feed.ui.components
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.Dp
+import com.tangem.core.ui.components.currency.icon.CurrencyIconState
+import com.tangem.core.ui.ds.image.TangemIcon
+import com.tangem.core.ui.ds.image.TangemIconUM
+import com.tangem.core.ui.res.TangemColorPalette
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.core.ui.res.TangemThemePreview
+
+private const val MIN_STACKED_ICON_COUNT = 1
+private const val MAX_STACKED_ICON_COUNT = 3
+private const val FIRST_BACK_LAYER_HORIZONTAL_OFFSET_MULTIPLIER = 1
+private const val SECOND_BACK_LAYER_HORIZONTAL_OFFSET_MULTIPLIER = 2
+private const val MIN_STACKED_COUNT_FOR_FIRST_BACK_LAYER = 2
+private const val FIRST_BACK_LAYER_ICON_ALPHA = 0.4f
+private const val SECOND_BACK_LAYER_ICON_ALPHA = 0.2f
+
+@Composable
+fun LayeringIcons(
+    tangemIconUM: TangemIconUM,
+    modifier: Modifier = Modifier,
+    count: Int = MIN_STACKED_ICON_COUNT,
+    layerHorizontalShift: Dp = TangemTheme.dimens2.x1,
+    iconSize: Dp = TangemTheme.dimens2.x10,
+) {
+    require(count > 0)
+
+    val stackTrailingWidth = layerHorizontalShift * SECOND_BACK_LAYER_HORIZONTAL_OFFSET_MULTIPLIER
+
+    Box(
+        modifier = modifier.size(
+            width = iconSize + stackTrailingWidth,
+            height = iconSize,
+        ),
+    ) {
+        val baseIconModifier = Modifier
+            .align(Alignment.TopStart)
+            .size(iconSize)
+
+        if (count >= MAX_STACKED_ICON_COUNT) {
+            TangemIcon(
+                tangemIconUM = tangemIconUM,
+                modifier = baseIconModifier
+                    .offset(x = layerHorizontalShift * SECOND_BACK_LAYER_HORIZONTAL_OFFSET_MULTIPLIER)
+                    .alpha(SECOND_BACK_LAYER_ICON_ALPHA),
+            )
+        }
+        if (count >= MIN_STACKED_COUNT_FOR_FIRST_BACK_LAYER) {
+            TangemIcon(
+                tangemIconUM = tangemIconUM,
+                modifier = baseIconModifier
+                    .offset(x = layerHorizontalShift * FIRST_BACK_LAYER_HORIZONTAL_OFFSET_MULTIPLIER)
+                    .alpha(FIRST_BACK_LAYER_ICON_ALPHA),
+            )
+        }
+        TangemIcon(
+            tangemIconUM = tangemIconUM,
+            modifier = baseIconModifier,
+        )
+    }
+}
+
+@Preview(showBackground = true, widthDp = 360)
+@Composable
+private fun LayeringIconsPreview() {
+    val previewCurrencyIcon = TangemIconUM.Currency(
+        currencyIconState = CurrencyIconState.TokenIcon(
+            url = null,
+            topBadgeIconResId = null,
+            fallbackTint = TangemColorPalette.Black,
+            fallbackBackground = TangemColorPalette.Meadow,
+            isGrayscale = false,
+            shouldShowCustomBadge = false,
+        ),
+    )
+    TangemThemePreview {
+        Column(horizontalAlignment = Alignment.End) {
+            LayeringIcons(count = MIN_STACKED_ICON_COUNT, tangemIconUM = previewCurrencyIcon)
+            LayeringIcons(
+                count = MAX_STACKED_ICON_COUNT,
+                tangemIconUM = previewCurrencyIcon,
+            )
+            LayeringIcons(
+                count = MIN_STACKED_COUNT_FOR_FIRST_BACK_LAYER,
+                tangemIconUM = previewCurrencyIcon,
+            )
+        }
+    }
+}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/ui/search/SearchContent.kt

@@ -1,22 +1,18 @@
 package com.tangem.features.feed.ui.search
 
+import androidx.compose.animation.core.tween
 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.LazyListScope
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.lazy.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.drawBehind
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalDensity
@@ -31,17 +27,20 @@ import com.tangem.core.ui.components.SpacerH
 import com.tangem.core.ui.components.SpacerW
 import com.tangem.core.ui.components.list.InfiniteListHandler
 import com.tangem.core.ui.ds.button.*
-import com.tangem.core.ui.ds.image.TangemIcon
 import com.tangem.core.ui.ds.image.TangemIconUM
 import com.tangem.core.ui.extensions.clickableSingle
 import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.core.ui.extensions.stringResourceSafe
 import com.tangem.core.ui.res.LocalMainBottomSheetColor
 import com.tangem.core.ui.res.TangemTheme
+import com.tangem.features.feed.ui.search.components.GroupedUserAssetItem
+import com.tangem.features.feed.ui.search.components.SingleUserAssetItem
 import com.tangem.features.feed.ui.search.state.*
+import kotlinx.collections.immutable.ImmutableList
 
 private const val PLACEHOLDER_COUNT = 10
 private const val LOAD_MORE_THRESHOLD = 5
+private const val USER_ASSETS_LIMIT = 3
 
 @Composable
 internal fun SearchContent(
@@ -54,6 +53,23 @@ internal fun SearchContent(
     val lazyListState = rememberLazyListState()
     val background = LocalMainBottomSheetColor.current.value
 
+    val contentStructureKey = when (content) {
+        is SearchContentUM.InitialEmpty -> "empty"
+        is SearchContentUM.History -> "history"
+        is SearchContentUM.Results -> "results_${content.userAssets.isNotEmpty()}"
+    }
+    LaunchedEffect(contentStructureKey) {
+        lazyListState.scrollToItem(0)
+    }
+
+    var isUserAssetsExpanded by rememberSaveable { mutableStateOf(false) }
+    val shouldShowUserAssetsPortfolio = content is SearchContentUM.Results && content.userAssets.isNotEmpty()
+    LaunchedEffect(shouldShowUserAssetsPortfolio) {
+        if (!shouldShowUserAssetsPortfolio) {
+            isUserAssetsExpanded = false
+        }
+    }
+
     LazyColumn(
         state = lazyListState,
         modifier = modifier
@@ -72,9 +88,12 @@ internal fun SearchContent(
                 history = content,
                 onClearAllClick = searchCallbacks.onClearHintsClick,
                 onHintClick = searchCallbacks.onTextHintClick,
+                onHistoryTokenClick = searchCallbacks.onHistoryTokenClick,
             )
             is SearchContentUM.Results -> searchResultsItems(
                 results = content,
+                isUserAssetsExpanded = isUserAssetsExpanded,
+                onUserAssetsExpandedChange = { isUserAssetsExpanded = it },
                 onResultMarketTokenClick = searchCallbacks.onResultMarketTokenClick,
             )
         }
@@ -98,6 +117,7 @@ private fun LazyListScope.searchHistoryItems(
     history: SearchContentUM.History,
     onClearAllClick: (() -> Unit),
     onHintClick: (String) -> Unit,
+    onHistoryTokenClick: (MarketsListItemUM) -> Unit,
 ) {
     if (!history.textHints.isEmpty() || !history.recentTokens.isEmpty()) {
         item(key = "recents") {
@@ -107,15 +127,20 @@ private fun LazyListScope.searchHistoryItems(
             )
         }
     }
-    items(
+    itemsIndexed(
         items = history.textHints,
-        key = { "hint_${it.text}" },
-    ) { hint ->
+        key = { _, item -> "hint_${item.text}" },
+    ) { index, hint ->
         TextHintItem(hint = hint, onHintClick = { onHintClick(hint.text) })
-        HorizontalDivider(
-            modifier = Modifier.padding(horizontal = TangemTheme.dimens2.x2),
-            color = TangemTheme.colors2.border.neutral.primary,
-        )
+        if (index < history.textHints.size - 1) {
+            HorizontalDivider(
+                modifier = Modifier.padding(horizontal = TangemTheme.dimens2.x2),
+                color = TangemTheme.colors2.border.neutral.primary,
+            )
+        }
+    }
+    item {
+        SpacerH(TangemTheme.dimens2.x2)
     }
     items(
         items = history.recentTokens,
@@ -129,25 +154,26 @@ private fun LazyListScope.searchHistoryItems(
                     shape = RoundedCornerShape(TangemTheme.dimens2.x5),
                 ),
             model = token,
-            onClick = {}, // TODO in [REDACTED_TASK_KEY]
+            onClick = { onHistoryTokenClick(token) },
         )
     }
 }
 
 private fun LazyListScope.searchResultsItems(
     results: SearchContentUM.Results,
+    isUserAssetsExpanded: Boolean,
+    onUserAssetsExpandedChange: (Boolean) -> Unit,
     onResultMarketTokenClick: (MarketsListItemUM) -> Unit,
 ) {
     if (results.userAssets.isNotEmpty()) {
         item(key = "header_portfolio") {
             SectionHeader(title = stringResourceSafe(R.string.markets_search_portfolio_header))
         }
-        items(
-            items = results.userAssets,
-            key = { it.id },
-        ) { asset ->
-            UserAssetItem(asset)
-        }
+        userAssetsPortfolioItems(
+            assets = results.userAssets,
+            expanded = isUserAssetsExpanded,
+            onExpandedChange = onUserAssetsExpandedChange,
+        )
     }
 
     when (val market = results.marketTokens) {
@@ -164,6 +190,42 @@ private fun LazyListScope.searchResultsItems(
     }
 }
 
+private fun LazyListScope.userAssetsPortfolioItems(
+    assets: ImmutableList<UserAssetItemUM>,
+    expanded: Boolean,
+    onExpandedChange: (Boolean) -> Unit,
+) {
+    val shouldShowToggle = assets.size > USER_ASSETS_LIMIT
+    val visibleCount = if (shouldShowToggle && !expanded) USER_ASSETS_LIMIT else assets.size
+
+    items(
+        count = visibleCount,
+        key = { index -> "user_asset_${assets[index].id}" },
+    ) { index ->
+        Column(
+            modifier = Modifier.animateItem(
+                fadeInSpec = tween(durationMillis = 300),
+                fadeOutSpec = tween(durationMillis = 250),
+            ),
+        ) {
+            UserAssetItem(assets[index])
+            SpacerH(TangemTheme.dimens2.x2)
+        }
+    }
+    if (shouldShowToggle) {
+        item(key = "user_assets_show_toggle") {
+            ShowAllUserAssetsButton(
+                modifier = Modifier.animateItem(
+                    fadeInSpec = tween(durationMillis = 300),
+                    fadeOutSpec = tween(durationMillis = 250),
+                ),
+                isExpanded = expanded,
+                onClick = { onExpandedChange(!expanded) },
+            )
+        }
+    }
+}
+
 private fun LazyListScope.marketSearchResultItems(
     market: MarketSearchResultUM.Content,
     hasUserAssetsSection: Boolean,
@@ -223,7 +285,7 @@ private fun LazyListScope.marketSearchResultNotFoundItem() {
         ) {
             Text(
                 text = stringResourceSafe(R.string.common_no_results),
-                style = TangemTheme.typography2.bodyRegular14,
+                style = TangemTheme.typography2.subheadlineMedium14,
                 color = TangemTheme.colors2.text.neutral.tertiary,
             )
         }
@@ -264,37 +326,37 @@ private fun TextHintItem(hint: TextHintItemUM, onHintClick: () -> Unit) {
     }
 }
 
-// TODO in [REDACTED_TASK_KEY] while just a stub item. Will be handled in next task.
 @Composable
 private fun UserAssetItem(asset: UserAssetItemUM) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .clickable(onClick = asset.onClick)
-            .padding(horizontal = 12.dp, vertical = 14.dp),
-        verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.spacedBy(8.dp),
+    when (asset) {
+        is UserAssetItemUM.Single -> SingleUserAssetItem(item = asset)
+        is UserAssetItemUM.Grouped -> GroupedUserAssetItem(item = asset)
+    }
+}
+
+@Composable
+private fun ShowAllUserAssetsButton(isExpanded: Boolean, onClick: () -> Unit, modifier: Modifier = Modifier) {
+    Box(
+        modifier = modifier.fillMaxWidth(),
+        contentAlignment = Alignment.Center,
     ) {
-        TangemIcon(
-            tangemIconUM = TangemIconUM.Url(asset.tokenIconUrl, fallbackRes = R.drawable.ic_custom_token_44),
-            modifier = Modifier
-                .size(40.dp)
-                .clip(CircleShape),
+        TangemButton(
+            buttonUM = TangemButtonUM(
+                text = if (isExpanded) {
+                    resourceReference(R.string.feed_search_show_less_user_assets)
+                } else {
+                    resourceReference(R.string.feed_search_show_all_user_assets)
+                },
+                tangemIconUM = TangemIconUM.Icon(
+                    iconRes = if (isExpanded) R.drawable.ic_chewron_up_20 else R.drawable.ic_chewron_down_20,
+                ),
+                iconPosition = TangemButtonIconPosition.End,
+                onClick = onClick,
+                type = TangemButtonType.Secondary,
+                size = TangemButtonSize.X7,
+                shape = TangemButtonShape.Rounded,
+            ),
         )
-        Column(modifier = Modifier.weight(1f)) {
-            Text(
-                text = asset.tokenName,
-                style = TangemTheme.typography2.bodySemibold16,
-                color = TangemTheme.colors2.text.neutral.primary,
-                maxLines = 1,
-            )
-            Text(
-                text = "${asset.tokenSymbol} · ${asset.accountName}",
-                style = TangemTheme.typography2.captionRegular13,
-                color = TangemTheme.colors2.text.neutral.tertiary,
-                maxLines = 1,
-            )
-        }
     }
 }
 
@@ -314,7 +376,7 @@ private fun ShowTokensUnder100kItem(onShowTokensClick: () -> Unit, modifier: Mod
     ) {
         Text(
             text = stringResourceSafe(R.string.markets_search_see_tokens_under_100k),
-            style = TangemTheme.typography2.bodyRegular14,
+            style = TangemTheme.typography2.subheadlineMedium14,
             color = TangemTheme.colors2.text.neutral.secondary,
         )
         TangemButton(

features/feed/impl/src/main/kotlin/com/tangem/features/feed/ui/search/components/BalanceColumn.kt

@@ -0,0 +1,175 @@
+package com.tangem.features.feed.ui.search.components
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.tangem.core.ui.R
+import com.tangem.core.ui.components.RectangleShimmer
+import com.tangem.core.ui.components.SpacerW
+import com.tangem.core.ui.components.flicker
+import com.tangem.core.ui.extensions.resolveAnnotatedReference
+import com.tangem.core.ui.extensions.resolveReference
+import com.tangem.core.ui.extensions.stringResourceSafe
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.features.feed.ui.search.state.BalanceDisplayState
+import com.tangem.utils.StringsSigns
+
+@Composable
+internal fun BalanceColumn(
+    balanceState: BalanceDisplayState,
+    isBalanceHidden: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    if (isBalanceHidden) {
+        HiddenBalance(modifier)
+        return
+    }
+    when (balanceState) {
+        is BalanceDisplayState.Loading -> LoadingBalanceColumn(modifier)
+        is BalanceDisplayState.Flickering -> FlickeringBalanceColumn(balanceState, modifier)
+        is BalanceDisplayState.Stale -> StaleBalanceColumn(balanceState, modifier)
+        is BalanceDisplayState.Unreachable -> UnreachableBalanceColumn(modifier)
+        is BalanceDisplayState.Loaded -> LoadedBalanceColumn(balanceState, modifier)
+    }
+}
+
+@Composable
+private fun BalanceColumnLayout(modifier: Modifier = Modifier, content: @Composable ColumnScope.() -> Unit) {
+    Column(
+        modifier = modifier,
+        horizontalAlignment = Alignment.End,
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+        content = content,
+    )
+}
+
+@Composable
+private fun LoadingBalanceColumn(modifier: Modifier = Modifier) {
+    BalanceColumnLayout(modifier) {
+        RectangleShimmer(modifier = Modifier.size(width = 108.dp, height = 20.dp), radius = 20.dp)
+        RectangleShimmer(modifier = Modifier.size(width = 64.dp, height = 16.dp), radius = 20.dp)
+    }
+}
+
+@Composable
+private fun FlickeringBalanceColumn(state: BalanceDisplayState.Flickering, modifier: Modifier = Modifier) {
+    val flickerModifier = Modifier.flicker(isFlickering = true)
+    BalanceColumnLayout(modifier) {
+        Text(
+            modifier = flickerModifier,
+            text = state.fiatBalance.resolveAnnotatedReference(),
+            style = TangemTheme.typography2.bodyMedium16,
+            color = TangemTheme.colors2.text.neutral.primary,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+        Text(
+            modifier = flickerModifier,
+            text = state.cryptoBalance.resolveReference(),
+            style = TangemTheme.typography2.captionMedium12,
+            color = TangemTheme.colors2.text.neutral.secondary,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
+
+@Composable
+private fun StaleBalanceColumn(state: BalanceDisplayState.Stale, modifier: Modifier = Modifier) {
+    BalanceColumnLayout(modifier) {
+        Row(verticalAlignment = Alignment.CenterVertically) {
+            Icon(
+                modifier = Modifier.size(16.dp),
+                painter = painterResource(id = R.drawable.ic_error_sync_24),
+                contentDescription = null,
+                tint = TangemTheme.colors2.markers.iconGray,
+            )
+            SpacerW(TangemTheme.dimens2.x0_5)
+            Text(
+                text = state.fiatBalance.resolveAnnotatedReference(),
+                style = TangemTheme.typography2.bodyMedium16,
+                color = TangemTheme.colors2.text.neutral.primary,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+            )
+        }
+        Text(
+            text = state.cryptoBalance.resolveReference(),
+            style = TangemTheme.typography2.captionMedium12,
+            color = TangemTheme.colors2.text.neutral.secondary,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
+
+@Composable
+private fun UnreachableBalanceColumn(modifier: Modifier = Modifier) {
+    BalanceColumnLayout(modifier) {
+        Text(
+            text = StringsSigns.DASH_SIGN,
+            style = TangemTheme.typography2.bodyMedium16,
+            color = TangemTheme.colors2.text.neutral.primary,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+        Row(verticalAlignment = Alignment.CenterVertically) {
+            Text(
+                text = stringResourceSafe(R.string.common_unreachable),
+                style = TangemTheme.typography2.captionMedium12,
+                color = TangemTheme.colors2.text.status.attention,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+            )
+            SpacerW(TangemTheme.dimens2.x0_5)
+            Icon(
+                modifier = Modifier.size(16.dp),
+                painter = painterResource(id = R.drawable.ic_alert_triange_24),
+                contentDescription = null,
+                tint = TangemTheme.colors2.graphic.status.attention,
+            )
+        }
+    }
+}
+
+@Composable
+private fun LoadedBalanceColumn(state: BalanceDisplayState.Loaded, modifier: Modifier = Modifier) {
+    BalanceColumnLayout(modifier) {
+        Text(
+            text = state.fiatBalance.resolveAnnotatedReference(),
+            style = TangemTheme.typography2.bodySemibold16,
+            color = TangemTheme.colors2.text.neutral.primary,
+            maxLines = 1,
+        )
+        Text(
+            text = state.cryptoBalance.resolveReference(),
+            style = TangemTheme.typography2.captionMedium12,
+            color = TangemTheme.colors2.text.neutral.secondary,
+            maxLines = 1,
+        )
+    }
+}
+
+@Composable
+private fun HiddenBalance(modifier: Modifier = Modifier) {
+    BalanceColumnLayout(modifier) {
+        Text(
+            text = StringsSigns.THREE_STARS,
+            style = TangemTheme.typography2.bodySemibold16,
+            color = TangemTheme.colors2.text.neutral.primary,
+            maxLines = 1,
+        )
+        Text(
+            text = StringsSigns.THREE_STARS,
+            style = TangemTheme.typography2.captionMedium12,
+            color = TangemTheme.colors2.text.neutral.secondary,
+            maxLines = 1,
+        )
+    }
+}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/ui/search/components/GroupedUserAssetItem.kt

@@ -0,0 +1,84 @@
+package com.tangem.features.feed.ui.search.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.layoutId
+import androidx.compose.ui.text.style.TextOverflow
+import com.tangem.core.ui.ds.button.*
+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.pluralStringResourceSafe
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.features.feed.impl.R
+import com.tangem.features.feed.ui.components.LayeringIcons
+import com.tangem.features.feed.ui.search.state.UserAssetItemUM
+
+@Composable
+internal fun GroupedUserAssetItem(item: UserAssetItemUM.Grouped, modifier: Modifier = Modifier) {
+    Box(
+        modifier = modifier.background(
+            color = TangemTheme.colors2.surface.level3,
+            shape = RoundedCornerShape(TangemTheme.dimens2.x5),
+        ),
+    ) {
+        TangemRowContainer(
+            modifier = Modifier.clickable(onClick = item.onClick),
+            content = {
+                LayeringIcons(
+                    modifier = Modifier
+                        .layoutId(layoutId = TangemRowLayoutId.HEAD)
+                        .padding(end = TangemTheme.dimens2.x1),
+                    tangemIconUM = item.icon,
+                    count = item.tokensCount,
+                )
+
+                Text(
+                    modifier = Modifier.layoutId(TangemRowLayoutId.START_TOP),
+                    text = item.tokenName,
+                    style = TangemTheme.typography2.bodyMedium16,
+                    color = TangemTheme.colors2.text.neutral.primary,
+                    maxLines = 1,
+                    overflow = TextOverflow.MiddleEllipsis,
+                )
+
+                Text(
+                    modifier = Modifier.layoutId(TangemRowLayoutId.START_BOTTOM),
+                    text = pluralStringResourceSafe(R.plurals.common_tokens_count, item.tokensCount, item.tokensCount),
+                    style = TangemTheme.typography2.captionMedium12,
+                    color = TangemTheme.colors2.text.neutral.secondary,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                )
+
+                BalanceColumn(
+                    modifier = Modifier.layoutId(layoutId = TangemRowLayoutId.END_TOP),
+                    balanceState = item.balanceState,
+                    isBalanceHidden = item.isBalanceHidden,
+                )
+
+                TangemButton(
+                    modifier = Modifier
+                        .padding(start = TangemTheme.dimens2.x2)
+                        .layoutId(TangemRowLayoutId.TAIL),
+                    buttonUM = TangemButtonUM(
+                        type = TangemButtonType.Secondary,
+                        tangemIconUM = TangemIconUM.Icon(
+                            iconRes = R.drawable.ic_chevron_24,
+                            tintReference = { TangemTheme.colors2.graphic.neutral.primary },
+                        ),
+                        shape = TangemButtonShape.Rounded,
+                        size = TangemButtonSize.X10,
+                        onClick = item.onClick,
+                    ),
+                )
+            },
+        )
+    }
+}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/ui/search/components/SingleUserAssetItem.kt

@@ -0,0 +1,117 @@
+package com.tangem.features.feed.ui.search.components
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.layoutId
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.tangem.core.ui.components.marketprice.PriceChangeInPercent
+import com.tangem.core.ui.components.marketprice.PriceChangeState
+import com.tangem.core.ui.ds.image.TangemIcon
+import com.tangem.core.ui.ds.row.TangemRowContainer
+import com.tangem.core.ui.ds.row.TangemRowLayoutId
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.features.feed.ui.search.state.BalanceDisplayState
+import com.tangem.features.feed.ui.search.state.UserAssetItemUM
+
+@Composable
+fun SingleUserAssetItem(item: UserAssetItemUM.Single, modifier: Modifier = Modifier) {
+    Box(
+        modifier = modifier.background(
+            color = TangemTheme.colors2.surface.level3,
+            shape = RoundedCornerShape(TangemTheme.dimens2.x5),
+        ),
+    ) {
+        TangemRowContainer(
+            modifier = Modifier.clickable(onClick = item.onClick),
+            content = {
+                TangemIcon(
+                    modifier = Modifier
+                        .layoutId(layoutId = TangemRowLayoutId.HEAD)
+                        .size(40.dp)
+                        .padding(end = TangemTheme.dimens2.x1),
+                    tangemIconUM = item.icon,
+                )
+
+                Text(
+                    modifier = Modifier.layoutId(TangemRowLayoutId.START_TOP),
+                    text = item.tokenName,
+                    style = TangemTheme.typography2.bodyMedium16,
+                    color = TangemTheme.colors2.text.neutral.primary,
+                    maxLines = 1,
+                    overflow = TextOverflow.MiddleEllipsis,
+                )
+
+                PriceBlock(
+                    modifier = Modifier.layoutId(TangemRowLayoutId.START_BOTTOM),
+                    priceChangeState = item.priceChangeState,
+                    fiatRate = item.fiatRate,
+                    balanceState = item.balanceState,
+                )
+
+                BalanceColumn(
+                    modifier = Modifier.layoutId(layoutId = TangemRowLayoutId.END_TOP),
+                    balanceState = item.balanceState,
+                    isBalanceHidden = item.isBalanceHidden,
+                )
+            },
+        )
+    }
+}
+
+@Composable
+private fun PriceBlock(
+    priceChangeState: PriceChangeState,
+    fiatRate: String?,
+    balanceState: BalanceDisplayState,
+    modifier: Modifier = Modifier,
+) {
+    val isDisabled = remember(balanceState) {
+        balanceState is BalanceDisplayState.Unreachable
+    }
+
+    Row(
+        modifier = modifier,
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(TangemTheme.dimens2.x1),
+    ) {
+        if (fiatRate != null) {
+            Text(
+                text = fiatRate,
+                style = TangemTheme.typography2.captionMedium12,
+                color = if (isDisabled) {
+                    TangemTheme.colors2.text.status.disabled
+                } else {
+                    TangemTheme.colors2.text.neutral.secondary
+                },
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+            )
+        }
+
+        AnimatedContent(
+            targetState = priceChangeState,
+            contentKey = { it::class },
+        ) { animatedState ->
+            when (animatedState) {
+                is PriceChangeState.Content -> {
+                    PriceChangeInPercent(
+                        valueInPercent = animatedState.valueInPercent,
+                        type = animatedState.type,
+                        textStyle = TangemTheme.typography2.captionMedium12,
+                        isDisabled = isDisabled,
+                    )
+                }
+                PriceChangeState.Unknown -> Unit
+            }
+        }
+    }
+}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/ui/search/preview/SearchContentPreview.kt

@@ -2,11 +2,7 @@ package com.tangem.features.feed.ui.search.preview
 
 import android.content.res.Configuration
 import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
@@ -15,7 +11,10 @@ import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import androidx.compose.ui.unit.dp
 import com.tangem.common.ui.charts.state.MarketChartRawData
 import com.tangem.common.ui.markets.models.MarketsListItemUM
+import com.tangem.core.ui.components.currency.icon.CurrencyIconState
+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.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreviewRedesign
@@ -206,18 +205,28 @@ internal object SearchContentPreviewFixtures {
         updateTimestamp = updateTimestamp,
     )
 
-    private fun userAsset(
-        id: String,
-        name: String,
-        symbol: String,
-        accountName: String,
-        iconUrl: String? = null,
-    ): UserAssetItemUM = UserAssetItemUM(
+    private fun userAsset(id: String, name: String, symbol: String): UserAssetItemUM = UserAssetItemUM.Single(
         id = id,
-        tokenIconUrl = iconUrl,
+        icon = TangemIconUM.Currency(
+            CurrencyIconState.CoinIcon(
+                url = null,
+                fallbackResId = com.tangem.core.ui.R.drawable.ic_ethereumpow_22,
+                isGrayscale = false,
+                shouldShowCustomBadge = false,
+            ),
+        ),
         tokenName = name,
         tokenSymbol = symbol,
-        accountName = accountName,
+        fiatRate = "$98,765.43",
+        priceChangeState = PriceChangeState.Content(
+            type = PriceChangeType.UP,
+            valueInPercent = "+2.34%",
+        ),
+        balanceState = BalanceDisplayState.Loaded(
+            cryptoBalance = stringReference("1.234 $symbol"),
+            fiatBalance = stringReference("$121,876.50"),
+        ),
+        isBalanceHidden = false,
         onClick = {},
     )
 
@@ -251,13 +260,8 @@ internal object SearchContentPreviewFixtures {
     )
 
     private fun portfolioTwo(): ImmutableList<UserAssetItemUM> = persistentListOf(
-        userAsset(id = "p1", name = "Ethereum", symbol = "ETH", accountName = "Main wallet"),
-        userAsset(
-            id = "p2",
-            name = "Polygon",
-            symbol = "POL",
-            accountName = "Account with a long label for preview",
-        ),
+        userAsset(id = "p1", name = "Ethereum", symbol = "ETH"),
+        userAsset(id = "p2", name = "Polygon", symbol = "POL"),
     )
 
     private fun marketListShort(): ImmutableList<MarketsListItemUM> = persistentListOf(
@@ -390,6 +394,7 @@ private val SearchContentPreviewCallbacks = SearchCallbacks(
     onClearHintsClick = {},
     onTextHintClick = { _ -> },
     onResultMarketTokenClick = { _ -> },
+    onHistoryTokenClick = { _ -> },
 )
 
 /** All [SearchContentPreviewScenario] values for the Preview Parameter dropdown in Android Studio. */

features/feed/impl/src/main/kotlin/com/tangem/features/feed/ui/search/preview/UserAssetItemPreview.kt

@@ -0,0 +1,238 @@
+package com.tangem.features.feed.ui.search.preview
+
+import android.content.res.Configuration
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+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 com.tangem.core.ui.components.currency.icon.CurrencyIconState
+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.res.TangemTheme
+import com.tangem.core.ui.res.TangemThemePreviewRedesign
+import com.tangem.features.feed.ui.search.components.GroupedUserAssetItem
+import com.tangem.features.feed.ui.search.components.SingleUserAssetItem
+import com.tangem.features.feed.ui.search.state.BalanceDisplayState
+import com.tangem.features.feed.ui.search.state.UserAssetItemUM
+import kotlinx.collections.immutable.persistentListOf
+
+/** Labeled UI state for [SingleUserAssetItem] previews (dropdown label in Studio). */
+internal data class SingleUserAssetItemPreviewScenario(
+    val title: String,
+    val item: UserAssetItemUM.Single,
+)
+
+/** Labeled UI state for [GroupedUserAssetItem] previews. */
+internal data class GroupedUserAssetItemPreviewScenario(
+    val title: String,
+    val item: UserAssetItemUM.Grouped,
+)
+
+@Suppress("StringLiteralDuplication")
+internal object UserAssetItemPreviewFixtures {
+
+    private val sampleIcon = TangemIconUM.Currency(
+        CurrencyIconState.CoinIcon(
+            url = null,
+            fallbackResId = com.tangem.core.ui.R.drawable.ic_ethereumpow_22,
+            isGrayscale = false,
+            shouldShowCustomBadge = false,
+        ),
+    )
+
+    private val cryptoRef = stringReference("1.234 ETH")
+    private val fiatRef = stringReference("$121,876.50")
+
+    private val samplePriceChange = PriceChangeState.Content(
+        valueInPercent = "+2.34%",
+        type = PriceChangeType.UP,
+    )
+
+    private fun balanceLoaded() = BalanceDisplayState.Loaded(
+        cryptoBalance = cryptoRef,
+        fiatBalance = fiatRef,
+    )
+
+    private fun balanceFlickering() = BalanceDisplayState.Flickering(
+        cryptoBalance = cryptoRef,
+        fiatBalance = fiatRef,
+    )
+
+    private fun balanceStale() = BalanceDisplayState.Stale(
+        cryptoBalance = cryptoRef,
+        fiatBalance = fiatRef,
+    )
+
+    private fun balanceLoading() = BalanceDisplayState.Loading
+
+    private fun balanceUnreachable() = BalanceDisplayState.Unreachable
+
+    fun allSingleScenarios(): List<SingleUserAssetItemPreviewScenario> = listOf(
+        SingleUserAssetItemPreviewScenario(
+            title = "Hidden (balanceState ignored)",
+            item = single(
+                balanceState = balanceLoaded(),
+                isBalanceHidden = true,
+            ),
+        ),
+        SingleUserAssetItemPreviewScenario(
+            title = "Balance – Loaded",
+            item = single(balanceState = balanceLoaded(), isBalanceHidden = false),
+        ),
+        SingleUserAssetItemPreviewScenario(
+            title = "Balance – Flickering",
+            item = single(balanceState = balanceFlickering(), isBalanceHidden = false),
+        ),
+        SingleUserAssetItemPreviewScenario(
+            title = "Balance – Stale",
+            item = single(balanceState = balanceStale(), isBalanceHidden = false),
+        ),
+        SingleUserAssetItemPreviewScenario(
+            title = "Balance – Loading",
+            item = single(balanceState = balanceLoading(), isBalanceHidden = false),
+        ),
+        SingleUserAssetItemPreviewScenario(
+            title = "Balance – Unreachable",
+            item = single(balanceState = balanceUnreachable(), isBalanceHidden = false),
+        ),
+    )
+
+    fun allGroupedScenarios(): List<GroupedUserAssetItemPreviewScenario> = listOf(
+        GroupedUserAssetItemPreviewScenario(
+            title = "Hidden (balanceState ignored)",
+            item = grouped(
+                balanceState = balanceLoaded(),
+                isBalanceHidden = true,
+            ),
+        ),
+        GroupedUserAssetItemPreviewScenario(
+            title = "Balance – Loaded",
+            item = grouped(balanceState = balanceLoaded(), isBalanceHidden = false),
+        ),
+        GroupedUserAssetItemPreviewScenario(
+            title = "Balance – Flickering",
+            item = grouped(balanceState = balanceFlickering(), isBalanceHidden = false),
+        ),
+        GroupedUserAssetItemPreviewScenario(
+            title = "Balance – Stale",
+            item = grouped(balanceState = balanceStale(), isBalanceHidden = false),
+        ),
+        GroupedUserAssetItemPreviewScenario(
+            title = "Balance – Loading",
+            item = grouped(balanceState = balanceLoading(), isBalanceHidden = false),
+        ),
+        GroupedUserAssetItemPreviewScenario(
+            title = "Balance – Unreachable",
+            item = grouped(balanceState = balanceUnreachable(), isBalanceHidden = false),
+        ),
+    )
+
+    private fun single(balanceState: BalanceDisplayState, isBalanceHidden: Boolean): UserAssetItemUM.Single =
+        UserAssetItemUM.Single(
+            id = "single_preview",
+            icon = sampleIcon,
+            tokenName = "Ethereum",
+            tokenSymbol = "ETH",
+            fiatRate = "$98,765.43",
+            priceChangeState = samplePriceChange,
+            balanceState = balanceState,
+            isBalanceHidden = isBalanceHidden,
+            onClick = {},
+        )
+
+    private fun grouped(balanceState: BalanceDisplayState, isBalanceHidden: Boolean): UserAssetItemUM.Grouped =
+        UserAssetItemUM.Grouped(
+            id = "grouped_preview",
+            icon = sampleIcon,
+            tokenName = "Ethereum",
+            tokenSymbol = "ETH",
+            tokensCount = 3,
+            balanceState = balanceState,
+            isBalanceHidden = isBalanceHidden,
+            children = persistentListOf(),
+            onClick = {},
+        )
+}
+
+internal class SingleUserAssetItemPreviewParameterProvider :
+    PreviewParameterProvider<SingleUserAssetItemPreviewScenario> {
+    override val values: Sequence<SingleUserAssetItemPreviewScenario>
+        get() = UserAssetItemPreviewFixtures.allSingleScenarios().asSequence()
+}
+
+internal class GroupedUserAssetItemPreviewParameterProvider :
+    PreviewParameterProvider<GroupedUserAssetItemPreviewScenario> {
+    override val values: Sequence<GroupedUserAssetItemPreviewScenario>
+        get() = UserAssetItemPreviewFixtures.allGroupedScenarios().asSequence()
+}
+
+@Composable
+private fun SingleUserAssetItemPreviewHost(
+    scenario: SingleUserAssetItemPreviewScenario,
+    modifier: Modifier = Modifier,
+) {
+    Box(
+        modifier = modifier
+            .fillMaxWidth()
+            .background(TangemTheme.colors2.surface.level1)
+            .padding(8.dp),
+    ) {
+        SingleUserAssetItem(item = scenario.item)
+    }
+}
+
+@Composable
+private fun GroupedUserAssetItemPreviewHost(
+    scenario: GroupedUserAssetItemPreviewScenario,
+    modifier: Modifier = Modifier,
+) {
+    Box(
+        modifier = modifier
+            .fillMaxWidth()
+            .background(TangemTheme.colors2.surface.level1)
+            .padding(8.dp),
+    ) {
+        GroupedUserAssetItem(item = scenario.item)
+    }
+}
+
+@Composable
+@Preview(name = "Single – all balance states (parameter)", showBackground = true, widthDp = 360)
+@Preview(
+    name = "Single – all balance states (night)",
+    showBackground = true,
+    widthDp = 360,
+    uiMode = Configuration.UI_MODE_NIGHT_YES,
+)
+private fun SingleUserAssetItemPreview_AllBalanceStates(
+    @PreviewParameter(SingleUserAssetItemPreviewParameterProvider::class) scenario: SingleUserAssetItemPreviewScenario,
+) {
+    TangemThemePreviewRedesign {
+        SingleUserAssetItemPreviewHost(scenario = scenario)
+    }
+}
+
+@Composable
+@Preview(name = "Grouped – all balance states (parameter)", showBackground = true, widthDp = 360)
+@Preview(
+    name = "Grouped – all balance states (night)",
+    showBackground = true,
+    widthDp = 360,
+    uiMode = Configuration.UI_MODE_NIGHT_YES,
+)
+private fun GroupedUserAssetItemPreview_AllBalanceStates(
+    @PreviewParameter(GroupedUserAssetItemPreviewParameterProvider::class)
+    scenario: GroupedUserAssetItemPreviewScenario,
+) {
+    TangemThemePreviewRedesign {
+        GroupedUserAssetItemPreviewHost(scenario = scenario)
+    }
+}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/ui/search/state/SearchCallbacks.kt

@@ -7,4 +7,5 @@ internal data class SearchCallbacks(
     val onClearHintsClick: () -> Unit,
     val onTextHintClick: (hint: String) -> Unit,
     val onResultMarketTokenClick: (MarketsListItemUM) -> Unit,
+    val onHistoryTokenClick: (MarketsListItemUM) -> Unit,
 )

features/feed/impl/src/main/kotlin/com/tangem/features/feed/ui/search/state/SearchUM.kt

@@ -1,8 +1,14 @@
 package com.tangem.features.feed.ui.search.state
 
 import androidx.compose.runtime.Immutable
+import com.tangem.common.ui.account.AccountNameUM
 import com.tangem.common.ui.markets.models.MarketsListItemUM
 import com.tangem.core.ui.components.fields.entity.SearchBarUM
+import com.tangem.core.ui.components.marketprice.PriceChangeState
+import com.tangem.core.ui.ds.image.TangemIconUM
+import com.tangem.core.ui.extensions.TextReference
+import com.tangem.domain.models.account.CryptoPortfolioIcon
+import com.tangem.domain.models.currency.CryptoCurrencyStatus
 import kotlinx.collections.immutable.ImmutableList
 
 data class SearchUM(
@@ -42,11 +48,65 @@ sealed interface MarketSearchResultUM {
 
 data class TextHintItemUM(val text: String)
 
-data class UserAssetItemUM(
-    val id: String,
-    val tokenIconUrl: String?,
-    val tokenName: String,
-    val tokenSymbol: String,
-    val accountName: String,
-    val onClick: () -> Unit,
-)
+@Immutable
+sealed interface BalanceDisplayState {
+
+    data class Loaded(
+        val cryptoBalance: TextReference,
+        val fiatBalance: TextReference,
+    ) : BalanceDisplayState
+
+    data class Flickering(
+        val cryptoBalance: TextReference,
+        val fiatBalance: TextReference,
+    ) : BalanceDisplayState
+
+    data class Stale(
+        val cryptoBalance: TextReference,
+        val fiatBalance: TextReference,
+    ) : BalanceDisplayState
+
+    data object Loading : BalanceDisplayState
+    data object Unreachable : BalanceDisplayState
+}
+
+@Immutable
+sealed interface UserAssetItemUM {
+    val id: String
+    val icon: TangemIconUM
+    val tokenName: String
+    val tokenSymbol: String
+    val onClick: () -> Unit
+
+    data class Single(
+        override val id: String,
+        override val icon: TangemIconUM,
+        override val tokenName: String,
+        override val tokenSymbol: String,
+        val fiatRate: String?,
+        val priceChangeState: PriceChangeState,
+        val balanceState: BalanceDisplayState,
+        val isBalanceHidden: Boolean,
+        override val onClick: () -> Unit,
+    ) : UserAssetItemUM
+
+    data class Grouped(
+        override val id: String,
+        override val icon: TangemIconUM,
+        override val tokenName: String,
+        override val tokenSymbol: String,
+        val tokensCount: Int,
+        val balanceState: BalanceDisplayState,
+        val isBalanceHidden: Boolean,
+        val children: ImmutableList<GroupedChild>,
+        override val onClick: () -> Unit,
+    ) : UserAssetItemUM
+
+    data class GroupedChild(
+        val walletName: String,
+        val accountName: AccountNameUM,
+        val accountIcon: CryptoPortfolioIcon.Icon,
+        val accountColor: CryptoPortfolioIcon.Color,
+        val currencyStatus: CryptoCurrencyStatus,
+    )
+}

features/feed/impl/src/main/kotlin/com/tangem/features/feed/ui/utils/EntryContentAnimationTransitions.kt

@@ -27,11 +27,7 @@ internal fun contentFeedEntryStackAnimation(): StackAnimation<
     ComposableModularBottomSheetContentComponent,
     > =
     stackAnimation { to, from, _ ->
-        val isSearchToTokenList =
-            (to.configuration as? FeedEntryChildFactory.Child.TokenList)?.params?.shouldAlwaysShowSearchBar == true
-        val isFromSearchTokenList =
-            (from.configuration as? FeedEntryChildFactory.Child.TokenList)?.params?.shouldAlwaysShowSearchBar == true
-        if (isSearchToTokenList || isFromSearchTokenList) {
+        if (to.configuration.usesFadeStackTransition() || from.configuration.usesFadeStackTransition()) {
             fade()
         } else {
             slide()

features/hot-wallet/api/src/main/kotlin/com/tangem/features/hotwallet/HotWalletFeatureToggles.kt

@@ -2,5 +2,5 @@ package com.tangem.features.hotwallet
 
 interface HotWalletFeatureToggles {
     val isWalletCreationRestrictionEnabled: Boolean
-    val isTokenSyncEnabled: Boolean
+    val isAssetsDiscoveryEnabled: Boolean
 }

features/hot-wallet/impl/build.gradle.kts

@@ -38,7 +38,7 @@ dependencies {
     implementation(projects.domain.feedback)
     implementation(projects.domain.feedback.models)
     implementation(projects.domain.hotWallet)
-    implementation(projects.domain.tokensync)
+    implementation(projects.domain.assetsdiscovery)
 
     /** Common */
     implementation(projects.common.ui)

features/hot-wallet/impl/src/main/kotlin/com/tangem/features/hotwallet/DefaultHotWalletFeatureToggles.kt

@@ -10,6 +10,6 @@ internal class DefaultHotWalletFeatureToggles(
     override val isWalletCreationRestrictionEnabled: Boolean
         get() = featureTogglesManager.isFeatureEnabled(FeatureToggles.HOT_WALLET_CREATION_RESTRICTION_ENABLED)
 
-    override val isTokenSyncEnabled: Boolean
-        get() = featureTogglesManager.isFeatureEnabled(FeatureToggles.TOKEN_SYNC_ENABLED)
+    override val isAssetsDiscoveryEnabled: Boolean
+        get() = featureTogglesManager.isFeatureEnabled(FeatureToggles.ASSETS_DISCOVERY_ENABLED)
 }

features/hot-wallet/impl/src/main/kotlin/com/tangem/features/hotwallet/accesscoderequest/HotAccessCodeRequestModel.kt

@@ -11,7 +11,7 @@ import com.tangem.core.ui.extensions.wrappedList
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.settings.CanUseBiometryUseCase
-import com.tangem.domain.tokensync.usecase.StartTokenSyncUseCase
+import com.tangem.domain.assetsdiscovery.usecase.StartAssetsDiscoveryUseCase
 import com.tangem.domain.wallets.hot.HotWalletAccessCodeAttemptsRepository
 import com.tangem.domain.wallets.hot.HotWalletAccessCodeAttemptsRepository.Attempts
 import com.tangem.domain.wallets.hot.HotWalletAccessCodeAttemptsRepository.Companion.MAX_FAST_FORWARD_ATTEMPTS
@@ -39,7 +39,7 @@ internal class HotAccessCodeRequestModel @Inject constructor(
     private val userWalletsListRepository: UserWalletsListRepository,
     private val canUseBiometryUseCase: CanUseBiometryUseCase,
     private val analyticsEventHandler: AnalyticsEventHandler,
-    private val startTokenSyncUseCase: StartTokenSyncUseCase,
+    private val startAssetsDiscoveryUseCase: StartAssetsDiscoveryUseCase,
     private val hotWalletFeatureToggles: HotWalletFeatureToggles,
 ) : Model() {
 
@@ -220,8 +220,8 @@ internal class HotAccessCodeRequestModel @Inject constructor(
         val userWallet = userWalletsListRepository.userWalletsSync()
             .firstOrNull { it is UserWallet.Hot && it.hotWalletId == currentRequest.hotWalletId } ?: return
 
-        if (hotWalletFeatureToggles.isTokenSyncEnabled) {
-            startTokenSyncUseCase.cancel(userWallet.walletId)
+        if (hotWalletFeatureToggles.isAssetsDiscoveryEnabled) {
+            startAssetsDiscoveryUseCase.cancel(userWallet.walletId)
         }
 
         userWalletsListRepository.delete(listOf(userWallet.walletId))

features/hot-wallet/impl/src/main/kotlin/com/tangem/features/hotwallet/addexistingwallet/im/port/model/AddExistingWalletImportModel.kt

@@ -17,9 +17,11 @@ import com.tangem.core.ui.message.bottomSheetMessage
 import com.tangem.crypto.bip39.Mnemonic
 import com.tangem.datasource.local.appsflyer.AppsFlyerStore
 import com.tangem.domain.common.wallets.error.SaveWalletError
-import com.tangem.domain.tokensync.usecase.StartTokenSyncUseCase
+import com.tangem.domain.assetsdiscovery.usecase.StartAssetsDiscoveryUseCase
 import com.tangem.domain.wallets.builder.HotUserWalletBuilder
+import com.tangem.domain.wallets.models.WalletSyncResult
 import com.tangem.domain.wallets.usecase.SaveWalletUseCase
+import com.tangem.domain.wallets.usecase.SyncWalletWithRemoteUseCase
 import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.features.hotwallet.MnemonicRepository
 import com.tangem.features.hotwallet.addexistingwallet.im.port.AddExistingWalletImportComponent
@@ -27,6 +29,7 @@ import com.tangem.features.hotwallet.addexistingwallet.im.port.entity.AddExistin
 import com.tangem.hot.sdk.TangemHotSdk
 import com.tangem.hot.sdk.model.HotAuth
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
@@ -42,7 +45,8 @@ internal class AddExistingWalletImportModel @Inject constructor(
     private val tangemHotSdk: TangemHotSdk,
     private val hotUserWalletBuilderFactory: HotUserWalletBuilder.Factory,
     private val saveUserWalletUseCase: SaveWalletUseCase,
-    private val startTokenSyncUseCase: StartTokenSyncUseCase,
+    private val syncWalletWithRemoteUseCase: SyncWalletWithRemoteUseCase,
+    private val startAssetsDiscoveryUseCase: StartAssetsDiscoveryUseCase,
     private val hotWalletFeatureToggles: HotWalletFeatureToggles,
     @GlobalUiMessageSender private val uiMessageSender: UiMessageSender,
     private val analyticsEventHandler: AnalyticsEventHandler,
@@ -114,8 +118,13 @@ internal class AddExistingWalletImportModel @Inject constructor(
                     .onRight {
                         setImportProgress(false)
 
-                        if (hotWalletFeatureToggles.isTokenSyncEnabled) {
-                            startTokenSyncUseCase(userWallet.walletId)
+                        launch(dispatchers.main + NonCancellable) {
+                            val syncResult = syncWalletWithRemoteUseCase(userWallet.walletId)
+                            if (hotWalletFeatureToggles.isAssetsDiscoveryEnabled &&
+                                syncResult == WalletSyncResult.Created
+                            ) {
+                                startAssetsDiscoveryUseCase(userWallet.walletId)
+                            }
                         }
 
                         analyticsEventHandler.send(

features/hot-wallet/impl/src/main/kotlin/com/tangem/features/hotwallet/addexistingwallet/im/port/ui/AddExistingWalletImportContent.kt

@@ -19,6 +19,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.text.input.TextFieldValue
@@ -39,6 +40,7 @@ import com.tangem.core.ui.components.PrimaryButton
 import com.tangem.core.ui.components.TangemTextFieldsDefault
 import com.tangem.core.ui.components.keyboardAsState
 import com.tangem.core.ui.extensions.resolveReference
+import com.tangem.core.ui.test.ImportWalletScreenTestTags
 import com.tangem.features.hotwallet.addexistingwallet.im.port.ui.utils.InvalidWordsColorTransformation
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
@@ -73,9 +75,10 @@ internal fun AddExistingWalletImportContent(state: AddExistingWalletImportUM, mo
                 )
 
                 OutlineTextFieldWithIcon(
-                    modifier = modifier
+                    modifier = Modifier
                         .padding(horizontal = 16.dp)
-                        .fillMaxWidth(),
+                        .fillMaxWidth()
+                        .testTag(ImportWalletScreenTestTags.PASSPHRASE_TEXT_FIELD),
                     value = state.passPhrase,
                     onValueChange = state.passPhraseChange,
                     iconResId = R.drawable.ic_information_24,
@@ -130,7 +133,8 @@ private fun PhraseBlock(state: AddExistingWalletImportUM, modifier: Modifier = M
         OutlinedTextField(
             modifier = Modifier
                 .fillMaxWidth()
-                .height(TangemTheme.dimens.size142),
+                .height(TangemTheme.dimens.size142)
+                .testTag(ImportWalletScreenTestTags.PHRASE_TEXT_FIELD),
             value = state.words,
             onValueChange = state.wordsChange,
             textStyle = TangemTheme.typography.body1,

features/hot-wallet/impl/src/main/kotlin/com/tangem/features/hotwallet/forgetwallet/ForgetWalletModel.kt

@@ -12,7 +12,7 @@ import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.core.ui.message.DialogMessage
 import com.tangem.core.ui.message.EventMessageAction
 import com.tangem.core.ui.message.SnackbarMessage
-import com.tangem.domain.tokensync.usecase.StartTokenSyncUseCase
+import com.tangem.domain.assetsdiscovery.usecase.StartAssetsDiscoveryUseCase
 import com.tangem.domain.wallets.usecase.DeleteWalletUseCase
 import com.tangem.features.hotwallet.ForgetWalletComponent
 import com.tangem.features.hotwallet.HotWalletFeatureToggles
@@ -33,7 +33,7 @@ internal class ForgetWalletModel @Inject constructor(
     private val router: Router,
     private val deleteWalletUseCase: DeleteWalletUseCase,
     private val uiMessageSender: UiMessageSender,
-    private val startTokenSyncUseCase: StartTokenSyncUseCase,
+    private val startAssetsDiscoveryUseCase: StartAssetsDiscoveryUseCase,
     private val hotWalletFeatureToggles: HotWalletFeatureToggles,
 ) : Model() {
 
@@ -84,8 +84,8 @@ internal class ForgetWalletModel @Inject constructor(
 
     private fun forgetWallet() {
         modelScope.launch {
-            if (hotWalletFeatureToggles.isTokenSyncEnabled) {
-                startTokenSyncUseCase.cancel(params.userWalletId)
+            if (hotWalletFeatureToggles.isAssetsDiscoveryEnabled) {
+                startAssetsDiscoveryUseCase.cancel(params.userWalletId)
             }
 
             val hasUserWallets = deleteWalletUseCase(params.userWalletId)

features/manage-tokens/api/src/main/kotlin/com/tangem/features/managetokens/component/ManageTokensSource.kt

@@ -9,6 +9,7 @@ enum class ManageTokensSource(val analyticsName: String) {
     ONBOARDING(analyticsName = "Onboarding"),
     SETTINGS(analyticsName = "Wallet Settings"),
     ACCOUNT(analyticsName = "Account"),
+    WALLET(analyticsName = "Wallet"),
     SEND_VIA_SWAP(analyticsName = "SendViaSwap"),
 }
 

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/component/preview/PreviewCustomTokenSelectorComponent.kt

@@ -57,7 +57,6 @@ internal class PreviewCustomTokenSelectorComponent(
                 CurrencyNetworkUM(
                     network = Network(
                         id = n.id,
-                        backendId = n.id.rawId.value,
                         name = "Network $index",
                         currencySymbol = "N$index",
                         derivationPath = Network.DerivationPath.Card(""),

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/component/preview/PreviewManageTokensComponent.kt

@@ -154,7 +154,6 @@ internal class PreviewManageTokensComponent(
         CurrencyNetworkUM(
             network = Network(
                 id = Network.ID(value = networkIndex.toString(), derivationPath = derivationPath),
-                backendId = networkIndex.toString(),
                 name = "Network $networkIndex",
                 currencySymbol = "N$networkIndex",
                 derivationPath = derivationPath,

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/component/preview/PreviewOnboardingManageTokensComponent.kt

@@ -95,7 +95,6 @@ internal class PreviewOnboardingManageTokensComponent(
         CurrencyNetworkUM(
             network = Network(
                 id = Network.ID(value = networkIndex.toString(), derivationPath = derivationPath),
-                backendId = networkIndex.toString(),
                 name = "Network $networkIndex",
                 currencySymbol = "N$networkIndex",
                 derivationPath = derivationPath,

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/model/CustomTokenFormModel.kt

@@ -183,7 +183,7 @@ internal class CustomTokenFormModel @Inject constructor(
     ) = modelScope.launch {
         val isNeedColdWalletInteraction = coldWalletAndHasMissedDerivationsUseCase.invoke(
             userWalletId = params.mode.userWalletId,
-            networksWithDerivationPath = mapOf(currency.network.backendId to getDerivationPath().value),
+            networksWithDerivationPath = mapOf(currency.network.rawId to getDerivationPath().value),
         )
 
         state.update { state ->

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/model/CustomTokenSelectorModel.kt

@@ -3,7 +3,7 @@ package com.tangem.features.managetokens.model
 import arrow.core.getOrElse
 import com.arkivanov.decompose.router.slot.SlotNavigation
 import com.arkivanov.decompose.router.slot.activate
-import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchainsdk.utils.toBlockchain
 import com.tangem.common.ui.account.toUM
 import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.Model
@@ -199,7 +199,7 @@ internal class CustomTokenSelectorModel @Inject constructor(
     private fun DerivationPathSelector.checkAccountDerivation(derivationPath: SelectedDerivationPath) =
         modelScope.launch {
             val account = derivationPath.id
-                ?.let { Blockchain.fromId(it.rawId.value) }
+                ?.toBlockchain()
                 ?.let(::AccountNodeRecognizer)
                 ?.let { recognizer ->
                     val derivationPathValue = derivationPath.value.value

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/model/ManageTokensModel.kt

@@ -293,7 +293,7 @@ internal class ManageTokensModel @Inject constructor(
             val networks = currenciesToAdd.values
                 .flatten()
                 .toSet()
-                .associate { network -> network.backendId to network.derivationPath.value }
+                .associate { network -> network.rawId to network.derivationPath.value }
             val isNeedToInteractWithColdWallet = useCasesFacade.needColdWalletInteraction(networks)
 
             state.update { state ->

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/model/OnboardingManageTokensModel.kt

@@ -212,7 +212,7 @@ internal class OnboardingManageTokensModel @Inject constructor(
             val network = currenciesToAdd.values
                 .flatten()
                 .toSet()
-                .associate { network -> network.backendId to network.derivationPath.value }
+                .associate { network -> network.rawId to network.derivationPath.value }
             val shouldShowTangemIcon = useCasesFacade.needColdWalletInteraction(network = network)
             state.update { state ->
                 state.copy(

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/utils/list/CustomTokenFormUseCasesFacade.kt

@@ -81,7 +81,7 @@ internal class CustomTokenFormUseCasesFacade @AssistedInject constructor(
 
     private fun CryptoCurrency.getAccountIndex(): Either<Throwable, Int> = either {
         val currency = this@getAccountIndex
-        val blockchain = Blockchain.fromNetworkId(networkId = currency.network.backendId)
+        val blockchain = Blockchain.fromNetworkId(networkId = currency.network.rawId)
         if (blockchain == null) {
             val exception = IllegalStateException("Token has unknown networkId: ${currency.id}")
             TangemLogger.e("Error", exception)

features/manage-tokens/impl/src/main/kotlin/com/tangem/features/managetokens/utils/list/ManageTokensUseCasesFacade.kt

@@ -79,7 +79,7 @@ internal class ManageTokensUseCasesFacade @AssistedInject constructor(
                     ?: return IllegalStateException("Account not found").left()
 
                 (account.cryptoCurrencies + added - removed).any { currency ->
-                    currency is CryptoCurrency.Token && currency.network.backendId == network.backendId &&
+                    currency is CryptoCurrency.Token && currency.network.rawId == network.rawId &&
                         currency.network.derivationPath == network.derivationPath
                 }
                     .right()

features/markets/impl/src/main/kotlin/com/tangem/features/markets/token/block/impl/ui/TokenMarketBlockLegacy.kt

@@ -106,6 +106,7 @@ private fun LeftSide(
                         modifier = Modifier.alignByBaseline(),
                         valueInPercent = percentText,
                         type = type,
+                        textStyle = TangemTheme.typography.body2,
                     )
                     Text(
                         modifier = Modifier.alignByBaseline(),

features/onramp/impl/build.gradle.kts

@@ -12,6 +12,9 @@ android {
 }
 
 dependencies {
+    /** Api */
+    implementation(projects.features.commonFeatures.api)
+
     /** Project - API */
     implementation(projects.features.account.api)
     implementation(projects.features.onramp.api)

features/onramp/impl/src/main/kotlin/com/tangem/features/onramp/hottokens/portfolio/model/OnrampAddTokenModel.kt

@@ -50,7 +50,7 @@ internal class OnrampAddTokenModel @Inject constructor(
             .distinctUntilChanged()
             .mapLatest { tokenToAdd: AddHotCryptoData ->
                 addTokenJob.join()
-                val backendId = tokenToAdd.cryptoCurrency.network.backendId
+                val backendId = tokenToAdd.cryptoCurrency.network.rawId
                 val userWalletId = tokenToAdd.account.accountId.userWalletId
                 val isTangemIconVisible = needColdWalletInteraction(
                     walletId = userWalletId,

features/onramp/impl/src/main/kotlin/com/tangem/features/onramp/swap/DefaultSwapSelectTokensComponent.kt

@@ -15,7 +15,7 @@ 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.ComposableBottomSheetComponent
-import com.tangem.features.feed.components.market.details.portfolio.add.AddToPortfolioComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioComponent
 import com.tangem.features.onramp.component.SwapSelectTokensComponent
 import com.tangem.features.onramp.swap.availablepairs.AvailableSwapPairsComponent
 import com.tangem.features.onramp.swap.availablepairs.model.AddToPortfolioRoute

features/onramp/impl/src/main/kotlin/com/tangem/features/onramp/swap/availablepairs/AvailableSwapPairsComponent.kt

@@ -7,8 +7,8 @@ import com.tangem.core.ui.components.token.state.TokenItemState
 import com.tangem.core.ui.decompose.ComposableListContentComponent
 import com.tangem.domain.models.currency.CryptoCurrencyStatus
 import com.tangem.domain.models.wallet.UserWalletId
-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.AddToPortfolioComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager
 import com.tangem.features.onramp.swap.availablepairs.model.AddToPortfolioRoute
 import com.tangem.features.onramp.tokenlist.entity.TokenListUM
 import kotlinx.coroutines.flow.StateFlow

features/onramp/impl/src/main/kotlin/com/tangem/features/onramp/swap/availablepairs/DefaultAvailableSwapPairsComponent.kt

@@ -6,8 +6,8 @@ import androidx.compose.ui.Modifier
 import com.arkivanov.decompose.router.slot.SlotNavigation
 import com.tangem.core.decompose.context.AppComponentContext
 import com.tangem.core.decompose.model.getOrCreateModel
-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.AddToPortfolioComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager
 import com.tangem.features.onramp.swap.availablepairs.model.AddToPortfolioRoute
 import com.tangem.features.onramp.swap.availablepairs.model.AvailableSwapPairsModel
 import com.tangem.features.onramp.tokenlist.entity.TokenListUM

features/onramp/impl/src/main/kotlin/com/tangem/features/onramp/swap/availablepairs/model/AvailableSwapPairsModel.kt

@@ -41,8 +41,8 @@ import com.tangem.domain.wallets.usecase.GetWalletsUseCase
 import com.tangem.feature.swap.domain.GetAvailablePairsUseCase
 import com.tangem.feature.swap.domain.models.domain.LeastTokenInfo
 import com.tangem.feature.swap.domain.models.domain.SwapPairLeast
-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.AddToPortfolioComponent
+import com.tangem.features.commonfeatures.api.addtoportfolio.AddToPortfolioManager
 import com.tangem.features.onramp.impl.R
 import com.tangem.features.onramp.swap.availablepairs.AvailableSwapPairsComponent
 import com.tangem.features.onramp.swap.availablepairs.entity.transformers.SetErrorWarningTransformer
@@ -251,7 +251,7 @@ internal class AvailableSwapPairsModel @Inject constructor(
             .associate { accountStatus ->
                 val statuses = accountStatus.tokenList.flattenCurrencies()
                     .filterNot { status ->
-                        status.currency.network.backendId == selectedStatus?.currency?.network?.backendId &&
+                        status.currency.network.rawId == selectedStatus?.currency?.network?.rawId &&
                             status.currency.id.contractAddress == selectedStatus.currency.id.contractAddress
                     }
                     .filterByQuery(query = query)
@@ -458,7 +458,7 @@ internal class AvailableSwapPairsModel @Inject constructor(
     private fun CryptoCurrencyStatus.toLeastTokenInfo(): LeastTokenInfo {
         return LeastTokenInfo(
             contractAddress = (currency as? CryptoCurrency.Token)?.contractAddress ?: "0",
-            network = currency.network.backendId,
+            network = currency.network.rawId,
         )
     }
 
@@ -603,7 +603,7 @@ internal class AvailableSwapPairsModel @Inject constructor(
 
             val networks = tokenMarket.networks?.filter { network ->
                 BlockchainUtils.isSupportedNetworkId(
-                    blockchainId = network.networkId,
+                    networkId = network.networkId,
                     coinId = tokenMarket.id.value,
                     contractAddress = network.contractAddress,
                     excludedBlockchains = excludedBlockchains,

features/send-v2/impl/src/main/java/com/tangem/features/send/v2/feeselector/component/extended/ui/FeeExtendedSelectorContent.kt

@@ -133,7 +133,6 @@ private fun Preview() {
                     value = "bitcoin",
                     derivationPath = Network.DerivationPath.None,
                 ),
-                backendId = "bitcoin",
                 name = "Bitcoin",
                 currencySymbol = "BTC",
                 derivationPath = Network.DerivationPath.None,

features/send-v2/impl/src/main/java/com/tangem/features/send/v2/feeselector/component/speed/ui/FeeSpeedSelectorContent.kt

@@ -516,7 +516,6 @@ private val cryptoCurrencyStatus
                     value = "bitcoin",
                     derivationPath = Network.DerivationPath.None,
                 ),
-                backendId = "bitcoin",
                 name = "Bitcoin",
                 currencySymbol = "BTC",
                 derivationPath = Network.DerivationPath.None,

features/send-v2/impl/src/main/java/com/tangem/features/send/v2/feeselector/component/token/ui/FeeTokenSelectorContent.kt

@@ -171,7 +171,6 @@ private fun Preview() {
                     value = "bitcoin",
                     derivationPath = Network.DerivationPath.None,
                 ),
-                backendId = "bitcoin",
                 name = "Bitcoin",
                 currencySymbol = "BTC",
                 derivationPath = Network.DerivationPath.None,

features/send-v2/impl/src/main/java/com/tangem/features/send/v2/feeselector/ui/FeeSelectorBlockContent.kt

@@ -258,7 +258,6 @@ private class FeeSelectorUMProvider : PreviewParameterProvider<FeeSelectorUM> {
                         value = "bitcoin",
                         derivationPath = Network.DerivationPath.None,
                     ),
-                    backendId = "bitcoin",
                     name = "Bitcoin",
                     currencySymbol = "BTC",
                     derivationPath = Network.DerivationPath.None,