Merge branch 'master' into fix/custom-numpad

# Conflicts:
#	app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt
#	app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt

Author: ovitrif

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

@@ -179,6 +179,7 @@ class BlocktankRepo @Inject constructor(
         description: String = Env.DEFAULT_INVOICE_MESSAGE,
     ): Result<IcJitEntry> = withContext(bgDispatcher) {
         try {
+            if (coreService.checkGeoBlock().first) throw ServiceError.GeoBlocked
             val nodeId = lightningService.nodeId ?: throw ServiceError.NodeNotStarted
             val lspBalance = getDefaultLspBalance(clientBalance = amountSats)
             val channelSizeSat = amountSats + lspBalance
@@ -207,6 +208,8 @@ class BlocktankRepo @Inject constructor(
         channelExpiryWeeks: UInt = DEFAULT_CHANNEL_EXPIRY_WEEKS,
     ): Result<IBtOrder> = withContext(bgDispatcher) {
         try {
+            if (coreService.checkGeoBlock().first) throw ServiceError.GeoBlocked
+
             val options = defaultCreateOrderOptions(clientBalanceSat = spendingBalanceSats)
 
             Logger.info(

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

@@ -62,7 +62,7 @@ import kotlin.time.Duration
 import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 
-private const val SYNC_TIMEOUT_MS = 10_000L
+private const val SYNC_TIMEOUT_MS = 15_000L
 
 @Singleton
 class LightningRepo @Inject constructor(
@@ -246,12 +246,11 @@ class LightningRepo @Inject constructor(
     }
 
     /**Updates the shouldBlockLightning state and returns the current value*/
-    private suspend fun updateGeoBlockState(): Boolean {
-        val shouldBlock = coreService.shouldBlockLightning()
+    suspend fun updateGeoBlockState() {
+        val (isGeoBlocked, shouldBlockLightning) = coreService.checkGeoBlock()
         _lightningState.update {
-            it.copy(shouldBlockLightning = shouldBlock)
+            it.copy(shouldBlockLightning = shouldBlockLightning, isGeoBlocked = isGeoBlocked)
         }
-        return shouldBlock
     }
 
     fun setInitNodeLifecycleState() {
@@ -409,7 +408,9 @@ class LightningRepo @Inject constructor(
     }
 
     suspend fun connectPeer(peer: LnPeer): Result<Unit> = executeWhenNodeRunning("connectPeer") {
-        lightningService.connectPeer(peer)
+        lightningService.connectPeer(peer).onFailure { e ->
+            return@executeWhenNodeRunning Result.failure(e)
+        }
         syncState()
         Result.success(Unit)
     }
@@ -430,7 +431,8 @@ class LightningRepo @Inject constructor(
         description: String,
         expirySeconds: UInt = 86_400u,
     ): Result<String> = executeWhenNodeRunning("Create invoice") {
-        if (updateGeoBlockState()) {
+        updateGeoBlockState()
+        if (lightningState.value.shouldBlockLightning) {
             return@executeWhenNodeRunning Result.failure(ServiceError.GeoBlocked)
         }
 
@@ -682,8 +684,13 @@ class LightningRepo @Inject constructor(
         }
     }
 
-    fun canSend(amountSats: ULong): Boolean =
-        _lightningState.value.nodeLifecycleState.isRunning() && lightningService.canSend(amountSats)
+    suspend fun canSend(amountSats: ULong, fallbackToCachedBalance: Boolean = true): Boolean {
+        return if (!_lightningState.value.nodeLifecycleState.isRunning() && fallbackToCachedBalance) {
+            amountSats <= (cacheStore.data.first().balance?.maxSendLightningSats ?: 0u)
+        } else {
+            lightningService.canSend(amountSats)
+        }
+    }
 
     fun getSyncFlow(): Flow<Unit> = lightningService.syncFlow()
 
@@ -850,4 +857,5 @@ data class LightningState(
     val channels: List<ChannelDetails> = emptyList(),
     val isSyncingWallet: Boolean = false,
     val shouldBlockLightning: Boolean = false,
+    val isGeoBlocked: Boolean = false,
 )

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

@@ -102,7 +102,7 @@ class WalletRepo @Inject constructor(
     suspend fun refreshBip21(force: Boolean = false): Result<Unit> = withContext(bgDispatcher) {
         Logger.debug("Refreshing bip21 (force: $force)", context = TAG)
 
-        if (coreService.shouldBlockLightning()) {
+        if (coreService.checkGeoBlock().second) {
             _walletState.update {
                 it.copy(receiveOnSpendingBalance = false)
             }
@@ -347,7 +347,7 @@ class WalletRepo @Inject constructor(
     }
 
     suspend fun toggleReceiveOnSpendingBalance(): Result<Unit> = withContext(bgDispatcher) {
-        if (!_walletState.value.receiveOnSpendingBalance && coreService.shouldBlockLightning()) {
+        if (!_walletState.value.receiveOnSpendingBalance && coreService.checkGeoBlock().second) {
             return@withContext Result.failure(ServiceError.GeoBlocked)
         }
 
@@ -419,7 +419,7 @@ class WalletRepo @Inject constructor(
         return@withContext try {
             if (!_walletState.value.receiveOnSpendingBalance) return@withContext Result.success(false)
 
-            if (coreService.checkGeoStatus() == true) return@withContext Result.success(false)
+            if (coreService.checkGeoBlock().first) return@withContext Result.success(false)
 
             val channels = lightningRepo.lightningState.value.channels
             if (channels.filterOpen().isEmpty()) return@withContext Result.success(false)

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

@@ -112,28 +112,34 @@ class CoreService @Inject constructor(
         }
     }
 
-    /** Returns true if geo blocked */
-    suspend fun checkGeoStatus(): Boolean? {
+    private suspend fun isGeoBlocked(): Boolean {
         return ServiceQueue.CORE.background {
-            Logger.verbose("Checking geo status…", context = "GeoCheck")
-            val response = httpClient.get(Env.geoCheckUrl)
-
-            when (response.status.value) {
-                HttpStatusCode.OK.value -> {
-                    Logger.verbose("Region allowed", context = "GeoCheck")
-                    false
-                }
-
-                HttpStatusCode.Forbidden.value -> {
-                    Logger.warn("Region blocked", context = "GeoCheck")
-                    true
-                }
-
-                else -> {
-                    Logger.warn("Unexpected status code: ${response.status.value}", context = "GeoCheck")
-                    null
+            runCatching {
+                Logger.verbose("Checking geo status…", context = "GeoCheck")
+                val response = httpClient.get(Env.geoCheckUrl)
+
+                when (response.status.value) {
+                    HttpStatusCode.OK.value -> {
+                        Logger.verbose("Region allowed", context = "GeoCheck")
+                        false
+                    }
+
+                    HttpStatusCode.Forbidden.value -> {
+                        Logger.warn("Region blocked", context = "GeoCheck")
+                        true
+                    }
+
+                    else -> {
+                        Logger.warn(
+                            "Unexpected status code: ${response.status.value}, defaulting to false",
+                            context = "GeoCheck"
+                        )
+                        false
+                    }
                 }
-            }
+            }.onFailure {
+                Logger.warn("Error. defaulting isGeoBlocked to false", context = "GeoCheck")
+            }.getOrDefault(false)
         }
     }
 
@@ -149,7 +155,18 @@ class CoreService @Inject constructor(
 
     suspend fun hasExternalNode() = getConnectedPeers().any { connectedPeer -> connectedPeer !in getLspPeers() }
 
-    suspend fun shouldBlockLightning() = checkGeoStatus() == true && !hasExternalNode()
+    /**
+     * This method checks if the device is geo blocked and if should block lighting features
+     * @return Pair(isGeoBlocked, shouldBlockLightning)*/
+    suspend fun checkGeoBlock(): Pair<Boolean, Boolean> {
+        val geoBlocked = isGeoBlocked()
+        val shouldBlockLightning = when {
+            hasExternalNode() -> false
+            else -> geoBlocked
+        }
+
+        return Pair(geoBlocked, shouldBlockLightning)
+    }
 }
 
 // endregion

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

@@ -445,11 +445,13 @@ class LightningService @Inject constructor(
             .getOrElse { e -> throw LdkError(e as NodeException) }
 
         return ServiceQueue.LDK.background {
-            when (sats != null) {
-                true -> node.bolt11Payment().sendUsingAmount(bolt11Invoice, sats * 1000u, null)
-                else -> node.bolt11Payment().send(bolt11Invoice, null)
+            runCatching {
+                when (sats != null) {
+                    true -> node.bolt11Payment().sendUsingAmount(bolt11Invoice, sats * 1000u, null)
+                    else -> node.bolt11Payment().send(bolt11Invoice, null)
+                }
             }
-        }
+        }.getOrThrow()
     }
 
     suspend fun estimateRoutingFees(bolt11: String): Result<ULong> {

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

@@ -333,7 +333,8 @@ fun ContentView(
                             ReceiveSheet(
                                 walletState = walletUiState,
                                 navigateToExternalConnection = {
-                                    navController.navigate(Routes.ExternalConnection)
+                                    navController.navigate(Routes.ExternalConnection())
+                                    appViewModel.hideSheet()
                                 }
                             )
                         }
@@ -515,6 +516,8 @@ private fun RootNavHost(
             }
             composableWithDefaultTransitions<Routes.Funding> {
                 val hasSeenSpendingIntro by settingsViewModel.hasSeenSpendingIntro.collectAsState()
+                val isGeoBlocked by appViewModel.isGeoBlocked.collectAsStateWithLifecycle()
+
                 FundingScreen(
                     onTransfer = {
                         if (!hasSeenSpendingIntro) {
@@ -534,6 +537,7 @@ private fun RootNavHost(
                     onAdvanced = { navController.navigate(Routes.FundingAdvanced) },
                     onBackClick = { navController.popBackStack() },
                     onCloseClick = { navController.navigateToHome() },
+                    isGeoBlocked = isGeoBlocked
                 )
             }
             composableWithDefaultTransitions<Routes.FundingAdvanced> {
@@ -1352,8 +1356,8 @@ fun NavController.navigateToWidgetsSettings() = navigate(
     route = Routes.WidgetsSettings,
 )
 
-fun NavController.navigateToQuickPaySettings() = navigate(
-    route = Routes.QuickPaySettings,
+fun NavController.navigateToQuickPaySettings(hasSeenIntro: Boolean = true) = navigate(
+    route = if (hasSeenIntro) Routes.QuickPaySettings else Routes.QuickPayIntro,
 )
 
 fun NavController.navigateToTagsSettings() = navigate(

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

@@ -1,5 +1,6 @@
 package to.bitkit.ui
 
+import android.app.NotificationManager
 import android.content.Intent
 import android.os.Bundle
 import androidx.activity.compose.setContent
@@ -70,10 +71,11 @@ class MainActivity : FragmentActivity() {
 
         initNotificationChannel()
         initNotificationChannel(
-            // TODO EXTRACT TO Strings
+            // TODO Transifex
             id = CHANNEL_ID_NODE,
             name = "Lightning node notification",
             desc = "Channel for LightningNodeService",
+            importance = NotificationManager.IMPORTANCE_LOW
         )
         startForegroundService(Intent(this, LightningNodeService::class.java))
         installSplashScreen()
@@ -191,9 +193,10 @@ private fun OnboardingNav(
         }
         composableWithDefaultTransitions<StartupRoutes.Slides> { navBackEntry ->
             val route = navBackEntry.toRoute<StartupRoutes.Slides>()
+            val isGeoBlocked by appViewModel.isGeoBlocked.collectAsStateWithLifecycle()
             OnboardingSlidesScreen(
                 currentTab = route.tab,
-                isGeoBlocked = appViewModel.isGeoBlocked == true,
+                isGeoBlocked = isGeoBlocked,
                 onAdvancedSetupClick = { startupNavController.navigate(StartupRoutes.Advanced) },
                 onCreateClick = {
                     scope.launch {

app/src/main/java/to/bitkit/ui/screens/transfer/FundingScreen.kt

@@ -28,7 +28,6 @@ import androidx.compose.ui.unit.dp
 import to.bitkit.R
 import to.bitkit.env.Env
 import to.bitkit.ui.LocalBalances
-import to.bitkit.ui.appViewModel
 import to.bitkit.ui.components.BodyM
 import to.bitkit.ui.components.BodyMB
 import to.bitkit.ui.components.Display
@@ -47,13 +46,13 @@ fun FundingScreen(
     onAdvanced: () -> Unit = {},
     onBackClick: () -> Unit = {},
     onCloseClick: () -> Unit = {},
+    isGeoBlocked: Boolean
 ) {
     val balances = LocalBalances.current
     val canTransfer = remember(balances.totalOnchainSats) {
         balances.totalOnchainSats >= Env.TransactionDefaults.recommendedBaseFee
     }
     var showNoFundsAlert by remember { mutableStateOf(false) }
-    val isGeoBlocked = appViewModel?.isGeoBlocked == true
 
     ScreenColumn {
         AppTopBar(
@@ -164,6 +163,6 @@ fun FundingScreen(
 @Composable
 private fun FundingScreenPreview() {
     AppThemeSurface {
-        FundingScreen()
+        FundingScreen(isGeoBlocked = false)
     }
 }

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

@@ -86,7 +86,7 @@ fun ReceiveSheet(
                     walletState = walletState,
                     onCjitToggle = { isOn ->
                         when {
-                            isOn && lightningState.shouldBlockLightning -> {
+                            isOn && lightningState.shouldBlockLightning -> { // TODO SHOULD BLOCK HERE
                                 navController.navigate(ReceiveRoute.GeoBlock)
                             }
 

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

@@ -274,6 +274,7 @@ private fun SendAmountNodeRunning(
             PrimaryButton(
                 text = stringResource(R.string.common__continue),
                 enabled = uiState.isAmountInputValid,
+                isLoading = uiState.isLoading,
                 onClick = onContinue,
                 modifier = Modifier.testTag("ContinueAmount")
             )