Updated on 2026-08-14

data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/MockTokensRepository.kt

@@ -9,10 +9,10 @@ import kotlinx.coroutines.flow.flowOf
 
 internal class MockTokensRepository : TokensRepository {
 
-    override suspend fun sortTokens(
+    override suspend fun saveTokens(
         userWalletId: UserWalletId,
-        sortedTokens: Set<Token>,
-        isGrouped: Boolean,
+        tokens: Set<Token>,
+        isGroupedByNetwork: Boolean,
         isSortedByBalance: Boolean,
     ) = Unit
 

domain/tokens/src/main/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCase.kt

@@ -42,7 +42,7 @@ class ApplyTokenListSortingUseCase(
         isSortedByBalance: Boolean,
     ) = withContext(dispatchers.io) {
         catch(
-            block = { tokensRepository.sortTokens(userWalletId, tokens, isGrouped, isSortedByBalance) },
+            block = { tokensRepository.saveTokens(userWalletId, tokens, isGrouped, isSortedByBalance) },
             catch = { raise(TokenListSortingError.DataError(it)) },
         )
     }

domain/tokens/src/main/kotlin/com/tangem/domain/tokens/repository/TokensRepository.kt

@@ -9,10 +9,10 @@ import kotlinx.coroutines.flow.Flow
  * */
 interface TokensRepository {
 
-    suspend fun sortTokens(
+    suspend fun saveTokens(
         userWalletId: UserWalletId,
-        sortedTokens: Set<Token>,
-        isGrouped: Boolean,
+        tokens: Set<Token>,
+        isGroupedByNetwork: Boolean,
         isSortedByBalance: Boolean,
     )
 

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ApplyTokenListSortingUseCaseTest.kt

@@ -0,0 +1,166 @@
+package com.tangem.domain.tokens
+
+import arrow.core.Either
+import arrow.core.left
+import arrow.core.right
+import com.tangem.domain.core.error.DataError
+import com.tangem.domain.tokens.error.TokenListSortingError
+import com.tangem.domain.tokens.mock.MockTokens
+import com.tangem.domain.tokens.repository.MockTokensRepository
+import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider
+import junit.framework.TestCase.assertEquals
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+internal class ApplyTokenListSortingUseCaseTest {
+
+    private val userWalletId = UserWalletId(value = null)
+
+    @Test
+    fun `when tokens are empty then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsEmpty.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(
+            userWalletId = userWalletId,
+            sortedTokens = emptySet(),
+            isGrouped = false,
+            isSortedByBalance = false,
+        )
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when tokens saving failed then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.DataError(DataError.NetworkError.NoInternetConnection).left()
+
+        val repository = getTokensRepository(
+            sortTokensResult = DataError.NetworkError.NoInternetConnection.left(),
+        )
+        val useCase = getUseCase(repository)
+
+        // When
+        val result = useCase(
+            userWalletId = userWalletId,
+            sortedTokens = MockTokens.tokens,
+            isGrouped = false,
+            isSortedByBalance = false,
+        )
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when apply sorting for sorted and grouped list then correct args should be used`() = runTest {
+        // Given
+        val expectedTokens = MockTokens.tokens
+        val expectedIsGrouped = true
+        val expectedIsSorted = true
+
+        val repository = getTokensRepository()
+        val useCase = getUseCase(repository)
+
+        // When
+        useCase(
+            userWalletId = userWalletId,
+            sortedTokens = expectedTokens,
+            isGrouped = expectedIsGrouped,
+            isSortedByBalance = expectedIsSorted,
+        )
+
+        // Then
+        assertEquals(expectedTokens, repository.tokensIdsAfterSortingApply)
+        assertEquals(expectedIsGrouped, repository.isTokensGroupedAfterSortingApply)
+        assertEquals(expectedIsSorted, repository.isTokensSortedByBalanceAfterSortingApply)
+    }
+
+    @Test
+    fun `when apply sorting for unsorted and grouped list then correct args should be used`() = runTest {
+        // Given
+        val expectedTokens = MockTokens.tokens
+        val expectedIsGrouped = true
+        val expectedIsSorted = false
+
+        val repository = getTokensRepository()
+        val useCase = getUseCase(repository)
+
+        // When
+        useCase(
+            userWalletId = userWalletId,
+            sortedTokens = expectedTokens,
+            isGrouped = expectedIsGrouped,
+            isSortedByBalance = expectedIsSorted,
+        )
+
+        // Then
+        assertEquals(expectedTokens, repository.tokensIdsAfterSortingApply)
+        assertEquals(expectedIsGrouped, repository.isTokensGroupedAfterSortingApply)
+        assertEquals(expectedIsSorted, repository.isTokensSortedByBalanceAfterSortingApply)
+    }
+
+    @Test
+    fun `when apply sorting for sorted and ungrouped list then correct args should be used`() = runTest {
+        // Given
+        val expectedTokens = MockTokens.tokens
+        val expectedIsGrouped = false
+        val expectedIsSorted = true
+
+        val repository = getTokensRepository()
+        val useCase = getUseCase(repository)
+
+        // When
+        useCase(
+            userWalletId = userWalletId,
+            sortedTokens = expectedTokens,
+            isGrouped = expectedIsGrouped,
+            isSortedByBalance = expectedIsSorted,
+        )
+
+        // Then
+        assertEquals(expectedTokens, repository.tokensIdsAfterSortingApply)
+        assertEquals(expectedIsGrouped, repository.isTokensGroupedAfterSortingApply)
+        assertEquals(expectedIsSorted, repository.isTokensSortedByBalanceAfterSortingApply)
+    }
+
+    @Test
+    fun `when apply sorting for unsorted and ungrouped list then correct args should be used`() = runTest {
+        // Given
+        val expectedTokens = MockTokens.tokens
+        val expectedIsGrouped = false
+        val expectedIsSorted = false
+
+        val repository = getTokensRepository()
+        val useCase = getUseCase(repository)
+
+        // When
+        useCase(
+            userWalletId = userWalletId,
+            sortedTokens = expectedTokens,
+            isGrouped = expectedIsGrouped,
+            isSortedByBalance = expectedIsSorted,
+        )
+
+        // Then
+        assertEquals(expectedTokens, repository.tokensIdsAfterSortingApply)
+        assertEquals(expectedIsGrouped, repository.isTokensGroupedAfterSortingApply)
+        assertEquals(expectedIsSorted, repository.isTokensSortedByBalanceAfterSortingApply)
+    }
+
+    private fun getUseCase(tokensRepository: MockTokensRepository = getTokensRepository()) =
+        ApplyTokenListSortingUseCase(
+            tokensRepository = tokensRepository,
+            dispatchers = TestingCoroutineDispatcherProvider(),
+        )
+
+    private fun getTokensRepository(sortTokensResult: Either<DataError, Unit> = Unit.right()) =
+        MockTokensRepository(sortTokensResult, emptyFlow(), emptyFlow(), emptyFlow())
+}

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetTokenListUseCaseTest.kt

@@ -31,7 +31,7 @@ internal class GetTokenListUseCaseTest {
     @Test
     fun `when list ungrouped and unsorted then correct token list should be returned`() = runTest {
         // Given
-        val expectedResult = MockTokenLists.ungroupedTokenList.right()
+        val expectedResult = MockTokenLists.failedUngroupedTokenList.right()
 
         val useCase = getUseCase(
             isGrouped = flowOf(false.right()),
@@ -137,7 +137,7 @@ internal class GetTokenListUseCaseTest {
         // Given
         val error = DataError.NetworkError.NoInternetConnection.left()
         val expectedResult = listOf(
-            MockTokenLists.ungroupedTokenList.right(),
+            MockTokenLists.failedUngroupedTokenList.right(),
             TokenListError.DataError(DataError.NetworkError.NoInternetConnection).left(),
         )
 
@@ -159,7 +159,7 @@ internal class GetTokenListUseCaseTest {
 
     @Test
     fun `when list grouped then correct token list should be received`() = runTest {
-        val expectedResult = MockTokenLists.groupedTokenList.right()
+        val expectedResult = MockTokenLists.failedGroupedTokenList.right()
 
         val useCase = getUseCase(isGrouped = flowOf(true.right()))
 
@@ -235,7 +235,7 @@ internal class GetTokenListUseCaseTest {
 
     @Test
     fun `when networks is empty and list is grouped then ungrouped list should be received`() = runTest {
-        val expectedResult = TokenListError.UnableToSortTokenList(MockTokenLists.ungroupedTokenList).left()
+        val expectedResult = TokenListError.UnableToSortTokenList(MockTokenLists.failedUngroupedTokenList).left()
 
         val useCase = getUseCase(
             networks = emptySet<Network>().right(),
@@ -326,7 +326,7 @@ internal class GetTokenListUseCaseTest {
         isSortedByBalance: Flow<Either<DataError, Boolean>> = flowOf(MockTokenLists.isSortedByBalance.right()),
     ) = GetTokenListUseCase(
         dispatchers = dispatchers,
-        tokensRepository = MockTokensRepository(tokens, isGrouped, isSortedByBalance),
+        tokensRepository = MockTokensRepository(Unit.right(), tokens, isGrouped, isSortedByBalance),
         quotesRepository = MockQuotesRepository(quotes),
         networksRepository = MockNetworksRepository(networks, statuses),
     )

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ToggleTokenListGroupingTest.kt

@@ -0,0 +1,180 @@
+package com.tangem.domain.tokens
+
+import arrow.core.Either
+import arrow.core.left
+import arrow.core.right
+import com.tangem.domain.core.error.DataError
+import com.tangem.domain.tokens.error.TokenListSortingError
+import com.tangem.domain.tokens.mock.MockNetworks
+import com.tangem.domain.tokens.mock.MockTokenLists
+import com.tangem.domain.tokens.model.Network
+import com.tangem.domain.tokens.repository.MockNetworksRepository
+import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider
+import junit.framework.TestCase.assertEquals
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+internal class ToggleTokenListGroupingTest {
+
+    @Test
+    fun `when grouped list is empty then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsEmpty.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.emptyGroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when ungrouped list is empty then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsEmpty.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.emptyUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is grouped and loading then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsLoading.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.loadingGroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is ungrouped and loading then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsLoading.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.loadingUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is not initialized then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsLoading.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.notInitializedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is ungrouped and sorted then sorted grouped list should be received`() = runTest {
+        // Given
+        val expectedResult = MockTokenLists.sortedGroupedTokenList.right()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.sortedUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is ungrouped and unsorted then unsorted grouped list should be received`() = runTest {
+        // Given
+        val expectedResult = MockTokenLists.unsortedGroupedTokenList.right()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.unsortedUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is grouped and sorted then sorted ungrouped list should be received`() = runTest {
+        // Given
+        val expectedResult = MockTokenLists.sortedUngroupedTokenList.right()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.sortedGroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is grouped and unsorted then unsorted ungrouped list should be received`() = runTest {
+        // Given
+        val expectedResult = MockTokenLists.unsortedUngroupedTokenList.right()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.unsortedGroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is ungrouped but networks is empty then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.UnableToSortTokenList.left()
+
+        val useCase = getUseCase(networks = emptySet<Network>().right())
+
+        // When
+        val result = useCase(MockTokenLists.unsortedUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is ungrouped but networks getting failed then error should be received`() = runTest {
+        // Given
+        val error = DataError.NetworkError.NoInternetConnection
+        val expectedResult = TokenListSortingError.DataError(error).left()
+
+        val useCase = getUseCase(networks = error.left())
+
+        // When
+        val result = useCase(MockTokenLists.unsortedUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    private fun getUseCase(networks: Either<DataError, Set<Network>> = MockNetworks.networks.right()) =
+        ToggleTokenListGroupingUseCase(
+            networksRepository = MockNetworksRepository(networks, statuses = flowOf()),
+            dispatchers = TestingCoroutineDispatcherProvider(),
+        )
+}

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/ToggleTokenListSortingUseCaseTest.kt

@@ -0,0 +1,143 @@
+package com.tangem.domain.tokens
+
+import arrow.core.left
+import arrow.core.right
+import com.tangem.domain.tokens.error.TokenListSortingError
+import com.tangem.domain.tokens.mock.MockTokenLists
+import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider
+import junit.framework.TestCase.assertEquals
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+internal class ToggleTokenListSortingUseCaseTest {
+
+    @Test
+    fun `when grouped list is not initialized then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsLoading.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.notInitializedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when grouped list is empty then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsEmpty.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.emptyGroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when ungrouped list is empty then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsEmpty.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.emptyUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is grouped and loading then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsLoading.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.loadingGroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is ungrouped and loading then error should be received`() = runTest {
+        // Given
+        val expectedResult = TokenListSortingError.TokenListIsLoading.left()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.loadingUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is grouped and unsorted then grouped and sorted list should be received`() = runTest {
+        // Given
+        val expectedResult = MockTokenLists.sortedGroupedTokenList.right()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.unsortedGroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is ungrouped and unsorted then ungrouped and sorted list should be received`() = runTest {
+        // Given
+        val expectedResult = MockTokenLists.sortedUngroupedTokenList.right()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.unsortedUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is grouped and sorted then grouped and unsorted list should be received`() = runTest {
+        // Given
+        val expectedResult = MockTokenLists.sortedGroupedTokenList.right()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.unsortedGroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    @Test
+    fun `when list is ungrouped and sorted then ungrouped and unsorted list should be received`() = runTest {
+        // Given
+        val expectedResult = MockTokenLists.sortedUngroupedTokenList.right()
+
+        val useCase = getUseCase()
+
+        // When
+        val result = useCase(MockTokenLists.unsortedUngroupedTokenList)
+
+        // Then
+        assertEquals(expectedResult, result)
+    }
+
+    private fun getUseCase() = ToggleTokenListSortingUseCase(
+        dispatchers = TestingCoroutineDispatcherProvider(),
+    )
+}

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockNetworksGroups.kt

@@ -0,0 +1,52 @@
+package com.tangem.domain.tokens.mock
+
+import arrow.core.nonEmptySetOf
+import arrow.core.toNonEmptySetOrNull
+import com.tangem.domain.tokens.model.NetworkGroup
+
+@Suppress("MemberVisibilityCanBePrivate")
+internal object MockNetworksGroups {
+
+    val networkGroup1 = NetworkGroup(
+        network = MockNetworks.network1,
+        tokens = MockTokensStates.failedTokenStates
+            .filter { it.networkId == MockNetworks.network1.id }
+            .toNonEmptySetOrNull()!!,
+    )
+
+    val networkGroup2 = NetworkGroup(
+        network = MockNetworks.network2,
+        tokens = MockTokensStates.failedTokenStates
+            .filter { it.networkId == MockNetworks.network2.id }
+            .toNonEmptySetOrNull()!!,
+    )
+
+    val networkGroup3 = NetworkGroup(
+        network = MockNetworks.network3,
+        tokens = MockTokensStates.failedTokenStates
+            .filter { it.networkId == MockNetworks.network3.id }
+            .toNonEmptySetOrNull()!!,
+    )
+
+    val failedNetworksGroups = nonEmptySetOf(networkGroup1, networkGroup2, networkGroup3)
+
+    val loadedNetworksGroups = failedNetworksGroups.map { group ->
+        group.copy(
+            tokens = MockTokensStates.loadedTokensStates
+                .filter { it.networkId == group.network.id }
+                .toNonEmptySetOrNull()!!,
+        )
+    }.toNonEmptySet()
+
+    val sortedNetworksGroups = loadedNetworksGroups.map { group ->
+        group.copy(
+            tokens = group.tokens
+                .sortedByDescending { it.value.fiatAmount }
+                .toNonEmptySetOrNull()!!,
+        )
+    }
+        .sortedByDescending { group ->
+            group.tokens.sumOf { it.value.fiatAmount!! }
+        }
+        .toNonEmptySetOrNull()!!
+}

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokenLists.kt

@@ -1,8 +1,10 @@
 package com.tangem.domain.tokens.mock
 
-import arrow.core.nonEmptySetOf
+import arrow.core.NonEmptySet
 import arrow.core.toNonEmptySetOrNull
-import com.tangem.domain.tokens.model.NetworkGroup
+import com.tangem.domain.tokens.mock.MockNetworksGroups.failedNetworksGroups
+import com.tangem.domain.tokens.mock.MockNetworksGroups.loadedNetworksGroups
+import com.tangem.domain.tokens.mock.MockNetworksGroups.sortedNetworksGroups
 import com.tangem.domain.tokens.model.TokenList
 import com.tangem.domain.tokens.model.TokenStatus
 import java.math.BigDecimal
@@ -13,72 +15,59 @@ internal object MockTokenLists {
     const val isGrouped = false
     const val isSortedByBalance = false
 
-    val networkGroup1 = NetworkGroup(
-        network = MockNetworks.network1,
-        tokens = MockTokensStates.tokenStates
-            .filter { it.networkId == MockNetworks.network1.id }
-            .toNonEmptySetOrNull()!!,
-    )
-
-    val networkGroup2 = NetworkGroup(
-        network = MockNetworks.network2,
-        tokens = MockTokensStates.tokenStates
-            .filter { it.networkId == MockNetworks.network2.id }
-            .toNonEmptySetOrNull()!!,
-    )
-
-    val networkGroup3 = NetworkGroup(
-        network = MockNetworks.network3,
-        tokens = MockTokensStates.tokenStates
-            .filter { it.networkId == MockNetworks.network3.id }
-            .toNonEmptySetOrNull()!!,
-    )
-
-    val networksGroups = nonEmptySetOf(networkGroup1, networkGroup2, networkGroup3)
-
-    val sortedNetworksGroups = networksGroups.map { group ->
-        group.copy(
-            tokens = MockTokensStates.loadedTokensStates
-                .filter { it.networkId == group.network.id }
-                .sortedByDescending { it.value.fiatAmount }
-                .toNonEmptySetOrNull()!!,
-        )
-    }
-        .sortedByDescending { group ->
-            group.tokens.sumOf { it.value.fiatAmount!! }
-        }
-        .toNonEmptySetOrNull()!!
-
     val notInitializedTokenList = TokenList.NotInitialized
 
-    val groupedTokenList = TokenList.GroupedByNetwork(
-        groups = networksGroups,
+    val emptyGroupedTokenList = TokenList.GroupedByNetwork(
+        groups = emptySet(),
         totalFiatBalance = TokenList.FiatBalance.Failed,
         sortedBy = TokenList.SortType.NONE,
     )
 
-    val ungroupedTokenList = TokenList.Ungrouped(
-        tokens = MockTokensStates.tokenStates,
+    val emptyUngroupedTokenList = TokenList.Ungrouped(
+        tokens = emptySet(),
         totalFiatBalance = TokenList.FiatBalance.Failed,
         sortedBy = TokenList.SortType.NONE,
     )
 
-    val loadingUngroupedTokenList = with(ungroupedTokenList) {
+    val failedGroupedTokenList = TokenList.GroupedByNetwork(
+        groups = failedNetworksGroups,
+        totalFiatBalance = TokenList.FiatBalance.Failed,
+        sortedBy = TokenList.SortType.NONE,
+    )
+
+    val failedUngroupedTokenList = TokenList.Ungrouped(
+        tokens = MockTokensStates.failedTokenStates,
+        totalFiatBalance = TokenList.FiatBalance.Failed,
+        sortedBy = TokenList.SortType.NONE,
+    )
+
+    val loadingUngroupedTokenList = with(failedUngroupedTokenList) {
         copy(
-            tokens = tokens.map { it.copy(value = TokenStatus.Loading) }.toSet(),
+            tokens = tokens.map { it.copy(value = TokenStatus.Loading) }.toNonEmptySetOrNull()!!,
             totalFiatBalance = TokenList.FiatBalance.Loading,
         )
     }
 
-    val sortedUngroupedTokenList: TokenList.Ungrouped
+    val loadingGroupedTokenList = with(failedGroupedTokenList) {
+        copy(
+            totalFiatBalance = TokenList.FiatBalance.Loading,
+            groups = groups.map { group ->
+                group.copy(
+                    tokens = group.tokens
+                        .map { it.copy(value = TokenStatus.Loading) }
+                        .toNonEmptySetOrNull()!!,
+                )
+            }.toNonEmptySetOrNull()!!,
+        )
+    }
+
+    val unsortedUngroupedTokenList: TokenList.Ungrouped
         get() {
             val tokens = MockTokensStates.loadedTokensStates
-                .sortedByDescending { it.value.fiatAmount }
-                .toNonEmptySetOrNull()!!
 
-            return ungroupedTokenList.copy(
+            return failedUngroupedTokenList.copy(
                 tokens = tokens,
-                sortedBy = TokenList.SortType.BALANCE,
+                sortedBy = TokenList.SortType.NONE,
                 totalFiatBalance = TokenList.FiatBalance.Loaded(
                     amount = tokens.sumOf { it.value.fiatAmount ?: BigDecimal.ZERO },
                     isAllAmountsSummarized = true,
@@ -86,19 +75,41 @@ internal object MockTokenLists {
             )
         }
 
-    val sortedGroupedTokenList: TokenList.GroupedByNetwork
+    val unsortedGroupedTokenList: TokenList.GroupedByNetwork
         get() {
-            val groups = sortedNetworksGroups.toSet()
+            val groups = loadedNetworksGroups
 
-            return groupedTokenList.copy(
+            return failedGroupedTokenList.copy(
                 groups = groups,
-                sortedBy = TokenList.SortType.BALANCE,
+                sortedBy = TokenList.SortType.NONE,
                 totalFiatBalance = TokenList.FiatBalance.Loaded(
                     amount = groups
-                        .flatMap { it.tokens }
+                        .flatMap { it.tokens as NonEmptySet<TokenStatus> }
                         .sumOf { it.value.fiatAmount ?: BigDecimal.ZERO },
                     isAllAmountsSummarized = true,
                 ),
             )
         }
+
+    val sortedUngroupedTokenList: TokenList.Ungrouped
+        get() {
+            val tokens = MockTokensStates.loadedTokensStates
+                .sortedByDescending { it.value.fiatAmount }
+                .toNonEmptySetOrNull()!!
+
+            return unsortedUngroupedTokenList.copy(
+                tokens = tokens,
+                sortedBy = TokenList.SortType.BALANCE,
+            )
+        }
+
+    val sortedGroupedTokenList: TokenList.GroupedByNetwork
+        get() {
+            val groups = sortedNetworksGroups
+
+            return unsortedGroupedTokenList.copy(
+                groups = groups,
+                sortedBy = TokenList.SortType.BALANCE,
+            )
+        }
 }

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokens.kt

@@ -1,6 +1,5 @@
 package com.tangem.domain.tokens.mock
 
-import arrow.core.nonEmptySetOf
 import com.tangem.domain.tokens.model.Token
 
 internal object MockTokens {
@@ -116,5 +115,5 @@ internal object MockTokens {
         derivationPath = null,
     )
 
-    val tokens = nonEmptySetOf(token1, token2, token3, token4, token5, token6, token7, token8, token9, token10)
+    val tokens = setOf(token1, token2, token3, token4, token5, token6, token7, token8, token9, token10)
 }

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/mock/MockTokensStates.kt

@@ -117,7 +117,7 @@ internal object MockTokensStates {
         value = TokenStatus.NoAccount,
     )
 
-    val tokenStates = nonEmptySetOf(
+    val failedTokenStates = nonEmptySetOf(
         tokenState1,
         tokenState2,
         tokenState3,
@@ -130,7 +130,7 @@ internal object MockTokensStates {
         tokenState10,
     )
 
-    val loadedTokensStates = tokenStates.map { state ->
+    val loadedTokensStates = failedTokenStates.map { state ->
         val networkStatus = MockNetworks.verifiedNetworksStatuses.first { it.networkId == state.networkId }
         val amount = (networkStatus.value as NetworkStatus.Verified).amounts[state.id]!!
         val quote = MockQuotes.quotes.first { it.tokenId == state.id }
@@ -144,5 +144,5 @@ internal object MockTokensStates {
                 hasTransactionsInProgress = false,
             ),
         )
-    }
+    }.toNonEmptySet()
 }

domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockTokensRepository.kt

@@ -9,17 +9,33 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
 internal class MockTokensRepository(
+    private val sortTokensResult: Either<DataError, Unit>,
     private val tokens: Flow<Either<DataError, Set<Token>>>,
     private val isGrouped: Flow<Either<DataError, Boolean>>,
     private val isSortedByBalance: Flow<Either<DataError, Boolean>>,
 ) : TokensRepository {
 
-    override suspend fun sortTokens(
+    var tokensIdsAfterSortingApply: Set<Token>? = null
+        private set
+
+    var isTokensGroupedAfterSortingApply: Boolean? = null
+        private set
+
+    var isTokensSortedByBalanceAfterSortingApply: Boolean? = null
+        private set
+
+    override suspend fun saveTokens(
         userWalletId: UserWalletId,
-        sortedTokens: Set<Token>,
-        isGrouped: Boolean,
+        tokens: Set<Token>,
+        isGroupedByNetwork: Boolean,
         isSortedByBalance: Boolean,
-    ) = Unit
+    ) {
+        sortTokensResult.onLeft { throw it }
+
+        tokensIdsAfterSortingApply = tokens
+        isTokensGroupedAfterSortingApply = isGroupedByNetwork
+        isTokensSortedByBalanceAfterSortingApply = isSortedByBalance
+    }
 
     override fun getTokens(userWalletId: UserWalletId, refresh: Boolean): Flow<Set<Token>> {
         return tokens.map { it.getOrElse { e -> throw e } }