fix: remove geoblock restrictions from inbound and outbound calculation

Author: jvsena42

Bitkit/Services/LightningService.swift

@@ -368,12 +368,8 @@ class LightningService {
             return false
         }
 
-        // When geoblocked, only count non-LSP channels
-        let isGeoblocked = GeoService.shared.isGeoBlocked
-        let channelsToUse = isGeoblocked ? getNonLspChannels() : channels
-
         let totalNextOutboundHtlcLimitSats =
-            channelsToUse
+            channels
                 .filter(\.isUsable)
                 .map(\.nextOutboundHtlcLimitMsat)
                 .reduce(0, +) / 1000
@@ -436,16 +432,6 @@ class LightningService {
             throw AppError(serviceError: .nodeNotSetup)
         }
 
-        // When geoblocked, verify we have external (non-LSP) peers
-        let isGeoblocked = GeoService.shared.isGeoBlocked
-        if isGeoblocked && !hasExternalPeers() {
-            Logger.error("Cannot send Lightning payment when geoblocked without external peers")
-            throw AppError(
-                message: "Lightning send unavailable",
-                debugMessage: "You need channels with non-Blocktank nodes to send Lightning payments."
-            )
-        }
-
         Logger.info("Paying bolt11: \(bolt11)")
 
         do {
@@ -657,31 +643,6 @@ extension LightningService {
             try node.getAddressBalance(addressStr: address)
         }
     }
-
-    /// Returns LSP (Blocktank) peer node IDs
-    func getLspPeerNodeIds() -> [String] {
-        return Env.trustedLnPeers.map(\.nodeId)
-    }
-
-    /// Checks if there are connected peers other than LSP peers
-    /// Used for geoblocking to determine if Lightning operations can proceed
-    func hasExternalPeers() -> Bool {
-        guard let peers else { return false }
-        let lspNodeIds = Set(getLspPeerNodeIds())
-        return peers.contains { peer in
-            !lspNodeIds.contains(peer.nodeId)
-        }
-    }
-
-    /// Filters channels to exclude LSP channels
-    /// Used for geoblocking to only allow operations through non-Blocktank channels
-    func getNonLspChannels() -> [ChannelDetails] {
-        guard let channels else { return [] }
-        let lspNodeIds = Set(getLspPeerNodeIds())
-        return channels.filter { channel in
-            !lspNodeIds.contains(channel.counterpartyNodeId)
-        }
-    }
 }
 
 // MARK: Events

Bitkit/ViewModels/WalletViewModel.swift

@@ -544,31 +544,10 @@ class WalletViewModel: ObservableObject {
         return capacity
     }
 
-    /// Total inbound Lightning capacity excluding LSP (Blocktank) channels
-    /// Used when geoblocked to show only non-Blocktank receiving capacity
-    var totalNonLspInboundLightningSats: UInt64? {
-        let nonLspChannels = lightningService.getNonLspChannels()
-        guard !nonLspChannels.isEmpty else {
-            return nil
-        }
-
-        var capacity: UInt64 = 0
-        for channel in nonLspChannels {
-            capacity += channel.inboundCapacityMsat / 1000
-        }
-        return capacity
-    }
-
     var hasUsableChannels: Bool {
         return channels?.contains(where: \.isChannelReady) ?? false
     }
 
-    /// Check if there are non-LSP (non-Blocktank) channels available
-    /// Used for geoblocking to determine if Lightning operations can proceed
-    func hasNonLspChannels() -> Bool {
-        return !lightningService.getNonLspChannels().isEmpty
-    }
-
     func refreshBip21(forceRefreshBolt11: Bool = false) async throws {
         // Get old payment ID and tags before refreshing (which may change payment ID)
         let oldPaymentId = await paymentId()

Bitkit/Views/Wallets/Receive/ReceiveEdit.swift

@@ -177,10 +177,7 @@ struct ReceiveEdit: View {
     private func needsAdditionalCjit() -> Bool {
         let isGeoBlocked = GeoService.shared.isGeoBlocked
         let minimumAmount = blocktank.minCjitSats ?? 0
-        // When geoblocked, only count non-LSP inbound capacity
-        let inboundCapacity = isGeoBlocked
-            ? (wallet.totalNonLspInboundLightningSats ?? 0)
-            : (wallet.totalInboundLightningSats ?? 0)
+        let inboundCapacity = wallet.totalInboundLightningSats ?? 0
         let invoiceAmount = amountViewModel.amountSats
 
         // Calculate maxClientBalance using TransferViewModel