Merge pull request #371 from synonymdev/fix/improve-geoblocks-checks

ovitrif · web-flow · commit 933b6192b710 · 2025-09-12T22:49:13.000+02:00
Improve geoblock validation for devices connected to external nodes
diff --git a/app/src/main/java/to/bitkit/repositories/BlocktankRepo.kt b/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(
diff --git a/app/src/main/java/to/bitkit/repositories/LightningRepo.kt b/app/src/main/java/to/bitkit/repositories/LightningRepo.kt
@@ -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)
         }
 
@@ -850,4 +852,5 @@ data class LightningState(
     val channels: List<ChannelDetails> = emptyList(),
     val isSyncingWallet: Boolean = false,
     val shouldBlockLightning: Boolean = false,
+    val isGeoBlocked: Boolean = false,
 )
diff --git a/app/src/main/java/to/bitkit/repositories/WalletRepo.kt b/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)
             }
@@ -352,7 +352,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)
         }
 
@@ -424,7 +424,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
             val inboundBalanceSats = channels.sumOf { it.inboundCapacityMsat / 1000u }
diff --git a/app/src/main/java/to/bitkit/services/CoreService.kt b/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
diff --git a/app/src/main/java/to/bitkit/ui/ContentView.kt b/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> {
diff --git a/app/src/main/java/to/bitkit/ui/MainActivity.kt b/app/src/main/java/to/bitkit/ui/MainActivity.kt
@@ -191,9 +191,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 {
diff --git a/app/src/main/java/to/bitkit/ui/screens/transfer/FundingScreen.kt b/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)
     }
 }
diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/receive/ReceiveSheet.kt
@@ -82,7 +82,7 @@ fun ReceiveSheet(
                     walletState = walletState,
                     onCjitToggle = { isOn ->
                         when {
-                            isOn && lightningState.shouldBlockLightning -> {
+                            isOn && lightningState.shouldBlockLightning -> { // TODO SHOULD BLOCK HERE
                                 navController.navigate(ReceiveRoute.GeoBlock)
                             }
 
diff --git a/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt b/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt
@@ -77,7 +77,6 @@ import to.bitkit.repositories.CurrencyRepo
 import to.bitkit.repositories.HealthRepo
 import to.bitkit.repositories.LightningRepo
 import to.bitkit.repositories.WalletRepo
-import to.bitkit.services.CoreService
 import to.bitkit.services.LdkNodeEventBus
 import to.bitkit.ui.Routes
 import to.bitkit.ui.components.Sheet
@@ -95,7 +94,6 @@ class AppViewModel @Inject constructor(
     private val keychain: Keychain,
     private val lightningRepo: LightningRepo,
     private val walletRepo: WalletRepo,
-    private val coreService: CoreService,
     private val ldkNodeEventBus: LdkNodeEventBus,
     private val settingsStore: SettingsStore,
     private val currencyRepo: CurrencyRepo,
@@ -112,8 +110,14 @@ class AppViewModel @Inject constructor(
     var splashVisible by mutableStateOf(true)
         private set
 
-    var isGeoBlocked by mutableStateOf<Boolean?>(null)
-        private set
+    val isGeoBlocked = lightningRepo.lightningState.map { it.isGeoBlocked }
+        .stateIn(
+            viewModelScope,
+            SharingStarted.WhileSubscribed(
+                5000
+            ),
+            false
+        )
 
     private val _sendUiState = MutableStateFlow(SendUiState())
     val sendUiState = _sendUiState.asStateFlow()
@@ -184,10 +188,12 @@ class AppViewModel @Inject constructor(
             delay(500)
             splashVisible = false
         }
+        viewModelScope.launch {
+            lightningRepo.updateGeoBlockState()
+        }
 
         observeLdkNodeEvents()
         observeSendEvents()
-        checkGeoStatus()
     }
 
     private fun observeLdkNodeEvents() {
@@ -271,16 +277,6 @@ class AppViewModel @Inject constructor(
         }
     }
 
-    private fun checkGeoStatus() {
-        viewModelScope.launch {
-            try {
-                isGeoBlocked = coreService.checkGeoStatus()
-            } catch (e: Throwable) {
-                Logger.error("Failed to check geo status: ${e.message}", e, context = TAG)
-            }
-        }
-    }
-
     // region send
 
     private fun observeSendEvents() {
diff --git a/app/src/test/java/to/bitkit/repositories/LightningRepoTest.kt b/app/src/test/java/to/bitkit/repositories/LightningRepoTest.kt
@@ -63,7 +63,7 @@ class LightningRepoTest : BaseUnitTest() {
 
     @Before
     fun setUp() {
-        wheneverBlocking { coreService.shouldBlockLightning() }.thenReturn(false)
+        wheneverBlocking { coreService.checkGeoBlock() }.thenReturn(Pair(false, false))
         sut = LightningRepo(
             bgDispatcher = testDispatcher,
             lightningService = lightningService,
diff --git a/app/src/test/java/to/bitkit/repositories/WalletRepoTest.kt b/app/src/test/java/to/bitkit/repositories/WalletRepoTest.kt
@@ -46,7 +46,7 @@ class WalletRepoTest : BaseUnitTest() {
 
     @Before
     fun setUp() {
-        wheneverBlocking { coreService.shouldBlockLightning() }.thenReturn(false)
+        wheneverBlocking { coreService.checkGeoBlock() }.thenReturn(Pair(false, false))
         whenever(cacheStore.data).thenReturn(flowOf(AppCacheData()))
         whenever(lightningRepo.getSyncFlow()).thenReturn(flowOf(Unit))
         whenever(lightningRepo.lightningState).thenReturn(MutableStateFlow(LightningState()))
@@ -137,7 +137,7 @@ class WalletRepoTest : BaseUnitTest() {
 
     @Test
     fun `refreshBip21 should set receiveOnSpendingBalance as false if shouldBlockLightning is true`() = test {
-        wheneverBlocking { coreService.shouldBlockLightning() }.thenReturn(true)
+        wheneverBlocking { coreService.checkGeoBlock() }.thenReturn(Pair(true, true))
         whenever(lightningRepo.newAddress()).thenReturn(Result.success("newAddress"))
         whenever(addressChecker.getAddressInfo(any())).thenReturn(mock())
 
@@ -338,7 +338,7 @@ class WalletRepoTest : BaseUnitTest() {
 
     @Test
     fun `toggleReceiveOnSpendingBalance should return failure if shouldBlockLightning is true`() = test {
-        wheneverBlocking { coreService.shouldBlockLightning() }.thenReturn(true)
+        wheneverBlocking { coreService.checkGeoBlock() }.thenReturn(Pair(true, true))
 
         if (sut.walletState.value.receiveOnSpendingBalance) {
             sut.toggleReceiveOnSpendingBalance()
@@ -370,9 +370,9 @@ class WalletRepoTest : BaseUnitTest() {
     }
 
     @Test
-    fun `shouldRequestAdditionalLiquidity should return false when receiveOnSpendingBalance is false`() = test {
+    fun `shouldRequestAdditionalLiquidity should return false when geoBlocked is true`() = test {
         // Given
-        whenever(coreService.checkGeoStatus()).thenReturn(false)
+        whenever(coreService.checkGeoBlock()).thenReturn(Pair(true, false))
         sut.toggleReceiveOnSpendingBalance() // Set to false (initial is true)
 
         // When
@@ -386,7 +386,7 @@ class WalletRepoTest : BaseUnitTest() {
     @Test
     fun `shouldRequestAdditionalLiquidity should return false when geo status is true`() = test {
         // Given
-        whenever(coreService.checkGeoStatus()).thenReturn(true)
+        whenever(coreService.checkGeoBlock()).thenReturn(Pair(true, false))
 
         // When
         val result = sut.shouldRequestAdditionalLiquidity()
@@ -399,7 +399,7 @@ class WalletRepoTest : BaseUnitTest() {
     @Test
     fun `shouldRequestAdditionalLiquidity should return true when amount exceeds inbound capacity`() = test {
         // Given
-        whenever(coreService.checkGeoStatus()).thenReturn(false)
+        whenever(coreService.checkGeoBlock()).thenReturn(Pair(false, false))
         val testChannels = listOf(
             mock<ChannelDetails> {
                 on { inboundCapacityMsat } doReturn 500_000u // 500 sats
@@ -422,7 +422,7 @@ class WalletRepoTest : BaseUnitTest() {
     @Test
     fun `shouldRequestAdditionalLiquidity should return false when amount is less than inbound capacity`() = test {
         // Given
-        whenever(coreService.checkGeoStatus()).thenReturn(false)
+        whenever(coreService.checkGeoBlock()).thenReturn(Pair(false, false))
         val testChannels = listOf(
             mock<ChannelDetails> {
                 on { inboundCapacityMsat } doReturn 500_000u // 500 sats
@@ -441,18 +441,6 @@ class WalletRepoTest : BaseUnitTest() {
         assertTrue(result.isSuccess)
         assertFalse(result.getOrThrow())
     }
-
-    @Test
-    fun `shouldRequestAdditionalLiquidity should return failure when exception occurs`() = test {
-        // Given
-        whenever(coreService.checkGeoStatus()).thenThrow(RuntimeException("Test error"))
-
-        // When
-        val result = sut.shouldRequestAdditionalLiquidity()
-
-        // Then
-        assertTrue(result.isFailure)
-    }
 }
 
 private fun mockAddressInfo() = AddressInfo(

Original file line number	Diff line number	Diff line change
`@@ -246,12 +246,11 @@ class LightningRepo @Inject constructor(`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`/*Updates the shouldBlockLightning state and returns the current value/`
`249`		`- private suspend fun updateGeoBlockState(): Boolean {`
`250`		`- val shouldBlock = coreService.shouldBlockLightning()`
	`249`	`+ suspend fun updateGeoBlockState() {`
	`250`	`+ val (isGeoBlocked, shouldBlockLightning) = coreService.checkGeoBlock()`
`251`	`251`	`_lightningState.update {`
`252`		`- it.copy(shouldBlockLightning = shouldBlock)`
	`252`	`+ it.copy(shouldBlockLightning = shouldBlockLightning, isGeoBlocked = isGeoBlocked)`
`253`	`253`	`}`
`254`		`- return shouldBlock`
`255`	`254`	`}`
`256`	`255`
`257`	`256`	`fun setInitNodeLifecycleState() {`
`@@ -409,7 +408,9 @@ class LightningRepo @Inject constructor(`
`409`	`408`	`}`
`410`	`409`
`411`	`410`	`suspend fun connectPeer(peer: LnPeer): Result<Unit> = executeWhenNodeRunning("connectPeer") {`
`412`		`- lightningService.connectPeer(peer)`
	`411`	`+ lightningService.connectPeer(peer).onFailure { e ->`
	`412`	`+ return@executeWhenNodeRunning Result.failure(e)`
	`413`	`+ }`
`413`	`414`	`syncState()`
`414`	`415`	`Result.success(Unit)`
`415`	`416`	`}`
`@@ -430,7 +431,8 @@ class LightningRepo @Inject constructor(`
`430`	`431`	`description: String,`
`431`	`432`	`expirySeconds: UInt = 86_400u,`
`432`	`433`	`): Result<String> = executeWhenNodeRunning("Create invoice") {`
`433`		`- if (updateGeoBlockState()) {`
	`434`	`+ updateGeoBlockState()`
	`435`	`+ if (lightningState.value.shouldBlockLightning) {`
`434`	`436`	`return@executeWhenNodeRunning Result.failure(ServiceError.GeoBlocked)`
`435`	`437`	`}`
`436`	`438`
`@@ -850,4 +852,5 @@ data class LightningState(`
`850`	`852`	`val channels: List<ChannelDetails> = emptyList(),`
`851`	`853`	`val isSyncingWallet: Boolean = false,`
`852`	`854`	`val shouldBlockLightning: Boolean = false,`
	`855`	`+ val isGeoBlocked: Boolean = false,`
`853`	`856`	`)`
Original file line number	Diff line number	Diff line change
`@@ -333,7 +333,8 @@ fun ContentView(`
`333`	`333`	`ReceiveSheet(`
`334`	`334`	`walletState = walletUiState,`
`335`	`335`	`navigateToExternalConnection = {`
`336`		`- navController.navigate(Routes.ExternalConnection)`
	`336`	`+ navController.navigate(Routes.ExternalConnection())`
	`337`	`+ appViewModel.hideSheet()`
`337`	`338`	`}`
`338`	`339`	`)`
`339`	`340`	`}`
`@@ -515,6 +516,8 @@ private fun RootNavHost(`
`515`	`516`	`}`
`516`	`517`	`composableWithDefaultTransitions<Routes.Funding> {`
`517`	`518`	`val hasSeenSpendingIntro by settingsViewModel.hasSeenSpendingIntro.collectAsState()`
	`519`	`+ val isGeoBlocked by appViewModel.isGeoBlocked.collectAsStateWithLifecycle()`
	`520`	`+`
`518`	`521`	`FundingScreen(`
`519`	`522`	`onTransfer = {`
`520`	`523`	`if (!hasSeenSpendingIntro) {`
`@@ -534,6 +537,7 @@ private fun RootNavHost(`
`534`	`537`	`onAdvanced = { navController.navigate(Routes.FundingAdvanced) },`
`535`	`538`	`onBackClick = { navController.popBackStack() },`
`536`	`539`	`onCloseClick = { navController.navigateToHome() },`
	`540`	`+ isGeoBlocked = isGeoBlocked`
`537`	`541`	`)`
`538`	`542`	`}`
`539`	`543`	`composableWithDefaultTransitions<Routes.FundingAdvanced> {`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ fun ReceiveSheet(`
`82`	`82`	`walletState = walletState,`
`83`	`83`	`onCjitToggle = { isOn ->`
`84`	`84`	`when {`
`85`		`- isOn && lightningState.shouldBlockLightning -> {`
	`85`	`+ isOn && lightningState.shouldBlockLightning -> { // TODO SHOULD BLOCK HERE`
`86`	`86`	`navController.navigate(ReceiveRoute.GeoBlock)`
`87`	`87`	`}`
`88`	`88`