Merge branch 'master' into fix/suggested-fee-calc-boost

Author: jvsena42

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

@@ -245,11 +245,10 @@ class LightningRepo @Inject constructor(
         }
     }
 
-    /**Updates the shouldBlockLightning state and returns the current value*/
     suspend fun updateGeoBlockState() {
         val (isGeoBlocked, shouldBlockLightning) = coreService.checkGeoBlock()
         _lightningState.update {
-            it.copy(shouldBlockLightning = shouldBlockLightning, isGeoBlocked = isGeoBlocked)
+            it.copy(isGeoBlocked = isGeoBlocked, shouldBlockLightningReceive = shouldBlockLightning)
         }
     }
 
@@ -432,7 +431,7 @@ class LightningRepo @Inject constructor(
         expirySeconds: UInt = 86_400u,
     ): Result<String> = executeWhenNodeRunning("Create invoice") {
         updateGeoBlockState()
-        if (lightningState.value.shouldBlockLightning) {
+        if (lightningState.value.shouldBlockLightningReceive) {
             return@executeWhenNodeRunning Result.failure(ServiceError.GeoBlocked)
         }
 
@@ -673,7 +672,7 @@ class LightningRepo @Inject constructor(
         Result.success(Unit)
     }
 
-    suspend fun syncState() {
+    fun syncState() {
         _lightningState.update {
             it.copy(
                 nodeId = getNodeId().orEmpty(),
@@ -709,8 +708,10 @@ class LightningRepo @Inject constructor(
     fun getChannels(): List<ChannelDetails>? =
         if (_lightningState.value.nodeLifecycleState.isRunning()) lightningService.channels else null
 
-    fun hasChannels(): Boolean =
-        _lightningState.value.nodeLifecycleState.isRunning() && lightningService.channels?.isNotEmpty() == true
+    fun canReceive(): Boolean {
+        val isRunning = _lightningState.value.nodeLifecycleState.isRunning()
+        return isRunning && lightningService.canReceive()
+    }
 
     suspend fun registerForNotifications(token: String? = null) = executeWhenNodeRunning("registerForNotifications") {
         return@executeWhenNodeRunning try {
@@ -856,6 +857,6 @@ data class LightningState(
     val peers: List<LnPeer> = emptyList(),
     val channels: List<ChannelDetails> = emptyList(),
     val isSyncingWallet: Boolean = false,
-    val shouldBlockLightning: Boolean = false,
+    val shouldBlockLightningReceive: Boolean = false,
     val isGeoBlocked: Boolean = false,
 )

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

@@ -102,10 +102,9 @@ class WalletRepo @Inject constructor(
     suspend fun refreshBip21(force: Boolean = false): Result<Unit> = withContext(bgDispatcher) {
         Logger.debug("Refreshing bip21 (force: $force)", context = TAG)
 
-        if (coreService.checkGeoBlock().second) {
-            _walletState.update {
-                it.copy(receiveOnSpendingBalance = false)
-            }
+        val shouldBlockLightningReceive = coreService.checkGeoBlock().second
+        _walletState.update {
+            it.copy(receiveOnSpendingBalance = !shouldBlockLightningReceive)
         }
 
         // Reset invoice state
@@ -383,9 +382,8 @@ class WalletRepo @Inject constructor(
             updateBip21AmountSats(amountSats)
             updateBip21Description(description)
 
-            val hasChannels = lightningRepo.hasChannels()
-
-            if (hasChannels && _walletState.value.receiveOnSpendingBalance) {
+            val canReceive = lightningRepo.canReceive()
+            if (canReceive && _walletState.value.receiveOnSpendingBalance) {
                 lightningRepo.createInvoice(
                     amountSats = _walletState.value.bip21AmountSats,
                     description = _walletState.value.bip21Description,

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

@@ -58,7 +58,6 @@ import to.bitkit.async.ServiceQueue
 import to.bitkit.data.CacheStore
 import to.bitkit.env.Env
 import to.bitkit.ext.amountSats
-import to.bitkit.models.LnPeer
 import to.bitkit.models.toCoreNetwork
 import to.bitkit.utils.AppError
 import to.bitkit.utils.Logger
@@ -143,29 +142,18 @@ class CoreService @Inject constructor(
         }
     }
 
-    private suspend fun getLspPeers(): List<LnPeer> {
-        val blocktankPeers = Env.trustedLnPeers
-        // TODO get from blocktank info when lightningService.setup sets trustedPeers0conf using BT API
-        // pseudocode idea:
-        // val blocktankPeers = getInfo(refresh = true)?.nodes?.map { LnPeer(nodeId = it.pubkey, address = "TO_DO") }.orEmpty()
-        return blocktankPeers
-    }
-
-    suspend fun getConnectedPeers(): List<LnPeer> = lightningService.peers.orEmpty()
-
-    suspend fun hasExternalNode() = getConnectedPeers().any { connectedPeer -> connectedPeer !in getLspPeers() }
-
     /**
-     * This method checks if the device is geo blocked and if should block lighting features
-     * @return Pair(isGeoBlocked, shouldBlockLightning)*/
+     * This method checks if the device is in a is geo blocked region and if lightning features should be blocked
+     * @return pair of `isGeoBlocked` to `shouldBlockLightningReceive`
+     * */
     suspend fun checkGeoBlock(): Pair<Boolean, Boolean> {
         val geoBlocked = isGeoBlocked()
-        val shouldBlockLightning = when {
-            hasExternalNode() -> false
+        val shouldBlockLightningReceive = when {
+            lightningService.hasExternalPeers() -> !lightningService.canReceive()
             else -> geoBlocked
         }
 
-        return Pair(geoBlocked, shouldBlockLightning)
+        return Pair(geoBlocked, shouldBlockLightningReceive)
     }
 }
 

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

@@ -318,6 +318,17 @@ class LightningService @Inject constructor(
             Logger.warn("Peer disconnect error: $peer", LdkError(e))
         }
     }
+
+    private fun getLspPeers(): List<LnPeer> {
+        val lspPeers = Env.trustedLnPeers
+        // TODO get from blocktank info.nodes[] when setup uses it to set trustedPeers0conf
+        // pseudocode idea:
+        // val lspPeers = getInfo(refresh = true)?.nodes?.map { LnPeer(nodeId = it.pubkey, address = "TO_DO") }
+        return lspPeers
+    }
+
+    fun hasExternalPeers() = peers?.any { it !in getLspPeers() } == true
+
     // endregion
 
     // region channels
@@ -374,6 +385,21 @@ class LightningService @Inject constructor(
     // endregion
 
     // region payments
+    fun canReceive(): Boolean {
+        val channels = this.channels
+        if (channels == null) {
+            Logger.warn("canReceive = false: Channels not available")
+            return false
+        }
+
+        if (channels.none { it.isChannelReady }) {
+            Logger.warn("canReceive = false: Found no LN channel ready to enable receive: $channels")
+            return false
+        }
+
+        return true
+    }
+
     suspend fun receive(sat: ULong? = null, description: String, expirySecs: UInt = 3600u): String {
         val node = this.node ?: throw ServiceError.NodeNotSetup
 

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

@@ -14,11 +14,8 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.rememberNavController
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.launch
 import kotlinx.serialization.Serializable
 import to.bitkit.repositories.LightningState
-import to.bitkit.ui.blocktankViewModel
 import to.bitkit.ui.screens.wallets.send.AddTagScreen
 import to.bitkit.ui.shared.modifiers.sheetHeight
 import to.bitkit.ui.utils.composableWithDefaultTransitions
@@ -34,8 +31,6 @@ fun ReceiveSheet(
     editInvoiceAmountViewModel: AmountInputViewModel = hiltViewModel(),
 ) {
     val wallet = requireNotNull(walletViewModel)
-    val blocktank = requireNotNull(blocktankViewModel)
-
     val navController = rememberNavController()
     LaunchedEffect(Unit) { editInvoiceAmountViewModel.clearInput() }
 
@@ -45,13 +40,7 @@ fun ReceiveSheet(
     val lightningState: LightningState by wallet.lightningState.collectAsStateWithLifecycle()
 
     LaunchedEffect(Unit) {
-        runCatching {
-            // TODO move to viewModel
-            coroutineScope {
-                launch { wallet.refreshBip21() }
-                launch { blocktank.refreshInfo() }
-            }
-        }
+        wallet.refreshReceiveState()
     }
 
     Column(
@@ -86,7 +75,7 @@ fun ReceiveSheet(
                     walletState = walletState,
                     onCjitToggle = { isOn ->
                         when {
-                            isOn && lightningState.shouldBlockLightning -> { // TODO SHOULD BLOCK HERE
+                            isOn && lightningState.shouldBlockLightningReceive -> {
                                 navController.navigate(ReceiveRoute.GeoBlock)
                             }
 

app/src/main/java/to/bitkit/viewmodels/BlocktankViewModel.kt

@@ -41,12 +41,6 @@ class BlocktankViewModel @Inject constructor(
         .distinctUntilChanged()
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)
 
-    fun refreshInfo() {
-        viewModelScope.launch {
-            blocktankRepo.refreshInfo()
-        }
-    }
-
     fun refreshOrders() {
         viewModelScope.launch {
             blocktankRepo.refreshOrders()

app/src/main/java/to/bitkit/viewmodels/WalletViewModel.kt

@@ -26,6 +26,7 @@ import to.bitkit.models.LnPeer
 import to.bitkit.models.NodeLifecycleState
 import to.bitkit.models.Toast
 import to.bitkit.repositories.BackupRepo
+import to.bitkit.repositories.BlocktankRepo
 import to.bitkit.repositories.LightningRepo
 import to.bitkit.repositories.WalletRepo
 import to.bitkit.ui.onboarding.LOADING_MS
@@ -42,6 +43,7 @@ class WalletViewModel @Inject constructor(
     private val lightningRepo: LightningRepo,
     private val settingsStore: SettingsStore,
     private val backupRepo: BackupRepo,
+    private val blocktankRepo: BlocktankRepo,
 ) : ViewModel() {
 
     val lightningState = lightningRepo.lightningState
@@ -240,6 +242,12 @@ class WalletViewModel @Inject constructor(
         }
     }
 
+    fun refreshReceiveState() = viewModelScope.launch(bgDispatcher) {
+        launch { lightningRepo.updateGeoBlockState() }
+        launch { walletRepo.refreshBip21() }
+        launch { blocktankRepo.refreshInfo() }
+    }
+
     fun refreshBip21() {
         viewModelScope.launch {
             walletRepo.refreshBip21()

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

@@ -254,8 +254,24 @@ class LightningRepoTest : BaseUnitTest() {
     }
 
     @Test
-    fun `hasChannels should return false when node is not running`() = test {
-        assertFalse(sut.hasChannels())
+    fun `canReceive should return false when node is not running`() = test {
+        assertFalse(sut.canReceive())
+    }
+
+    @Test
+    fun `canReceive should return false when node is running but cannot receive`() = test {
+        startNodeForTesting()
+        whenever(lightningService.canReceive()).thenReturn(false)
+
+        assertFalse(sut.canReceive())
+    }
+
+    @Test
+    fun `canReceive should return true when node can receive`() = test {
+        startNodeForTesting()
+        whenever(lightningService.canReceive()).thenReturn(true)
+
+        assertTrue(sut.canReceive())
     }
 
     @Test

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

@@ -136,7 +136,7 @@ class WalletRepoTest : BaseUnitTest() {
     }
 
     @Test
-    fun `refreshBip21 should set receiveOnSpendingBalance as false if shouldBlockLightning is true`() = test {
+    fun `refreshBip21 should set receiveOnSpendingBalance false when shouldBlockLightning is true`() = test {
         wheneverBlocking { coreService.checkGeoBlock() }.thenReturn(Pair(true, true))
         whenever(lightningRepo.newAddress()).thenReturn(Result.success("newAddress"))
         whenever(addressChecker.getAddressInfo(any())).thenReturn(mock())
@@ -147,6 +147,18 @@ class WalletRepoTest : BaseUnitTest() {
         assertEquals(false, sut.walletState.value.receiveOnSpendingBalance)
     }
 
+    @Test
+    fun `refreshBip21 should set receiveOnSpendingBalance true when shouldBlockLightning is false`() = test {
+        wheneverBlocking { coreService.checkGeoBlock() }.thenReturn(Pair(true, false))
+        whenever(lightningRepo.newAddress()).thenReturn(Result.success("newAddress"))
+        whenever(addressChecker.getAddressInfo(any())).thenReturn(mock())
+
+        val result = sut.refreshBip21()
+
+        assertTrue(result.isSuccess)
+        assertEquals(true, sut.walletState.value.receiveOnSpendingBalance)
+    }
+
     @Test
     fun `refreshBip21 should generate new address when current has transactions`() = test {
         val testAddress = "testAddress"
@@ -246,10 +258,10 @@ class WalletRepoTest : BaseUnitTest() {
     }
 
     @Test
-    fun `updateBip21Invoice should create bolt11 when channels exist`() = test {
+    fun `updateBip21Invoice should create bolt11 when node can receive`() = test {
         val testInvoice = "testInvoice"
-        whenever(lightningRepo.hasChannels()).thenReturn(true)
-        whenever(lightningRepo.createInvoice(1000uL, description = "test")).thenReturn(Result.success(testInvoice))
+        whenever(lightningRepo.canReceive()).thenReturn(true)
+        whenever(lightningRepo.createInvoice(anyOrNull(), any(), any())).thenReturn(Result.success(testInvoice))
 
         sut.updateBip21Invoice(amountSats = 1000uL, description = "test").let { result ->
             assertTrue(result.isSuccess)
@@ -258,9 +270,7 @@ class WalletRepoTest : BaseUnitTest() {
     }
 
     @Test
-    fun `updateBip21Invoice should not create bolt11 when no channels exist`() = test {
-        whenever(lightningRepo.hasChannels()).thenReturn(false)
-
+    fun `updateBip21Invoice should not create bolt11 when node cannot receive`() = test {
         sut.updateBip21Invoice(amountSats = 1000uL, description = "test").let { result ->
             assertTrue(result.isSuccess)
             assertEquals("", sut.walletState.value.bolt11)
@@ -271,7 +281,7 @@ class WalletRepoTest : BaseUnitTest() {
     fun `updateBip21Invoice should build correct BIP21 URL`() = test {
         val testAddress = "testAddress"
         whenever(cacheStore.data).thenReturn(flowOf(AppCacheData(onchainAddress = testAddress)))
-        whenever(lightningRepo.hasChannels()).thenReturn(false)
+        whenever(lightningRepo.createInvoice(anyOrNull(), any(), any())).thenReturn(Result.success("testInvoice"))
         sut = createSut()
 
         sut.updateBip21Invoice(amountSats = 1000uL, description = "test").let { result ->