fix: subtract coop closing amount from balanceInTransferToSavings

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

@@ -117,12 +117,6 @@ class TransferRepo @Inject constructor(
             val toSavings = activeTransfers.filter { it.type.isToSavings() }
 
             for (transfer in toSavings) {
-                if (transfer.type == TransferType.COOP_CLOSE) {
-                    markSettled(transfer.id)
-                    Logger.debug("Coop close settled immediately: ${transfer.id}", context = TAG)
-                    continue
-                }
-
                 val channelId = resolveChannelIdForTransfer(transfer, channels)
                 val hasBalance = balances?.lightningBalances?.any {
                     it.channelId() == channelId

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

@@ -52,6 +52,7 @@ class WalletRepo @Inject constructor(
     private val deriveBalanceStateUseCase: DeriveBalanceStateUseCase,
     private val wipeWalletUseCase: WipeWalletUseCase,
     private val transferRepo: TransferRepo,
+    private val activityRepo: ActivityRepo,
 ) {
     private val repoScope = CoroutineScope(bgDispatcher + SupervisorJob())
 
@@ -204,6 +205,7 @@ class WalletRepo @Inject constructor(
             delay(EVENT_SYNC_DEBOUNCE_MS)
             syncBalances()
             transferRepo.syncTransferStates()
+            activityRepo.syncActivities()
         }
     }
 

app/src/main/java/to/bitkit/usecases/DeriveBalanceStateUseCase.kt

@@ -33,6 +33,7 @@ class DeriveBalanceStateUseCase @Inject constructor(
         val pendingChannelsSats = getPendingChannelsSats(activeTransfers, channels, balanceDetails)
 
         val toSavingsAmount = getTransferToSavingsSats(activeTransfers, channels, balanceDetails)
+        val coopCloseSavingsSats = getCoopCloseTransferSats(activeTransfers, channels, balanceDetails)
         val toSpendingAmount = paidOrdersSats.safe() + pendingChannelsSats.safe()
 
         val totalOnchainSats = balanceDetails.totalOnchainBalanceSats
@@ -44,7 +45,7 @@ class DeriveBalanceStateUseCase @Inject constructor(
             totalLightningSats = totalLightningSats,
             maxSendLightningSats = lightningRepo.getChannels().totalNextOutboundHtlcLimitSats(),
             maxSendOnchainSats = getMaxSendAmount(balanceDetails),
-            balanceInTransferToSavings = toSavingsAmount,
+            balanceInTransferToSavings = toSavingsAmount.safe() - coopCloseSavingsSats.safe(),
             balanceInTransferToSpending = toSpendingAmount,
         )
 
@@ -87,7 +88,7 @@ class DeriveBalanceStateUseCase @Inject constructor(
         balanceDetails: BalanceDetails,
     ): ULong {
         var toSavingsAmount = 0uL
-        val toSavings = transfers.filter { it.type.isToSavings() && it.type != TransferType.COOP_CLOSE }
+        val toSavings = transfers.filter { it.type.isToSavings() }
 
         for (transfer in toSavings) {
             val channelId = transferRepo.resolveChannelIdForTransfer(transfer, channels)
@@ -98,6 +99,20 @@ class DeriveBalanceStateUseCase @Inject constructor(
         return toSavingsAmount
     }
 
+    private suspend fun getCoopCloseTransferSats(
+        transfers: List<TransferEntity>,
+        channels: List<ChannelDetails>,
+        balanceDetails: BalanceDetails,
+    ): ULong {
+        var amount = 0uL
+        for (transfer in transfers.filter { it.type == TransferType.COOP_CLOSE }) {
+            val channelId = transferRepo.resolveChannelIdForTransfer(transfer, channels)
+            val channelBalance = balanceDetails.lightningBalances.find { it.channelId() == channelId }
+            amount += channelBalance?.amountSats() ?: 0u
+        }
+        return amount
+    }
+
     private suspend fun getMaxSendAmount(balanceDetails: BalanceDetails): ULong {
         val spendableOnchainSats = balanceDetails.spendableOnchainBalanceSats
         if (spendableOnchainSats == 0uL) return 0u

app/src/test/java/to/bitkit/repositories/TransferRepoTest.kt

@@ -461,8 +461,7 @@ class TransferRepoTest : BaseUnitTest() {
     }
 
     @Test
-    fun `syncTransferStates settles COOP_CLOSE immediately without waiting for balance sweep`() = test {
-        val settledAt = setupClockNowMock()
+    fun `syncTransferStates does not settle COOP_CLOSE while LDK balance exists`() = test {
         val transfer = TransferEntity(
             id = ID_TRANSFER,
             type = TransferType.COOP_CLOSE,
@@ -489,6 +488,37 @@ class TransferRepoTest : BaseUnitTest() {
             pendingBalancesFromChannelClosures = emptyList(),
         )
 
+        whenever(transferDao.getActiveTransfers()).thenReturn(flowOf(listOf(transfer)))
+        whenever(lightningRepo.getChannels()).thenReturn(emptyList())
+        whenever(lightningRepo.getBalancesAsync()).thenReturn(Result.success(balances))
+
+        val result = sut.syncTransferStates()
+
+        assertTrue(result.isSuccess)
+        verify(transferDao, never()).markSettled(any(), any())
+    }
+
+    @Test
+    fun `syncTransferStates settles COOP_CLOSE when LDK balance is gone`() = test {
+        val settledAt = setupClockNowMock()
+        val transfer = TransferEntity(
+            id = ID_TRANSFER,
+            type = TransferType.COOP_CLOSE,
+            amountSats = 75000L,
+            channelId = ID_CHANNEL,
+            isSettled = false,
+            createdAt = 1000L,
+        )
+
+        val balances = BalanceDetails(
+            totalOnchainBalanceSats = 75000u,
+            spendableOnchainBalanceSats = 75000u,
+            totalAnchorChannelsReserveSats = 0u,
+            totalLightningBalanceSats = 0u,
+            lightningBalances = emptyList(),
+            pendingBalancesFromChannelClosures = emptyList(),
+        )
+
         whenever(transferDao.getActiveTransfers()).thenReturn(flowOf(listOf(transfer)))
         whenever(lightningRepo.getChannels()).thenReturn(emptyList())
         whenever(lightningRepo.getBalancesAsync()).thenReturn(Result.success(balances))

app/src/test/java/to/bitkit/repositories/WalletRepoTest.kt

@@ -45,6 +45,7 @@ class WalletRepoTest : BaseUnitTest() {
     private val deriveBalanceStateUseCase = mock<DeriveBalanceStateUseCase>()
     private val wipeWalletUseCase = mock<WipeWalletUseCase>()
     private val transferRepo = mock<TransferRepo>()
+    private val activityRepo = mock<ActivityRepo>()
 
     companion object Fixtures {
         const val ACTIVITY_TAG = "testTag"
@@ -109,6 +110,7 @@ class WalletRepoTest : BaseUnitTest() {
         deriveBalanceStateUseCase = deriveBalanceStateUseCase,
         wipeWalletUseCase = wipeWalletUseCase,
         transferRepo = transferRepo,
+        activityRepo = activityRepo,
     )
 
     @Test

app/src/test/java/to/bitkit/usecases/DeriveBalanceStateUseCaseTest.kt

@@ -193,7 +193,7 @@ class DeriveBalanceStateUseCaseTest : BaseUnitTest() {
     }
 
     @Test
-    fun `should not count coop close channel balance for transfer to savings`() = test {
+    fun `should subtract coop close balance from lightning without showing transfer in progress`() = test {
         val channelId = "closing-channel-id"
         val amountSats = 40_000uL
         val closingChannelBalance = newClosingChannelBalance(channelId, amountSats)
@@ -215,16 +215,17 @@ class DeriveBalanceStateUseCaseTest : BaseUnitTest() {
 
         whenever(lightningRepo.getChannels()).thenReturn(emptyList())
         whenever(transferRepo.activeTransfers).thenReturn(flowOf(transfers))
+        wheneverBlocking { transferRepo.resolveChannelIdForTransfer(any(), any()) }.thenReturn(channelId)
 
         val result = sut()
 
         assertTrue(result.isSuccess)
         val balanceState = result.getOrThrow()
-        assertEquals(0uL, balanceState.balanceInTransferToSavings)
+        assertEquals(0uL, balanceState.balanceInTransferToSavings, "No transfer in progress for coop close")
         assertEquals(
-            amountSats,
+            0uL,
             balanceState.totalLightningSats,
-            "Lightning balance not reduced - coop close funds are immediately spendable"
+            "Lightning balance reduced - coop close balance subtracted"
         )
     }