Support multi-chain NFT wallet displays

android/app-newm/src/main/java/io/newm/di/android/Dependencies.kt

@@ -120,7 +120,9 @@ val viewModule =
             )
         }
 
-        factory { params -> WalletsPresenter(params.get(), get(), get(), get(), get(), get(), get()) }
+        factory { params ->
+            WalletsPresenter(params.get(), get(), get(), get(), get(), get(), get(), get())
+        }
 
         factory { params ->
             WalletDetailPresenter(
@@ -132,8 +134,6 @@ val viewModule =
                 syncWalletConnectionsUseCase = get(),
                 logger = get(),
                 nftTracksUseCase = get(),
-                getPortfolioDataUseCase = get(),
-                recaptchaClientProvider = get(),
             )
         }
 

android/app-newm/src/main/java/io/newm/screens/investment/portfolio/InvestmentPortfolioPresenter.kt

@@ -40,7 +40,7 @@ class InvestmentPortfolioPresenter(
                         .onSuccess { token ->
                             value =
                                 getPortfolioDataUseCase.getInvestmentPortfolio(
-                                    walletAddress = wallets.first().stakeAddress,
+                                    walletAddress = wallets.first().address,
                                     humanVerificationCode = token,
                                 )
                         }.onFailure {

android/app-newm/src/main/java/io/newm/screens/library/NFTLibraryPresenter.kt

@@ -22,6 +22,7 @@ import io.newm.shared.commonPublic.analytics.NewmAppEventLogger
 import io.newm.shared.commonPublic.analytics.events.AppScreens
 import io.newm.shared.commonPublic.featureflags.FeatureFlagService
 import io.newm.shared.commonPublic.featureflags.FeatureFlags
+import io.newm.shared.commonPublic.models.ChainType
 import io.newm.shared.commonPublic.models.NFTTrack
 import io.newm.shared.commonPublic.usecases.ConnectWalletUseCase
 import io.newm.shared.commonPublic.usecases.HasWalletConnectionsUseCase
@@ -88,19 +89,28 @@ class NFTLibraryPresenter(
 
         var filters: NFTLibraryFilters by rememberRetained {
             mutableStateOf(
-                NFTLibraryFilters(sortType = NFTLibrarySortType.None, showShortTracks = false),
+                NFTLibraryFilters(sortType = NFTLibrarySortType.None, showShortTracks = true),
             )
         }
 
-        val filteredNftTracks =
-            remember(nftTracks, query, filters) { nftTracks.filterAndSort(query, filters) }
+        val (filteredEthereumTracks, filteredCardanoTracks) =
+            remember(nftTracks, query, filters) {
+                val filtered = nftTracks.filterAndSort(query, filters)
+                val ethereum = filtered.filter { it.chainType == ChainType.Ethereum }
+                val cardano = filtered.filter { it.chainType == ChainType.Cardano }
+                ethereum to cardano
+            }
 
         val filteredStreamTokens =
             remember(streamTracks, query, filters) { streamTracks.filterAndSort(query, filters) }
 
         val playList =
-            remember(filteredNftTracks, filteredStreamTokens) {
-                Playlist(filteredNftTracks.toTrack() + filteredStreamTokens.toTrack())
+            remember(filteredEthereumTracks, filteredCardanoTracks, filteredStreamTokens) {
+                Playlist(
+                    filteredEthereumTracks.toTrack() +
+                        filteredCardanoTracks.toTrack() +
+                        filteredStreamTokens.toTrack(),
+                )
             }
 
         val currentTrackId =
@@ -182,7 +192,8 @@ class NFTLibraryPresenter(
 
             else -> {
                 NFTLibraryState.Content(
-                    nftTracks = filteredNftTracks,
+                    ethereumTracks = filteredEthereumTracks,
+                    cardanoTracks = filteredCardanoTracks,
                     streamTokenTracks = filteredStreamTokens,
                     showZeroResultFound = showZeroResultFound,
                     filters = filters,

android/app-newm/src/main/java/io/newm/screens/library/NFTLibraryScreenUi.kt

@@ -71,6 +71,8 @@ import io.newm.core.resources.library_remove_description
 import io.newm.core.resources.library_search
 import io.newm.core.resources.nft_library_error_message
 import io.newm.core.resources.title_nft_library
+import io.newm.core.resources.wallet_detail_cardano_header
+import io.newm.core.resources.wallet_detail_ethereum_header
 import io.newm.core.ui.LoadingScreen
 import io.newm.core.ui.text.SearchBar
 import io.newm.core.ui.theme.CerisePink
@@ -161,7 +163,8 @@ fun NFTLibraryScreenUi(
 
                 NFTTracks(
                     modifier = Modifier.weight(1f),
-                    nftTracks = state.nftTracks,
+                    ethereumTracks = state.ethereumTracks,
+                    cardanoTracks = state.cardanoTracks,
                     streamTokenTracks = state.streamTokenTracks,
                     showZeroResultsFound = state.showZeroResultFound,
                     filters = state.filters,
@@ -186,7 +189,8 @@ fun NFTLibraryScreenUi(
 @Composable
 private fun NFTTracks(
     modifier: Modifier = Modifier,
-    nftTracks: List<NFTTrack>,
+    ethereumTracks: List<NFTTrack>,
+    cardanoTracks: List<NFTTrack>,
     streamTokenTracks: List<NFTTrack>,
     showZeroResultsFound: Boolean,
     filters: NFTLibraryFilters,
@@ -239,19 +243,63 @@ private fun NFTTracks(
                     item { ZeroSearchResults() }
                 }
 
-                nftTracks.isNotEmpty() || streamTokenTracks.isNotEmpty() -> {
-                    items(nftTracks + streamTokenTracks, key = { track -> track.id }) { track ->
-                        Box(modifier = Modifier.background(Gray16)) {
-                            TrackRowItemWrapper(
-                                track = track,
-                                onPlaySong = onPlaySong,
-                                onDownloadSong = { onDownloadSong(track) },
-                                isSelected = track.id == currentTrackId,
-                                downloadsEnabled = downloadsEnabled,
-                                downloadState = downloadStates[track.id] ?: DownloadState.None,
-                                onRemoveSong = { onRemoveSong(track) },
+                ethereumTracks.isNotEmpty() ||
+                    cardanoTracks.isNotEmpty() ||
+                    streamTokenTracks.isNotEmpty() -> {
+                    if (ethereumTracks.isNotEmpty()) {
+                        item {
+                            SectionHeader(
+                                title = stringResource(Res.string.wallet_detail_ethereum_header),
                             )
                         }
+                        items(ethereumTracks, key = { track -> track.id }) { track ->
+                            Box(modifier = Modifier.background(Gray16)) {
+                                TrackRowItemWrapper(
+                                    track = track,
+                                    onPlaySong = onPlaySong,
+                                    onDownloadSong = { onDownloadSong(track) },
+                                    isSelected = track.id == currentTrackId,
+                                    downloadsEnabled = downloadsEnabled,
+                                    downloadState = downloadStates[track.id] ?: DownloadState.None,
+                                    onRemoveSong = { onRemoveSong(track) },
+                                )
+                            }
+                        }
+                    }
+                    if (cardanoTracks.isNotEmpty()) {
+                        item {
+                            SectionHeader(
+                                title = stringResource(Res.string.wallet_detail_cardano_header),
+                            )
+                        }
+                        items(cardanoTracks, key = { track -> track.id }) { track ->
+                            Box(modifier = Modifier.background(Gray16)) {
+                                TrackRowItemWrapper(
+                                    track = track,
+                                    onPlaySong = onPlaySong,
+                                    onDownloadSong = { onDownloadSong(track) },
+                                    isSelected = track.id == currentTrackId,
+                                    downloadsEnabled = downloadsEnabled,
+                                    downloadState = downloadStates[track.id] ?: DownloadState.None,
+                                    onRemoveSong = { onRemoveSong(track) },
+                                )
+                            }
+                        }
+                    }
+                    if (streamTokenTracks.isNotEmpty()) {
+                        items(streamTokenTracks, key = { track -> track.id }) { track ->
+                            Box(modifier = Modifier.background(Gray16)) {
+                                TrackRowItemWrapper(
+                                    track = track,
+                                    onPlaySong = onPlaySong,
+                                    onDownloadSong = { onDownloadSong(track) },
+                                    isSelected = track.id == currentTrackId,
+                                    downloadsEnabled = downloadsEnabled,
+                                    downloadState = downloadStates[track.id] ?: DownloadState.None,
+                                    onRemoveSong = { onRemoveSong(track) },
+                                )
+                            }
+                        }
                     }
                 }
             }
@@ -267,6 +315,21 @@ private fun NFTTracks(
     }
 }
 
+@Composable
+private fun SectionHeader(title: String) {
+    Text(
+        text = title,
+        modifier = Modifier.fillMaxWidth().padding(vertical = 12.dp),
+        style =
+            TextStyle(
+                fontFamily = FontFamily.Default,
+                fontWeight = FontWeight.Bold,
+                fontSize = 18.sp,
+                brush = textGradient(SteelPink, CerisePink),
+            ),
+    )
+}
+
 @OptIn(ExperimentalMaterialApi::class)
 @Composable
 private fun TrackRowItemWrapper(
@@ -511,7 +574,8 @@ fun PreviewNftLibrary() {
         NFTLibraryScreenUi(
             state =
                 NFTLibraryState.Content(
-                    nftTracks = emptyList(),
+                    ethereumTracks = emptyList(),
+                    cardanoTracks = emptyList(),
                     streamTokenTracks = emptyList(),
                     showZeroResultFound = false,
                     filters =

android/app-newm/src/main/java/io/newm/screens/library/NFTLibraryState.kt

@@ -14,7 +14,8 @@ sealed interface NFTLibraryState : CircuitUiState {
     data object EmptyWallet : NFTLibraryState
 
     data class Content(
-        val nftTracks: List<NFTTrack>,
+        val ethereumTracks: List<NFTTrack>,
+        val cardanoTracks: List<NFTTrack>,
         val streamTokenTracks: List<NFTTrack>,
         val showZeroResultFound: Boolean,
         val filters: NFTLibraryFilters,

android/app-newm/src/main/java/io/newm/screens/walletdetail/WalletDetailPresenter.kt

@@ -1,29 +1,28 @@
 package io.newm.screens.walletdetail
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.produceState
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
-import com.google.android.recaptcha.RecaptchaAction
 import com.slack.circuit.retained.collectAsRetainedState
 import com.slack.circuit.runtime.Navigator
 import com.slack.circuit.runtime.presenter.Presenter
 import io.newm.screens.library.NFTLibraryState
 import io.newm.shared.NewmAppLogger
 import io.newm.shared.commonPublic.analytics.NewmAppEventLogger
 import io.newm.shared.commonPublic.analytics.events.AppScreens
+import io.newm.shared.commonPublic.models.ChainType
 import io.newm.shared.commonPublic.models.NFTTrack
 import io.newm.shared.commonPublic.models.WalletConnection
+import io.newm.shared.commonPublic.models.hasAllocationForWallet
 import io.newm.shared.commonPublic.models.mocks.EmptyWallet
 import io.newm.shared.commonPublic.usecases.FindWalletConnectionUseCase
-import io.newm.shared.commonPublic.usecases.GetInvestmentPortfolioDataUseCase
 import io.newm.shared.commonPublic.usecases.SyncWalletConnectionsUseCase
 import io.newm.shared.commonPublic.usecases.WalletNFTTracksUseCase
-import io.newm.sharedfeatures.screens.auth.login.RecaptchaClientProvider
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.launch
 
@@ -36,8 +35,6 @@ class WalletDetailPresenter(
     private val findWalletConnectionUseCase: FindWalletConnectionUseCase,
     private val syncWalletConnectionsUseCase: SyncWalletConnectionsUseCase,
     private val nftTracksUseCase: WalletNFTTracksUseCase,
-    private val getPortfolioDataUseCase: GetInvestmentPortfolioDataUseCase,
-    private val recaptchaClientProvider: RecaptchaClientProvider,
 ) : Presenter<WalletDetailUiState> {
     @Composable
     override fun present(): WalletDetailUiState {
@@ -65,22 +62,7 @@ class WalletDetailPresenter(
             remember { nftTracksUseCase.getAllStreamTokensFlow() }
                 .collectAsRetainedState(initial = emptyList())
 
-        val claimableTokenAmount by
-            produceState(initialValue = 0L) {
-                val connection = walletConnection
-                if (connection != null) {
-                    recaptchaClientProvider
-                        .get()
-                        .execute(RecaptchaAction.custom("get_earnings"))
-                        .onSuccess { token ->
-                            value =
-                                getPortfolioDataUseCase.getInvestmentPortfolio(
-                                    walletAddress = connection.stakeAddress,
-                                    humanVerificationCode = token,
-                                )
-                        }.onFailure { logger.error(TAG, "Error getting recaptcha token", it) }
-                }
-            }
+        LaunchedEffect(Unit) { nftTracksUseCase.refresh() }
 
         var isSyncing by remember { mutableStateOf(false) }
         val scope = rememberCoroutineScope()
@@ -99,6 +81,7 @@ class WalletDetailPresenter(
                             scope.launch {
                                 isSyncing = true
                                 syncWalletConnectionsUseCase.syncWalletConnectionsFromNetworkToDevice()
+                                nftTracksUseCase.refresh()
                                 isSyncing = false
                             }
                         }
@@ -116,14 +99,18 @@ class WalletDetailPresenter(
             }
 
             else -> {
+                val walletNftTracks = nftTracks.filter { it.hasAllocationForWallet(walletID) }
+                val walletStreamTokens = streamTokens.filter { it.hasAllocationForWallet(walletID) }
+                val ethereumTracks = walletNftTracks.filter { it.chainType == ChainType.Ethereum }
+                val cardanoTracks = walletNftTracks.filter { it.chainType == ChainType.Cardano }
                 WalletDetailUiState.Content(
                     eventSink,
                     isSyncing,
                     walletName,
                     requireNotNull(walletConnection) { "Wallet connection should not be null" },
-                    nftTracks,
-                    streamTokens,
-                    claimableTokenAmount,
+                    ethereumTracks,
+                    cardanoTracks,
+                    walletStreamTokens,
                 )
             }
         }

android/app-newm/src/main/java/io/newm/screens/walletdetail/WalletDetailUiState.kt

@@ -26,8 +26,8 @@ sealed interface WalletDetailUiState : CircuitUiState {
         override val isSyncing: Boolean,
         override val walletName: String,
         val walletConnection: WalletConnection,
-        val nftTracks: List<NFTTrack>,
+        val ethereumTracks: List<NFTTrack>,
+        val cardanoTracks: List<NFTTrack>,
         val streamTokens: List<NFTTrack>,
-        val claimableTokenAmount: Long,
     ) : WalletDetailUiState
 }