wip: reset activity state and wipe fixes

Author: ovitrif

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

@@ -1,5 +1,6 @@
 package to.bitkit.repositories
 
+import androidx.annotation.VisibleForTesting
 import com.synonym.bitkitcore.Activity
 import com.synonym.bitkitcore.ActivityFilter
 import com.synonym.bitkitcore.ActivityTags
@@ -29,6 +30,7 @@ import to.bitkit.data.entities.TagMetadataEntity
 import to.bitkit.di.BgDispatcher
 import to.bitkit.ext.amountOnClose
 import to.bitkit.ext.matchesPaymentId
+import to.bitkit.ext.nowMillis
 import to.bitkit.ext.nowTimestamp
 import to.bitkit.ext.rawId
 import to.bitkit.models.ActivityBackupV1
@@ -54,53 +56,55 @@ class ActivityRepo @Inject constructor(
 ) {
     val isSyncingLdkNodePayments = MutableStateFlow(false)
 
+    private val _state = MutableStateFlow(ActivityState())
+    val state: StateFlow<ActivityState> = _state
+
     private val _activitiesChanged = MutableStateFlow(0L)
     val activitiesChanged: StateFlow<Long> = _activitiesChanged
 
-    private fun notifyActivitiesChanged() = _activitiesChanged.update { clock.now().toEpochMilliseconds() }
+    private fun notifyActivitiesChanged() = _activitiesChanged.update { nowMillis(clock) }
+
+    suspend fun resetState() = withContext(bgDispatcher) {
+        _state.update { ActivityState() }
+        isSyncingLdkNodePayments.update { false }
+        notifyActivitiesChanged()
+        Logger.debug("Activity state reset", context = TAG)
+    }
 
     suspend fun syncActivities(): Result<Unit> = withContext(bgDispatcher) {
         Logger.debug("syncActivities called", context = TAG)
 
-        return@withContext runCatching {
+        val result = runCatching {
             withTimeout(SYNC_TIMEOUT_MS) {
                 Logger.debug("isSyncingLdkNodePayments = ${isSyncingLdkNodePayments.value}", context = TAG)
                 isSyncingLdkNodePayments.first { !it }
             }
 
-            isSyncingLdkNodePayments.value = true
+            isSyncingLdkNodePayments.update { true }
 
             deletePendingActivities()
-            return@withContext lightningRepo.getPayments()
-                .onSuccess { payments ->
-                    Logger.debug("Got payments with success, syncing activities", context = TAG)
-                    syncLdkNodePayments(payments = payments).onFailure { e ->
-                        return@withContext Result.failure(e)
-                    }
-                    updateActivitiesMetadata()
-                    syncTagsMetadata()
-                    boostPendingActivities()
-                    transferRepo.syncTransferStates()
-                    isSyncingLdkNodePayments.value = false
-                    return@withContext Result.success(Unit)
-                }.onFailure { e ->
-                    Logger.error("Failed to sync ldk-node payments", e, context = TAG)
-                    isSyncingLdkNodePayments.value = false
-                    return@withContext Result.failure(e)
-                }.map { Unit }
-        }.onFailure { e ->
-            when (e) {
-                is TimeoutCancellationException -> {
-                    isSyncingLdkNodePayments.value = false
-                    Logger.warn("Timeout waiting for sync to complete, forcing reset", context = TAG)
-                }
 
-                else -> {
-                    isSyncingLdkNodePayments.value = false
-                    Logger.error("syncActivities error", e, context = TAG)
-                }
+            lightningRepo.getPayments().mapCatching { payments ->
+                Logger.debug("Got payments with success, syncing activities", context = TAG)
+                syncLdkNodePayments(payments).getOrThrow()
+                updateActivitiesMetadata()
+                syncTagsMetadata()
+                boostPendingActivities()
+                transferRepo.syncTransferStates()
+                getAllAvailableTags().map { }.getOrThrow()
+            }.getOrThrow()
+        }.onFailure { e ->
+            if (e is TimeoutCancellationException) {
+                Logger.warn("syncActivities timeout, forcing reset", context = TAG)
+            } else {
+                Logger.error("Failed to sync activities", e, context = TAG)
             }
         }
+
+        isSyncingLdkNodePayments.update { false }
+        notifyActivitiesChanged()
+
+        return@withContext result
     }
 
     /**
@@ -542,10 +546,11 @@ class ActivityRepo @Inject constructor(
         cacheStore.addActivityToPendingBoost(pendingBoostActivity)
     }
 
-    /**
-     * Adds tags to an activity with business logic validation
-     */
-    suspend fun addTagsToActivity(activityId: String, tags: List<String>): Result<Unit> = withContext(bgDispatcher) {
+    @VisibleForTesting
+    suspend fun addTagsToActivity(
+        activityId: String,
+        tags: List<String>,
+    ): Result<Unit> = withContext(bgDispatcher) {
         return@withContext runCatching {
             checkNotNull(coreService.activity.getActivity(activityId)) { "Activity with ID $activityId not found" }
 
@@ -578,11 +583,9 @@ class ActivityRepo @Inject constructor(
             paymentHashOrTxId = paymentHashOrTxId,
             type = type,
             txType = txType
-        ).onSuccess { activity ->
-            addTagsToActivity(activity.rawId(), tags = tags)
-        }.onFailure { e ->
-            return@withContext Result.failure(e)
-        }.map { Unit }
+        ).mapCatching { activity ->
+            addTagsToActivity(activity.rawId(), tags = tags).getOrThrow()
+        }
     }
 
     /**
@@ -612,12 +615,11 @@ class ActivityRepo @Inject constructor(
         }
     }
 
-    /**
-     * Gets all possible tags across all activities
-     */
     suspend fun getAllAvailableTags(): Result<List<String>> = withContext(bgDispatcher) {
         return@withContext runCatching {
             coreService.activity.allPossibleTags()
+        }.onSuccess { tags ->
+            _state.update { it.copy(tags = tags) }
         }.onFailure { e ->
             Logger.error("getAllAvailableTags error", e, context = TAG)
         }
@@ -705,3 +707,7 @@ class ActivityRepo @Inject constructor(
         private const val TAG = "ActivityRepo"
     }
 }
+
+data class ActivityState(
+    val tags: List<String> = emptyList(),
+)

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

@@ -69,16 +69,20 @@ class BackupRepo @Inject constructor(
     private val dataListenerJobs = mutableListOf<Job>()
     private var periodicCheckJob: Job? = null
     private var isObserving = false
+    private var lastNotificationTime = 0L
+
     private val _isRestoring = MutableStateFlow(false)
     val isRestoring: StateFlow<Boolean> = _isRestoring.asStateFlow()
 
-    private var lastNotificationTime = 0L
+    private val _isWiping = MutableStateFlow(false)
 
     fun reset() {
         stopObservingBackups()
         vssBackupClient.reset()
     }
 
+    fun setWiping(isWiping: Boolean) = _isWiping.update { isWiping }
+
     fun startObservingBackups() {
         if (isObserving) return
 
@@ -144,7 +148,7 @@ class BackupRepo @Inject constructor(
                 .distinctUntilChanged()
                 .drop(1)
                 .collect {
-                    if (isRestoring.value) return@collect
+                    if (shouldSkipBackup()) return@collect
                     markBackupRequired(BackupCategory.SETTINGS)
                 }
         }
@@ -155,7 +159,7 @@ class BackupRepo @Inject constructor(
                 .distinctUntilChanged()
                 .drop(1)
                 .collect {
-                    if (isRestoring.value) return@collect
+                    if (shouldSkipBackup()) return@collect
                     markBackupRequired(BackupCategory.WIDGETS)
                 }
         }
@@ -167,7 +171,7 @@ class BackupRepo @Inject constructor(
                 .distinctUntilChanged()
                 .drop(1)
                 .collect {
-                    if (isRestoring.value) return@collect
+                    if (shouldSkipBackup()) return@collect
                     markBackupRequired(BackupCategory.WALLET)
                 }
         }
@@ -179,7 +183,7 @@ class BackupRepo @Inject constructor(
                 .distinctUntilChanged()
                 .drop(1)
                 .collect {
-                    if (isRestoring.value) return@collect
+                    if (shouldSkipBackup()) return@collect
                     markBackupRequired(BackupCategory.METADATA)
                 }
         }
@@ -192,7 +196,7 @@ class BackupRepo @Inject constructor(
                 .distinctUntilChanged()
                 .drop(1)
                 .collect {
-                    if (isRestoring.value) return@collect
+                    if (shouldSkipBackup()) return@collect
                     markBackupRequired(BackupCategory.METADATA)
                 }
         }
@@ -203,18 +207,18 @@ class BackupRepo @Inject constructor(
             blocktankRepo.blocktankState
                 .drop(1)
                 .collect {
-                    if (isRestoring.value) return@collect
+                    if (shouldSkipBackup()) return@collect
                     markBackupRequired(BackupCategory.BLOCKTANK)
                 }
         }
         dataListenerJobs.add(blocktankJob)
 
-        // ACTIVITY - Observe all activity changes notified by ActivityRepo on any mutation to core's activity store
+        // ACTIVITY - Observe activity changes
         val activityChangesJob = scope.launch {
             activityRepo.activitiesChanged
                 .drop(1)
                 .collect {
-                    if (isRestoring.value) return@collect
+                    if (shouldSkipBackup()) return@collect
                     markBackupRequired(BackupCategory.ACTIVITY)
                 }
         }
@@ -227,7 +231,7 @@ class BackupRepo @Inject constructor(
                     val lastSync = lightningService.status?.latestLightningWalletSyncTimestamp?.toLong()
                         ?.let { it * 1000 } // Convert seconds to millis
                         ?: return@collect
-                    if (isRestoring.value) return@collect
+                    if (shouldSkipBackup()) return@collect
                     cacheStore.updateBackupStatus(BackupCategory.LIGHTNING_CONNECTIONS) {
                         it.copy(required = lastSync, synced = lastSync, running = false)
                     }
@@ -505,7 +509,9 @@ class BackupRepo @Inject constructor(
 
     private fun currentTimeMillis(): Long = nowMillis(clock)
 
-    private fun BackupItemStatus.shouldBackup() = this.isRequired && !this.running && !isRestoring.value
+    private fun shouldSkipBackup(): Boolean = _isRestoring.value || _isWiping.value
+
+    private fun BackupItemStatus.shouldBackup() = this.isRequired && !this.running && !shouldSkipBackup()
 
     companion object {
         private const val TAG = "BackupRepo"

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

@@ -52,6 +52,7 @@ class WalletRepo @Inject constructor(
     private val deriveBalanceStateUseCase: DeriveBalanceStateUseCase,
     private val backupRepo: BackupRepo,
     private val blocktankRepo: BlocktankRepo,
+    private val activityRepo: ActivityRepo,
 ) {
     private val repoScope = CoroutineScope(bgDispatcher + SupervisorJob())
 
@@ -237,29 +238,44 @@ class WalletRepo @Inject constructor(
     }
 
     suspend fun wipeWallet(walletIndex: Int = 0): Result<Unit> = withContext(bgDispatcher) {
+        // !order is critical
         try {
+            backupRepo.setWiping(true)
             backupRepo.reset()
-            blocktankRepo.resetState()
-
-            _walletState.update { WalletState() }
-            _balanceState.update { BalanceState() }
 
             keychain.wipe()
+
+            // clear stored state
+            coreService.wipeData()
             db.clearAllTables()
             settingsStore.reset()
             cacheStore.reset()
-            // TODO CLEAN ACTIVITY'S AND UPDATE STATE. CHECK ActivityListViewModel.removeAllActivities
-            coreService.wipeData()
-            Logger.reset()
-            setWalletExistsState()
 
-            return@withContext lightningRepo.wipeStorage(walletIndex = walletIndex)
+            // clear cached state
+            blocktankRepo.resetState()
+            activityRepo.resetState()
+            resetState()
+
+            // stop and wipe node caches
+            return@withContext lightningRepo.wipeStorage(walletIndex)
+                .onSuccess {
+                    // trigger nav to onboarding
+                    setWalletExistsState()
+                    Logger.reset()
+                }
         } catch (e: Throwable) {
             Logger.error("Wipe wallet error", e)
             Result.failure(e)
+        } finally {
+            backupRepo.setWiping(false)
         }
     }
 
+    private fun resetState() {
+        _walletState.update { WalletState() }
+        _balanceState.update { BalanceState() }
+    }
+
     // Blockchain address management
     fun getOnchainAddress(): String = _walletState.value.onchainAddress
 

app/src/main/java/to/bitkit/ui/ContentView.kt

@@ -311,7 +311,7 @@ fun ContentView(
 
         LaunchedEffect(balance) {
             // Anytime we receive a balance update, we should sync the payments to activity list
-            activityListViewModel.syncLdkNodePayments()
+            activityListViewModel.resync()
         }
 
         // Keep backups in sync

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

@@ -161,10 +161,9 @@ fun HomeScreen(
         drawerState = drawerState,
         latestActivities = latestActivities,
         onRefresh = {
-            activityListViewModel.fetchLatestActivities()
+            activityListViewModel.resync()
             walletViewModel.onPullToRefresh()
             homeViewModel.refreshWidgets()
-            activityListViewModel.syncLdkNodePayments()
         },
         onClickProfile = {
             if (!hasSeenProfileIntro) {

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

@@ -155,7 +155,7 @@ fun ActivityDetailScreen(
                             title = context.getString(R.string.wallet__boost_success_title),
                             description = context.getString(R.string.wallet__boost_success_msg)
                         )
-                        listViewModel.fetchLatestActivities()
+                        listViewModel.resync()
                         onCloseClick()
                     },
                     onFailure = {