Updated on 2026-08-14

data/search/.gitignore

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

data/search/build.gradle.kts

@@ -0,0 +1,40 @@
+plugins {
+    alias(deps.plugins.android.library)
+    alias(deps.plugins.kotlin.android)
+    alias(deps.plugins.kotlin.kapt)
+    id("configuration")
+}
+
+android {
+    namespace = "com.tangem.data.search"
+}
+
+dependencies {
+    // region Project - Core
+    implementation(projects.core.datasource)
+    api(projects.core.utils)
+    // endregion
+
+    // region Project - Data
+    implementation(projects.data.common)
+    // endregion
+
+    // region Project - Domain
+    implementation(projects.domain.search)
+    implementation(projects.domain.common)
+    implementation(projects.domain.account.status)
+    implementation(projects.domain.markets.models)
+    implementation(projects.domain.wallets)
+    implementation(projects.domain.appCurrency)
+    // endregion
+
+    // region DI
+    implementation(deps.hilt.android)
+    kapt(deps.hilt.kapt)
+    // endregion
+
+    // region Other libraries
+    implementation(deps.androidx.datastore)
+    implementation(deps.moshi.kotlin)
+    // endregion
+}

data/search/src/main/java/com/tangem/data/search/converter/SearchHistoryConverter.kt

@@ -0,0 +1,41 @@
+package com.tangem.data.search.converter
+
+import com.tangem.data.search.model.RecentTokenDTO
+import com.tangem.data.search.model.TextHintDTO
+import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.domain.search.model.RecentSearchToken
+import com.tangem.domain.search.model.SearchTextHint
+import com.tangem.utils.converter.Converter
+
+internal class TextHintDTOToSearchTextHintConverter : Converter<TextHintDTO, SearchTextHint> {
+    override fun convert(value: TextHintDTO): SearchTextHint {
+        return SearchTextHint(
+            text = value.text,
+            timestamp = value.timestamp,
+        )
+    }
+}
+
+internal class RecentTokenDTOToRecentSearchTokenConverter : Converter<RecentTokenDTO, RecentSearchToken> {
+    override fun convert(value: RecentTokenDTO): RecentSearchToken {
+        return RecentSearchToken(
+            id = CryptoCurrency.RawID(value.id),
+            name = value.name,
+            symbol = value.symbol,
+            imageUrl = value.imageUrl,
+            timestamp = value.timestamp,
+        )
+    }
+}
+
+internal class RecentSearchTokenToRecentTokenDTOConverter : Converter<RecentSearchToken, RecentTokenDTO> {
+    override fun convert(value: RecentSearchToken): RecentTokenDTO {
+        return RecentTokenDTO(
+            id = value.id.value,
+            name = value.name,
+            symbol = value.symbol,
+            imageUrl = value.imageUrl,
+            timestamp = value.timestamp,
+        )
+    }
+}

data/search/src/main/java/com/tangem/data/search/di/SearchDataModule.kt

@@ -0,0 +1,98 @@
+package com.tangem.data.search.di
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.core.DataStoreFactory
+import androidx.datastore.dataStoreFile
+import com.squareup.moshi.Moshi
+import com.squareup.moshi.adapter
+import com.tangem.data.search.model.SearchHistoryDTO
+import com.tangem.data.search.repository.DefaultSearchRepository
+import com.tangem.data.search.store.DefaultSearchHistoryStore
+import com.tangem.data.search.store.SearchHistoryStore
+import com.tangem.datasource.di.NetworkMoshi
+import com.tangem.datasource.utils.MoshiDataStoreSerializer
+import com.tangem.domain.account.status.supplier.MultiAccountStatusListSupplier
+import com.tangem.domain.common.wallets.UserWalletsListRepository
+import com.tangem.domain.search.repository.SearchRepository
+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.usecase.SaveSearchQueryUseCase
+import com.tangem.utils.coroutines.AppCoroutineScope
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object SearchDataModule {
+
+    @OptIn(ExperimentalStdlibApi::class)
+    @Provides
+    @Singleton
+    fun provideSearchHistoryDataStore(
+        @NetworkMoshi moshi: Moshi,
+        @ApplicationContext context: Context,
+        appScope: AppCoroutineScope,
+    ): DataStore<SearchHistoryDTO> {
+        return DataStoreFactory.create(
+            serializer = MoshiDataStoreSerializer(
+                defaultValue = SearchHistoryDTO(),
+                adapter = moshi.adapter<SearchHistoryDTO>(),
+            ),
+            produceFile = { context.dataStoreFile(fileName = "search_history") },
+            scope = appScope,
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideSearchHistoryStore(dataStore: DataStore<SearchHistoryDTO>): SearchHistoryStore {
+        return DefaultSearchHistoryStore(dataStore = dataStore)
+    }
+
+    @Provides
+    @Singleton
+    fun provideSearchRepository(
+        store: SearchHistoryStore,
+        dispatchers: CoroutineDispatcherProvider,
+    ): SearchRepository {
+        return DefaultSearchRepository(
+            store = store,
+            dispatchers = dispatchers,
+        )
+    }
+
+    @Provides
+    fun provideGetSearchResultsUseCase(
+        searchRepository: SearchRepository,
+        multiAccountStatusListSupplier: MultiAccountStatusListSupplier,
+        userWalletsListRepository: UserWalletsListRepository,
+    ): GetSearchResultsUseCase {
+        return GetSearchResultsUseCase(
+            searchRepository = searchRepository,
+            multiAccountStatusListSupplier = multiAccountStatusListSupplier,
+            userWalletsListRepository = userWalletsListRepository,
+        )
+    }
+
+    @Provides
+    fun provideSaveSearchQueryUseCase(searchRepository: SearchRepository): SaveSearchQueryUseCase {
+        return SaveSearchQueryUseCase(searchRepository = searchRepository)
+    }
+
+    @Provides
+    fun provideSaveRecentSearchTokenUseCase(searchRepository: SearchRepository): SaveRecentSearchTokenUseCase {
+        return SaveRecentSearchTokenUseCase(searchRepository = searchRepository)
+    }
+
+    @Provides
+    fun provideClearSearchHistoryUseCase(searchRepository: SearchRepository): ClearSearchHistoryUseCase {
+        return ClearSearchHistoryUseCase(searchRepository = searchRepository)
+    }
+}

data/search/src/main/java/com/tangem/data/search/model/SearchHistory.kt

@@ -0,0 +1,24 @@
+package com.tangem.data.search.model
+
+import com.squareup.moshi.JsonClass
+
+@JsonClass(generateAdapter = true)
+internal data class SearchHistoryDTO(
+    val textHints: List<TextHintDTO> = emptyList(),
+    val recentTokens: List<RecentTokenDTO> = emptyList(),
+)
+
+@JsonClass(generateAdapter = true)
+internal data class TextHintDTO(
+    val text: String,
+    val timestamp: Long,
+)
+
+@JsonClass(generateAdapter = true)
+internal data class RecentTokenDTO(
+    val id: String,
+    val name: String,
+    val symbol: String,
+    val imageUrl: String?,
+    val timestamp: Long,
+)

data/search/src/main/java/com/tangem/data/search/repository/DefaultSearchRepository.kt

@@ -0,0 +1,60 @@
+package com.tangem.data.search.repository
+
+import com.tangem.data.search.converter.RecentSearchTokenToRecentTokenDTOConverter
+import com.tangem.data.search.converter.RecentTokenDTOToRecentSearchTokenConverter
+import com.tangem.data.search.converter.TextHintDTOToSearchTextHintConverter
+import com.tangem.data.search.model.TextHintDTO
+import com.tangem.data.search.store.SearchHistoryStore
+import com.tangem.domain.search.model.RecentSearchToken
+import com.tangem.domain.search.model.SearchTextHint
+import com.tangem.domain.search.repository.SearchRepository
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.withContext
+
+internal class DefaultSearchRepository(
+    private val store: SearchHistoryStore,
+    private val dispatchers: CoroutineDispatcherProvider,
+) : SearchRepository {
+
+    private val textHintConverter by lazy {
+        TextHintDTOToSearchTextHintConverter()
+    }
+    private val recentTokenConverter by lazy {
+        RecentTokenDTOToRecentSearchTokenConverter()
+    }
+    private val recentTokenDMConverter by lazy {
+        RecentSearchTokenToRecentTokenDTOConverter()
+    }
+
+    override fun getTextHints(): Flow<List<SearchTextHint>> {
+        return store.getTextHints()
+            .map { textHintConverter.convertList(it) }
+            .flowOn(dispatchers.io)
+    }
+
+    override fun getRecentTokens(): Flow<List<RecentSearchToken>> {
+        return store.getRecentTokens()
+            .map { recentTokenConverter.convertList(it) }
+            .flowOn(dispatchers.io)
+    }
+
+    override suspend fun saveTextHint(text: String) = withContext(dispatchers.io) {
+        store.saveTextHint(
+            TextHintDTO(
+                text = text,
+                timestamp = System.currentTimeMillis(),
+            ),
+        )
+    }
+
+    override suspend fun saveRecentToken(token: RecentSearchToken) = withContext(dispatchers.io) {
+        store.saveRecentToken(recentTokenDMConverter.convert(token))
+    }
+
+    override suspend fun clearHistory() = withContext(dispatchers.io) {
+        store.clearAll()
+    }
+}

data/search/src/main/java/com/tangem/data/search/store/DefaultSearchHistoryStore.kt

@@ -0,0 +1,53 @@
+package com.tangem.data.search.store
+
+import androidx.datastore.core.DataStore
+import com.tangem.data.search.model.RecentTokenDTO
+import com.tangem.data.search.model.SearchHistoryDTO
+import com.tangem.data.search.model.TextHintDTO
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+internal class DefaultSearchHistoryStore(
+    private val dataStore: DataStore<SearchHistoryDTO>,
+) : SearchHistoryStore {
+
+    override fun getTextHints(): Flow<List<TextHintDTO>> {
+        return dataStore.data.map { it.textHints.sortedByDescending(TextHintDTO::timestamp) }
+    }
+
+    override fun getRecentTokens(): Flow<List<RecentTokenDTO>> {
+        return dataStore.data.map { it.recentTokens.sortedByDescending(RecentTokenDTO::timestamp) }
+    }
+
+    override suspend fun saveTextHint(hint: TextHintDTO) {
+        dataStore.updateData { current ->
+            val updated = current.textHints
+                .filter { it.text != hint.text }
+                .toMutableList()
+                .apply { add(0, hint) }
+                .take(MAX_HISTORY_SIZE)
+            current.copy(textHints = updated)
+        }
+    }
+
+    override suspend fun saveRecentToken(token: RecentTokenDTO) {
+        dataStore.updateData { current ->
+            val updated = current.recentTokens
+                .filter { it.id != token.id }
+                .toMutableList()
+                .apply { add(0, token) }
+                .take(MAX_HISTORY_SIZE)
+            current.copy(recentTokens = updated)
+        }
+    }
+
+    override suspend fun clearAll() {
+        dataStore.updateData {
+            SearchHistoryDTO()
+        }
+    }
+
+    private companion object {
+        const val MAX_HISTORY_SIZE = 3
+    }
+}

data/search/src/main/java/com/tangem/data/search/store/SearchHistoryStore.kt

@@ -0,0 +1,13 @@
+package com.tangem.data.search.store
+
+import com.tangem.data.search.model.RecentTokenDTO
+import com.tangem.data.search.model.TextHintDTO
+import kotlinx.coroutines.flow.Flow
+
+internal interface SearchHistoryStore {
+    fun getTextHints(): Flow<List<TextHintDTO>>
+    fun getRecentTokens(): Flow<List<RecentTokenDTO>>
+    suspend fun saveTextHint(hint: TextHintDTO)
+    suspend fun saveRecentToken(token: RecentTokenDTO)
+    suspend fun clearAll()
+}