Progress cards

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

@@ -9,6 +9,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.serialization.Serializable
+import to.bitkit.data.dto.InProgressTransfer
 import to.bitkit.data.dto.PendingBoostActivity
 import to.bitkit.data.dto.TransactionMetadata
 import to.bitkit.data.serializers.AppCacheSerializer
@@ -130,6 +131,22 @@ class CacheStore @Inject constructor(
         }
     }
 
+    suspend fun addInProgressTransfer(item: InProgressTransfer) {
+        if (item in store.data.first().inProgressTransfers) return
+
+        store.updateData {
+            it.copy(inProgressTransfers = it.inProgressTransfers + item)
+        }
+    }
+
+    suspend fun removeInProgressTransfer(item: InProgressTransfer) {
+        if (item in store.data.first().inProgressTransfers) return
+
+        store.updateData {
+            it.copy(inProgressTransfers = it.inProgressTransfers - item)
+        }
+    }
+
     suspend fun reset() {
         store.updateData { AppCacheData() }
         Logger.info("Deleted all app cached data.")
@@ -153,4 +170,5 @@ data class AppCacheData(
     val activitiesPendingDelete: List<String> = listOf(),
     val pendingBoostActivities: List<PendingBoostActivity> = listOf(),
     val transactionsMetadata: List<TransactionMetadata> = listOf(),
+    val inProgressTransfers: List<InProgressTransfer> = listOf(),
 )

app/src/main/java/to/bitkit/data/dto/InProgressTransfer.kt

@@ -0,0 +1,9 @@
+package to.bitkit.data.dto
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class InProgressTransfer(
+    val activityId: String,
+    val type: TransferType,
+)

app/src/main/java/to/bitkit/data/dto/TransferType.kt

@@ -0,0 +1,8 @@
+package to.bitkit.data.dto
+
+enum class TransferType {
+    TO_SPENDING,
+    TO_SAVINGS,
+    FORCE_CLOSE,
+    COOP_CLOSE,
+}

app/src/main/java/to/bitkit/models/Suggestion.kt

@@ -10,15 +10,15 @@ enum class Suggestion(
     @StringRes val title: Int,
     @StringRes val description: Int,
     @DrawableRes val icon: Int,
-    val color: Color
+    val color: Color,
 ) {
     BUY(
         title = R.string.cards__buyBitcoin__title,
         description = R.string.cards__buyBitcoin__description,
         color = Colors.Brand,
         icon = R.drawable.b_emboss
     ),
-    SPEND(
+    SPEND( // Lightning ready from RN
         title = R.string.cards__lightning__title,
         description = R.string.cards__lightning__description,
         color = Colors.Purple,
@@ -66,6 +66,36 @@ enum class Suggestion(
         color = Colors.Green,
         icon = R.drawable.fast_forward
     ),
+
+    /**Replaces SPEND when a LN channel is being force closed*/
+    TRANSFER_PENDING(
+        title = R.string.cards__lightningSettingUp__title,
+        description = R.string.cards__transferPending__description,
+        color = Colors.Purple24,
+        icon = R.drawable.transfer
+    ),
+
+    /**When the LN channel could not be cooped closed immediately*/
+    TRANSFER_CLOSING_CHANNEL(
+        title = R.string.cards__transferClosingChannel__title,
+        description = R.string.cards__transferClosingChannel__description,
+        color = Colors.Red24,
+        icon = R.drawable.transfer
+    ),
+
+    /**Replaces SPEND when the transfer to spending balance is in progress*/
+    LIGHTNING_SETTING_UP(
+        title = R.string.cards__lightningSettingUp__title,
+        description = R.string.cards__lightningSettingUp__description,
+        color = Colors.Purple24,
+        icon = R.drawable.transfer
+    ),
+    LIGHTNING_READY(
+        title = R.string.cards__lightningReady__title,
+        description = R.string.cards__lightningReady__description,
+        color = Colors.Purple24,
+        icon = R.drawable.transfer
+    ),
 }
 
 fun String.toSuggestionOrNull() = Suggestion.entries.firstOrNull { it.name == this }

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

@@ -7,11 +7,16 @@
 import com.synonym.bitkitcore.SortDirection
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withContext
 import org.lightningdevkit.ldknode.PaymentDetails
 import to.bitkit.data.CacheStore
+import to.bitkit.data.dto.InProgressTransfer
 import to.bitkit.data.dto.PendingBoostActivity
+import to.bitkit.data.dto.TransferType
 import to.bitkit.di.BgDispatcher
 import to.bitkit.ext.matchesPaymentId
 import to.bitkit.ext.rawId
@@ -31,6 +36,9 @@
 
     var isSyncingLdkNodePayments = false
 
+    private val _pendingTransfers: MutableStateFlow<List<Activity.Onchain>> = MutableStateFlow(emptyList())
+    val pendingTransfers = _pendingTransfers.asStateFlow()
+
     suspend fun syncActivities(): Result<Unit> = withContext(bgDispatcher) {
         Logger.debug("syncActivities called", context = TAG)
 
@@ -49,6 +57,7 @@
                     syncLdkNodePayments(payments = payments)
                     updateActivitiesMetadata()
                     boostPendingActivities()
+                    updateInProgressTransfers()
                     isSyncingLdkNodePayments = false
                     return@withContext Result.success(Unit)
                 }.onFailure { e ->
@@ -278,20 +287,33 @@
 
                 when (activityToUpdate) {
                     is Activity.Onchain -> {
+                        val onChainActivity = activityToUpdate.v1.copy(
+                            feeRate = activityMetaData.feeRate.toULong(),
+                            address = activityMetaData.address,
+                            isTransfer = activityMetaData.isTransfer,
+                            channelId = activityMetaData.channelId,
+                            transferTxId = activityMetaData.transferTxId
+                        )
                         val updatedActivity = Onchain(
-                            v1 = activityToUpdate.v1.copy(
-                                feeRate = activityMetaData.feeRate.toULong(),
-                                address = activityMetaData.address,
-                                isTransfer = activityMetaData.isTransfer,
-                                channelId = activityMetaData.channelId,
-                                transferTxId = activityMetaData.transferTxId
-                            )
+                            v1 = onChainActivity
                         )
 
                         updateActivity(
                             id = updatedActivity.v1.id,
                             activity = updatedActivity
                         ).onSuccess {
+                            if (onChainActivity.isTransfer && onChainActivity.doesExist) {
+                                cacheStore.addInProgressTransfer(
+                                    InProgressTransfer(
+                                        activityId = updatedActivity.v1.id,
+                                        type = if (onChainActivity.txType == PaymentType.SENT) {
+                                            TransferType.TO_SPENDING
+                                        } else {
+                                            TransferType.TO_SAVINGS
+                                        }
+                                    )
+                                )
+                            }
                             cacheStore.removeTransactionMetadata(activityMetaData)
                         }
                     }
@@ -302,6 +324,18 @@
         }
     }
 
+    private suspend fun updateInProgressTransfers() {
+        cacheStore.data.first().inProgressTransfers.forEach { transfer ->
+            getActivity(transfer.activityId).onSuccess { activity ->
+                (activity as? Onchain)?.let { onChain ->
+                    if (onChain.v1.confirmed) {
+                        cacheStore.removeInProgressTransfer(transfer)
+                    }
+                }
+            }
+        }
+    }
+
     private suspend fun boostPendingActivities() = withContext(bgDispatcher) {
         cacheStore.data.first().pendingBoostActivities.forEach { pendingBoostActivity ->
             findActivityByPaymentId(

app/src/main/java/to/bitkit/ui/screens/wallets/HomeScreen.kt

@@ -221,6 +221,11 @@ fun HomeScreen(
                         rootNavController.navigate(Routes.QuickPaySettings)
                     }
                 }
+
+                Suggestion.TRANSFER_PENDING -> Unit
+                Suggestion.TRANSFER_CLOSING_CHANNEL -> Unit
+                Suggestion.LIGHTNING_SETTING_UP -> TODO()
+                Suggestion.LIGHTNING_READY -> TODO()
             }
         },
         onClickAddWidget = {

app/src/main/java/to/bitkit/ui/screens/wallets/HomeViewModel.kt

@@ -20,6 +20,7 @@
 import to.bitkit.models.widget.ArticleModel
 import to.bitkit.models.widget.toArticleModel
 import to.bitkit.models.widget.toBlockModel
+import to.bitkit.repositories.ActivityRepo
 import to.bitkit.repositories.CurrencyRepo
 import to.bitkit.repositories.WalletRepo
 import to.bitkit.repositories.WidgetsRepo
@@ -33,7 +34,8 @@
     private val walletRepo: WalletRepo,
     private val widgetsRepo: WidgetsRepo,
     private val settingsStore: SettingsStore,
-    private val currencyRepo: CurrencyRepo
+    private val currencyRepo: CurrencyRepo,
+    private val activityRepo: ActivityRepo,
 ) : ViewModel() {
 
     private val _uiState = MutableStateFlow(HomeUiState())
@@ -273,7 +275,7 @@
             balanceState.totalOnchainSats > 0uL -> { // Only on chain balance
                 listOfNotNull(
                     Suggestion.BACK_UP.takeIf { !settings.backupVerified },
-                    Suggestion.SPEND,
+                    Suggestion.SPEND, // TODO Replace with LIGHTNING_SETTING_UP when the spending balance is confirming
                     Suggestion.SECURE.takeIf { !settings.isPinEnabled },
                     Suggestion.BUY,
                     Suggestion.SUPPORT,