Currency repository

app/src/main/java/to/bitkit/data/AppStorage.kt

@@ -20,7 +20,7 @@ import kotlin.reflect.KProperty
 
 const val APP_PREFS = "bitkit_prefs"
 
-// TODO refactor to dataStore (named 'CacheStore'?!)
+@Deprecated("Replace with CacheStore")
 @Singleton
 class AppStorage @Inject constructor(
     @ApplicationContext private val appContext: Context,

app/src/main/java/to/bitkit/data/CacheStore.kt

@@ -0,0 +1,46 @@
+package to.bitkit.data
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.core.DataStoreFactory
+import androidx.datastore.dataStoreFile
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.serialization.Serializable
+import to.bitkit.data.serializers.AppCacheSerializer
+import to.bitkit.data.serializers.SettingsSerializer
+import to.bitkit.models.BitcoinDisplayUnit
+import to.bitkit.models.FxRate
+import to.bitkit.models.PrimaryDisplay
+import to.bitkit.models.Suggestion
+import to.bitkit.models.TransactionSpeed
+import to.bitkit.utils.Logger
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class CacheStore @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+    private val store: DataStore<AppCacheData> = DataStoreFactory.create(
+        serializer = AppCacheSerializer,
+        produceFile = { context.dataStoreFile("app_cache.json") },
+    )
+
+    val data: Flow<AppCacheData> = store.data
+
+    suspend fun update(transform: (AppCacheData) -> AppCacheData) {
+        store.updateData(transform)
+    }
+
+
+    suspend fun reset() {
+        store.updateData { AppCacheData() }
+        Logger.info("Deleted all app cached data.")
+    }
+}
+
+@Serializable
+data class AppCacheData(
+    val cachedRates : List<FxRate> = listOf()
+)

app/src/main/java/to/bitkit/data/serializers/AppCacheSerializer.kt

@@ -0,0 +1,27 @@
+package to.bitkit.data.serializers
+
+import androidx.datastore.core.Serializer
+import kotlinx.serialization.SerializationException
+import to.bitkit.data.AppCacheData
+import to.bitkit.data.SettingsData
+import to.bitkit.di.json
+import to.bitkit.utils.Logger
+import java.io.InputStream
+import java.io.OutputStream
+
+object AppCacheSerializer : Serializer<AppCacheData> {
+    override val defaultValue: AppCacheData = AppCacheData()
+
+    override suspend fun readFrom(input: InputStream): AppCacheData {
+        return try {
+            json.decodeFromString(input.readBytes().decodeToString())
+        } catch (e: SerializationException) {
+            Logger.error("Failed to deserialize: $e")
+            defaultValue
+        }
+    }
+
+    override suspend fun writeTo(t: AppCacheData, output: OutputStream) {
+        output.write(json.encodeToString(t).encodeToByteArray())
+    }
+}

app/src/main/java/to/bitkit/repositories/CurrencyRepo.kt

@@ -0,0 +1,188 @@
+package to.bitkit.repositories
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import to.bitkit.data.CacheStore
+import to.bitkit.data.SettingsStore
+import to.bitkit.di.BgDispatcher
+import to.bitkit.env.Env
+import to.bitkit.models.BitcoinDisplayUnit
+import to.bitkit.models.ConvertedAmount
+import to.bitkit.models.FxRate
+import to.bitkit.models.PrimaryDisplay
+import to.bitkit.models.Toast
+import to.bitkit.services.CurrencyService
+import to.bitkit.ui.shared.toast.ToastEventBus
+import to.bitkit.utils.Logger
+import java.util.Date
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class CurrencyRepo @Inject constructor(
+    @BgDispatcher private val bgDispatcher: CoroutineDispatcher,
+    private val currencyService: CurrencyService,
+    private val settingsStore: SettingsStore,
+    private val cacheStore: CacheStore
+) {
+    private val repoScope = CoroutineScope(bgDispatcher + SupervisorJob())
+
+    private val _currencyState = MutableStateFlow(CurrencyState())
+    val currencyState: StateFlow<CurrencyState> = _currencyState.asStateFlow()
+
+    private var lastSuccessfulRefresh: Date? = null
+    private var isRefreshing = false
+
+    private val pollingFlow: Flow<Unit>
+        get() = flow {
+            while (currentCoroutineContext().isActive) {
+                emit(Unit)
+                delay(Env.fxRateRefreshInterval)
+            }
+        }.flowOn(bgDispatcher)
+
+    init {
+        startPolling()
+        observeStaleData()
+        collectCachedData()
+    }
+
+    private fun startPolling() {
+        repoScope.launch {
+            pollingFlow.collect {
+                refresh()
+            }
+        }
+    }
+
+    private fun observeStaleData() {
+        repoScope.launch {
+            currencyState.map { it.hasStaleData }.distinctUntilChanged().collect { isStale ->
+                if (isStale) {
+                    ToastEventBus.send(
+                        type = Toast.ToastType.ERROR,
+                        title = "Rates currently unavailable",
+                        description = "An error has occurred. Please try again later."
+                    )
+                }
+            }
+        }
+    }
+
+    private fun collectCachedData() {
+        repoScope.launch {
+            combine(settingsStore.data, cacheStore.data) { settings, cachedData ->
+                _currencyState.value.copy(
+                    rates = cachedData.cachedRates,
+                    selectedCurrency = settings.selectedCurrency,
+                    displayUnit = settings.displayUnit,
+                    primaryDisplay = settings.primaryDisplay,
+                    currencySymbol = cachedData.cachedRates.firstOrNull { rate ->
+                        rate.quote == settings.selectedCurrency
+                    }?.currencySymbol ?: "$"
+                )
+            }.collect { newState ->
+                _currencyState.update { newState }
+            }
+        }
+    }
+
+    suspend fun triggerRefresh() = withContext(bgDispatcher) {
+        refresh()
+    }
+
+    private suspend fun refresh() {
+        if (isRefreshing) return
+        isRefreshing = true
+        try {
+            val fetchedRates = currencyService.fetchLatestRates()
+            cacheStore.update { it.copy(cachedRates = fetchedRates) }
+            _currencyState.update {
+                it.copy(
+                    error = null,
+                    hasStaleData = false
+                )
+            }
+            lastSuccessfulRefresh = Date()
+            Logger.debug("Currency rates refreshed successfully", context = TAG)
+        } catch (e: Exception) {
+            _currencyState.update { it.copy(error = e) }
+            Logger.error("Currency rates refresh failed", e, context = TAG)
+
+            lastSuccessfulRefresh?.let { last ->
+                _currencyState.update {
+                    it.copy(hasStaleData = Date().time - last.time > Env.fxRateStaleThreshold)
+                }
+            }
+        } finally {
+            isRefreshing = false
+        }
+    }
+
+    suspend fun togglePrimaryDisplay() = withContext(bgDispatcher) {
+        currencyState.value.primaryDisplay.let {
+            val newDisplay = if (it == PrimaryDisplay.BITCOIN) PrimaryDisplay.FIAT else PrimaryDisplay.BITCOIN
+            settingsStore.update { it.copy(primaryDisplay = newDisplay) }
+        }
+    }
+
+    suspend fun setPrimaryDisplayUnit(unit: PrimaryDisplay) = withContext(bgDispatcher) {
+        settingsStore.update { it.copy(primaryDisplay = unit) }
+    }
+
+    suspend fun setBtcDisplayUnit(unit: BitcoinDisplayUnit) = withContext(bgDispatcher) {
+        settingsStore.update { it.copy(displayUnit = unit) }
+    }
+
+    suspend fun setSelectedCurrency(currency: String) = withContext(bgDispatcher) {
+        settingsStore.update { it.copy(selectedCurrency = currency) }
+        refresh()
+    }
+
+    fun getCurrencySymbol(): String {
+        val currentState = currencyState.value
+        return currentState.rates.firstOrNull { it.quote == currentState.selectedCurrency }?.currencySymbol ?: ""
+    }
+
+    // Conversion helpers
+    fun convertSatsToFiat(sats: Long, currency: String? = null): ConvertedAmount? {
+        val targetCurrency = currency ?: currencyState.value.selectedCurrency
+        val rate = currencyService.getCurrentRate(targetCurrency, currencyState.value.rates)
+        return rate?.let { currencyService.convert(sats = sats, rate = it) }
+    }
+
+    fun convertFiatToSats(fiatAmount: Double, currency: String? = null): Long {
+        val sourceCurrency = currency ?: currencyState.value.selectedCurrency
+        return currencyService.convertFiatToSats(fiatAmount, sourceCurrency, currencyState.value.rates)
+    }
+
+    companion object {
+        private const val TAG = "CurrencyRepo"
+    }
+}
+
+data class CurrencyState(
+    val rates: List<FxRate> = emptyList(),
+    val error: Throwable? = null,
+    val hasStaleData: Boolean = false,
+    val selectedCurrency: String = "USD",
+    val currencySymbol: String = "$",
+    val displayUnit: BitcoinDisplayUnit = BitcoinDisplayUnit.MODERN,
+    val primaryDisplay: PrimaryDisplay = PrimaryDisplay.BITCOIN,
+)

app/src/main/java/to/bitkit/repositories/WalletRepo.kt

@@ -13,6 +13,7 @@ import org.lightningdevkit.ldknode.Event
 import org.lightningdevkit.ldknode.Txid
 import to.bitkit.data.AppDb
 import to.bitkit.data.AppStorage
+import to.bitkit.data.CacheStore
 import to.bitkit.data.SettingsStore
 import to.bitkit.data.entities.InvoiceTagEntity
 import to.bitkit.data.keychain.Keychain
@@ -47,6 +48,7 @@ class WalletRepo @Inject constructor(
     private val settingsStore: SettingsStore,
     private val addressChecker: AddressChecker,
     private val lightningRepo: LightningRepo,
+    private val cacheStore: CacheStore
 ) {
 
     private val _walletState = MutableStateFlow(
@@ -201,6 +203,7 @@ class WalletRepo @Inject constructor(
             keychain.wipe()
             appStorage.clear()
             settingsStore.reset()
+            cacheStore.reset()
             coreService.activity.removeAll()
             deleteAllInvoices()
             _walletState.update { WalletState() }

app/src/main/java/to/bitkit/services/CurrencyService.kt

@@ -16,7 +16,7 @@ import kotlin.math.pow
 import kotlin.math.roundToLong
 
 @Singleton
-class CurrencyService @Inject constructor(
+class CurrencyService @Inject constructor( //TODO REPLACE DIRECT ACCESS WITH CurrencyRepo
     private val blocktankHttpClient: BlocktankHttpClient,
 ) {
     private var cachedRates: List<FxRate>? = null