fix(settings): roll back electrum connection on failure (#261)

Author: pwltr

Bitkit/Constants/Env.swift

@@ -69,17 +69,18 @@ enum Env {
 
     static var electrumServerUrl: String {
         if isE2E {
-            return "127.0.0.1:60001"
+            return "tcp://127.0.0.1:60001"
         }
+
         switch network {
-        case .regtest:
-            return "34.65.252.32:18483"
         case .bitcoin:
-            return "35.187.18.233:18484"
-        case .testnet:
-            fatalError("Testnet network not implemented")
+            return "ssl://35.187.18.233:8900"
         case .signet:
             fatalError("Signet network not implemented")
+        case .testnet:
+            return "ssl://electrum.blockstream.info:60002"
+        case .regtest:
+            return "tcp://34.65.252.32:18483"
         }
     }
 

Bitkit/Models/ElectrumServer.swift

@@ -14,6 +14,12 @@ struct ElectrumServer: Equatable, Codable {
         return "\(host):\(port)"
     }
 
+    /// Returns the full URL with protocol prefix (tcp:// or ssl://)
+    var fullUrl: String {
+        let protocolPrefix = protocolType == .ssl ? "ssl://" : "tcp://"
+        return "\(protocolPrefix)\(host):\(port)"
+    }
+
     var portString: String {
         return String(port)
     }

Bitkit/Services/ElectrumConfigService.swift

@@ -28,15 +28,21 @@ class ElectrumConfigService {
     /// Gets the default server parsed from Env.electrumServerUrl
     func getDefaultServer() -> ElectrumServer {
         let defaultServerUrl = Env.electrumServerUrl
-        let components = defaultServerUrl.split(separator: ":")
+
+        guard defaultServerUrl.hasPrefix("tcp://") || defaultServerUrl.hasPrefix("ssl://") else {
+            fatalError("Invalid default Electrum server URL format: \(defaultServerUrl). Expected tcp:// or ssl:// prefix.")
+        }
+
+        let protocolType: ElectrumProtocol = defaultServerUrl.hasPrefix("ssl://") ? .ssl : .tcp
+        let urlWithoutProtocol = String(defaultServerUrl.dropFirst(6)) // Remove "ssl://" or "tcp://"
+        let components = urlWithoutProtocol.split(separator: ":")
 
         guard components.count >= 2 else {
             fatalError("Invalid default Electrum server URL: \(defaultServerUrl)")
         }
 
         let host = String(components[0])
         let port = String(components[1])
-        let protocolType = getProtocolForPort(port)
 
         return ElectrumServer(host: host, portString: port, protocolType: protocolType)
     }
@@ -45,7 +51,7 @@ class ElectrumConfigService {
     func saveServerConfig(_ server: ElectrumServer) {
         do {
             electrumServerData = try JSONEncoder().encode(server)
-            Logger.info("Saved Electrum server config: \(server.url) (\(server.protocolType.rawValue))")
+            Logger.info("Saved Electrum server config: \(server.fullUrl)")
         } catch {
             Logger.error(error, context: "Failed to encode Electrum server config")
         }

Bitkit/Services/LightningService.swift

@@ -119,10 +119,52 @@ class LightningService {
         }
 
         // Restart the node with the current configuration
-        try await setup(walletIndex: currentWalletIndex, electrumServerUrl: electrumServerUrl, rgsServerUrl: rgsServerUrl)
-        try await start()
+        do {
+            try await setup(walletIndex: currentWalletIndex, electrumServerUrl: electrumServerUrl, rgsServerUrl: rgsServerUrl)
+            try await start()
+            Logger.info("Node restarted successfully")
+        } catch {
+            Logger.warn("Failed ldk-node config change, attempting recovery…")
+            // Attempt to restart with previous config
+            // If recovery fails, log it but still throw the original error
+            do {
+                try await restartWithPreviousConfig()
+            } catch {
+                Logger.error("Recovery attempt also failed: \(error)")
+            }
+            // Always re-throw the original error that caused the restart failure
+            throw error
+        }
+    }
+
+    /// Restarts the node with the previous stored configuration (recovery method)
+    /// This is called when a config change fails to restore the node to a working state
+    private func restartWithPreviousConfig() async throws {
+        Logger.debug("Stopping node for recovery attempt")
+
+        // Stop the current node if it exists
+        if node != nil {
+            do {
+                try await stop()
+            } catch {
+                Logger.error("Failed to stop node during recovery: \(error)")
+                // Clear the node reference anyway
+                node = nil
+                try? StateLocker.unlock(.lightning)
+            }
+        }
+
+        Logger.debug("Starting node with previous config for recovery")
 
-        Logger.info("Node restarted successfully")
+        do {
+            // Restart with nil URLs to use stored/default configuration
+            try await setup(walletIndex: currentWalletIndex, electrumServerUrl: nil, rgsServerUrl: nil)
+            try await start()
+            Logger.debug("Successfully started node with previous config")
+        } catch {
+            Logger.error("Failed starting node with previous config: \(error)")
+            throw error
+        }
     }
 
     /// Pass onEvent when being used in the background to listen for payments, channels, closes, etc

Bitkit/ViewModels/Extensions/SettingsViewModel+Electrum.swift

@@ -32,36 +32,60 @@ extension SettingsViewModel {
             return (success: false, host: host, port: port, errorMessage: validationError)
         }
 
-        // Update current server config immediately after validation
-        electrumCurrentServer = ElectrumServer(
+        // Create server config (don't save yet - only save after successful connection)
+        let serverConfig = ElectrumServer(
             host: host,
             portString: port,
             protocolType: electrumSelectedProtocol
         )
 
         do {
-            // Save the configuration to settings
-            electrumConfigService.saveServerConfig(electrumCurrentServer)
-
             // Restart the Lightning node with the new Electrum server
             let currentRgsUrl = rgsConfigService.getCurrentServerUrl()
             try await lightningService.restart(
-                electrumServerUrl: electrumCurrentServer.url,
+                electrumServerUrl: serverConfig.fullUrl,
                 rgsServerUrl: currentRgsUrl.isEmpty ? nil : currentRgsUrl
             )
 
+            // Wait a bit for the connection to establish and verify it's actually working
+            try await Task.sleep(nanoseconds: 1_000_000_000) // 1 second
+
+            // Verify the node is actually running and connected
+            guard let status = lightningService.status, status.isRunning else {
+                electrumIsLoading = false
+                Logger.error("Electrum connection failed: Node is not running after restart")
+
+                // Reload form and connection status from actual current server (node may have fallen back to previous server)
+                let actualServer = electrumConfigService.getCurrentServer()
+                updateForm(with: actualServer)
+                electrumCurrentServer = actualServer
+                // Check if node is actually running with the previous server
+                electrumIsConnected = lightningService.status?.isRunning == true
+
+                return (success: false, host: host, port: port, errorMessage: t("settings__es__server_error_description"))
+            }
+
+            // Only save the configuration after successful connection validation
+            electrumConfigService.saveServerConfig(serverConfig)
+            electrumCurrentServer = serverConfig
             electrumIsConnected = true
             electrumIsLoading = false
 
-            Logger.info("Successfully connected to Electrum server: \(electrumCurrentServer.url)")
+            Logger.info("Successfully connected to Electrum server: \(serverConfig.fullUrl)")
 
             return (success: true, host: host, port: port, errorMessage: nil)
         } catch {
-            electrumIsConnected = false
             electrumIsLoading = false
 
             Logger.error(error, context: "Failed to connect to Electrum server")
 
+            // Reload form and connection status from actual current server (node may have fallen back to previous server)
+            let actualServer = electrumConfigService.getCurrentServer()
+            updateForm(with: actualServer)
+            electrumCurrentServer = actualServer
+            // Check if node is actually running with the previous server
+            electrumIsConnected = lightningService.status?.isRunning == true
+
             return (success: false, host: host, port: port, errorMessage: nil)
         }
     }
@@ -151,6 +175,20 @@ extension SettingsViewModel {
     }
 
     private func parseElectrumScanData(_ data: String) -> ElectrumServer? {
+        // Handle URLs with tcp:// or ssl:// prefix
+        if data.hasPrefix("tcp://") || data.hasPrefix("ssl://") {
+            let protocolType: ElectrumProtocol = data.hasPrefix("ssl://") ? .ssl : .tcp
+            let urlWithoutProtocol = String(data.dropFirst(6)) // Remove "ssl://" or "tcp://"
+            let components = urlWithoutProtocol.split(separator: ":")
+
+            guard components.count >= 2 else { return nil }
+
+            let host = String(components[0])
+            let port = String(components[1])
+
+            return ElectrumServer(host: host, portString: port, protocolType: protocolType)
+        }
+
         // Handle plain format: host:port or host:port:s (Umbrel format)
         if !data.hasPrefix("http://") && !data.hasPrefix("https://") {
             let parts = data.split(separator: ":")

Bitkit/ViewModels/Extensions/SettingsViewModel+Rgs.swift

@@ -26,7 +26,7 @@ extension SettingsViewModel {
             rgsConfigService.saveServerUrl(url)
 
             // Restart the Lightning node with the new RGS server
-            let currentElectrumUrl = electrumConfigService.getCurrentServer().url
+            let currentElectrumUrl = electrumConfigService.getCurrentServer().fullUrl
             try await lightningService.restart(electrumServerUrl: currentElectrumUrl, rgsServerUrl: url.isEmpty ? nil : url)
 
             rgsIsLoading = false

Bitkit/ViewModels/SettingsViewModel.swift

@@ -344,9 +344,7 @@ class SettingsViewModel: NSObject, ObservableObject {
             }
         }
 
-        let electrumServer = electrumConfigService.getCurrentServer()
-        let protocolPrefix = electrumServer.protocolType == .ssl ? "ssl://" : "tcp://"
-        let electrumServerUrl = "\(protocolPrefix)\(electrumServer.url)"
+        let electrumServerUrl = electrumConfigService.getCurrentServer().fullUrl
         if !electrumServerUrl.isEmpty { dict["electrumServer"] = electrumServerUrl }
 
         let rgsServerUrl = rgsConfigService.getCurrentServerUrl()
@@ -377,7 +375,7 @@ class SettingsViewModel: NSObject, ObservableObject {
         }
 
         if urlString.hasPrefix("tcp://") || urlString.hasPrefix("ssl://") {
-            let withoutProtocol = urlString.replacingOccurrences(of: "tcp://", with: "").replacingOccurrences(of: "ssl://", with: "")
+            let withoutProtocol = String(urlString.dropFirst(6)) // Remove "ssl://" or "tcp://"
             let parts = withoutProtocol.split(separator: ":")
             guard parts.count >= 2 else { return nil }
 

Bitkit/ViewModels/WalletViewModel.swift

@@ -100,7 +100,7 @@ class WalletViewModel: ObservableObject {
 
         syncState()
         do {
-            let electrumServerUrl = electrumConfigService.getCurrentServer().url
+            let electrumServerUrl = electrumConfigService.getCurrentServer().fullUrl
             let rgsServerUrl = rgsConfigService.getCurrentServerUrl()
             try await lightningService.setup(
                 walletIndex: walletIndex,
@@ -472,10 +472,19 @@ class WalletViewModel: ObservableObject {
         syncBalances()
     }
 
-    /// Sync node status and ID only
+    /// Sync node status, ID and lifecycle state
     private func syncNodeStatus() {
         nodeStatus = lightningService.status
         nodeId = lightningService.nodeId
+
+        // Sync lifecycle state based on service status
+        if let status = lightningService.status {
+            if status.isRunning && nodeLifecycleState != .running {
+                nodeLifecycleState = .running
+            } else if !status.isRunning && nodeLifecycleState == .running {
+                nodeLifecycleState = .stopped
+            }
+        }
     }
 
     /// Sync channels and peers only

Bitkit/Views/Settings/Advanced/ElectrumSettingsScreen.swift

@@ -4,6 +4,7 @@ struct ElectrumSettingsScreen: View {
     @EnvironmentObject var app: AppViewModel
     @EnvironmentObject var navigation: NavigationViewModel
     @EnvironmentObject var settings: SettingsViewModel
+    @EnvironmentObject var wallet: WalletViewModel
 
     @FocusState private var isTextFieldFocused: Bool
 
@@ -100,12 +101,17 @@ struct ElectrumSettingsScreen: View {
                             }
                             .accessibilityIdentifier("ConnectToHost")
                         }
-                        .buttonBottomPadding(isFocused: isTextFieldFocused)
+                        .bottomSafeAreaPadding()
                     }
                     .frame(minHeight: geometry.size.height)
-                    .bottomSafeAreaPadding()
+                    .contentShape(Rectangle())
+                    .onTapGesture {
+                        isTextFieldFocused = false
+                    }
                 }
+                .scrollDismissesKeyboard(.interactively)
             }
+            .ignoresSafeArea(.keyboard, edges: .bottom)
         }
         .navigationBarHidden(true)
         .padding(.horizontal, 16)
@@ -117,13 +123,17 @@ struct ElectrumSettingsScreen: View {
     private func onConnect() {
         Task {
             let result = await settings.connectToElectrumServer()
+            // Sync wallet state to update node lifecycle state for app status
+            wallet.syncState()
             showToast(result.success, result.host, result.port, result.errorMessage)
         }
     }
 
     private func onReset() {
         Task {
             let result = await settings.resetElectrumToDefault()
+            // Sync wallet state to update node lifecycle state for app status
+            wallet.syncState()
             showToast(result.success, result.host, result.port, result.errorMessage)
         }
     }