Updated on 2026-08-14

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

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

features/account/impl/src/main/java/com/tangem/features/account/fetcher/DefaultPortfolioFetcher.kt

@@ -1,96 +0,0 @@
-package com.tangem.features.account.fetcher
-
-import com.tangem.domain.account.models.AccountStatusList
-import com.tangem.domain.account.status.producer.SingleAccountStatusListProducer
-import com.tangem.domain.account.status.supplier.SingleAccountStatusListSupplier
-import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
-import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.models.wallet.isMultiCurrency
-import com.tangem.domain.wallets.usecase.GetWalletsUseCase
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.account.PortfolioFetcher.*
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.channels.BufferOverflow
-import kotlinx.coroutines.flow.*
-
-@Suppress("LongParameterList")
-internal class DefaultPortfolioFetcher @AssistedInject constructor(
-    private val getSelectedAppCurrencyUseCase: GetSelectedAppCurrencyUseCase,
-    private val getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
-    private val singleAccountStatusListSupplier: SingleAccountStatusListSupplier,
-    private val getWallets: GetWalletsUseCase,
-    dispatchers: CoroutineDispatcherProvider,
-    @Assisted mode: Mode,
-    @Assisted private val scope: CoroutineScope,
-) : PortfolioFetcher {
-
-    private val _mode = MutableStateFlow(mode)
-    private val _data = MutableSharedFlow<Data>(
-        replay = 1,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST,
-    )
-
-    override val data: Flow<Data>
-        get() = _data.distinctUntilChanged()
-    override val mode: StateFlow<Mode>
-        get() = _mode
-
-    init {
-        _mode
-            // reset cache if mode(StateFlow) changed
-            .onEach { _data.resetReplayCache() }
-            .flatMapLatest(::combineUseCases)
-            .flowOn(dispatchers.default)
-            .onEach { _data.emit(it) }
-            .launchIn(scope)
-    }
-
-    override fun updateMode(mode: Mode) {
-        _mode.value = mode
-    }
-
-    private fun combineUseCases(mode: Mode) = combine(
-        flow = getWallets()
-            .map { it.filterWallets(mode) }
-            .distinctUntilChanged()
-            .flatMapLatest { wallets -> balancesForWallets(wallets) },
-        flow2 = getSelectedAppCurrencyUseCase.invokeOrDefault(),
-        flow3 = getBalanceHidingSettingsUseCase.isBalanceHidden(),
-    ) { balances, appCurrency, isBalanceHiding ->
-        Data(
-            appCurrency = appCurrency,
-            isBalanceHidden = isBalanceHiding,
-            balances = balances,
-        )
-    }
-
-    private fun List<UserWallet>.filterWallets(mode: Mode): List<UserWallet> = this.filter { wallet ->
-        when (mode) {
-            is Mode.All -> if (mode.isOnlyMultiCurrency) wallet.isMultiCurrency else true
-            is Mode.Wallet -> wallet.walletId == mode.walletId
-        }
-    }
-
-    private fun balancesForWallets(wallets: List<UserWallet>): Flow<Map<UserWalletId, PortfolioBalance>> {
-        if (wallets.isEmpty()) return flowOf(emptyMap())
-        val balanceFlows = wallets.map { walletAccountsBalancesFlow(it) }
-        return combine(balanceFlows) { pairs -> pairs.toMap() }
-    }
-
-    private fun walletAccountsBalancesFlow(wallet: UserWallet): Flow<Pair<UserWalletId, PortfolioBalance>> =
-        accountStatusListFlow(wallet).map { wallet.walletId to PortfolioBalance(wallet, it) }
-
-    private fun accountStatusListFlow(wallet: UserWallet): Flow<AccountStatusList> =
-        singleAccountStatusListSupplier(SingleAccountStatusListProducer.Params(wallet.walletId))
-
-    @AssistedFactory
-    interface Factory : PortfolioFetcher.Factory {
-        override fun create(mode: Mode, scope: CoroutineScope): DefaultPortfolioFetcher
-    }
-}

features/account/impl/src/main/java/com/tangem/features/account/selector/DefaultPortfolioSelectorComponent.kt

@@ -1,59 +0,0 @@
-package com.tangem.features.account.selector
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.tangem.core.decompose.context.AppComponentContext
-import com.tangem.core.decompose.model.getOrCreateModel
-import com.tangem.core.ui.extensions.TextReference
-import com.tangem.features.account.PortfolioSelectorComponent
-import com.tangem.features.account.selector.ui.PortfolioSelectorBS
-import com.tangem.features.account.selector.ui.PortfolioSelectorContent
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-
-internal class DefaultPortfolioSelectorComponent @AssistedInject constructor(
-    @Assisted appComponentContext: AppComponentContext,
-    @Assisted private val params: PortfolioSelectorComponent.Params,
-) : AppComponentContext by appComponentContext, PortfolioSelectorComponent {
-
-    private val model: PortfolioSelectorModel = getOrCreateModel(params)
-
-    override val title: StateFlow<TextReference>
-        get() = model.state
-            .map { it.title }
-            .stateIn(componentScope, SharingStarted.Lazily, model.state.value.title)
-
-    override fun dismiss() {
-        params.bsCallback?.onDismiss()
-    }
-
-    @Composable
-    override fun BottomSheet() {
-        val state by model.state.collectAsStateWithLifecycle()
-        PortfolioSelectorBS(state = state, onDismiss = ::dismiss, onBack = { params.bsCallback?.onBack() })
-    }
-
-    @Composable
-    override fun Content(modifier: Modifier) {
-        val state by model.state.collectAsStateWithLifecycle()
-        PortfolioSelectorContent(
-            state = state,
-            modifier = modifier,
-        )
-    }
-
-    @AssistedFactory
-    interface Factory : PortfolioSelectorComponent.Factory {
-        override fun create(
-            appComponentContext: AppComponentContext,
-            params: PortfolioSelectorComponent.Params,
-        ): DefaultPortfolioSelectorComponent
-    }
-}

features/account/impl/src/main/java/com/tangem/features/account/selector/DefaultPortfolioSelectorController.kt

@@ -1,58 +0,0 @@
-package com.tangem.features.account.selector
-
-import com.tangem.domain.account.status.usecase.IsAccountsModeEnabledUseCase
-import com.tangem.domain.models.account.AccountId
-import com.tangem.domain.models.account.AccountStatus
-import com.tangem.domain.models.account.filterCryptoPortfolio
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.account.PortfolioSelectorController
-import kotlinx.coroutines.channels.BufferOverflow
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.combine
-import javax.inject.Inject
-
-internal class DefaultPortfolioSelectorController @Inject constructor(
-    private val isAccountsModeEnabledUseCase: IsAccountsModeEnabledUseCase,
-) : PortfolioSelectorController {
-
-    private val _selectedAccount: MutableSharedFlow<AccountId?> = MutableSharedFlow(
-        replay = 1,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST,
-    )
-
-    override val isAccountMode: Flow<Boolean> by lazy { isAccountsModeEnabledUseCase() }
-    // without StateFlow and distinctUntilChanged to allow reselect and correct navigation
-    override val selectedAccount: Flow<AccountId?> get() = _selectedAccount
-    override val selectedAccountSync: AccountId? get() = _selectedAccount.replayCache.firstOrNull()
-
-    override val isEnabled: MutableStateFlow<(UserWallet, AccountStatus) -> Boolean> = MutableStateFlow { _, _ -> true }
-
-    override suspend fun isAccountModeSync(): Boolean = isAccountsModeEnabledUseCase.invokeSync()
-
-    override fun selectAccount(accountId: AccountId?) {
-        _selectedAccount.tryEmit(accountId)
-    }
-
-    override fun selectedAccountWithData(
-        portfolioFetcher: PortfolioFetcher,
-    ): Flow<Pair<UserWallet, AccountStatus.CryptoPortfolio>?> = combine(
-        flow = _selectedAccount,
-        flow2 = portfolioFetcher.data,
-        transform = { accountId, data ->
-            accountId ?: return@combine null
-            var result: Pair<UserWallet, AccountStatus.CryptoPortfolio>? = null
-
-            data.balances.forEach { wallet, balance ->
-                val accountStatuses = balance.accountsBalance.accountStatuses
-                    .filterCryptoPortfolio()
-                    .find { accountId == it.account.accountId }
-                if (accountStatuses != null) result = balance.userWallet to accountStatuses
-            }
-
-            return@combine result
-        },
-    )
-}

features/account/impl/src/main/java/com/tangem/features/account/selector/PortfolioSelectorModel.kt

@@ -1,218 +0,0 @@
-package com.tangem.features.account.selector
-
-import com.tangem.common.ui.account.AccountPortfolioItemUMConverter
-import com.tangem.common.ui.userwallet.converter.UserWalletItemUMConverter
-import com.tangem.common.ui.userwallet.state.UserWalletItemUM
-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.extensions.TextReference
-import com.tangem.core.ui.extensions.resourceReference
-import com.tangem.core.ui.extensions.stringReference
-import com.tangem.domain.account.status.usecase.IsAccountsModeEnabledUseCase
-import com.tangem.domain.models.account.AccountId
-import com.tangem.domain.models.account.AccountStatus
-import com.tangem.domain.models.account.filterCryptoPortfolio
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.features.account.PortfolioFetcher
-import com.tangem.features.account.PortfolioSelectorComponent
-import com.tangem.features.account.impl.R
-import com.tangem.features.account.selector.entity.PortfolioSelectorItemUM
-import com.tangem.features.account.selector.entity.PortfolioSelectorUM
-import com.tangem.features.wallet.utils.UserWalletImageFetcher
-import com.tangem.operations.attestation.ArtworkSize
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.collections.immutable.persistentListOf
-import kotlinx.collections.immutable.toImmutableList
-import kotlinx.coroutines.flow.*
-import javax.inject.Inject
-
-@ModelScoped
-internal class PortfolioSelectorModel @Inject constructor(
-    paramsContainer: ParamsContainer,
-    walletImageFetcher: UserWalletImageFetcher,
-    isAccountsModeEnabledUseCase: IsAccountsModeEnabledUseCase,
-    override val dispatchers: CoroutineDispatcherProvider,
-) : Model() {
-
-    private val params = paramsContainer.require<PortfolioSelectorComponent.Params>()
-    private val balanceFetcher get() = params.portfolioFetcher
-    private val selectorController get() = params.controller
-
-    internal val state: StateFlow<PortfolioSelectorUM>
-        field = MutableStateFlow<PortfolioSelectorUM>(emptyState())
-
-    init {
-        val selectedAccountState = selectorController.selectedAccount
-            .stateIn(modelScope, started = SharingStarted.Eagerly, initialValue = null)
-
-        combine(
-            flow = isAccountsModeEnabledUseCase(),
-            flow2 = balanceFetcher.data,
-            flow3 = walletImageFetcher.allWallets(ArtworkSize.SMALL),
-            flow4 = selectorController.isEnabled,
-            flow5 = selectedAccountState,
-            transform = { isAccountsMode, portfolioData, artworks, isEnabled, selectedAccount ->
-                val uiList = buildUiList(
-                    isAccountsMode = isAccountsMode,
-                    portfolioData = portfolioData,
-                    artworks = artworks,
-                    isEnabled = isEnabled,
-                    selectedAccount = selectedAccount,
-                )
-                val title = when (isAccountsMode) {
-                    true -> resourceReference(R.string.common_choose_account)
-                    false -> resourceReference(R.string.common_choose_wallet)
-                }
-                state.value = PortfolioSelectorUM(
-                    title = title,
-                    items = uiList.toImmutableList(),
-                )
-            },
-        )
-            .flowOn(dispatchers.default)
-            .launchIn(modelScope)
-    }
-
-    private fun buildUiList(
-        isAccountsMode: Boolean,
-        portfolioData: PortfolioFetcher.Data,
-        artworks: Map<UserWalletId, UserWalletItemUM.ImageState>,
-        isEnabled: (UserWallet, AccountStatus) -> Boolean,
-        selectedAccount: AccountId?,
-    ): List<PortfolioSelectorItemUM> = when (isAccountsMode) {
-        true -> buildAccountsList(
-            portfolioData = portfolioData,
-            artworks = artworks,
-            isEnabled = isEnabled,
-            selectedAccount = selectedAccount,
-        )
-        false -> buildWalletList(
-            portfolioData = portfolioData,
-            artworks = artworks,
-            isEnabled = isEnabled,
-            selectedAccount = selectedAccount,
-        )
-    }
-
-    private fun buildWalletList(
-        portfolioData: PortfolioFetcher.Data,
-        artworks: Map<UserWalletId, UserWalletItemUM.ImageState>,
-        isEnabled: (UserWallet, AccountStatus) -> Boolean,
-        selectedAccount: AccountId?,
-    ): List<PortfolioSelectorItemUM> = buildList {
-        val appCurrency = portfolioData.appCurrency
-        val isBalanceHidden = portfolioData.isBalanceHidden
-        val lockedWallets = mutableListOf<PortfolioSelectorItemUM>()
-        portfolioData.balances.forEach { (_, portfolio) ->
-            val balance = portfolio.walletBalance
-            val wallet = portfolio.userWallet
-            val walletItemUM = UserWalletItemUMConverter(
-                onClick = {
-                    selectorController.selectAccount(portfolio.accountsBalance.mainAccount.account.accountId)
-                },
-                appCurrency = appCurrency,
-                balance = balance,
-                isBalanceHidden = isBalanceHidden,
-                artwork = artworks[wallet.walletId],
-                isAuthMode = false,
-                mode = UserWalletItemUMConverter.InfoField.Tokens(
-                    tokensCount = portfolio.accountsBalance.flattenCurrencies().size,
-                ),
-            ).convert(wallet)
-            if (walletItemUM.isEnabled) {
-                val mainAccount = portfolio.accountsBalance.mainAccount
-                val isEnabledByFeature = isEnabled(wallet, mainAccount)
-                val finalWalletItemUM =
-                    if (isEnabledByFeature) walletItemUM else walletItemUM.copy(isEnabled = false)
-                val isSelected = mainAccount.isSelected(selectedAccount)
-                add(PortfolioSelectorItemUM.Portfolio(finalWalletItemUM, isSelected))
-            } else {
-                lockedWallets.add(PortfolioSelectorItemUM.Portfolio(walletItemUM, isSelected = false))
-            }
-        }
-
-        if (lockedWallets.isNotEmpty()) {
-            addAll(createLockedWallets(wallets = lockedWallets))
-        }
-    }
-
-    private fun buildAccountsList(
-        portfolioData: PortfolioFetcher.Data,
-        artworks: Map<UserWalletId, UserWalletItemUM.ImageState>,
-        isEnabled: (UserWallet, AccountStatus) -> Boolean,
-        selectedAccount: AccountId?,
-    ): List<PortfolioSelectorItemUM> = buildList {
-        val appCurrency = portfolioData.appCurrency
-        val isBalanceHidden = portfolioData.isBalanceHidden
-        val lockedWallets = mutableListOf<PortfolioSelectorItemUM>()
-        portfolioData.balances.forEach { (_, portfolio) ->
-            val balance = portfolio.walletBalance
-            val wallet = portfolio.userWallet
-            val walletItemUM = UserWalletItemUMConverter(
-                onClick = {
-                    selectorController.selectAccount(portfolio.accountsBalance.mainAccount.account.accountId)
-                },
-                appCurrency = appCurrency,
-                balance = balance,
-                isBalanceHidden = isBalanceHidden,
-                artwork = artworks[wallet.walletId],
-                isAuthMode = false,
-            ).convert(wallet)
-            if (!walletItemUM.isEnabled) {
-                lockedWallets.add(PortfolioSelectorItemUM.Portfolio(walletItemUM, false))
-                return@forEach
-            }
-
-            when (balanceFetcher.mode.value) {
-                // for Wallet mode expected single portfolioData.balances
-                is PortfolioFetcher.Mode.Wallet -> Unit
-                is PortfolioFetcher.Mode.All -> {
-                    if (portfolioData.balances.size > 1) {
-                        val walletTitle = PortfolioSelectorItemUM.GroupTitle(
-                            id = "GroupTitle ${wallet.walletId.stringValue}",
-                            name = stringReference(wallet.name),
-                        )
-
-                        add(walletTitle)
-                    }
-                }
-            }
-
-            portfolio.accountsBalance.accountStatuses.filterCryptoPortfolio().forEach { accountStatus ->
-                val isEnabledByFeature = isEnabled(wallet, accountStatus)
-                val account = accountStatus.account
-                val accountBalance = accountStatus.tokenList.totalFiatBalance
-                val accountItemUM = AccountPortfolioItemUMConverter(
-                    onClick = { selectorController.selectAccount(account.accountId) },
-                    appCurrency = appCurrency,
-                    accountBalance = accountBalance,
-                    isEnabled = isEnabledByFeature,
-                    isBalanceHidden = isBalanceHidden,
-                ).convert(account)
-                val isSelected = accountStatus.isSelected(selectedAccount)
-                add(PortfolioSelectorItemUM.Portfolio(accountItemUM, isSelected))
-            }
-        }
-        if (lockedWallets.isNotEmpty()) {
-            addAll(createLockedWallets(wallets = lockedWallets))
-        }
-    }
-
-    private fun createLockedWallets(wallets: List<PortfolioSelectorItemUM>): List<PortfolioSelectorItemUM> {
-        val lockedWalletsTitle = PortfolioSelectorItemUM.GroupTitle(
-            id = "lockedWalletsTitleId",
-            name = resourceReference(R.string.common_locked_wallets),
-        )
-
-        return listOf(lockedWalletsTitle) + wallets
-    }
-
-    private fun AccountStatus.isSelected(selectedId: AccountId?) = this.account.accountId == selectedId
-
-    private fun emptyState() = PortfolioSelectorUM(
-        items = persistentListOf(),
-        title = TextReference.EMPTY,
-    )
-}

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

@@ -1,20 +0,0 @@
-package com.tangem.features.account.selector.di
-
-import com.tangem.core.decompose.di.ModelComponent
-import com.tangem.core.decompose.model.Model
-import com.tangem.features.account.selector.PortfolioSelectorModel
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.multibindings.ClassKey
-import dagger.multibindings.IntoMap
-
-@Module
-@InstallIn(ModelComponent::class)
-internal interface PortfolioSelectorModule {
-
-    @Binds
-    @IntoMap
-    @ClassKey(PortfolioSelectorModel::class)
-    fun portfolioSelectorModel(model: PortfolioSelectorModel): Model
-}

features/account/impl/src/main/java/com/tangem/features/account/selector/entity/PortfolioSelectorUM.kt

@@ -1,28 +0,0 @@
-package com.tangem.features.account.selector.entity
-
-import androidx.compose.runtime.Immutable
-import com.tangem.common.ui.userwallet.state.UserWalletItemUM
-import com.tangem.core.ui.extensions.TextReference
-import kotlinx.collections.immutable.ImmutableList
-
-data class PortfolioSelectorUM(
-    val title: TextReference,
-    val items: ImmutableList<PortfolioSelectorItemUM>,
-)
-
-@Immutable
-sealed interface PortfolioSelectorItemUM {
-    val id: String
-
-    data class GroupTitle(
-        override val id: String,
-        val name: TextReference,
-    ) : PortfolioSelectorItemUM
-
-    data class Portfolio(
-        val item: UserWalletItemUM,
-        val isSelected: Boolean,
-    ) : PortfolioSelectorItemUM {
-        override val id: String = item.id
-    }
-}

features/account/impl/src/main/java/com/tangem/features/account/selector/ui/PortfolioSelectorBS.kt

@@ -1,65 +0,0 @@
-package com.tangem.features.account.selector.ui
-
-import android.content.res.Configuration
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.padding
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.tooling.preview.PreviewParameter
-import androidx.compose.ui.unit.dp
-import com.tangem.core.ui.components.bottomsheets.TangemBottomSheetConfig
-import com.tangem.core.ui.components.bottomsheets.TangemBottomSheetConfigContent
-import com.tangem.core.ui.components.bottomsheets.modal.TangemModalBottomSheet
-import com.tangem.core.ui.components.bottomsheets.modal.TangemModalBottomSheetTitle
-import com.tangem.core.ui.res.TangemTheme
-import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.features.account.impl.R
-import com.tangem.features.account.selector.entity.PortfolioSelectorUM
-
-@Composable
-internal fun PortfolioSelectorBS(
-    state: PortfolioSelectorUM,
-    onDismiss: () -> Unit,
-    onBack: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    TangemModalBottomSheet<TangemBottomSheetConfigContent.Empty>(
-        config = TangemBottomSheetConfig(
-            isShown = true,
-            onDismissRequest = onDismiss,
-            content = TangemBottomSheetConfigContent.Empty,
-        ),
-        onBack = onBack,
-        scrollableContent = false,
-        containerColor = TangemTheme.colors.background.tertiary,
-        title = {
-            TangemModalBottomSheetTitle(
-                title = state.title,
-                startIconRes = R.drawable.ic_back_24,
-                onStartClick = onBack,
-            )
-        },
-        content = {
-            PortfolioSelectorContent(
-                state = state,
-                contentPadding = PaddingValues(bottom = 16.dp),
-                modifier = modifier.padding(horizontal = 16.dp),
-            )
-        },
-    )
-}
-
-@Preview(showBackground = true, widthDp = 360)
-@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
-@Composable
-private fun Preview(@PreviewParameter(PortfolioSelectorPreviewStateProvider::class) params: PortfolioSelectorUM) {
-    TangemThemePreview {
-        PortfolioSelectorBS(
-            state = params,
-            onDismiss = {},
-            modifier = Modifier,
-            onBack = {},
-        )
-    }
-}

features/account/impl/src/main/java/com/tangem/features/account/selector/ui/PortfolioSelectorContent.kt

@@ -1,225 +0,0 @@
-package com.tangem.features.account.selector.ui
-
-import android.content.res.Configuration
-import androidx.compose.foundation.BorderStroke
-import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.itemsIndexed
-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.draw.alpha
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.tooling.preview.PreviewParameter
-import androidx.compose.ui.tooling.preview.datasource.CollectionPreviewParameterProvider
-import androidx.compose.ui.unit.dp
-import com.tangem.common.ui.account.AccountIconPreviewData
-import com.tangem.common.ui.userwallet.UserWalletItemRow
-import com.tangem.common.ui.userwallet.state.UserWalletItemUM
-import com.tangem.common.ui.userwallet.state.UserWalletItemUM.ImageState
-import com.tangem.core.ui.extensions.conditional
-import com.tangem.core.ui.extensions.resolveReference
-import com.tangem.core.ui.extensions.resourceReference
-import com.tangem.core.ui.extensions.stringReference
-import com.tangem.core.ui.res.TangemTheme
-import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.features.account.impl.R
-import com.tangem.features.account.selector.entity.PortfolioSelectorItemUM
-import com.tangem.features.account.selector.entity.PortfolioSelectorUM
-import com.tangem.features.account.selector.ui.PortfolioSelectorPreviewData.firstList
-import com.tangem.features.account.selector.ui.PortfolioSelectorPreviewData.lockedWalletList
-import com.tangem.features.account.selector.ui.PortfolioSelectorPreviewData.secondList
-import com.tangem.features.account.selector.ui.PortfolioSelectorPreviewData.walletList
-import kotlinx.collections.immutable.toImmutableList
-import java.util.UUID
-
-private const val DISABLED_WALLET_ALPHA = 0.5f
-
-@Composable
-internal fun PortfolioSelectorContent(
-    state: PortfolioSelectorUM,
-    modifier: Modifier = Modifier,
-    contentPadding: PaddingValues = PaddingValues(),
-) {
-    LazyColumn(
-        modifier = modifier,
-        contentPadding = contentPadding,
-    ) {
-        val items = state.items
-        itemsIndexed(
-            items = items,
-            key = { _, item -> item.id },
-        ) { index, item ->
-            val previewItem = items.getOrNull(index.dec())
-            val offsetModifier = when {
-                previewItem == null -> Modifier
-                item is PortfolioSelectorItemUM.GroupTitle -> Modifier.padding(
-                    top = TangemTheme.dimens.spacing16,
-                )
-                else -> Modifier.padding(
-                    top = TangemTheme.dimens.spacing8,
-                )
-            }
-
-            val portfolioShape = RoundedCornerShape(TangemTheme.dimens.radius14)
-            val border = BorderStroke(
-                width = 1.dp,
-                color = TangemTheme.colors.text.accent,
-            )
-
-            when (item) {
-                is PortfolioSelectorItemUM.Portfolio -> UserWalletItemRow(
-                    state = item.item,
-                    modifier = offsetModifier
-                        .fillMaxWidth()
-                        .heightIn(min = TangemTheme.dimens.size68)
-                        .clip(portfolioShape)
-                        .background(TangemTheme.colors.background.action)
-                        .conditional(item.isSelected) { border(border, portfolioShape) }
-                        .clickable(enabled = item.item.isEnabled, onClick = item.item.onClick)
-                        .padding(all = TangemTheme.dimens.spacing12)
-                        .conditional(!item.item.isEnabled) { alpha(DISABLED_WALLET_ALPHA) },
-                )
-                is PortfolioSelectorItemUM.GroupTitle -> WalletNameRow(
-                    model = item,
-                    modifier = offsetModifier
-                        .fillMaxWidth()
-                        .padding(horizontal = TangemTheme.dimens.spacing16),
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun WalletNameRow(model: PortfolioSelectorItemUM.GroupTitle, modifier: Modifier = Modifier) {
-    Text(
-        modifier = modifier,
-        text = model.name.resolveReference(),
-        style = TangemTheme.typography.subtitle2,
-        color = TangemTheme.colors.text.tertiary,
-        maxLines = 1,
-        overflow = TextOverflow.Ellipsis,
-    )
-}
-
-@Preview(showBackground = true, widthDp = 360)
-@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
-@Composable
-private fun Preview(@PreviewParameter(PortfolioSelectorPreviewStateProvider::class) params: PortfolioSelectorUM) {
-    TangemThemePreview {
-        PortfolioSelectorContent(
-            state = params,
-            modifier = Modifier.background(color = TangemTheme.colors.background.tertiary),
-        )
-    }
-}
-
-internal object PortfolioSelectorPreviewData {
-
-    val accountName get() = stringReference(value = "Portfolio")
-    val walletName get() = stringReference(value = "Tangem 2.0")
-
-    private val accountItem: UserWalletItemUM
-        get() = UserWalletItemUM(
-            id = UUID.randomUUID().toString(),
-            name = accountName,
-            information = UserWalletItemUM.Information.Loaded(stringReference("12 tokens")),
-            balance = UserWalletItemUM.Balance.Loaded("$726.04", false),
-            isEnabled = true,
-            onClick = { },
-            imageState = ImageState.Account(
-                name = accountName,
-                icon = AccountIconPreviewData.randomAccountIcon(),
-            ),
-        )
-
-    private val lockedAccountItem: UserWalletItemUM
-        get() = accountItem.copy(isEnabled = false)
-
-    private val walletItem: UserWalletItemUM
-        get() = UserWalletItemUM(
-            id = UUID.randomUUID().toString(),
-            name = walletName,
-            information = UserWalletItemUM.Information.Loaded(stringReference("12 tokens")),
-            balance = UserWalletItemUM.Balance.Loaded("$726.04", false),
-            isEnabled = true,
-            onClick = { },
-            imageState = ImageState.MobileWallet,
-        )
-
-    private val lockedWalletItem: UserWalletItemUM
-        get() = walletItem.copy(isEnabled = false)
-
-    val firstList
-        get() = listOf(
-            PortfolioSelectorItemUM.GroupTitle(
-                id = UUID.randomUUID().toString(),
-                name = stringReference("Tangem 2.0"),
-            ),
-            PortfolioSelectorItemUM.Portfolio(accountItem, false),
-            PortfolioSelectorItemUM.Portfolio(lockedAccountItem, false),
-            PortfolioSelectorItemUM.GroupTitle(
-                id = UUID.randomUUID().toString(),
-                name = stringReference("Tangem White"),
-            ),
-            PortfolioSelectorItemUM.Portfolio(accountItem, true),
-        )
-
-    val secondList
-        get() = firstList + listOf(
-            PortfolioSelectorItemUM.GroupTitle(
-                id = UUID.randomUUID().toString(),
-                name = resourceReference(R.string.common_locked_wallets),
-            ),
-            PortfolioSelectorItemUM.Portfolio(lockedWalletItem, false),
-            PortfolioSelectorItemUM.Portfolio(lockedWalletItem, false),
-        )
-
-    val walletList
-        get() = listOf(
-            PortfolioSelectorItemUM.Portfolio(walletItem, false),
-            PortfolioSelectorItemUM.Portfolio(walletItem, true),
-        )
-
-    val lockedWalletList
-        get() = listOf(
-            PortfolioSelectorItemUM.Portfolio(walletItem, true),
-            PortfolioSelectorItemUM.GroupTitle(
-                id = UUID.randomUUID().toString(),
-                name = resourceReference(R.string.common_locked_wallets),
-            ),
-            PortfolioSelectorItemUM.Portfolio(lockedWalletItem, false),
-            PortfolioSelectorItemUM.Portfolio(lockedWalletItem, false),
-        )
-}
-
-internal class PortfolioSelectorPreviewStateProvider : CollectionPreviewParameterProvider<PortfolioSelectorUM>(
-    listOf(
-        PortfolioSelectorUM(
-            title = resourceReference(R.string.common_choose_account),
-            items = firstList.toImmutableList(),
-        ),
-        PortfolioSelectorUM(
-            title = resourceReference(R.string.common_choose_account),
-            items = secondList.toImmutableList(),
-        ),
-        PortfolioSelectorUM(
-            title = resourceReference(R.string.common_choose_wallet),
-            items = walletList.toImmutableList(),
-        ),
-        PortfolioSelectorUM(
-            title = resourceReference(R.string.common_choose_wallet),
-            items = lockedWalletList.toImmutableList(),
-        ),
-    ),
-)