fix(receive): dont request liquidity for 0 LN channels

Author: ovitrif

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

@@ -17,14 +17,14 @@ import kotlinx.coroutines.withContext
 import kotlinx.datetime.Clock
 import org.lightningdevkit.ldknode.BalanceDetails
 import org.lightningdevkit.ldknode.Event
-import org.lightningdevkit.ldknode.Txid
 import to.bitkit.data.AppDb
 import to.bitkit.data.CacheStore
 import to.bitkit.data.SettingsStore
 import to.bitkit.data.entities.TagMetadataEntity
 import to.bitkit.data.keychain.Keychain
 import to.bitkit.di.BgDispatcher
 import to.bitkit.env.Env
+import to.bitkit.ext.filterOpen
 import to.bitkit.ext.nowTimestamp
 import to.bitkit.ext.toHex
 import to.bitkit.ext.totalNextOutboundHtlcLimitSats
@@ -422,6 +422,8 @@ class WalletRepo @Inject constructor(
             if (coreService.checkGeoStatus() == true) return@withContext Result.success(false)
 
             val channels = lightningRepo.lightningState.value.channels
+            if (channels.filterOpen().isEmpty()) return@withContext Result.success(false)
+
             val inboundBalanceSats = channels.sumOf { it.inboundCapacityMsat / 1000u }
 
             Result.success((_walletState.value.bip21AmountSats ?: 0uL) >= inboundBalanceSats)
@@ -461,27 +463,6 @@ class WalletRepo @Inject constructor(
             }
         }
 
-    suspend fun searchInvoiceByPaymentHash(paymentHash: String): Result<TagMetadataEntity> = withContext(bgDispatcher) {
-        return@withContext try {
-            val invoiceTag =
-                db.tagMetadataDao().searchByPaymentHash(paymentHash = paymentHash) ?: return@withContext Result.failure(
-                    Exception("Invoice not found")
-                )
-            Result.success(invoiceTag)
-        } catch (e: Throwable) {
-            Logger.error("searchInvoice error", e, context = TAG)
-            Result.failure(e)
-        }
-    }
-
-    suspend fun deleteInvoice(txId: Txid) = withContext(bgDispatcher) {
-        try {
-            db.tagMetadataDao().deleteByPaymentHash(paymentHash = txId)
-        } catch (e: Throwable) {
-            Logger.error("deleteInvoice error", e, context = TAG)
-        }
-    }
-
     suspend fun deleteAllInvoices() = withContext(bgDispatcher) {
         try {
             db.tagMetadataDao().deleteAll()

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

@@ -402,14 +402,16 @@ class WalletRepoTest : BaseUnitTest() {
         whenever(coreService.checkGeoStatus()).thenReturn(false)
         val testChannels = listOf(
             mock<ChannelDetails> {
-                on { inboundCapacityMsat } doReturn 500_000u // 500 sats
+                on { inboundCapacityMsat } doReturn 500_000u
+                on { isChannelReady } doReturn true
             },
             mock<ChannelDetails> {
-                on { inboundCapacityMsat } doReturn 300_000u // 300 sats
+                on { inboundCapacityMsat } doReturn 300_000u
+                on { isChannelReady } doReturn true
             }
         )
         whenever(lightningRepo.lightningState).thenReturn(MutableStateFlow(LightningState(channels = testChannels)))
-        sut.updateBip21Invoice(amountSats = 1000uL) // 1000 sats
+        sut.updateBip21Invoice(amountSats = 1000uL)
 
         // When
         val result = sut.shouldRequestAdditionalLiquidity()
@@ -419,6 +421,18 @@ class WalletRepoTest : BaseUnitTest() {
         assertTrue(result.getOrThrow())
     }
 
+    @Test
+    fun `should not request additional liquidity for 0 channels`() = test {
+        whenever(coreService.checkGeoStatus()).thenReturn(false)
+        whenever(lightningRepo.lightningState).thenReturn(MutableStateFlow(LightningState()))
+        sut.updateBip21Invoice(amountSats = 1000uL)
+
+        val result = sut.shouldRequestAdditionalLiquidity()
+
+        assertTrue(result.isSuccess)
+        assertFalse(result.getOrThrow())
+    }
+
     @Test
     fun `shouldRequestAdditionalLiquidity should return false when amount is less than inbound capacity`() = test {
         // Given