test(swift-sdk): add testnet identity-discovery UI test

.github/workflows/swift-example-app-ui-smoke.yml

@@ -2,6 +2,20 @@ name: Swift Example App UI Smoke
 
 'on':
   workflow_dispatch:
+  schedule:
+    # 23:00 UTC daily. Aligns with the main `Tests` workflow's nightly
+    # cron (also 23:00 UTC) but runs on a different runner pool
+    # (self-hosted macOS), so they don't compete for compute. The Swift
+    # discovery test hits testnet DAPI; if that becomes a contention
+    # signal, shift to 02:00 UTC.
+    - cron: "0 23 * * *"
+
+concurrency:
+  # Prevents an in-flight manual dispatch from being clobbered by the
+  # cron firing (or vice versa) on the single self-hosted Mac. Cancels
+  # the older run in favor of the newer one.
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 permissions:
   contents: read
@@ -161,25 +175,41 @@ jobs:
         env:
           SIM_UDID: ${{ steps.simulator.outputs.udid }}
           RESULT_BUNDLE_PATH: ${{ runner.temp }}/SwiftExampleAppUITests.xcresult
+          # Forwarded into the XCUITest runner as `UI_TEST_MNEMONIC` —
+          # `xcodebuild test` strips the `TEST_RUNNER_` prefix before
+          # passing env vars through to the test process. Empty on PRs
+          # from forks (GitHub withholds secrets there), and the test
+          # self-skips when the value is empty.
+          TEST_RUNNER_UI_TEST_MNEMONIC: ${{ secrets.UI_TEST_MNEMONIC }}
         run: |
           set -euo pipefail
           xcodebuild test \
             -project SwiftExampleApp/SwiftExampleApp.xcodeproj \
             -scheme SwiftExampleApp \
             -destination "platform=iOS Simulator,id=$SIM_UDID" \
             -only-testing:SwiftExampleAppUITests/SwiftExampleAppUITests/testCreateGeneratedWalletFlow \
+            -only-testing:SwiftExampleAppUITests/WalletPersistenceTests/testWalletPersistsAcrossRelaunch \
+            -only-testing:SwiftExampleAppUITests/WalletPersistenceTests/testWalletDeletionCleanupSurvivesRelaunch \
+            -only-testing:SwiftExampleAppUITests/CreditTransferTest/testImportWalletAndDiscoverIdentity \
             -parallel-testing-enabled NO \
             -maximum-concurrent-test-simulator-destinations 1 \
             -resultBundlePath "$RESULT_BUNDLE_PATH"
 
       - name: Upload XCUITest result bundle
-        if: always()
+        # `failure()` only — xcresult bundles include the XCUITest activity
+        # log (which records `typeText` arguments) and may include failure
+        # screenshots. `importWallet` types the testnet mnemonic into a
+        # plain TextField, so a successful run's artifact would archive
+        # the mnemonic in the activity log. Restricting to failures
+        # narrows the leak surface (you only get the artifact when there's
+        # something to debug). 7-day retention also reduces exposure.
+        if: failure()
         uses: actions/upload-artifact@v4
         with:
           name: SwiftExampleAppUITests-xcresult
           path: ${{ runner.temp }}/SwiftExampleAppUITests.xcresult
           if-no-files-found: ignore
-          retention-days: 14
+          retention-days: 7
 
       - name: Delete disposable simulator
         if: always() && steps.simulator.outputs.udid != ''

packages/swift-sdk/SwiftExampleApp/SwiftExampleApp/AppState.swift

@@ -9,12 +9,27 @@ class AppState: ObservableObject {
     @Published var showError = false
     @Published var errorMessage = ""
 
+    /// `true` from the moment a network change is requested until the
+    /// new SDK is bound. Spans the full async cycle (didSet → Task →
+    /// `switchNetwork` → `sdk = newSDK`), so consumers can wait on it
+    /// as a real readiness signal. UI bindings should treat
+    /// `appState.sdk != nil && !isSwitchingNetwork` as "connected on
+    /// the current network" — `appState.sdk != nil` alone is true even
+    /// while `switchNetwork` is still tearing down the previous SDK.
+    @Published var isSwitchingNetwork: Bool = false
+
+    /// Monotonic request id for in-flight switches. If two switches
+    /// overlap (user taps mainnet → testnet before the first lands), the
+    /// earlier task's completion would otherwise clear `isSwitchingNetwork`
+    /// while the later switch is still running. Each new request bumps
+    /// this counter and the spawned task only clears the flag when its
+    /// captured id still matches.
+    private var networkSwitchRequestID: UInt64 = 0
+
     @Published var currentNetwork: Network {
         didSet {
-            UserDefaults.standard.set(Int(currentNetwork.rawValue), forKey: "currentNetwork")
-            Task {
-                await switchNetwork(to: currentNetwork)
-            }
+            UserDefaults.standard.set(currentNetwork.rawValue, forKey: "currentNetwork")
+            beginNetworkSwitch()
         }
     }
 
@@ -27,10 +42,32 @@ class AppState: ObservableObject {
             UserDefaults.standard.set(useDockerSetup, forKey: "useLocalhostPlatform")
             UserDefaults.standard.set(useDockerSetup, forKey: "useLocalhostCore")
             UserDefaults.standard.set(useDockerSetup, forKey: "useLocalhost")
-            Task { await switchNetwork(to: currentNetwork) }
+            beginNetworkSwitch()
         }
     }
 
+    /// Bumps `networkSwitchRequestID`, raises `isSwitchingNetwork`, and
+    /// spawns the SDK-rebuild task. Only the task that owns the latest
+    /// request id may lower `isSwitchingNetwork` again — overlapping
+    /// switches' earlier tasks no-op on completion.
+    private func beginNetworkSwitch() {
+        networkSwitchRequestID &+= 1
+        let requestID = networkSwitchRequestID
+        isSwitchingNetwork = true
+        Task {
+            await switchNetwork(to: currentNetwork, requestID: requestID)
+            if requestID == networkSwitchRequestID {
+                isSwitchingNetwork = false
+            }
+        }
+    }
+
+    /// True if `token` is still the most recent network-switch request.
+    /// Stale tasks bail out before mutating shared state.
+    private func isCurrent(_ token: UInt64) -> Bool {
+        token == networkSwitchRequestID
+    }
+
     // Identity-key signing is performed per-flow via a fresh
     // `KeychainSigner` constructed from the active `ModelContainer`
     // (see `CreateIdentityView.submit()`). `AppState` no longer holds
@@ -101,8 +138,9 @@ class AppState: ObservableObject {
         showError = true
     }
 
-    func switchNetwork(to network: Network) async {
+    func switchNetwork(to network: Network, requestID: UInt64) async {
         guard let modelContext = modelContext else { return }
+        guard isCurrent(requestID) else { return }
 
         // Identities, contracts, documents, and token balances are
         // scoped per-network inside SwiftData. `@Query` consumers
@@ -118,13 +156,16 @@ class AppState: ObservableObject {
 
             // Create new SDK instance for the network
             let newSDK = try SDK(network: network)
+            guard isCurrent(requestID) else { return }
             sdk = newSDK
 
             // Load known contracts into the SDK's trusted provider
             await loadKnownContractsIntoSDK(sdk: newSDK, modelContext: modelContext)
+            guard isCurrent(requestID) else { return }
 
             isLoading = false
         } catch {
+            guard isCurrent(requestID) else { return }
             sdk = nil
             showError(message: "Failed to switch network: \(error.localizedDescription)")
             NSLog("❌ AppState.switchNetwork: \(error)")

packages/swift-sdk/SwiftExampleApp/SwiftExampleApp/ContentView.swift

@@ -91,6 +91,7 @@ struct ContentView: View {
 
                 // Tab 3: Identities
                 IdentitiesTabView()
+                    .accessibilityIdentifier("rootTab.identities")
                     .tabItem {
                         Label("Identities", systemImage: "person.crop.circle")
                     }
@@ -112,6 +113,7 @@ struct ContentView: View {
 
                 // Tab 5: Settings (includes Platform section)
                 SettingsView()
+                    .accessibilityIdentifier("rootTab.settings")
                     .tabItem {
                         Label("Settings", systemImage: "gearshape")
                     }

packages/swift-sdk/SwiftExampleApp/SwiftExampleApp/Core/Views/CreateWalletView.swift

@@ -161,6 +161,7 @@ struct CreateWalletView: View {
 
             Section {
                 Toggle("Import Existing Wallet", isOn: $showImportOption)
+                    .accessibilityIdentifier("createWallet.importToggle")
             } header: {
                 Text("Options")
             }
@@ -189,6 +190,7 @@ struct CreateWalletView: View {
                         .autocorrectionDisabled()
                         .lineLimit(3...6)
                         .focused($focusedField, equals: .mnemonic)
+                        .accessibilityIdentifier("createWallet.mnemonicField")
                 } header: {
                     Text("Recovery Phrase")
                 } footer: {

packages/swift-sdk/SwiftExampleApp/SwiftExampleApp/Core/Views/IdentitiesContentView.swift

@@ -156,9 +156,11 @@ struct IdentitiesContentView: View {
                     } label: {
                         Label("Re-scan for Identities", systemImage: "magnifyingglass")
                     }
+                    .accessibilityIdentifier("identities.searchWalletsMenuItem")
                 } label: {
                     Image(systemName: "plus")
                 }
+                .accessibilityIdentifier("identities.addMenu")
             }
         }
         .sheet(isPresented: $showingLoadIdentity) {

packages/swift-sdk/SwiftExampleApp/SwiftExampleApp/SwiftExampleAppApp.swift

@@ -147,19 +147,24 @@ struct SwiftExampleAppApp: App {
     }
 
     /// Lazy-create + cache a `PlatformWalletManager` for `network`,
-    /// configured against `platformState.sdk`. No-ops on the
-    /// already-active network. Called from bootstrap and from
+    /// configured against a freshly-built per-network SDK. No-ops on
+    /// the already-active network. Called from bootstrap and from
     /// `currentNetwork.onChange`.
+    ///
+    /// The SDK is built locally rather than read from `platformState.sdk`
+    /// because the SwiftUI `.onChange` handler that calls this fires
+    /// synchronously the moment `currentNetwork` changes, while
+    /// `AppState.switchNetwork` rebuilds `platformState.sdk`
+    /// asynchronously — at this instant the shared SDK still points at
+    /// the previous network. `PlatformWalletManager` is network-locked
+    /// to its configure-time SDK for its lifetime and the cache is
+    /// never invalidated, so capturing the stale reference would
+    /// permanently bind the new network's manager to the previous
+    /// network's backend. Mirrors `WalletManagerStore.backgroundManager(for:)`.
     @MainActor
     private func activateManager(for network: Network) {
-        guard let sdk = platformState.sdk else {
-            SDKLogger.error(
-                "Cannot activate wallet manager for \(network.displayName): "
-                    + "no SDK available (still bootstrapping?)"
-            )
-            return
-        }
         do {
+            let sdk = try SDK(network: network)
             try walletManagerStore.activate(network: network, sdk: sdk)
         } catch {
             SDKLogger.error(

packages/swift-sdk/SwiftExampleApp/SwiftExampleApp/Views/IdentitiesView.swift

@@ -100,6 +100,7 @@ struct IdentityRow: View {
             }
             .padding(.vertical, 4)
         }
+        .accessibilityIdentifier("identities.row.\(identity.identityIdBase58)")
     }
 
     private func refreshBalance() async {

packages/swift-sdk/SwiftExampleApp/SwiftExampleApp/Views/IdentityDetailView.swift

@@ -139,6 +139,12 @@ struct IdentityDetailView: View {
                     Text(identity.formattedBalance)
                         .foregroundColor(.blue)
                         .fontWeight(.medium)
+                        .accessibilityIdentifier("identityDetail.balanceLabel")
+                        // Display string is "%.8f DASH" — rounding hides
+                        // sub-1000-credit deltas. Expose the raw signed
+                        // credit count via accessibilityValue for tests
+                        // that need exact numbers.
+                        .accessibilityValue("\(identity.balance)")
                 }
 
                 // Top-up entry point. Hidden for purely-local rows

packages/swift-sdk/SwiftExampleApp/SwiftExampleApp/Views/OptionsView.swift

@@ -9,7 +9,6 @@ struct OptionsView: View {
     @State private var showingDataManagement = false
     @State private var showingAbout = false
     @State private var showingContracts = false
-    @State private var isSwitchingNetwork = false
     @State private var sdkStatus: SDKStatus?
     @State private var isLoadingStatus = false
 
@@ -102,27 +101,22 @@ struct OptionsView: View {
                         get: { appState.currentNetwork },
                         set: { newNetwork in
                             if newNetwork != appState.currentNetwork {
-                                isSwitchingNetwork = true
-                                Task {
-                                    // Auto-disable Docker when leaving Local
-                                    if newNetwork != .regtest && appState.useDockerSetup {
-                                        appState.useDockerSetup = false
-                                    }
-
-                                    // Update platform state (which will trigger SDK switch)
-                                    appState.currentNetwork = newNetwork
-
-                                    // Reset per-network services. TODO(platform-wallet):
-                                    // Once PlatformWalletManager supports network
-                                    // switching cleanly, call into it here.
-                                    try? walletManager.stopSpv()
-                                    platformBalanceSyncService.reset()
-                                    shieldedService.reset()
-
-                                    await MainActor.run {
-                                        isSwitchingNetwork = false
-                                    }
+                                // Auto-disable Docker when leaving Local
+                                if newNetwork != .regtest && appState.useDockerSetup {
+                                    appState.useDockerSetup = false
                                 }
+
+                                // `currentNetwork.didSet` (in AppState) flips
+                                // `isSwitchingNetwork` for us and awaits the
+                                // SDK rebind, so the status label below stays
+                                // in the switching state across the entire
+                                // async cycle. Reset per-network services
+                                // alongside the switch — these don't gate
+                                // readiness, they just clean up stale UI.
+                                appState.currentNetwork = newNetwork
+                                try? walletManager.stopSpv()
+                                platformBalanceSyncService.reset()
+                                shieldedService.reset()
                             }
                         }
                     )) {
@@ -141,23 +135,20 @@ struct OptionsView: View {
                     .modifier(
                         NetworkPickerInFlightGate(
                             coordinator: walletManager.registrationCoordinator,
-                            isSwitching: isSwitchingNetwork
+                            isSwitching: appState.isSwitchingNetwork
                         )
                     )
+                    .accessibilityIdentifier("options.networkPicker")
 
                     NetworkInFlightFooter(
                         coordinator: walletManager.registrationCoordinator
                     )
 
                     if appState.currentNetwork == .regtest {
+                        // `useDockerSetup.didSet` (in AppState) drives the
+                        // SDK rebuild and `isSwitchingNetwork`; no view-side
+                        // onChange is needed.
                         Toggle("Use Docker Setup", isOn: $appState.useDockerSetup)
-                            .onChange(of: appState.useDockerSetup) { _, _ in
-                                isSwitchingNetwork = true
-                                Task {
-                                    await appState.switchNetwork(to: appState.currentNetwork)
-                                    await MainActor.run { isSwitchingNetwork = false }
-                                }
-                            }
                             .help("Connect to local dashmate Docker network.")
 
                         if appState.useDockerSetup {
@@ -226,23 +217,32 @@ struct OptionsView: View {
                     HStack {
                         Text("Network Status")
                         Spacer()
-                        if isSwitchingNetwork {
-                            HStack(spacing: 4) {
-                                ProgressView()
-                                    .scaleEffect(0.8)
-                                Text("Switching...")
-                                    .font(.caption)
-                                    .foregroundColor(.secondary)
-                            }
-                        } else if appState.sdk != nil {
-                            Label("Connected", systemImage: "checkmark.circle.fill")
+                        Group {
+                            if appState.isSwitchingNetwork {
+                                HStack(spacing: 4) {
+                                    ProgressView()
+                                        .scaleEffect(0.8)
+                                    Text("Switching...")
+                                        .font(.caption)
+                                        .foregroundColor(.secondary)
+                                }
+                            } else if appState.sdk != nil {
+                                Label(
+                                    "Connected to \(appState.currentNetwork.displayName)",
+                                    systemImage: "checkmark.circle.fill"
+                                )
                                 .font(.caption)
                                 .foregroundColor(.green)
-                        } else {
-                            Label("Disconnected", systemImage: "xmark.circle.fill")
-                                .font(.caption)
-                                .foregroundColor(.red)
+                            } else {
+                                Label("Disconnected", systemImage: "xmark.circle.fill")
+                                    .font(.caption)
+                                    .foregroundColor(.red)
+                            }
                         }
+                        // Combine the icon + text into a single accessibility element
+                        // so the network status reads as one string under the shared identifier.
+                        .accessibilityElement(children: .combine)
+                        .accessibilityIdentifier("options.networkStatusLabel")
                     }
 
                 }