Run local packages’ tests as well on CI

* Extract message list into dedicated MessageListView

* Fix broken smoke test

Mounts two distinct fixtures to cover separate render branches: a truncatable message (>2000 chars, no payment tokens) and a payment message (lightning + cashu, private, partial delivery). Expectations guard that each fixture actually reaches its intended branch.

---------

Co-authored-by: jack <212554440+jackjackbits@users.noreply.github.com>

.github/workflows/fetch_georelays.yml

@@ -25,47 +25,18 @@ jobs:
           wget -q https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv
           mv nostr_relays.csv ./relays/online_relays_gps.csv
 
-      - name: Configure git
+      - name: Check for changes
+        id: git-check
         run: |
-          git config user.email "action@github.com"
+          git diff --exit-code || echo "changes=true" >> $GITHUB_OUTPUT
-          git config user.name "GitHub Action"
+    
-
+      - name: Commit and push changes
-      - name: Create update branch if changes
+        if: steps.git-check.outputs.changes == 'true'
-        id: create_branch
         run: |
-          # exit early if no changes
+          git config --local user.email "action@github.com"
-          if git diff --quiet --relays/online_relays_gps.csv; then
+          git config --local user.name "GitHub Action"
-            echo "changed=false" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-
-          # branch name with timestamp
-          BRANCH="update-georelays-$(date -u +%Y%m%dT%H%M%SZ)"
-          git checkout -b "$BRANCH"
-
           git add relays/online_relays_gps.csv
-          git commit -m "Automated update of relay data - $(date -u --rfc-3339=seconds)"
+          git commit -m "Automated update of relay data - $(date -u)"
-          echo "changed=true" >> $GITHUB_OUTPUT
+          git push
-          echo "branch=$BRANCH" >> $GITHUB_OUTPUT
+        env:
-
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      - name: Push branch
-        if: steps.create_branch.outputs.changed == 'true'
-        run: |
-          git push --set-upstream origin "${{ steps.create_branch.outputs.branch }}"
-
-      - name: Create pull request
-        if: steps.create_branch.outputs.changed == 'true'
-        uses: peter-evans/create-pull-request@v5
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: Automated update of relay data
-          branch: ${{ steps.create_branch.outputs.branch }}
-          base: main
-          title: Automated update of relay data
-          body: |
-            This PR was created automatically by the scheduled workflow. It updates relays/online_relays_gps.csv from the GeoRelays source.
-          labels: automated, georelays
-
-      - name: No changes
-        if: steps.create_branch.outputs.changed != 'true'
-        run: echo "No changes to relays/online_relays_gps.csv"

.github/workflows/swift-tests.yml

@@ -5,14 +5,21 @@ on:
     branches:
       - main
   pull_request:
-    branches:
-      - main
 
 jobs:
   test:
-    name: Run Swift Tests
+    name: Run Swift Tests (${{ matrix.name }})
     runs-on: macos-latest
 
+    strategy:
+      fail-fast: false # Don't cancel other matrix jobs when one fails
+      matrix:
+        include:
+          - name: app
+            path: .
+          - name: BitLogger
+            path: localPackages/BitLogger
+
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
@@ -20,8 +27,14 @@ jobs:
       - name: Set up Swift
         uses: swift-actions/setup-swift@v2
 
-      - name: Build the package
+      - name: Cache build artifacts
-        run: swift build
+        uses: actions/cache@v4
+        with:
+          path: ${{ matrix.path }}/.build
+          key: ${{ runner.os }}-${{ matrix.name }}-${{ hashFiles(format('{0}/**/*.swift', matrix.path), format('{0}/**/Package.resolved', matrix.path)) }}
+          restore-keys: |
+            ${{ runner.os }}-${{ matrix.name }}-${{ hashFiles(format('{0}/**/Package.resolved', matrix.path)) }}
+            ${{ runner.os }}-${{ matrix.name }}-
 
       - name: Run Tests
-        run: swift test --parallel
+        run: swift test --parallel --quiet --package-path ${{ matrix.path }}

.gitignore

@@ -8,6 +8,7 @@ plans/
 ## AI
 CLAUDE.md
 AGENTS.md
+.claude/
 
 ## compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9)
 *.xcscmblueprint

Configs/Release.xcconfig

@@ -1,4 +1,4 @@
-MARKETING_VERSION = 1.5.0
+MARKETING_VERSION = 1.5.1
 CURRENT_PROJECT_VERSION = 1
 
 IPHONEOS_DEPLOYMENT_TARGET = 16.0
@@ -9,3 +9,4 @@ DEVELOPMENT_TEAM = L3N5LHJD5Y
 CODE_SIGN_STYLE = Automatic
 
 PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat
+APP_GROUP_ID = group.chat.bitchat

Package.swift

@@ -16,7 +16,7 @@ let package = Package(
         ),
     ],
     dependencies:[
-        .package(path: "localPackages/Tor"),
+        .package(path: "localPackages/Arti"),
         .package(path: "localPackages/BitLogger"),
         .package(url: "https://github.com/21-DOT-DEV/swift-secp256k1", exact: "0.21.1")
     ],
@@ -26,12 +26,13 @@ let package = Package(
             dependencies: [
                 .product(name: "P256K", package: "swift-secp256k1"),
                 .product(name: "BitLogger", package: "BitLogger"),
-                .product(name: "Tor", package: "Tor")
+                .product(name: "Tor", package: "Arti")
             ],
             path: "bitchat",
             exclude: [
                 "Info.plist",
                 "Assets.xcassets",
+                "_PreviewHelpers/PreviewAssets.xcassets",
                 "bitchat.entitlements",
                 "bitchat-macOS.entitlements",
                 "LaunchScreen.storyboard",

README.md

@@ -8,9 +8,6 @@ A decentralized peer-to-peer messaging app with dual transport architecture: loc
 
 📲 [App Store](https://apps.apple.com/us/app/bitchat-mesh/id6748219622)
 
-> [!WARNING]
-> Private messages have not received external security review and may contain vulnerabilities. Do not use for sensitive use cases, and do not rely on its security until it has been reviewed. Now uses the [Noise Protocol](https://www.noiseprotocol.org) for identity and encryption. Public local chat (the main feature) has no security concerns.
-
 ## License
 
 This project is released into the public domain. See the [LICENSE](LICENSE) file for details.

bitchat.xcodeproj/project.pbxproj

@@ -14,7 +14,6 @@
 		A6E3E5722E7703760032EA8A /* BitLogger in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3E5712E7703760032EA8A /* BitLogger */; };
 		A6E3EA7F2E7706720032EA8A /* Tor in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3EA7E2E7706720032EA8A /* Tor */; };
 		A6E3EA812E7706A80032EA8A /* Tor in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3EA802E7706A80032EA8A /* Tor */; };
-		A6F183FD2E948783006A9046 /* tor-nolzma.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = A6F183FC2E948783006A9046 /* tor-nolzma.xcframework */; };
 		E0A1B2C3D4E5F6012345678D /* relays/online_relays_gps.csv in Resources */ = {isa = PBXBuildFile; fileRef = E0A1B2C3D4E5F6012345678A /* relays/online_relays_gps.csv */; };
 		E0A1B2C3D4E5F6012345678E /* relays/online_relays_gps.csv in Resources */ = {isa = PBXBuildFile; fileRef = E0A1B2C3D4E5F6012345678A /* relays/online_relays_gps.csv */; };
 /* End PBXBuildFile section */
@@ -162,7 +161,6 @@
 		B5A5CC493FFB3D8966548140 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			files = (
-				A6F183FD2E948783006A9046 /* tor-nolzma.xcframework in Frameworks */,
 				A6E3E5702E77036A0032EA8A /* BitLogger in Frameworks */,
 				885BBED78092484A5B069461 /* P256K in Frameworks */,
 				A6E3EA7F2E7706720032EA8A /* Tor in Frameworks */,
@@ -345,7 +343,7 @@
 			packageReferences = (
 				B8C407587481BBB190741C93 /* XCRemoteSwiftPackageReference "swift-secp256k1" */,
 				A6E3E56E2E77036A0032EA8A /* XCLocalSwiftPackageReference "localPackages/BitLogger" */,
-				A6E3EA7D2E7706720032EA8A /* XCLocalSwiftPackageReference "localPackages/Tor" */,
+				A6E3EA7D2E7706720032EA8A /* XCLocalSwiftPackageReference "localPackages/Arti" */,
 			);
 			preferredProjectObjectVersion = 90;
 			projectDirPath = "";
@@ -550,6 +548,7 @@
 				CODE_SIGNING_REQUIRED = YES;
 				CODE_SIGN_ENTITLEMENTS = bitchat/bitchat.entitlements;
 				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
+				DEVELOPMENT_ASSET_PATHS = bitchat/_PreviewHelpers;
 				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				ENABLE_PREVIEWS = NO;
 				INFOPLIST_FILE = bitchat/Info.plist;
@@ -560,7 +559,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = "$(MARKETING_VERSION)";
+				MARKETING_VERSION = 1.5.1;
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
@@ -610,6 +609,7 @@
 				CODE_SIGNING_REQUIRED = YES;
 				CODE_SIGN_ENTITLEMENTS = bitchat/bitchat.entitlements;
 				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
+				DEVELOPMENT_ASSET_PATHS = bitchat/_PreviewHelpers;
 				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				ENABLE_PREVIEWS = YES;
 				INFOPLIST_FILE = bitchat/Info.plist;
@@ -620,7 +620,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = "$(MARKETING_VERSION)";
+				MARKETING_VERSION = 1.5.1;
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
@@ -656,7 +656,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				MARKETING_VERSION = "$(MARKETING_VERSION)";
+				MARKETING_VERSION = 1.5.1;
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
@@ -748,7 +748,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				MARKETING_VERSION = "$(MARKETING_VERSION)";
+				MARKETING_VERSION = 1.5.1;
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
@@ -913,9 +913,9 @@
 			isa = XCLocalSwiftPackageReference;
 			relativePath = localPackages/BitLogger;
 		};
-		A6E3EA7D2E7706720032EA8A /* XCLocalSwiftPackageReference "localPackages/Tor" */ = {
+		A6E3EA7D2E7706720032EA8A /* XCLocalSwiftPackageReference "localPackages/Arti" */ = {
 			isa = XCLocalSwiftPackageReference;
-			relativePath = localPackages/Tor;
+			relativePath = localPackages/Arti;
 		};
 /* End XCLocalSwiftPackageReference section */
 
@@ -924,8 +924,8 @@
 			isa = XCRemoteSwiftPackageReference;
 			repositoryURL = "https://github.com/21-DOT-DEV/swift-secp256k1";
 			requirement = {
-				kind = upToNextMajorVersion;
+				kind = exactVersion;
-				minimumVersion = 0.21.1;
+				version = 0.21.1;
 			};
 		};
 /* End XCRemoteSwiftPackageReference section */

bitchat/BitchatApp.swift

@@ -63,6 +63,10 @@ struct BitchatApp: App {
 
                     // Initialize network activation policy; will start Tor/Nostr only when allowed
                     NetworkActivationService.shared.start()
+                    
+                    // Start presence service (will wait for Tor readiness)
+                    GeohashPresenceService.shared.start()
+
                     // Check for shared content
                     checkForSharedContent()
                 }
@@ -275,8 +279,3 @@ final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
     }
 }
 
-extension String {
-    var nilIfEmpty: String? {
-        self.isEmpty ? nil : self
-    }
-}

bitchat/Features/voice/VoiceNotePlaybackController.swift

@@ -9,6 +9,18 @@ final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlay
     @Published private(set) var duration: TimeInterval = 0
     @Published private(set) var progress: Double = 0
 
+    /// rounded so 4.9s shows "00:05"
+    var roundedDuration: Int {
+        guard duration.isFinite else { return 0 }
+        return Int(duration.rounded())
+    }
+
+    /// ceil so "00:01" stays visible until playback ends, capped to rounded duration
+    var remainingSeconds: Int {
+        let remaining = max(0, duration - currentTime)
+        return min(roundedDuration, Int(ceil(remaining)))
+    }
+
     private var player: AVAudioPlayer?
     private var timer: Timer?
     private var url: URL

bitchat/Features/voice/VoiceRecorder.swift

@@ -2,8 +2,7 @@ import Foundation
 import AVFoundation
 
 /// Manages audio capture for mesh voice notes with predictable encoding settings.
-/// Recording runs on an internal serial queue to avoid AVAudioSession contention.
+actor VoiceRecorder {
-final class VoiceRecorder: NSObject, AVAudioRecorderDelegate {
     enum RecorderError: Error {
         case microphoneAccessDenied
         case recorderInitializationFailed
@@ -12,21 +11,16 @@ final class VoiceRecorder: NSObject, AVAudioRecorderDelegate {
 
     static let shared = VoiceRecorder()
 
-    private let queue = DispatchQueue(label: "com.bitchat.voice-recorder")
     private let paddingInterval: TimeInterval = 0.5
     private let maxRecordingDuration: TimeInterval = 120
+    static let minRecordingDuration: TimeInterval = 1
 
     private var recorder: AVAudioRecorder?
     private var currentURL: URL?
-    private var stopWorkItem: DispatchWorkItem?
-
-    private override init() {
-        super.init()
-    }
 
     // MARK: - Permissions
 
-    @discardableResult
+    nonisolated
     func requestPermission() async -> Bool {
         #if os(iOS)
         return await withCheckedContinuation { continuation in
@@ -47,106 +41,88 @@ final class VoiceRecorder: NSObject, AVAudioRecorderDelegate {
 
     // MARK: - Recording Lifecycle
 
+    @discardableResult
     func startRecording() throws -> URL {
-        try queue.sync {
+        if recorder?.isRecording == true {
-            if recorder?.isRecording == true {
+            throw RecorderError.recordingInProgress
-                throw RecorderError.recordingInProgress
-            }
-
-            #if os(iOS)
-            let session = AVAudioSession.sharedInstance()
-            guard session.recordPermission == .granted else {
-                throw RecorderError.microphoneAccessDenied
-            }
-            #if targetEnvironment(simulator)
-            // allowBluetoothHFP is not available on iOS Simulator
-            try session.setCategory(
-                .playAndRecord,
-                mode: .default,
-                options: [.defaultToSpeaker, .allowBluetoothA2DP]
-            )
-            #else
-            try session.setCategory(
-                .playAndRecord,
-                mode: .default,
-                options: [.defaultToSpeaker, .allowBluetoothA2DP, .allowBluetoothHFP]
-            )
-            #endif
-            try session.setActive(true, options: .notifyOthersOnDeactivation)
-            #endif
-            #if os(macOS)
-            guard AVCaptureDevice.authorizationStatus(for: .audio) == .authorized else {
-                throw RecorderError.microphoneAccessDenied
-            }
-            #endif
-
-            let outputURL = try makeOutputURL()
-            let settings: [String: Any] = [
-                AVFormatIDKey: kAudioFormatMPEG4AAC,
-                AVSampleRateKey: 16_000,
-                AVNumberOfChannelsKey: 1,
-                AVEncoderBitRateKey: 16_000
-            ]
-
-            let audioRecorder = try AVAudioRecorder(url: outputURL, settings: settings)
-            audioRecorder.delegate = self
-            audioRecorder.isMeteringEnabled = true
-            audioRecorder.prepareToRecord()
-            audioRecorder.record(forDuration: maxRecordingDuration)
-
-            recorder = audioRecorder
-            currentURL = outputURL
-            stopWorkItem?.cancel()
-            stopWorkItem = nil
-            return outputURL
         }
+
+        #if os(iOS)
+        let session = AVAudioSession.sharedInstance()
+        guard session.recordPermission == .granted else {
+            throw RecorderError.microphoneAccessDenied
+        }
+        #if targetEnvironment(simulator)
+        // allowBluetoothHFP is not available on iOS Simulator
+        try session.setCategory(
+            .playAndRecord,
+            mode: .default,
+            options: [.defaultToSpeaker, .allowBluetoothA2DP]
+        )
+        #else
+        try session.setCategory(
+            .playAndRecord,
+            mode: .default,
+            options: [.defaultToSpeaker, .allowBluetoothA2DP, .allowBluetoothHFP]
+        )
+        #endif
+        try session.setActive(true, options: .notifyOthersOnDeactivation)
+        #endif
+        #if os(macOS)
+        guard AVCaptureDevice.authorizationStatus(for: .audio) == .authorized else {
+            throw RecorderError.microphoneAccessDenied
+        }
+        #endif
+
+        let outputURL = try makeOutputURL()
+        let settings: [String: Any] = [
+            AVFormatIDKey: kAudioFormatMPEG4AAC,
+            AVSampleRateKey: 16_000,
+            AVNumberOfChannelsKey: 1,
+            AVEncoderBitRateKey: 16_000
+        ]
+
+        let audioRecorder = try AVAudioRecorder(url: outputURL, settings: settings)
+        audioRecorder.isMeteringEnabled = true
+        audioRecorder.prepareToRecord()
+        audioRecorder.record(forDuration: maxRecordingDuration)
+
+        recorder = audioRecorder
+        currentURL = outputURL
+        return outputURL
     }
 
-    func stopRecording(completion: @escaping (URL?) -> Void) {
+    func stopRecording() async -> URL? {
-        queue.async { [weak self] in
+        guard let recorder, recorder.isRecording else {
-            guard let self = self, let recorder = self.recorder, recorder.isRecording else {
+            return currentURL
-                completion(self?.currentURL)
-                return
-            }
-
-            let item = DispatchWorkItem { [weak self] in
-                guard let self = self else { return }
-                recorder.stop()
-                self.cleanupSession()
-                let url = self.currentURL
-                self.recorder = nil
-                self.currentURL = url
-                completion(url)
-            }
-            self.stopWorkItem = item
-            self.queue.asyncAfter(deadline: .now() + self.paddingInterval, execute: item)
         }
+
+        let sessionURL = currentURL
+
+        try? await Task.sleep(nanoseconds: UInt64(paddingInterval * 1_000_000_000))
+
+        recorder.stop()
+
+        // A new session may have started during the sleep — don't touch its state
+        if self.recorder === recorder {
+            cleanupSession()
+            self.recorder = nil
+            currentURL = nil
+        }
+
+        return sessionURL
     }
 
     func cancelRecording() {
-        queue.async { [weak self] in
+        if let recorder, recorder.isRecording {
-            guard let self = self else { return }
+            recorder.stop()
-            self.stopWorkItem?.cancel()
-            self.stopWorkItem = nil
-            if let recorder = self.recorder, recorder.isRecording {
-                recorder.stop()
-            }
-            self.cleanupSession()
-            if let url = self.currentURL {
-                try? FileManager.default.removeItem(at: url)
-            }
-            self.recorder = nil
-            self.currentURL = nil
         }
-    }
+        cleanupSession()
-
+        if let currentURL {
-    // MARK: - Metering
+            try? FileManager.default.removeItem(at: currentURL)
-
-    func currentAveragePower() -> Float {
-        queue.sync {
-            recorder?.updateMeters()
-            return recorder?.averagePower(forChannel: 0) ?? -160
         }
+        recorder = nil
+        currentURL = nil
     }
 
     // MARK: - Helpers

bitchat/Identity/SecureIdentityStateManager.swift

@@ -331,16 +331,15 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     
     func updateSocialIdentity(_ identity: SocialIdentity) {
         queue.async(flags: .barrier) {
+            let previousClaimedNickname = self.cache.socialIdentities[identity.fingerprint]?.claimedNickname
             self.cache.socialIdentities[identity.fingerprint] = identity
             
             // Update nickname index
-            if let existingIdentity = self.cache.socialIdentities[identity.fingerprint] {
+            if let previousClaimedNickname,
-                // Remove old nickname from index if changed
+               previousClaimedNickname != identity.claimedNickname {
-                if existingIdentity.claimedNickname != identity.claimedNickname {
+                self.cache.nicknameIndex[previousClaimedNickname]?.remove(identity.fingerprint)
-                    self.cache.nicknameIndex[existingIdentity.claimedNickname]?.remove(identity.fingerprint)
+                if self.cache.nicknameIndex[previousClaimedNickname]?.isEmpty == true {
-                    if self.cache.nicknameIndex[existingIdentity.claimedNickname]?.isEmpty == true {
+                    self.cache.nicknameIndex.removeValue(forKey: previousClaimedNickname)
-                        self.cache.nicknameIndex.removeValue(forKey: existingIdentity.claimedNickname)
-                    }
                 }
             }
             
@@ -532,4 +531,16 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
             return cache.verifiedFingerprints
         }
     }
+
+    var debugNicknameIndex: [String: Set<String>] {
+        queue.sync { cache.nicknameIndex }
+    }
+
+    func debugEphemeralSession(for peerID: PeerID) -> EphemeralIdentity? {
+        queue.sync { ephemeralSessions[peerID] }
+    }
+
+    func debugLastInteraction(for fingerprint: String) -> Date? {
+        queue.sync { cache.lastInteractions[fingerprint] }
+    }
 }

bitchat/Info.plist

@@ -2,6 +2,8 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>AppGroupID</key>
+	<string>$(APP_GROUP_ID)</string>
 	<key>CFBundleDevelopmentRegion</key>
 	<string>$(DEVELOPMENT_LANGUAGE)</string>
 	<key>CFBundleDisplayName</key>
@@ -37,12 +39,12 @@
 	<string>bitchat uses Bluetooth to discover and connect with other bitchat users nearby.</string>
 	<key>NSCameraUsageDescription</key>
 	<string>bitchat uses the camera to scan QR codes to verify peers.</string>
-	<key>NSPhotoLibraryUsageDescription</key>
-	<string>bitchat lets you pick images from your photo library to share with nearby peers.</string>
-	<key>NSMicrophoneUsageDescription</key>
-	<string>bitchat uses the microphone to record voice notes that relay across the mesh.</string>
 	<key>NSLocationWhenInUseUsageDescription</key>
 	<string>bitchat uses your approximate location to compute local geohash channels for optional public chats. Exact GPS is never shared.</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>bitchat uses the microphone to record voice notes that relay across the mesh.</string>
+	<key>NSPhotoLibraryUsageDescription</key>
+	<string>bitchat lets you pick images from your photo library to share with nearby peers.</string>
 	<key>UIBackgroundModes</key>
 	<array>
 		<string>bluetooth-central</string>

bitchat/Models/BitchatMessage+Media.swift

@@ -0,0 +1,68 @@
+//
+// BitchatMessage+Media.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+extension BitchatMessage {
+    enum Media {
+        case voice(URL)
+        case image(URL)
+
+        var url: URL {
+            switch self {
+            case .voice(let url), .image(let url):
+                return url
+            }
+        }
+    }
+
+    // Cache the directory lookup to avoid repeated FileManager calls during view rendering
+    private struct Cache {
+        let filesDir: URL?
+
+        static let shared = Cache()
+        private init() {
+            do {
+                let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+                let filesDir = base.appendingPathComponent("files", isDirectory: true)
+                try FileManager.default.createDirectory(at: filesDir, withIntermediateDirectories: true, attributes: nil)
+                self.filesDir = filesDir
+            } catch {
+                filesDir = nil
+            }
+        }
+    }
+
+    func mediaAttachment(for nickname: String) -> Media? {
+        guard let baseDirectory = Cache.shared.filesDir else { return nil }
+
+        func url(for category: MimeType.Category) -> URL? {
+            guard content.hasPrefix(category.messagePrefix),
+                  let filename = String(content.dropFirst(category.messagePrefix.count)).trimmedOrNilIfEmpty
+            else {
+                return nil
+            }
+
+            // Check outgoing first for sent messages, incoming for received
+            let subdir = sender == nickname ? "\(category.mediaDir)/outgoing" : "\(category.mediaDir)/incoming"
+
+            // Construct URL directly without fileExists check (avoids blocking disk I/O in view body)
+            // Files are checked during playback/display, so missing files fail gracefully
+            let directory = baseDirectory.appendingPathComponent(subdir, isDirectory: true)
+            return directory.appendingPathComponent(filename)
+        }
+
+        if let url = url(for: .audio) {
+            return .voice(url)
+        }
+        if let url = url(for: .image) {
+            return .image(url)
+        }
+        return nil
+    }
+}

bitchat/Models/BitchatMessage.swift

@@ -338,7 +338,7 @@ extension BitchatMessage {
 extension Array where Element == BitchatMessage {
     /// Filters out empty ones and deduplicate by ID while preserving order (from oldest to newest)
     func cleanedAndDeduped() -> [Element] {
-        let arr = filter { $0.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false }
+        let arr = filter { $0.content.trimmed.isEmpty == false }
         guard arr.count > 1 else {
             return arr
         }

bitchat/Models/BitchatPacket.swift

@@ -22,8 +22,9 @@ struct BitchatPacket: Codable {
     var signature: Data?
     var ttl: UInt8
     var route: [Data]?
+    var isRSR: Bool
     
-    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8, version: UInt8 = 1, route: [Data]? = nil) {
+    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8, version: UInt8 = 1, route: [Data]? = nil, isRSR: Bool = false) {
         self.version = version
         self.type = type
         self.senderID = senderID
@@ -33,10 +34,11 @@ struct BitchatPacket: Codable {
         self.signature = signature
         self.ttl = ttl
         self.route = route
+        self.isRSR = isRSR
     }
     
     // Convenience initializer for new binary format
-    init(type: UInt8, ttl: UInt8, senderID: PeerID, payload: Data) {
+    init(type: UInt8, ttl: UInt8, senderID: PeerID, payload: Data, isRSR: Bool = false) {
         self.version = 1
         self.type = type
         // Convert hex string peer ID to binary data (8 bytes)
@@ -56,6 +58,7 @@ struct BitchatPacket: Codable {
         self.signature = nil
         self.ttl = ttl
         self.route = nil
+        self.isRSR = isRSR
     }
     
     var data: Data? {
@@ -85,7 +88,8 @@ struct BitchatPacket: Codable {
             signature: nil, // Remove signature for signing
             ttl: 0, // Use fixed TTL=0 for signing to ensure relay compatibility
             version: version,
-            route: route
+            route: route,
+            isRSR: false // RSR flag is mutable and not part of the signature
         )
         return BinaryProtocol.encode(unsignedPacket)
     }

bitchat/Models/RequestSyncPacket.swift

@@ -9,12 +9,16 @@ struct RequestSyncPacket {
     let m: UInt32
     let data: Data
     let types: SyncTypeFlags?
+    let sinceTimestamp: UInt64?
+    let fragmentIdFilter: String?
 
-    init(p: Int, m: UInt32, data: Data, types: SyncTypeFlags? = nil) {
+    init(p: Int, m: UInt32, data: Data, types: SyncTypeFlags? = nil, sinceTimestamp: UInt64? = nil, fragmentIdFilter: String? = nil) {
         self.p = p
         self.m = m
         self.data = data
         self.types = types
+        self.sinceTimestamp = sinceTimestamp
+        self.fragmentIdFilter = fragmentIdFilter
     }
 
     func encode() -> Data {
@@ -36,15 +40,24 @@ struct RequestSyncPacket {
         if let typesData = types?.toData() {
             putTLV(0x04, typesData)
         }
+        if let ts = sinceTimestamp {
+            var tsBE = ts.bigEndian
+            putTLV(0x05, withUnsafeBytes(of: &tsBE) { Data($0) })
+        }
+        if let fid = fragmentIdFilter, let fidData = fid.data(using: .utf8) {
+            putTLV(0x06, fidData)
+        }
         return out
     }
-
+    
     static func decode(from data: Data, maxAcceptBytes: Int = 1024) -> RequestSyncPacket? {
         var off = 0
         var p: Int? = nil
         var m: UInt32? = nil
         var payload: Data? = nil
         var types: SyncTypeFlags? = nil
+        var sinceTimestamp: UInt64? = nil
+        var fragmentIdFilter: String? = nil
 
         while off + 3 <= data.count {
             let t = Int(data[off]); off += 1
@@ -68,12 +81,22 @@ struct RequestSyncPacket {
                 if let decoded = SyncTypeFlags.decode(v) {
                     types = decoded
                 }
+            case 0x05:
+                if v.count == 8 {
+                    var ts: UInt64 = 0
+                    for b in v { ts = (ts << 8) | UInt64(b) }
+                    sinceTimestamp = ts
+                }
+            case 0x06:
+                if let fid = String(data: v, encoding: .utf8) {
+                    fragmentIdFilter = fid
+                }
             default:
                 break // forward compatible; ignore unknown TLVs
             }
         }
 
         guard let pp = p, let mm = m, let dd = payload, pp >= 1, mm > 0 else { return nil }
-        return RequestSyncPacket(p: pp, m: mm, data: dd, types: types)
+        return RequestSyncPacket(p: pp, m: mm, data: dd, types: types, sinceTimestamp: sinceTimestamp, fragmentIdFilter: fragmentIdFilter)
     }
 }

bitchat/Noise/NoiseProtocol.swift

@@ -165,19 +165,23 @@ final class NoiseCipherState {
     // MARK: - Sliding Window Replay Protection
     
     /// Check if nonce is valid for replay protection
+    /// BCH-01-010: Use safe arithmetic to prevent integer overflow
     private func isValidNonce(_ receivedNonce: UInt64) -> Bool {
-        if receivedNonce + UInt64(Self.REPLAY_WINDOW_SIZE) <= highestReceivedNonce {
+        // Safe overflow check: instead of (receivedNonce + WINDOW_SIZE <= highest)
+        // use (highest >= WINDOW_SIZE && receivedNonce <= highest - WINDOW_SIZE)
+        let windowSize = UInt64(Self.REPLAY_WINDOW_SIZE)
+        if highestReceivedNonce >= windowSize && receivedNonce <= highestReceivedNonce - windowSize {
             return false  // Too old, outside window
         }
-        
+
         if receivedNonce > highestReceivedNonce {
             return true  // Always accept newer nonces
         }
-        
+
         let offset = Int(highestReceivedNonce - receivedNonce)
         let byteIndex = offset / 8
         let bitIndex = offset % 8
-        
+
         return (replayWindow[byteIndex] & (1 << bitIndex)) == 0  // Not yet seen
     }
     
@@ -347,16 +351,20 @@ final class NoiseCipherState {
         
         do {
             let plaintext = try ChaChaPoly.open(sealedBox, using: key, authenticating: associatedData)
-            
+
+            // BCH-01-010: Atomic nonce state update
+            // Both replay window marking and nonce increment must complete together
+            // to prevent state desynchronization. We perform both after successful
+            // decryption only, ensuring state consistency on any failure path.
             if useExtractedNonce {
-                // Mark nonce as seen after successful decryption
                 markNonceAsSeen(decryptionNonce)
             }
             nonce += 1
+
             return plaintext
         } catch {
+            // Decryption failed - nonce state remains unchanged (atomic rollback)
             SecureLogger.debug("Decrypt failed: \(error) for nonce \(decryptionNonce)")
-            // Log authentication failures with nonce info
             SecureLogger.error("Decryption failed at nonce \(decryptionNonce)", category: .encryption)
             throw error
         }
@@ -376,6 +384,16 @@ final class NoiseCipherState {
             replayWindow[i] = 0
         }
     }
+
+    #if DEBUG
+    func setNonceForTesting(_ nonce: UInt64) {
+        self.nonce = nonce
+    }
+
+    func extractNonceFromCiphertextPayloadForTesting(_ combinedPayload: Data) throws -> (nonce: UInt64, ciphertext: Data)? {
+        try extractNonceFromCiphertextPayload(combinedPayload)
+    }
+    #endif
 }
 
 // MARK: - Symmetric State
@@ -455,13 +473,36 @@ final class NoiseSymmetricState {
         let output = hkdf(chainingKey: chainingKey, inputKeyMaterial: Data(), numOutputs: 2)
         let tempKey1 = SymmetricKey(data: output[0])
         let tempKey2 = SymmetricKey(data: output[1])
-        
+
         let c1 = NoiseCipherState(key: tempKey1, useExtractedNonce: useExtractedNonce)
         let c2 = NoiseCipherState(key: tempKey2, useExtractedNonce: useExtractedNonce)
-        
+
+        // BCH-01-010: Clear symmetric state after split per Noise spec
+        // The chaining key and hash should not be retained after handshake completes
+        clearSensitiveData()
+
         return (c1, c2)
     }
-    
+
+    /// BCH-01-010: Securely clear sensitive cryptographic state
+    /// Called after split() to clear chaining key and hash per Noise spec
+    func clearSensitiveData() {
+        // Clear chaining key by overwriting with zeros
+        let chainingKeyCount = chainingKey.count
+        chainingKey = Data(repeating: 0, count: chainingKeyCount)
+
+        // Clear hash by overwriting with zeros
+        let hashCount = hash.count
+        hash = Data(repeating: 0, count: hashCount)
+
+        // Clear the internal cipher state
+        cipherState.clearSensitiveData()
+    }
+
+    deinit {
+        clearSensitiveData()
+    }
+
     // HKDF implementation
     private func hkdf(chainingKey: Data, inputKeyMaterial: Data, numOutputs: Int) -> [Data] {
         let tempKey = HMAC<SHA256>.authenticationCode(for: inputKeyMaterial, using: SymmetricKey(data: chainingKey))
@@ -554,8 +595,9 @@ final class NoiseHandshakeState {
             break // No pre-message keys
         case .IK, .NK:
             if role == .initiator, let remoteStatic = remoteStaticPublic {
-                _ = symmetricState.getHandshakeHash()
                 symmetricState.mixHash(remoteStatic.rawRepresentation)
+            } else if role == .responder, let localStatic = localStaticPublic {
+                symmetricState.mixHash(localStatic.rawRepresentation)
             }
         }
     }
@@ -807,16 +849,20 @@ final class NoiseHandshakeState {
         return currentPattern >= messagePatterns.count
     }
     
-    func getTransportCiphers(useExtractedNonce: Bool) throws -> (send: NoiseCipherState, receive: NoiseCipherState) {
+    func getTransportCiphers(useExtractedNonce: Bool) throws -> (send: NoiseCipherState, receive: NoiseCipherState, handshakeHash: Data) {
         guard isHandshakeComplete() else {
             throw NoiseError.handshakeNotComplete
         }
-        
+
+        // BCH-01-010: Capture handshake hash BEFORE split() clears symmetric state
+        let finalHandshakeHash = symmetricState.getHandshakeHash()
+
         let (c1, c2) = symmetricState.split(useExtractedNonce: useExtractedNonce)
-        
+
         // Initiator uses c1 for sending, c2 for receiving
         // Responder uses c2 for sending, c1 for receiving
-        return role == .initiator ? (c1, c2) : (c2, c1)
+        let ciphers = role == .initiator ? (c1, c2) : (c2, c1)
+        return (send: ciphers.0, receive: ciphers.1, handshakeHash: finalHandshakeHash)
     }
     
     func getRemoteStaticPublicKey() -> Curve25519.KeyAgreement.PublicKey? {
@@ -826,6 +872,20 @@ final class NoiseHandshakeState {
     func getHandshakeHash() -> Data {
         return symmetricState.getHandshakeHash()
     }
+
+    #if DEBUG
+    func performDHOperationForTesting(_ pattern: NoiseMessagePattern) throws {
+        try performDHOperation(pattern)
+    }
+
+    func setCurrentPatternForTesting(_ currentPattern: Int) {
+        self.currentPattern = currentPattern
+    }
+
+    func setRemoteEphemeralPublicKeyForTesting(_ key: Curve25519.KeyAgreement.PublicKey?) {
+        self.remoteEphemeralPublic = key
+    }
+    #endif
 }
 
 // MARK: - Pattern Extensions
@@ -877,22 +937,47 @@ enum NoiseError: Error {
     case nonceExceeded
 }
 
+// MARK: - Constant-Time Operations
+
+/// BCH-01-010: Constant-time comparison to prevent timing side-channel attacks
+/// This function compares two Data objects in constant time, preventing
+/// information leakage via timing analysis.
+private func constantTimeCompare(_ a: Data, _ b: Data) -> Bool {
+    guard a.count == b.count else { return false }
+
+    var result: UInt8 = 0
+    for i in 0..<a.count {
+        result |= a[a.startIndex.advanced(by: i)] ^ b[b.startIndex.advanced(by: i)]
+    }
+    return result == 0
+}
+
+/// BCH-01-010: Constant-time check if all bytes are zero
+private func constantTimeIsZero(_ data: Data) -> Bool {
+    var result: UInt8 = 0
+    for byte in data {
+        result |= byte
+    }
+    return result == 0
+}
+
 // MARK: - Key Validation
 
 extension NoiseHandshakeState {
     /// Validate a Curve25519 public key
     /// Checks for weak/invalid keys that could compromise security
+    /// BCH-01-010: Uses constant-time operations to prevent timing side-channels
     static func validatePublicKey(_ keyData: Data) throws -> Curve25519.KeyAgreement.PublicKey {
         // Check key length
         guard keyData.count == 32 else {
             throw NoiseError.invalidPublicKey
         }
-        
+
-        // Check for all-zero key (point at infinity)
+        // BCH-01-010: Constant-time check for all-zero key (point at infinity)
-        if keyData.allSatisfy({ $0 == 0 }) {
+        if constantTimeIsZero(keyData) {
             throw NoiseError.invalidPublicKey
         }
-        
+
         // Check for low-order points that could enable small subgroup attacks
         // These are the known bad points for Curve25519
         let lowOrderPoints: [Data] = [
@@ -913,13 +998,21 @@ extension NoiseHandshakeState {
                   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
                   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])  // Another bad point
         ]
-        
+
-        // Check against known bad points
+        // BCH-01-010: Constant-time check against known bad points
-        if lowOrderPoints.contains(keyData) {
+        // We check all points and accumulate matches to avoid early exit timing leaks
+        var foundBadPoint = false
+        for badPoint in lowOrderPoints {
+            if constantTimeCompare(keyData, badPoint) {
+                foundBadPoint = true
+            }
+        }
+
+        if foundBadPoint {
             SecureLogger.warning("Low-order point detected", category: .security)
             throw NoiseError.invalidPublicKey
         }
-        
+
         // Try to create the key - CryptoKit will validate curve points internally
         do {
             let publicKey = try Curve25519.KeyAgreement.PublicKey(rawRepresentation: keyData)

bitchat/Noise/NoiseSession.swift

@@ -102,23 +102,23 @@ class NoiseSession {
             
             // Check if handshake is complete
             if handshake.isHandshakeComplete() {
-                // Get transport ciphers
+                // Get transport ciphers and handshake hash (hash captured before split clears state)
-                let (send, receive) = try handshake.getTransportCiphers(useExtractedNonce: true)
+                let (send, receive, hash) = try handshake.getTransportCiphers(useExtractedNonce: true)
                 sendCipher = send
                 receiveCipher = receive
-                
+
                 // Store remote static key
                 remoteStaticPublicKey = handshake.getRemoteStaticPublicKey()
-                
+
                 // Store handshake hash for channel binding
-                handshakeHash = handshake.getHandshakeHash()
+                handshakeHash = hash
-                
+
                 state = .established
                 handshakeState = nil // Clear handshake state
-                
+
                 SecureLogger.debug("NoiseSession[\(peerID)]: Handshake complete (no response needed), transitioning to established")
                 SecureLogger.info(.handshakeCompleted(peerID: peerID.id))
-                
+
                 return nil
             } else {
                 // Generate response
@@ -128,20 +128,20 @@ class NoiseSession {
                 
                 // Check if handshake is complete after writing
                 if handshake.isHandshakeComplete() {
-                    // Get transport ciphers
+                    // Get transport ciphers and handshake hash (hash captured before split clears state)
-                    let (send, receive) = try handshake.getTransportCiphers(useExtractedNonce: true)
+                    let (send, receive, hash) = try handshake.getTransportCiphers(useExtractedNonce: true)
                     sendCipher = send
                     receiveCipher = receive
-                    
+
                     // Store remote static key
                     remoteStaticPublicKey = handshake.getRemoteStaticPublicKey()
-                    
+
                     // Store handshake hash for channel binding
-                    handshakeHash = handshake.getHandshakeHash()
+                    handshakeHash = hash
-                    
+
                     state = .established
                     handshakeState = nil // Clear handshake state
-                    
+
                     SecureLogger.debug("NoiseSession[\(peerID)]: Handshake complete after writing response, transitioning to established")
                     SecureLogger.info(.handshakeCompleted(peerID: peerID.id))
                 }

bitchat/Noise/NoiseSessionManager.swift

@@ -14,6 +14,7 @@ final class NoiseSessionManager {
     private var sessions: [PeerID: NoiseSession] = [:]
     private let localStaticKey: Curve25519.KeyAgreement.PrivateKey
     private let keychain: KeychainManagerProtocol
+    private let sessionFactory: (PeerID, NoiseRole) -> NoiseSession
     private let managerQueue = DispatchQueue(label: "chat.bitchat.noise.manager", attributes: .concurrent)
     
     // Callbacks
@@ -23,7 +24,27 @@ final class NoiseSessionManager {
     init(localStaticKey: Curve25519.KeyAgreement.PrivateKey, keychain: KeychainManagerProtocol) {
         self.localStaticKey = localStaticKey
         self.keychain = keychain
+        self.sessionFactory = { peerID, role in
+            SecureNoiseSession(
+                peerID: peerID,
+                role: role,
+                keychain: keychain,
+                localStaticKey: localStaticKey
+            )
+        }
     }
+
+    #if DEBUG
+    init(
+        localStaticKey: Curve25519.KeyAgreement.PrivateKey,
+        keychain: KeychainManagerProtocol,
+        sessionFactory: @escaping (PeerID, NoiseRole) -> NoiseSession
+    ) {
+        self.localStaticKey = localStaticKey
+        self.keychain = keychain
+        self.sessionFactory = sessionFactory
+    }
+    #endif
     
     // MARK: - Session Management
     
@@ -66,12 +87,7 @@ final class NoiseSessionManager {
             }
             
             // Create new initiator session
-            let session = SecureNoiseSession(
+            let session = sessionFactory(peerID, .initiator)
-                peerID: peerID,
-                role: .initiator,
-                keychain: keychain,
-                localStaticKey: localStaticKey
-            )
             sessions[peerID] = session
             
             do {
@@ -117,12 +133,7 @@ final class NoiseSessionManager {
             // Get or create session
             let session: NoiseSession
             if shouldCreateNew {
-                let newSession = SecureNoiseSession(
+                let newSession = sessionFactory(peerID, .responder)
-                    peerID: peerID,
-                    role: .responder,
-                    keychain: keychain,
-                    localStaticKey: localStaticKey
-                )
                 sessions[peerID] = newSession
                 session = newSession
             } else {

bitchat/Noise/SecureNoiseSession.swift

@@ -10,7 +10,7 @@ import Foundation
 
 final class SecureNoiseSession: NoiseSession {
     private(set) var messageCount: UInt64 = 0
-    private let sessionStartTime = Date()
+    private var sessionStartTime = Date()
     private(set) var lastActivityTime = Date()
     
     override func encrypt(_ plaintext: Data) throws -> Data {
@@ -77,5 +77,9 @@ final class SecureNoiseSession: NoiseSession {
     func setMessageCountForTesting(_ count: UInt64) {
         messageCount = count
     }
+
+    func setSessionStartTimeForTesting(_ date: Date) {
+        sessionStartTime = date
+    }
     #endif
 }

bitchat/Nostr/GeoRelayDirectory.swift

@@ -8,39 +8,154 @@ import AppKit
 #endif
 
 /// Directory of online Nostr relays with approximate GPS locations, used for geohash routing.
+struct GeoRelayDirectoryDependencies {
+    var userDefaults: UserDefaults
+    var notificationCenter: NotificationCenter
+    var now: () -> Date
+    var remoteURL: URL
+    var fetchInterval: TimeInterval
+    var refreshCheckInterval: TimeInterval
+    var retryInitialSeconds: TimeInterval
+    var retryMaxSeconds: TimeInterval
+    var awaitTorReady: @Sendable () async -> Bool
+    var makeFetchData: @MainActor @Sendable () -> (@Sendable (URLRequest) async throws -> Data)
+    var readData: (URL) -> Data?
+    var writeData: (Data, URL) throws -> Void
+    var cacheURL: () -> URL?
+    var bundledCSVURLs: () -> [URL]
+    var currentDirectoryPath: () -> String?
+    var retrySleep: (TimeInterval) async -> Void
+    var activeNotificationName: Notification.Name?
+    var autoStart: Bool
+}
+
+private extension GeoRelayDirectoryDependencies {
+    @MainActor
+    static func live() -> Self {
+#if os(iOS)
+        let activeNotificationName: Notification.Name? = UIApplication.didBecomeActiveNotification
+#elseif os(macOS)
+        let activeNotificationName: Notification.Name? = NSApplication.didBecomeActiveNotification
+#else
+        let activeNotificationName: Notification.Name? = nil
+#endif
+
+        return Self(
+            userDefaults: .standard,
+            notificationCenter: .default,
+            now: Date.init,
+            remoteURL: URL(string: "https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv")!,
+            fetchInterval: TransportConfig.geoRelayFetchIntervalSeconds,
+            refreshCheckInterval: TransportConfig.geoRelayRefreshCheckIntervalSeconds,
+            retryInitialSeconds: TransportConfig.geoRelayRetryInitialSeconds,
+            retryMaxSeconds: TransportConfig.geoRelayRetryMaxSeconds,
+            awaitTorReady: { await TorManager.shared.awaitReady() },
+            makeFetchData: {
+                let session = TorURLSession.shared.session
+                return { request in
+                    let (data, _) = try await session.data(for: request)
+                    return data
+                }
+            },
+            readData: { try? Data(contentsOf: $0) },
+            writeData: { data, url in
+                try data.write(to: url, options: .atomic)
+            },
+            cacheURL: {
+                do {
+                    let base = try FileManager.default.url(
+                        for: .applicationSupportDirectory,
+                        in: .userDomainMask,
+                        appropriateFor: nil,
+                        create: true
+                    )
+                    let dir = base.appendingPathComponent("bitchat", isDirectory: true)
+                    try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+                    return dir.appendingPathComponent("georelays_cache.csv")
+                } catch {
+                    return nil
+                }
+            },
+            bundledCSVURLs: {
+                [
+                    Bundle.main.url(forResource: "nostr_relays", withExtension: "csv"),
+                    Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv"),
+                    Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv", subdirectory: "relays")
+                ].compactMap { $0 }
+            },
+            currentDirectoryPath: { FileManager.default.currentDirectoryPath },
+            retrySleep: { delay in
+                let nanoseconds = UInt64(delay * 1_000_000_000)
+                try? await Task.sleep(nanoseconds: nanoseconds)
+            },
+            activeNotificationName: activeNotificationName,
+            autoStart: true
+        )
+    }
+}
+
 @MainActor
 final class GeoRelayDirectory {
-    struct Entry: Hashable {
+    private final class CleanupState {
+        let notificationCenter: NotificationCenter
+        var observers: [NSObjectProtocol] = []
+        var refreshTimer: Timer?
+        var retryTask: Task<Void, Never>?
+
+        init(notificationCenter: NotificationCenter) {
+            self.notificationCenter = notificationCenter
+        }
+
+        deinit {
+            observers.forEach { notificationCenter.removeObserver($0) }
+            refreshTimer?.invalidate()
+            retryTask?.cancel()
+        }
+    }
+
+    struct Entry: Hashable, Sendable {
         let host: String
         let lat: Double
         let lon: Double
     }
 
+    private enum DetachedFetchOutcome: Sendable {
+        case success(entries: [Entry], csv: String)
+        case torNotReady
+        case invalidData
+        case network(String)
+    }
+
     static let shared = GeoRelayDirectory()
 
     private(set) var entries: [Entry] = []
-    private let cacheFileName = "georelays_cache.csv"
     private let lastFetchKey = "georelay.lastFetchAt"
-    private let remoteURL = URL(string: "https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv")!
+    private let dependencies: GeoRelayDirectoryDependencies
-    private let fetchInterval: TimeInterval = TransportConfig.geoRelayFetchIntervalSeconds
+    private let cleanupState: CleanupState
 
-    private var refreshTimer: Timer?
-    private var retryTask: Task<Void, Never>?
     private var retryAttempt: Int = 0
     private var isFetching: Bool = false
-    private var observers: [NSObjectProtocol] = []
 
     private init() {
+        self.dependencies = .live()
+        self.cleanupState = CleanupState(notificationCenter: dependencies.notificationCenter)
         entries = loadLocalEntries()
-        registerObservers()
+        if dependencies.autoStart {
-        startRefreshTimer()
+            registerObservers()
-        prefetchIfNeeded()
+            startRefreshTimer()
+            prefetchIfNeeded()
+        }
     }
 
-    deinit {
+    internal init(dependencies: GeoRelayDirectoryDependencies) {
-        observers.forEach { NotificationCenter.default.removeObserver($0) }
+        self.dependencies = dependencies
-        refreshTimer?.invalidate()
+        self.cleanupState = CleanupState(notificationCenter: dependencies.notificationCenter)
-        retryTask?.cancel()
+        entries = loadLocalEntries()
+        if dependencies.autoStart {
+            registerObservers()
+            startRefreshTimer()
+            prefetchIfNeeded()
+        }
     }
 
     /// Returns up to `count` relay URLs (wss://) closest to the geohash center.
@@ -83,13 +198,13 @@ final class GeoRelayDirectory {
     func prefetchIfNeeded(force: Bool = false) {
         guard !isFetching else { return }
 
-        let now = Date()
+        let now = dependencies.now()
-        let last = UserDefaults.standard.object(forKey: lastFetchKey) as? Date ?? .distantPast
+        let last = dependencies.userDefaults.object(forKey: lastFetchKey) as? Date ?? .distantPast
 
         if !force {
-            guard now.timeIntervalSince(last) >= fetchInterval else { return }
+            guard now.timeIntervalSince(last) >= dependencies.fetchInterval else { return }
         } else if last != .distantPast,
-                  now.timeIntervalSince(last) < TransportConfig.geoRelayRetryInitialSeconds {
+                  now.timeIntervalSince(last) < dependencies.retryInitialSeconds {
             // Skip forced fetches if we just refreshed moments ago.
             return
         }
@@ -103,51 +218,73 @@ final class GeoRelayDirectory {
         isFetching = true
 
         let request = URLRequest(
-            url: remoteURL,
+            url: dependencies.remoteURL,
             cachePolicy: .reloadIgnoringLocalCacheData,
             timeoutInterval: 15
         )
+        let awaitTorReady = dependencies.awaitTorReady
+        let fetchData = dependencies.makeFetchData()
 
-        Task.detached { [weak self] in
+        Task { [weak self] in
             guard let self else { return }
 
-            let ready = await TorManager.shared.awaitReady()
+            let outcome = await Self.fetchRemoteOutcome(
-            if !ready {
+                request: request,
-                await self.handleFetchFailure(.torNotReady)
+                awaitTorReady: awaitTorReady,
-                return
+                fetchData: fetchData
-            }
+            )
 
-            do {
+            switch outcome {
-                let (data, _) = try await TorURLSession.shared.session.data(for: request)
+            case .success(let parsed, let csv):
-                guard let text = String(data: data, encoding: .utf8) else {
+                self.handleFetchSuccess(entries: parsed, csv: csv)
-                    await self.handleFetchFailure(.invalidData)
+            case .torNotReady:
-                    return
+                self.handleFetchFailure(.torNotReady)
-                }
+            case .invalidData:
-
+                self.handleFetchFailure(.invalidData)
-                let parsed = GeoRelayDirectory.parseCSV(text)
+            case .network(let description):
-                guard !parsed.isEmpty else {
+                self.handleFetchFailure(.network(description))
-                    await self.handleFetchFailure(.invalidData)
-                    return
-                }
-
-                await self.handleFetchSuccess(entries: parsed, csv: text)
-            } catch {
-                await self.handleFetchFailure(.network(error))
             }
         }
     }
 
+    nonisolated private static func fetchRemoteOutcome(
+        request: URLRequest,
+        awaitTorReady: @escaping @Sendable () async -> Bool,
+        fetchData: @escaping @Sendable (URLRequest) async throws -> Data
+    ) async -> DetachedFetchOutcome {
+        await Task.detached(priority: .utility) {
+            let ready = await awaitTorReady()
+            guard ready else { return .torNotReady }
+
+            do {
+                let data = try await fetchData(request)
+                guard let text = String(data: data, encoding: .utf8) else {
+                    return .invalidData
+                }
+
+                let parsed = Self.parseCSV(text)
+                guard !parsed.isEmpty else {
+                    return .invalidData
+                }
+
+                return .success(entries: parsed, csv: text)
+            } catch {
+                return .network(error.localizedDescription)
+            }
+        }.value
+    }
+
     private enum FetchFailure {
         case torNotReady
         case invalidData
-        case network(Error)
+        case network(String)
     }
 
     @MainActor
     private func handleFetchSuccess(entries parsed: [Entry], csv: String) {
         entries = parsed
         persistCache(csv)
-        UserDefaults.standard.set(Date(), forKey: lastFetchKey)
+        dependencies.userDefaults.set(dependencies.now(), forKey: lastFetchKey)
         SecureLogger.info("GeoRelayDirectory: refreshed \(parsed.count) relays from remote", category: .session)
         isFetching = false
         retryAttempt = 0
@@ -161,8 +298,8 @@ final class GeoRelayDirectory {
             SecureLogger.warning("GeoRelayDirectory: Tor not ready; scheduling retry", category: .session)
         case .invalidData:
             SecureLogger.warning("GeoRelayDirectory: remote fetch returned invalid data; scheduling retry", category: .session)
-        case .network(let error):
+        case .network(let errorDescription):
-            SecureLogger.warning("GeoRelayDirectory: remote fetch failed with error: \(error.localizedDescription)", category: .session)
+            SecureLogger.warning("GeoRelayDirectory: remote fetch failed with error: \(errorDescription)", category: .session)
         }
         isFetching = false
         scheduleRetry()
@@ -171,32 +308,34 @@ final class GeoRelayDirectory {
     @MainActor
     private func scheduleRetry() {
         retryAttempt = min(retryAttempt + 1, 10)
-        let base = TransportConfig.geoRelayRetryInitialSeconds
+        let base = dependencies.retryInitialSeconds
-        let maxDelay = TransportConfig.geoRelayRetryMaxSeconds
+        let maxDelay = dependencies.retryMaxSeconds
         let multiplier = pow(2.0, Double(max(retryAttempt - 1, 0)))
         let calculated = base * multiplier
         let delay = min(maxDelay, max(base, calculated))
 
         cancelRetry()
-        retryTask = Task { [weak self] in
+        cleanupState.retryTask = Task { [weak self] in
-            let nanoseconds = UInt64(delay * 1_000_000_000)
+            guard let self else { return }
-            try? await Task.sleep(nanoseconds: nanoseconds)
+            await self.dependencies.retrySleep(delay)
+            guard !Task.isCancelled else { return }
             await MainActor.run {
-                self?.prefetchIfNeeded(force: true)
+                self.prefetchIfNeeded(force: true)
             }
         }
     }
 
     @MainActor
     private func cancelRetry() {
-        retryTask?.cancel()
+        cleanupState.retryTask?.cancel()
-        retryTask = nil
+        cleanupState.retryTask = nil
     }
 
     private func persistCache(_ text: String) {
-        guard let url = cacheURL() else { return }
+        guard let url = dependencies.cacheURL() else { return }
+        guard let data = text.data(using: .utf8) else { return }
         do {
-            try text.data(using: .utf8)?.write(to: url, options: .atomic)
+            try dependencies.writeData(data, url)
         } catch {
             SecureLogger.warning("GeoRelayDirectory: failed to write cache: \(error)", category: .session)
         }
@@ -205,22 +344,18 @@ final class GeoRelayDirectory {
     // MARK: - Loading
     private func loadLocalEntries() -> [Entry] {
         // Prefer cached file if present
-        if let cache = cacheURL(),
+        if let cache = dependencies.cacheURL(),
-           let data = try? Data(contentsOf: cache),
+           let data = dependencies.readData(cache),
            let text = String(data: data, encoding: .utf8) {
             let arr = Self.parseCSV(text)
             if !arr.isEmpty { return arr }
         }
 
         // Try bundled resource(s)
-        let bundleCandidates = [
+        let bundleCandidates = dependencies.bundledCSVURLs()
-            Bundle.main.url(forResource: "nostr_relays", withExtension: "csv"),
-            Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv"),
-            Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv", subdirectory: "relays")
-        ].compactMap { $0 }
 
         for url in bundleCandidates {
-            if let data = try? Data(contentsOf: url),
+            if let data = dependencies.readData(url),
                let text = String(data: data, encoding: .utf8) {
                 let arr = Self.parseCSV(text)
                 if !arr.isEmpty { return arr }
@@ -228,8 +363,8 @@ final class GeoRelayDirectory {
         }
 
         // Try filesystem path (development/test)
-        if let cwd = FileManager.default.currentDirectoryPath as String?,
+        if let cwd = dependencies.currentDirectoryPath(),
-           let data = try? Data(contentsOf: URL(fileURLWithPath: cwd).appendingPathComponent("relays/online_relays_gps.csv")),
+           let data = dependencies.readData(URL(fileURLWithPath: cwd).appendingPathComponent("relays/online_relays_gps.csv")),
            let text = String(data: data, encoding: .utf8) {
             return Self.parseCSV(text)
         }
@@ -242,10 +377,9 @@ final class GeoRelayDirectory {
         var result: Set<Entry> = []
         let lines = text.split(whereSeparator: { $0.isNewline })
         for (idx, raw) in lines.enumerated() {
-            let line = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard let line = raw.trimmedOrNilIfEmpty else { continue }
-            if line.isEmpty { continue }
             if idx == 0 && line.lowercased().contains("relay url") { continue }
-            let parts = line.split(separator: ",").map { String($0).trimmingCharacters(in: .whitespaces) }
+            let parts = line.split(separator: ",").map { $0.trimmed }
             guard parts.count >= 3 else { continue }
             var host = parts[0]
             host = host.replacingOccurrences(of: "https://", with: "")
@@ -259,25 +393,9 @@ final class GeoRelayDirectory {
         return Array(result)
     }
 
-    private func cacheURL() -> URL? {
-        do {
-            let base = try FileManager.default.url(
-                for: .applicationSupportDirectory,
-                in: .userDomainMask,
-                appropriateFor: nil,
-                create: true
-            )
-            let dir = base.appendingPathComponent("bitchat", isDirectory: true)
-            try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-            return dir.appendingPathComponent(cacheFileName)
-        } catch {
-            return nil
-        }
-    }
-
     // MARK: - Observers & Timers
     private func registerObservers() {
-        let center = NotificationCenter.default
+        let center = dependencies.notificationCenter
 
         let torReady = center.addObserver(
             forName: .TorDidBecomeReady,
@@ -289,38 +407,26 @@ final class GeoRelayDirectory {
                 self.prefetchIfNeeded(force: true)
             }
         }
-        observers.append(torReady)
+        cleanupState.observers.append(torReady)
 
-#if os(iOS)
+        if let activeNotificationName = dependencies.activeNotificationName {
-        let didBecomeActive = center.addObserver(
+            let didBecomeActive = center.addObserver(
-            forName: UIApplication.didBecomeActiveNotification,
+                forName: activeNotificationName,
-            object: nil,
+                object: nil,
-            queue: .main
+                queue: .main
-        ) { [weak self] _ in
+            ) { [weak self] _ in
-            guard let self else { return }
+                guard let self else { return }
-            Task { @MainActor in
+                Task { @MainActor in
-                self.prefetchIfNeeded()
+                    self.prefetchIfNeeded()
+                }
             }
+            cleanupState.observers.append(didBecomeActive)
         }
-        observers.append(didBecomeActive)
-#elseif os(macOS)
-        let didBecomeActive = center.addObserver(
-            forName: NSApplication.didBecomeActiveNotification,
-            object: nil,
-            queue: .main
-        ) { [weak self] _ in
-            guard let self else { return }
-            Task { @MainActor in
-                self.prefetchIfNeeded()
-            }
-        }
-        observers.append(didBecomeActive)
-#endif
     }
 
     private func startRefreshTimer() {
-        refreshTimer?.invalidate()
+        cleanupState.refreshTimer?.invalidate()
-        let interval = TransportConfig.geoRelayRefreshCheckIntervalSeconds
+        let interval = dependencies.refreshCheckInterval
         guard interval > 0 else { return }
 
         let timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
@@ -329,9 +435,13 @@ final class GeoRelayDirectory {
                 self.prefetchIfNeeded()
             }
         }
-        refreshTimer = timer
+        cleanupState.refreshTimer = timer
         RunLoop.main.add(timer, forMode: .common)
     }
+
+    var debugRetryAttempt: Int { retryAttempt }
+    var debugHasRetryTask: Bool { cleanupState.retryTask != nil }
+    var debugObserverCount: Int { cleanupState.observers.count }
 }
 
 // MARK: - Distance

bitchat/Nostr/NostrProtocol.swift

@@ -18,6 +18,7 @@ struct NostrProtocol {
         case seal = 13 // NIP-17 sealed event
         case giftWrap = 1059 // NIP-59 gift wrap
         case ephemeralEvent = 20000
+        case geohashPresence = 20001
     }
     
     /// Create a NIP-17 private message
@@ -108,7 +109,7 @@ struct NostrProtocol {
         teleported: Bool = false
     ) throws -> NostrEvent {
         var tags = [["g", geohash]]
-        if let nickname = nickname?.trimmingCharacters(in: .whitespacesAndNewlines), !nickname.isEmpty {
+        if let nickname = nickname?.trimmedOrNilIfEmpty {
             tags.append(["n", nickname])
         }
         if teleported {
@@ -125,6 +126,24 @@ struct NostrProtocol {
         return try event.sign(with: schnorrKey)
     }
 
+    /// Create a geohash presence heartbeat (kind 20001)
+    /// Must contain empty content and NO nickname tag
+    static func createGeohashPresenceEvent(
+        geohash: String,
+        senderIdentity: NostrIdentity
+    ) throws -> NostrEvent {
+        let tags = [["g", geohash]]
+        let event = NostrEvent(
+            pubkey: senderIdentity.publicKeyHex,
+            createdAt: Date(),
+            kind: .geohashPresence,
+            tags: tags,
+            content: ""
+        )
+        let schnorrKey = try senderIdentity.schnorrSigningKey()
+        return try event.sign(with: schnorrKey)
+    }
+
     /// Create a persistent location note (kind 1: text note) tagged to a street-level geohash.
     static func createGeohashTextNote(
         content: String,
@@ -133,7 +152,7 @@ struct NostrProtocol {
         nickname: String? = nil
     ) throws -> NostrEvent {
         var tags = [["g", geohash]]
-        if let nickname = nickname?.trimmingCharacters(in: .whitespacesAndNewlines), !nickname.isEmpty {
+        if let nickname = nickname?.trimmedOrNilIfEmpty {
             tags.append(["n", nickname])
         }
         let event = NostrEvent(
@@ -509,6 +528,26 @@ struct NostrEvent: Codable {
         signed.sig = signatureHex
         return signed
     }
+
+    /// Validate that the event ID and Schnorr signature match the content and pubkey.
+    /// Returns false when the signature is missing, malformed, or does not verify.
+    func isValidSignature() -> Bool {
+        guard let sig = sig,
+              let sigData = Data(hexString: sig),
+              let pubData = Data(hexString: pubkey),
+              sigData.count == 64,
+              pubData.count == 32,
+              let signature = try? P256K.Schnorr.SchnorrSignature(dataRepresentation: sigData),
+              let (expectedId, eventHash) = try? calculateEventId(),
+              expectedId == id
+        else {
+            return false
+        }
+
+        var messageBytes = [UInt8](eventHash)
+        let xonly = P256K.Schnorr.XonlyKey(dataRepresentation: pubData)
+        return xonly.isValid(signature, for: &messageBytes)
+    }
     
     private func calculateEventId() throws -> (String, Data) {
         let serialized = [

bitchat/Nostr/NostrRelayManager.swift

@@ -4,6 +4,100 @@ import Network
 import Combine
 import Tor
 
+protocol NostrRelayConnectionProtocol: AnyObject {
+    func resume()
+    func cancel(with closeCode: URLSessionWebSocketTask.CloseCode, reason: Data?)
+    func send(_ message: URLSessionWebSocketTask.Message, completionHandler: @escaping (Error?) -> Void)
+    func receive(completionHandler: @escaping (Result<URLSessionWebSocketTask.Message, Error>) -> Void)
+    func sendPing(pongReceiveHandler: @escaping (Error?) -> Void)
+}
+
+protocol NostrRelaySessionProtocol {
+    func webSocketTask(with url: URL) -> NostrRelayConnectionProtocol
+}
+
+private final class URLSessionWebSocketTaskAdapter: NostrRelayConnectionProtocol {
+    private let base: URLSessionWebSocketTask
+
+    init(base: URLSessionWebSocketTask) {
+        self.base = base
+    }
+
+    func resume() {
+        base.resume()
+    }
+
+    func cancel(with closeCode: URLSessionWebSocketTask.CloseCode, reason: Data?) {
+        base.cancel(with: closeCode, reason: reason)
+    }
+
+    func send(_ message: URLSessionWebSocketTask.Message, completionHandler: @escaping (Error?) -> Void) {
+        base.send(message, completionHandler: completionHandler)
+    }
+
+    func receive(completionHandler: @escaping (Result<URLSessionWebSocketTask.Message, Error>) -> Void) {
+        base.receive(completionHandler: completionHandler)
+    }
+
+    func sendPing(pongReceiveHandler: @escaping (Error?) -> Void) {
+        base.sendPing(pongReceiveHandler: pongReceiveHandler)
+    }
+}
+
+private struct URLSessionAdapter: NostrRelaySessionProtocol {
+    let base: URLSession
+
+    func webSocketTask(with url: URL) -> NostrRelayConnectionProtocol {
+        URLSessionWebSocketTaskAdapter(base: base.webSocketTask(with: url))
+    }
+}
+
+struct NostrRelayManagerDependencies {
+    var activationAllowed: () -> Bool
+    var userTorEnabled: () -> Bool
+    var hasMutualFavorites: () -> Bool
+    var hasLocationPermission: () -> Bool
+    var mutualFavoritesPublisher: AnyPublisher<Set<Data>, Never>
+    var locationPermissionPublisher: AnyPublisher<LocationChannelManager.PermissionState, Never>
+    var torEnforced: () -> Bool
+    var torIsReady: () -> Bool
+    var torIsForeground: () -> Bool
+    var awaitTorReady: (@escaping (Bool) -> Void) -> Void
+    var makeSession: () -> NostrRelaySessionProtocol
+    var scheduleAfter: @Sendable (TimeInterval, @escaping @Sendable () -> Void) -> Void
+    var now: () -> Date
+}
+
+private extension NostrRelayManagerDependencies {
+    @MainActor
+    static func live() -> Self {
+        Self(
+            activationAllowed: { NetworkActivationService.shared.activationAllowed },
+            userTorEnabled: { NetworkActivationService.shared.userTorEnabled },
+            hasMutualFavorites: { !FavoritesPersistenceService.shared.mutualFavorites.isEmpty },
+            hasLocationPermission: { LocationChannelManager.shared.permissionState == .authorized },
+            mutualFavoritesPublisher: FavoritesPersistenceService.shared.$mutualFavorites.eraseToAnyPublisher(),
+            locationPermissionPublisher: LocationChannelManager.shared.$permissionState.eraseToAnyPublisher(),
+            torEnforced: { TorManager.shared.torEnforced },
+            torIsReady: { TorManager.shared.isReady },
+            torIsForeground: { TorManager.shared.isForeground() },
+            awaitTorReady: { completion in
+                Task.detached {
+                    let ready = await TorManager.shared.awaitReady()
+                    await MainActor.run {
+                        completion(ready)
+                    }
+                }
+            },
+            makeSession: { URLSessionAdapter(base: TorURLSession.shared.session) },
+            scheduleAfter: { delay, action in
+                DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: action)
+            },
+            now: Date.init
+        )
+    }
+}
+
 /// Manages WebSocket connections to Nostr relays
 @MainActor
 final class NostrRelayManager: ObservableObject {
@@ -41,10 +135,11 @@ final class NostrRelayManager: ObservableObject {
     @Published private(set) var relays: [Relay] = []
     @Published private(set) var isConnected = false
     
+    private let dependencies: NostrRelayManagerDependencies
     private var allowDefaultRelays: Bool = false
     private var hasMutualFavorites: Bool = false
     private var hasLocationPermission: Bool = false
-    private var connections: [String: URLSessionWebSocketTask] = [:]
+    private var connections: [String: NostrRelayConnectionProtocol] = [:]
     private var subscriptions: [String: Set<String>] = [:] // relay URL -> active subscription IDs
     private var pendingSubscriptions: [String: [String: String]] = [:] // relay URL -> (subscription id -> encoded REQ JSON)
     private var messageHandlers: [String: (NostrEvent) -> Void] = [:]
@@ -69,9 +164,7 @@ final class NostrRelayManager: ObservableObject {
     private var messageQueue: [PendingSend] = []
     private let messageQueueLock = NSLock()
     private let encoder = JSONEncoder()
-    private let decoder = JSONDecoder()
+    private var shouldUseTor: Bool { dependencies.userTorEnabled() }
-    private var networkService: NetworkActivationService { NetworkActivationService.shared }
-    private var shouldUseTor: Bool { networkService.userTorEnabled }
     
     // Exponential backoff configuration
     private let initialBackoffInterval: TimeInterval = TransportConfig.nostrRelayInitialBackoffSeconds
@@ -79,18 +172,17 @@ final class NostrRelayManager: ObservableObject {
     private let backoffMultiplier: Double = TransportConfig.nostrRelayBackoffMultiplier
     private let maxReconnectAttempts = TransportConfig.nostrRelayMaxReconnectAttempts
     
-    // Reconnection timer
-    private var reconnectionTimer: Timer?
     // Bump generation to invalidate scheduled reconnects when we reset/disconnect
     private var connectionGeneration: Int = 0
     
     init() {
-        hasMutualFavorites = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
+        self.dependencies = .live()
-        hasLocationPermission = LocationChannelManager.shared.permissionState == .authorized
+        hasMutualFavorites = dependencies.hasMutualFavorites()
+        hasLocationPermission = dependencies.hasLocationPermission()
         applyDefaultRelayPolicy(force: true)
         // Deterministic JSON shape for outbound requests
         self.encoder.outputFormatting = .sortedKeys
-        FavoritesPersistenceService.shared.$mutualFavorites
+        dependencies.mutualFavoritesPublisher
             .receive(on: DispatchQueue.main)
             .sink { [weak self] favorites in
                 guard let self = self else { return }
@@ -98,7 +190,34 @@ final class NostrRelayManager: ObservableObject {
                 self.applyDefaultRelayPolicy()
             }
             .store(in: &cancellables)
-        LocationChannelManager.shared.$permissionState
+        dependencies.locationPermissionPublisher
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] state in
+                guard let self = self else { return }
+                let authorized = (state == .authorized)
+                if authorized == self.hasLocationPermission { return }
+                self.hasLocationPermission = authorized
+                self.applyDefaultRelayPolicy()
+            }
+            .store(in: &cancellables)
+    }
+
+    internal init(dependencies: NostrRelayManagerDependencies) {
+        self.dependencies = dependencies
+        hasMutualFavorites = dependencies.hasMutualFavorites()
+        hasLocationPermission = dependencies.hasLocationPermission()
+        applyDefaultRelayPolicy(force: true)
+        // Deterministic JSON shape for outbound requests
+        self.encoder.outputFormatting = .sortedKeys
+        dependencies.mutualFavoritesPublisher
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] favorites in
+                guard let self = self else { return }
+                self.hasMutualFavorites = !favorites.isEmpty
+                self.applyDefaultRelayPolicy()
+            }
+            .store(in: &cancellables)
+        dependencies.locationPermissionPublisher
             .receive(on: DispatchQueue.main)
             .sink { [weak self] state in
                 guard let self = self else { return }
@@ -113,20 +232,18 @@ final class NostrRelayManager: ObservableObject {
     /// Connect to all configured relays
     func connect() {
         // Global network policy gate
-        guard networkService.activationAllowed else { return }
+        guard dependencies.activationAllowed() else { return }
         if shouldUseTor {
             // Ensure Tor is started early and wait for readiness off-main; then hop back to connect.
-            Task.detached {
+            dependencies.awaitTorReady { [weak self] ready in
-                let ready = await TorManager.shared.awaitReady()
+                guard let self = self else { return }
-                await MainActor.run {
+                if !ready {
-                    if !ready {
+                    SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
-                        SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
+                    return
-                        return
+                }
-                    }
+                SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
-                    SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
+                for relay in self.relays {
-                    for relay in self.relays {
+                    self.connectToRelay(relay.url)
-                        self.connectToRelay(relay.url)
-                    }
                 }
             }
         } else {
@@ -153,15 +270,14 @@ final class NostrRelayManager: ObservableObject {
     /// Ensure connections exist to the given relay URLs (idempotent).
     func ensureConnections(to relayUrls: [String]) {
         // Global network policy gate
-        guard networkService.activationAllowed else { return }
+        guard dependencies.activationAllowed() else { return }
         let targets = allowedRelayList(from: relayUrls)
         guard !targets.isEmpty else { return }
-        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady() {
             // Defer until Tor is fully ready; avoid queuing connection attempts early
-            Task.detached { [weak self] in
+            dependencies.awaitTorReady { [weak self] ready in
                 guard let self = self else { return }
-                let ready = await TorManager.shared.awaitReady()
+                if ready { self.ensureConnections(to: relayUrls) }
-                await MainActor.run { if ready { self.ensureConnections(to: relayUrls) } }
             }
             return
         }
@@ -178,13 +294,12 @@ final class NostrRelayManager: ObservableObject {
     /// Send an event to specified relays (or all if none specified)
     func sendEvent(_ event: NostrEvent, to relayUrls: [String]? = nil) {
         // Global network policy gate
-        guard networkService.activationAllowed else { return }
+        guard dependencies.activationAllowed() else { return }
-        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady() {
             // Defer sends until Tor is ready to avoid premature queueing
-            Task.detached { [weak self] in
+            dependencies.awaitTorReady { [weak self] ready in
                 guard let self = self else { return }
-                let ready = await TorManager.shared.awaitReady()
+                if ready { self.sendEvent(event, to: relayUrls) }
-                await MainActor.run { if ready { self.sendEvent(event, to: relayUrls) } }
             }
             return
         }
@@ -256,24 +371,21 @@ final class NostrRelayManager: ObservableObject {
         onEOSE: (() -> Void)? = nil
     ) {
         // Global network policy gate
-        guard networkService.activationAllowed else { return }
+        guard dependencies.activationAllowed() else { return }
         // Coalesce rapid duplicate subscribe requests only if a handler already exists
-        let now = Date()
+        let now = dependencies.now()
         if messageHandlers[id] != nil {
             if let last = subscribeCoalesce[id], now.timeIntervalSince(last) < 1.0 {
                 return
             }
         }
         subscribeCoalesce[id] = now
-        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady() {
             // Defer subscription setup until Tor is ready; avoid queuing subs early
-            Task.detached { [weak self] in
+            dependencies.awaitTorReady { [weak self] ready in
                 guard let self = self else { return }
-                let ready = await TorManager.shared.awaitReady()
+                if ready {
-                await MainActor.run {
+                    self.subscribe(filter: filter, id: id, relayUrls: relayUrls, handler: handler, onEOSE: onEOSE)
-                    if ready {
-                        self.subscribe(filter: filter, id: id, relayUrls: relayUrls, handler: handler)
-                    }
                 }
             }
             return
@@ -300,7 +412,7 @@ final class NostrRelayManager: ObservableObject {
             for url in urls where !existingSet.contains(url) {
                 relays.append(Relay(url: url))
             }
-            for url in candidateUrls {
+            for url in urls {
                 var map = self.pendingSubscriptions[url] ?? [:]
                 map[id] = messageString
                 self.pendingSubscriptions[url] = map
@@ -349,7 +461,7 @@ final class NostrRelayManager: ObservableObject {
                 relays.append(Relay(url: url))
                 existing.insert(url)
             }
-            if networkService.activationAllowed {
+            if dependencies.activationAllowed() {
                 ensureConnections(to: Self.defaultRelays)
             }
         } else {
@@ -359,6 +471,7 @@ final class NostrRelayManager: ObservableObject {
                 }
                 connections.removeValue(forKey: url)
                 subscriptions.removeValue(forKey: url)
+                pendingSubscriptions.removeValue(forKey: url)
             }
             messageQueueLock.lock()
             for index in (0..<messageQueue.count).reversed() {
@@ -403,10 +516,9 @@ final class NostrRelayManager: ObservableObject {
         // Send unsubscribe to all relays
         for (relayUrl, connection) in connections {
             if subscriptions[relayUrl]?.contains(id) == true {
+                subscriptions[relayUrl]?.remove(id)
                 connection.send(.string(messageString)) { _ in
-                    Task { @MainActor in
+                    // Local state is cleared before sending so callers can re-subscribe immediately.
-                        self.subscriptions[relayUrl]?.remove(id)
-                    }
                 }
             }
         }
@@ -416,14 +528,14 @@ final class NostrRelayManager: ObservableObject {
     
     private func connectToRelay(_ urlString: String) {
         // Global network policy gate
-        guard networkService.activationAllowed else { return }
+        guard dependencies.activationAllowed() else { return }
         guard let url = URL(string: urlString) else { 
             SecureLogger.warning("Invalid relay URL: \(urlString)", category: .session)
             return 
         }
 
         // Avoid initiating connections while app is backgrounded; we'll reconnect on foreground
-        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isForeground() {
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsForeground() {
             return
         }
         
@@ -438,19 +550,16 @@ final class NostrRelayManager: ObservableObject {
         // Attempting to connect to Nostr relay via the proxied session
         
         // If Tor is enforced but not ready, delay connection until it is.
-        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady() {
-            Task.detached { [weak self] in
+            dependencies.awaitTorReady { [weak self] ready in
                 guard let self = self else { return }
-                let ready = await TorManager.shared.awaitReady()
+                if ready { self.connectToRelay(urlString) }
-                await MainActor.run {
+                else { SecureLogger.error("❌ Tor not ready; skipping connection to \(urlString)", category: .session) }
-                    if ready { self.connectToRelay(urlString) }
-                    else { SecureLogger.error("❌ Tor not ready; skipping connection to \(urlString)", category: .session) }
-                }
             }
             return
         }
         
-        let session = TorURLSession.shared.session
+        let session = dependencies.makeSession()
         let task = session.webSocketTask(with: url)
         
         connections[urlString] = task
@@ -498,7 +607,7 @@ final class NostrRelayManager: ObservableObject {
         pendingSubscriptions[relayUrl] = nil
     }
     
-    private func receiveMessage(from task: URLSessionWebSocketTask, relayUrl: String) {
+    private func receiveMessage(from task: NostrRelayConnectionProtocol, relayUrl: String) {
         task.receive { [weak self] result in
             guard let self = self else { return }
             
@@ -508,7 +617,7 @@ final class NostrRelayManager: ObservableObject {
                 Task.detached(priority: .utility) {
                     guard let parsed = ParsedInbound(message) else { return }
                     await MainActor.run {
-                        NostrRelayManager.shared.handleParsedMessage(parsed, from: relayUrl)
+                        self.handleParsedMessage(parsed, from: relayUrl)
                     }
                 }
                 
@@ -572,7 +681,7 @@ final class NostrRelayManager: ObservableObject {
         }
     }
     
-    private func sendToRelay(event: NostrEvent, connection: URLSessionWebSocketTask, relayUrl: String) {
+    private func sendToRelay(event: NostrEvent, connection: NostrRelayConnectionProtocol, relayUrl: String) {
         let req = NostrRequest.event(event)
         
         do {
@@ -604,11 +713,11 @@ final class NostrRelayManager: ObservableObject {
             relays[index].isConnected = isConnected
             relays[index].lastError = error
             if isConnected {
-                relays[index].lastConnectedAt = Date()
+                relays[index].lastConnectedAt = dependencies.now()
                 relays[index].reconnectAttempts = 0  // Reset on successful connection
                 relays[index].nextReconnectTime = nil
             } else {
-                relays[index].lastDisconnectedAt = Date()
+                relays[index].lastDisconnectedAt = dependencies.now()
             }
         }
         updateConnectionStatus()
@@ -624,7 +733,7 @@ final class NostrRelayManager: ObservableObject {
     
     private func handleDisconnection(relayUrl: String, error: Error) {
         // If networking is disallowed, do not schedule reconnection
-        if !networkService.activationAllowed {
+        if !dependencies.activationAllowed() {
             connections.removeValue(forKey: relayUrl)
             subscriptions.removeValue(forKey: relayUrl)
             updateRelayStatus(relayUrl, isConnected: false, error: error)
@@ -669,19 +778,21 @@ final class NostrRelayManager: ObservableObject {
             maxBackoffInterval
         )
         
-        let nextReconnectTime = Date().addingTimeInterval(backoffInterval)
+        let nextReconnectTime = dependencies.now().addingTimeInterval(backoffInterval)
         relays[index].nextReconnectTime = nextReconnectTime
         
         
         // Schedule reconnection with exponential backoff
         let gen = connectionGeneration
-        DispatchQueue.main.asyncAfter(deadline: .now() + backoffInterval) { [weak self] in
+        dependencies.scheduleAfter(backoffInterval) { [weak self] in
-            guard let self = self else { return }
+            Task { @MainActor [weak self] in
-            // Ignore stale scheduled reconnects from a previous generation
+                guard let self = self else { return }
-            guard gen == self.connectionGeneration else { return }
+                // Ignore stale scheduled reconnects from a previous generation
-            // Check if we should still reconnect (relay might have been removed)
+                guard gen == self.connectionGeneration else { return }
-            if self.relays.contains(where: { $0.url == relayUrl }) {
+                // Check if we should still reconnect (relay might have been removed)
-                self.connectToRelay(relayUrl)
+                if self.relays.contains(where: { $0.url == relayUrl }) {
+                    self.connectToRelay(relayUrl)
+                }
             }
         }
     }
@@ -695,6 +806,7 @@ final class NostrRelayManager: ObservableObject {
         // Reset reconnection attempts
         relays[index].reconnectAttempts = 0
         relays[index].nextReconnectTime = nil
+        relays[index].lastError = nil
         
         // Disconnect if connected
         if let connection = connections[relayUrl] {
@@ -715,6 +827,20 @@ final class NostrRelayManager: ObservableObject {
              nextReconnectTime: relay.nextReconnectTime)
         }
     }
+
+    var debugPendingMessageQueueCount: Int {
+        messageQueueLock.lock()
+        defer { messageQueueLock.unlock() }
+        return messageQueue.count
+    }
+
+    func debugPendingSubscriptionCount(for relayUrl: String) -> Int {
+        pendingSubscriptions[relayUrl]?.count ?? 0
+    }
+
+    func debugFlushMessageQueue() {
+        flushMessageQueue(for: nil)
+    }
     
     /// Reset all relay connections
     func resetAllConnections() {
@@ -767,7 +893,8 @@ private enum ParsedInbound {
             if array.count >= 3,
                let subId = array[1] as? String,
                let eventDict = array[2] as? [String: Any],
-               let event = try? NostrEvent(from: eventDict) {
+               let event = try? NostrEvent(from: eventDict),
+               event.isValidSignature() {
                 self = .event(subId: subId, event: event)
                 return
             }
@@ -887,10 +1014,10 @@ struct NostrFilter: Encodable {
         return filter
     }
 
-    // For location channels: geohash-scoped ephemeral events (kind 20000)
+    // For location channels: geohash-scoped ephemeral events (kind 20000) and presence (kind 20001)
-    static func geohashEphemeral(_ geohash: String, since: Date? = nil, limit: Int = 200) -> NostrFilter {
+    static func geohashEphemeral(_ geohash: String, since: Date? = nil, limit: Int = 1000) -> NostrFilter {
         var filter = NostrFilter()
-        filter.kinds = [20000]
+        filter.kinds = [20000, 20001]
         filter.since = since?.timeIntervalSince1970.toInt()
         filter.tagFilters = ["g": [geohash]]
         filter.limit = limit

bitchat/Protocols/BinaryEncodingUtils.swift

@@ -28,7 +28,7 @@ extension Data {
     ///   Whitespace is trimmed. Must have even length after prefix removal.
     /// - Returns: nil if the string has odd length or contains invalid hex characters.
     init?(hexString: String) {
-        var hex = hexString.trimmingCharacters(in: .whitespaces)
+        var hex = hexString.trimmed
 
         // Remove optional 0x prefix
         if hex.hasPrefix("0x") || hex.hasPrefix("0X") {

bitchat/Protocols/BinaryProtocol.swift

@@ -138,6 +138,7 @@ struct BinaryProtocol {
         static let hasSignature: UInt8 = 0x02
         static let isCompressed: UInt8 = 0x04
         static let hasRoute: UInt8 = 0x08
+        static let isRSR: UInt8 = 0x10
     }
     
     // Encode BitchatPacket to binary format
@@ -161,7 +162,9 @@ struct BinaryProtocol {
         }
 
         let lengthFieldBytes = lengthFieldSize(for: version)
-        let originalRoute = packet.route ?? []
+        
+        // Route is only supported for v2+ packets (per SOURCE_ROUTING.md spec)
+        let originalRoute = (version >= 2) ? (packet.route ?? []) : []
         if originalRoute.contains(where: { $0.isEmpty }) { return nil }
         let sanitizedRoute: [Data] = originalRoute.map { hop in
             if hop.count == senderIDSize { return hop }
@@ -175,13 +178,14 @@ struct BinaryProtocol {
         let hasRoute = !sanitizedRoute.isEmpty
         let routeLength = hasRoute ? 1 + sanitizedRoute.count * senderIDSize : 0
         let originalSizeFieldBytes = isCompressed ? lengthFieldBytes : 0
-        let payloadDataSize = routeLength + payload.count + originalSizeFieldBytes
+        // payloadLength in header is payload-only (does NOT include route bytes)
+        let payloadDataSize = payload.count + originalSizeFieldBytes
 
         if version == 1 && payloadDataSize > Int(UInt16.max) { return nil }
         if version == 2 && payloadDataSize > Int(UInt32.max) { return nil }
 
         guard let headerSize = headerSize(for: version) else { return nil }
-        let estimatedHeader = headerSize + senderIDSize + (packet.recipientID == nil ? 0 : recipientIDSize)
+        let estimatedHeader = headerSize + senderIDSize + (packet.recipientID == nil ? 0 : recipientIDSize) + routeLength
         let estimatedPayload = payloadDataSize
         let estimatedSignature = (packet.signature == nil ? 0 : signatureSize)
         var data = Data()
@@ -199,9 +203,11 @@ struct BinaryProtocol {
         if packet.recipientID != nil { flags |= Flags.hasRecipient }
         if packet.signature != nil { flags |= Flags.hasSignature }
         if isCompressed { flags |= Flags.isCompressed }
-        if hasRoute { flags |= Flags.hasRoute }
+        // HAS_ROUTE is only valid for v2+ packets
+        if hasRoute && version >= 2 { flags |= Flags.hasRoute }
+        if packet.isRSR { flags |= Flags.isRSR }
         data.append(flags)
-
+        
         if version == 2 {
             let length = UInt32(payloadDataSize)
             for shift in stride(from: 24, through: 0, by: -8) {
@@ -323,7 +329,10 @@ struct BinaryProtocol {
             let hasRecipient = (flags & Flags.hasRecipient) != 0
             let hasSignature = (flags & Flags.hasSignature) != 0
             let isCompressed = (flags & Flags.isCompressed) != 0
-
+            // HAS_ROUTE is only valid for v2+ packets; ignore the flag for v1
+            let hasRoute = (version >= 2) && (flags & Flags.hasRoute) != 0
+            let isRSR = (flags & Flags.isRSR) != 0
+            
             let payloadLength: Int
             if version == 2 {
                 guard let len = read32() else { return nil }
@@ -334,6 +343,7 @@ struct BinaryProtocol {
             }
 
             guard payloadLength >= 0 else { return nil }
+            guard payloadLength <= FileTransferLimits.maxFramedFileBytes else { return nil }
 
             guard let senderID = readData(senderIDSize) else { return nil }
 
@@ -343,27 +353,24 @@ struct BinaryProtocol {
                 if recipientID == nil { return nil }
             }
 
+            // Route (optional, v2+ only): route bytes are NOT included in payloadLength
             var route: [Data]? = nil
-            var remainingPayloadBytes = payloadLength
+            if hasRoute {
-
+                guard let routeCount = read8() else { return nil }
-            if (flags & Flags.hasRoute) != 0 {
-                guard remainingPayloadBytes >= 1, let routeCount = read8() else { return nil }
-                remainingPayloadBytes -= 1
                 if routeCount > 0 {
                     var hops: [Data] = []
                     for _ in 0..<Int(routeCount) {
-                        guard remainingPayloadBytes >= senderIDSize,
+                        guard let hop = readData(senderIDSize) else { return nil }
-                              let hop = readData(senderIDSize) else { return nil }
-                        remainingPayloadBytes -= senderIDSize
                         hops.append(hop)
                     }
                     route = hops
                 }
             }
 
+            // Payload: payloadLength is exactly the payload size (+ compression preamble if compressed)
             let payload: Data
             if isCompressed {
-                guard remainingPayloadBytes >= lengthFieldBytes else { return nil }
+                guard payloadLength >= lengthFieldBytes else { return nil }
                 let originalSize: Int
                 if version == 2 {
                     guard let rawSize = read32() else { return nil }
@@ -372,11 +379,9 @@ struct BinaryProtocol {
                     guard let rawSize = read16() else { return nil }
                     originalSize = Int(rawSize)
                 }
-                remainingPayloadBytes -= lengthFieldBytes
                 guard originalSize >= 0 && originalSize <= FileTransferLimits.maxFramedFileBytes else { return nil }
-                let compressedSize = remainingPayloadBytes
+                let compressedSize = payloadLength - lengthFieldBytes
                 guard compressedSize > 0, let compressed = readData(compressedSize) else { return nil }
-                remainingPayloadBytes = 0
 
                 let compressionRatio = Double(originalSize) / Double(compressedSize)
                 guard compressionRatio <= 50_000.0 else {
@@ -388,9 +393,7 @@ struct BinaryProtocol {
                       decompressed.count == originalSize else { return nil }
                 payload = decompressed
             } else {
-                guard remainingPayloadBytes >= 0,
+                guard let rawPayload = readData(payloadLength) else { return nil }
-                      let rawPayload = readData(remainingPayloadBytes) else { return nil }
-                remainingPayloadBytes = 0
                 payload = rawPayload
             }
 
@@ -411,7 +414,8 @@ struct BinaryProtocol {
                 signature: signature,
                 ttl: ttl,
                 version: version,
-                route: route
+                route: route,
+                isRSR: isRSR
             )
         }
     }

bitchat/Services/BLE/MimeType.swift

@@ -191,5 +191,22 @@ enum MimeType: CaseIterable, Hashable {
 extension MimeType {
     enum Category: String {
         case audio, image, file
+
+        /// Ends with a space
+        var messagePrefix: String {
+            switch self {
+            case .audio: "[voice] "
+            case .image: "[image] "
+            case .file: "[file] "
+            }
+        }
+
+        var mediaDir: String {
+            switch self {
+            case .audio: "voicenotes"
+            case .image: "images"
+            case .file: "files"
+            }
+        }
     }
 }

bitchat/Services/CommandProcessor.swift

@@ -59,22 +59,11 @@ final class CommandProcessor {
     weak var meshService: Transport?
     private let identityManager: SecureIdentityStateManagerProtocol
 
-    /// Backward-compatible property for existing code
-    weak var chatViewModel: CommandContextProvider? {
-        get { contextProvider }
-        set { contextProvider = newValue }
-    }
-
     init(contextProvider: CommandContextProvider? = nil, meshService: Transport? = nil, identityManager: SecureIdentityStateManagerProtocol) {
         self.contextProvider = contextProvider
         self.meshService = meshService
         self.identityManager = identityManager
     }
-
-    /// Backward-compatible initializer
-    convenience init(chatViewModel: ChatViewModel? = nil, meshService: Transport? = nil, identityManager: SecureIdentityStateManagerProtocol) {
-        self.init(contextProvider: chatViewModel, meshService: meshService, identityManager: identityManager)
-    }
     
     /// Process a command string
     @MainActor
@@ -177,7 +166,7 @@ final class CommandProcessor {
     }
     
     private func handleEmote(_ args: String, command: String, action: String, emoji: String, suffix: String = "") -> CommandResult {
-        let targetName = args.trimmingCharacters(in: .whitespaces)
+        let targetName = args.trimmed
         guard !targetName.isEmpty else {
             return .error(message: "usage: /\(command) <nickname>")
         }
@@ -220,7 +209,7 @@ final class CommandProcessor {
     }
     
     private func handleBlock(_ args: String) -> CommandResult {
-        let targetName = args.trimmingCharacters(in: .whitespaces)
+        let targetName = args.trimmed
         
         if targetName.isEmpty {
             // List blocked users (mesh) and geohash (Nostr) blocks
@@ -295,7 +284,7 @@ final class CommandProcessor {
     }
     
     private func handleUnblock(_ args: String) -> CommandResult {
-        let targetName = args.trimmingCharacters(in: .whitespaces)
+        let targetName = args.trimmed
         guard !targetName.isEmpty else {
             return .error(message: "usage: /unblock <nickname>")
         }
@@ -322,7 +311,7 @@ final class CommandProcessor {
     }
     
     private func handleFavorite(_ args: String, add: Bool) -> CommandResult {
-        let targetName = args.trimmingCharacters(in: .whitespaces)
+        let targetName = args.trimmed
         guard !targetName.isEmpty else {
             return .error(message: "usage: /\(add ? "fav" : "unfav") <nickname>")
         }

bitchat/Services/FavoritesPersistenceService.swift

@@ -31,9 +31,6 @@ final class FavoritesPersistenceService: ObservableObject {
     @Published private(set) var favorites: [Data: FavoriteRelationship] = [:] // Noise pubkey -> relationship
     @Published private(set) var mutualFavorites: Set<Data> = []
     
-    private let userDefaults = UserDefaults.standard
-    private var cancellables = Set<AnyCancellable>()
-    
     static let shared = FavoritesPersistenceService()
 
     init(keychain: KeychainManagerProtocol = KeychainManager()) {

bitchat/Services/GeohashParticipantTracker.swift

@@ -83,6 +83,9 @@ public final class GeohashParticipantTracker: ObservableObject {
         var map = participants[geohash] ?? [:]
         map[key] = Date()
         participants[geohash] = map
+        
+        // Always notify observers that state has changed so counts in UI update
+        objectWillChange.send()
 
         // Only refresh visible list if this geohash is currently active
         if activeGeohash == geohash {

bitchat/Services/GeohashPresenceService.swift

@@ -0,0 +1,264 @@
+//
+// GeohashPresenceService.swift
+// bitchat
+//
+// Manages the broadcasting of ephemeral presence heartbeats (Kind 20001)
+// to geohash location channels.
+//
+// This is free and unencumbered software released into the public domain.
+//
+
+import Foundation
+import Combine
+import BitLogger
+import Tor
+
+protocol GeohashPresenceTimerProtocol: AnyObject {
+    var isValid: Bool { get }
+    func invalidate()
+}
+
+private final class GeohashPresenceTimerAdapter: GeohashPresenceTimerProtocol {
+    private let base: Timer
+
+    init(base: Timer) {
+        self.base = base
+    }
+
+    var isValid: Bool { base.isValid }
+
+    func invalidate() {
+        base.invalidate()
+    }
+}
+
+/// Service that coordinates the broadcasting of presence heartbeats.
+///
+/// Behavior:
+/// - Monitors location changes via LocationStateManager
+/// - Broadcasts Kind 20001 events to low-precision geohash channels
+/// - Uses randomized timing (40-80s loop) and decorrelated bursts
+/// - Respects privacy by NOT broadcasting to Neighborhood/Block/Building levels
+@MainActor
+final class GeohashPresenceService: ObservableObject {
+    static let shared = GeohashPresenceService()
+
+    private var subscriptions = Set<AnyCancellable>()
+    private var heartbeatTimer: GeohashPresenceTimerProtocol?
+    private let availableChannelsProvider: () -> [GeohashChannel]
+    private let locationChanges: AnyPublisher<[GeohashChannel], Never>
+    private let torReadyPublisher: AnyPublisher<Void, Never>
+    private let torIsReady: () -> Bool
+    private let torIsForeground: () -> Bool
+    private let deriveIdentity: (String) throws -> NostrIdentity
+    private let relayLookup: (String, Int) -> [String]
+    private let relaySender: (NostrEvent, [String]) -> Void
+    private let sleeper: (UInt64) async -> Void
+    private let scheduleTimer: (TimeInterval, @escaping () -> Void) -> GeohashPresenceTimerProtocol
+    
+    // MARK: - Constants
+
+    // Loop interval range in seconds
+    private let loopMinInterval: TimeInterval
+    private let loopMaxInterval: TimeInterval
+    
+    // Per-broadcast decorrelation delay range in seconds
+    private let burstMinDelay: TimeInterval
+    private let burstMaxDelay: TimeInterval
+
+    // Privacy: Only broadcast to these levels
+    private let allowedPrecisions: Set<Int> = [
+        GeohashChannelLevel.region.precision,    // 2
+        GeohashChannelLevel.province.precision,  // 4
+        GeohashChannelLevel.city.precision       // 5
+    ]
+
+    private init() {
+        let idBridge = NostrIdentityBridge()
+        self.availableChannelsProvider = { LocationStateManager.shared.availableChannels }
+        self.locationChanges = LocationStateManager.shared.$availableChannels.eraseToAnyPublisher()
+        self.torReadyPublisher = NotificationCenter.default.publisher(for: .TorDidBecomeReady)
+            .map { _ in () }
+            .eraseToAnyPublisher()
+        self.torIsReady = { TorManager.shared.isReady }
+        self.torIsForeground = { TorManager.shared.isForeground() }
+        self.deriveIdentity = { try idBridge.deriveIdentity(forGeohash: $0) }
+        self.relayLookup = { geohash, count in
+            GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: count)
+        }
+        self.relaySender = { event, relays in
+            NostrRelayManager.shared.sendEvent(event, to: relays)
+        }
+        self.sleeper = { nanoseconds in
+            try? await Task.sleep(nanoseconds: nanoseconds)
+        }
+        self.scheduleTimer = { interval, action in
+            GeohashPresenceTimerAdapter(
+                base: Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { _ in
+                    action()
+                }
+            )
+        }
+        self.loopMinInterval = 40.0
+        self.loopMaxInterval = 80.0
+        self.burstMinDelay = 2.0
+        self.burstMaxDelay = 5.0
+        setupObservers()
+    }
+
+    internal init(
+        availableChannelsProvider: @escaping () -> [GeohashChannel],
+        locationChanges: AnyPublisher<[GeohashChannel], Never>,
+        torReadyPublisher: AnyPublisher<Void, Never>,
+        torIsReady: @escaping () -> Bool,
+        torIsForeground: @escaping () -> Bool,
+        deriveIdentity: @escaping (String) throws -> NostrIdentity,
+        relayLookup: @escaping (String, Int) -> [String],
+        relaySender: @escaping (NostrEvent, [String]) -> Void,
+        sleeper: @escaping (UInt64) async -> Void = { nanoseconds in try? await Task.sleep(nanoseconds: nanoseconds) },
+        scheduleTimer: @escaping (TimeInterval, @escaping () -> Void) -> GeohashPresenceTimerProtocol = { interval, action in
+            GeohashPresenceTimerAdapter(
+                base: Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { _ in
+                    action()
+                }
+            )
+        },
+        loopMinInterval: TimeInterval = 40.0,
+        loopMaxInterval: TimeInterval = 80.0,
+        burstMinDelay: TimeInterval = 2.0,
+        burstMaxDelay: TimeInterval = 5.0
+    ) {
+        self.availableChannelsProvider = availableChannelsProvider
+        self.locationChanges = locationChanges
+        self.torReadyPublisher = torReadyPublisher
+        self.torIsReady = torIsReady
+        self.torIsForeground = torIsForeground
+        self.deriveIdentity = deriveIdentity
+        self.relayLookup = relayLookup
+        self.relaySender = relaySender
+        self.sleeper = sleeper
+        self.scheduleTimer = scheduleTimer
+        self.loopMinInterval = loopMinInterval
+        self.loopMaxInterval = loopMaxInterval
+        self.burstMinDelay = burstMinDelay
+        self.burstMaxDelay = burstMaxDelay
+        setupObservers()
+    }
+    
+    /// Start the service (safe to call multiple times)
+    func start() {
+        SecureLogger.info("Presence: service starting...", category: .session)
+        scheduleNextHeartbeat()
+    }
+
+    private func setupObservers() {
+        // Monitor location channel changes
+        locationChanges
+            .dropFirst()
+            .sink { [weak self] _ in
+                self?.handleLocationChange()
+            }
+            .store(in: &subscriptions)
+
+        // Monitor Tor readiness to kick off heartbeat if it was stalled
+        torReadyPublisher
+            .sink { [weak self] _ in
+                self?.handleConnectivityChange()
+            }
+            .store(in: &subscriptions)
+    }
+
+    func handleLocationChange() {
+        // When location changes, we trigger an immediate (but slightly delayed) heartbeat
+        // to announce presence in the new zone, then reset the loop.
+        SecureLogger.debug("Presence: location changed, scheduling update", category: .session)
+        heartbeatTimer?.invalidate()
+        
+        // Small delay to allow location state to settle
+        heartbeatTimer = scheduleTimer(5.0) { [weak self] in
+            Task { @MainActor [weak self] in
+                self?.performHeartbeat()
+            }
+        }
+    }
+    
+    func handleConnectivityChange() {
+        SecureLogger.debug("Presence: connectivity restored, triggering heartbeat", category: .session)
+        // If we were waiting for network, do it now
+        if heartbeatTimer == nil || !heartbeatTimer!.isValid {
+            scheduleNextHeartbeat()
+        }
+    }
+
+    func scheduleNextHeartbeat() {
+        heartbeatTimer?.invalidate()
+        let interval = TimeInterval.random(in: loopMinInterval...loopMaxInterval)
+        heartbeatTimer = scheduleTimer(interval) { [weak self] in
+            Task { @MainActor [weak self] in
+                self?.performHeartbeat()
+            }
+        }
+    }
+
+    func performHeartbeat() {
+        // Always schedule next loop first ensures continuity even if this one fails/skips
+        defer { scheduleNextHeartbeat() }
+
+        // 1. Check preconditions
+        guard torIsReady() else {
+            SecureLogger.debug("Presence: skipping heartbeat (Tor not ready)", category: .session)
+            return
+        }
+        
+        // App must be active (or at least we shouldn't broadcast if in background, usually)
+        if !torIsForeground() {
+            return
+        }
+
+        // 2. Get channels
+        let channels = availableChannelsProvider()
+        guard !channels.isEmpty else { return }
+
+        // 3. Filter and broadcast
+        // We use Task + sleep for decorrelation to allow the main runloop to proceed
+        for channel in channels {
+            // Check privacy restriction
+            if !self.allowedPrecisions.contains(channel.geohash.count) {
+                continue
+            }
+            
+            // Launch independent task for each channel's delay
+            Task { @MainActor in
+                // Random delay for decorrelation
+                let delay = TimeInterval.random(in: self.burstMinDelay...self.burstMaxDelay)
+                let nanoseconds = UInt64(delay * 1_000_000_000)
+                await self.sleeper(nanoseconds)
+                
+                self.broadcastPresence(for: channel.geohash)
+            }
+        }
+    }
+
+    func broadcastPresence(for geohash: String) {
+        do {
+            guard let identity = try? deriveIdentity(geohash) else {
+                return
+            }
+            
+            let event = try NostrProtocol.createGeohashPresenceEvent(
+                geohash: geohash,
+                senderIdentity: identity
+            )
+            
+            // Send via RelayManager
+            let targetRelays = relayLookup(geohash, TransportConfig.nostrGeoRelayCount)
+            
+            if !targetRelays.isEmpty {
+                relaySender(event, targetRelays)
+                SecureLogger.debug("Presence: sent heartbeat for \(geohash) (pub=\(identity.publicKeyHex.prefix(6))...)", category: .session)
+            }
+        } catch {
+            SecureLogger.error("Presence: failed to create event for \(geohash): \(error)", category: .session)
+        }
+    }
+}

bitchat/Services/KeychainManager.swift

@@ -10,6 +10,47 @@ import BitLogger
 import Foundation
 import Security
 
+// MARK: - Keychain Error Types
+// BCH-01-009: Proper error classification to distinguish expected states from critical failures
+
+/// Result of a keychain read operation with proper error classification
+enum KeychainReadResult {
+    case success(Data)
+    case itemNotFound        // Expected: key doesn't exist yet
+    case accessDenied        // Critical: app lacks keychain access
+    case deviceLocked        // Recoverable: device is locked
+    case authenticationFailed // Recoverable: biometric/passcode failed
+    case otherError(OSStatus) // Unexpected error
+
+    var isRecoverableError: Bool {
+        switch self {
+        case .deviceLocked, .authenticationFailed:
+            return true
+        default:
+            return false
+        }
+    }
+}
+
+/// Result of a keychain save operation with proper error classification
+enum KeychainSaveResult {
+    case success
+    case duplicateItem       // Can retry with update
+    case accessDenied        // Critical: app lacks keychain access
+    case deviceLocked        // Recoverable: device is locked
+    case storageFull         // Critical: no space available
+    case otherError(OSStatus)
+
+    var isRecoverableError: Bool {
+        switch self {
+        case .duplicateItem, .deviceLocked:
+            return true
+        default:
+            return false
+        }
+    }
+}
+
 protocol KeychainManagerProtocol {
     func saveIdentityKey(_ keyData: Data, forKey key: String) -> Bool
     func getIdentityKey(forKey key: String) -> Data?
@@ -21,6 +62,12 @@ protocol KeychainManagerProtocol {
 
     func verifyIdentityKeyExists() -> Bool
 
+    // BCH-01-009: Methods with proper error classification
+    /// Get identity key with detailed result for error handling
+    func getIdentityKeyWithResult(forKey key: String) -> KeychainReadResult
+    /// Save identity key with detailed result for error handling
+    func saveIdentityKeyWithResult(_ keyData: Data, forKey key: String) -> KeychainSaveResult
+
     // MARK: - Generic Data Storage (consolidated from KeychainHelper)
     /// Save data with a custom service name
     func save(key: String, data: Data, service: String, accessible: CFString?)
@@ -54,7 +101,181 @@ final class KeychainManager: KeychainManagerProtocol {
         SecureLogger.logKeyOperation(.delete, keyType: key, success: result)
         return result
     }
-    
+
+    // MARK: - BCH-01-009: Methods with Proper Error Classification
+
+    /// Get identity key with detailed result for proper error handling
+    /// Distinguishes between missing keys (expected) and critical failures
+    func getIdentityKeyWithResult(forKey key: String) -> KeychainReadResult {
+        let fullKey = "identity_\(key)"
+        return retrieveDataWithResult(forKey: fullKey)
+    }
+
+    /// Save identity key with detailed result and retry logic for transient errors
+    func saveIdentityKeyWithResult(_ keyData: Data, forKey key: String) -> KeychainSaveResult {
+        let fullKey = "identity_\(key)"
+        return saveDataWithResult(keyData, forKey: fullKey)
+    }
+
+    /// Internal method to save data with detailed result and retry for transient errors
+    private func saveDataWithResult(_ data: Data, forKey key: String, retryCount: Int = 2) -> KeychainSaveResult {
+        // Delete any existing item first to ensure clean state
+        _ = delete(forKey: key)
+
+        // Build base query
+        var base: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: key,
+            kSecValueData as String: data,
+            kSecAttrService as String: service,
+            kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlocked,
+            kSecAttrLabel as String: "bitchat-\(key)"
+        ]
+        #if os(macOS)
+        base[kSecAttrSynchronizable as String] = false
+        #endif
+
+        func attempt(addAccessGroup: Bool) -> OSStatus {
+            var query = base
+            if addAccessGroup { query[kSecAttrAccessGroup as String] = appGroup }
+            return SecItemAdd(query as CFDictionary, nil)
+        }
+
+        #if os(iOS)
+        var status = attempt(addAccessGroup: true)
+        if status == -34018 { // Missing entitlement, retry without access group
+            status = attempt(addAccessGroup: false)
+        }
+        #else
+        let status = attempt(addAccessGroup: false)
+        #endif
+
+        // Classify the result
+        let result = classifySaveStatus(status)
+
+        // Log all outcomes consistently
+        switch result {
+        case .success:
+            SecureLogger.debug("Keychain save succeeded for key: \(key)", category: .keychain)
+        case .duplicateItem:
+            SecureLogger.warning("Keychain save found duplicate for key: \(key)", category: .keychain)
+        case .accessDenied:
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Keychain access denied for key: \(key)", category: .keychain)
+        case .deviceLocked:
+            SecureLogger.warning("Device locked during keychain save for key: \(key)", category: .keychain)
+        case .storageFull:
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Keychain storage full for key: \(key)", category: .keychain)
+        case .otherError(let code):
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(code)),
+                               context: "Keychain save failed for key: \(key)", category: .keychain)
+        }
+
+        // Retry transient errors with exponential backoff
+        if result.isRecoverableError && retryCount > 0 {
+            let delayMs = UInt32((3 - retryCount) * 100) // 100ms, 200ms backoff
+            usleep(delayMs * 1000)
+            SecureLogger.debug("Retrying keychain save for key: \(key), attempts remaining: \(retryCount)", category: .keychain)
+            return saveDataWithResult(data, forKey: key, retryCount: retryCount - 1)
+        }
+
+        return result
+    }
+
+    /// Internal method to retrieve data with detailed result
+    private func retrieveDataWithResult(forKey key: String) -> KeychainReadResult {
+        let base: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: key,
+            kSecAttrService as String: service,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne
+        ]
+
+        var result: AnyObject?
+        func attempt(withAccessGroup: Bool) -> OSStatus {
+            var q = base
+            if withAccessGroup { q[kSecAttrAccessGroup as String] = appGroup }
+            return SecItemCopyMatching(q as CFDictionary, &result)
+        }
+
+        #if os(iOS)
+        var status = attempt(withAccessGroup: true)
+        if status == -34018 { status = attempt(withAccessGroup: false) }
+        #else
+        let status = attempt(withAccessGroup: false)
+        #endif
+
+        // Classify the result
+        let readResult = classifyReadStatus(status, data: result as? Data)
+
+        // Log all outcomes consistently
+        switch readResult {
+        case .success:
+            SecureLogger.debug("Keychain read succeeded for key: \(key)", category: .keychain)
+        case .itemNotFound:
+            // Expected case - no logging needed for missing keys
+            break
+        case .accessDenied:
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Keychain access denied for key: \(key)", category: .keychain)
+        case .deviceLocked:
+            SecureLogger.warning("Device locked during keychain read for key: \(key)", category: .keychain)
+        case .authenticationFailed:
+            SecureLogger.warning("Authentication failed for keychain read of key: \(key)", category: .keychain)
+        case .otherError(let code):
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(code)),
+                               context: "Keychain read failed for key: \(key)", category: .keychain)
+        }
+
+        return readResult
+    }
+
+    /// Classify keychain read status into meaningful categories
+    private func classifyReadStatus(_ status: OSStatus, data: Data?) -> KeychainReadResult {
+        switch status {
+        case errSecSuccess:
+            if let data = data {
+                return .success(data)
+            }
+            return .otherError(status)
+        case errSecItemNotFound:
+            return .itemNotFound
+        case errSecInteractionNotAllowed:
+            // Device is locked or in a state that doesn't allow keychain access
+            return .deviceLocked
+        case errSecAuthFailed:
+            return .authenticationFailed
+        case -34018: // errSecMissingEntitlement
+            return .accessDenied
+        case errSecNotAvailable:
+            return .accessDenied
+        default:
+            return .otherError(status)
+        }
+    }
+
+    /// Classify keychain save status into meaningful categories
+    private func classifySaveStatus(_ status: OSStatus) -> KeychainSaveResult {
+        switch status {
+        case errSecSuccess:
+            return .success
+        case errSecDuplicateItem:
+            return .duplicateItem
+        case errSecInteractionNotAllowed:
+            return .deviceLocked
+        case -34018: // errSecMissingEntitlement
+            return .accessDenied
+        case errSecNotAvailable:
+            return .accessDenied
+        case errSecDiskFull:
+            return .storageFull
+        default:
+            return .otherError(status)
+        }
+    }
+
     // MARK: - Generic Operations
     
     private func save(_ value: String, forKey key: String) -> Bool {

bitchat/Services/LocationNotesManager.swift

@@ -63,7 +63,7 @@ final class LocationNotesManager: ObservableObject {
 
         var displayName: String {
             let suffix = String(pubkey.suffix(4))
-            if let nick = nickname, !nick.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+            if let nick = nickname?.trimmedOrNilIfEmpty {
                 return "\(nick)#\(suffix)"
             }
             return "anon#\(suffix)"
@@ -199,8 +199,7 @@ final class LocationNotesManager: ObservableObject {
 
     /// Send a location note for the current geohash using the per-geohash identity.
     func send(content: String, nickname: String) {
-        let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let trimmed = content.trimmedOrNilIfEmpty else { return }
-        guard !trimmed.isEmpty else { return }
         let relays = dependencies.relayLookup(geohash, TransportConfig.nostrGeoRelayCount)
         guard !relays.isEmpty else {
             state = .noRelays

bitchat/Services/LocationStateManager.swift

@@ -5,6 +5,79 @@ import Combine
 #if os(iOS) || os(macOS)
 import CoreLocation
 
+protocol LocationStateManaging: AnyObject {
+    var delegate: CLLocationManagerDelegate? { get set }
+    var desiredAccuracy: CLLocationAccuracy { get set }
+    var distanceFilter: CLLocationDistance { get set }
+    var authorizationStatus: CLAuthorizationStatus { get }
+    func requestWhenInUseAuthorization()
+    func requestLocation()
+    func startUpdatingLocation()
+    func stopUpdatingLocation()
+}
+
+protocol LocationStateGeocoding: AnyObject {
+    func cancelGeocode()
+    func reverseGeocodeLocation(
+        _ location: CLLocation,
+        completionHandler: @escaping ([CLPlacemark]?, Error?) -> Void
+    )
+}
+
+private final class CLLocationManagerAdapter: NSObject, LocationStateManaging {
+    private let base = CLLocationManager()
+
+    var delegate: CLLocationManagerDelegate? {
+        get { base.delegate }
+        set { base.delegate = newValue }
+    }
+
+    var desiredAccuracy: CLLocationAccuracy {
+        get { base.desiredAccuracy }
+        set { base.desiredAccuracy = newValue }
+    }
+
+    var distanceFilter: CLLocationDistance {
+        get { base.distanceFilter }
+        set { base.distanceFilter = newValue }
+    }
+
+    var authorizationStatus: CLAuthorizationStatus {
+        base.authorizationStatus
+    }
+
+    func requestWhenInUseAuthorization() {
+        base.requestWhenInUseAuthorization()
+    }
+
+    func requestLocation() {
+        base.requestLocation()
+    }
+
+    func startUpdatingLocation() {
+        base.startUpdatingLocation()
+    }
+
+    func stopUpdatingLocation() {
+        base.stopUpdatingLocation()
+    }
+}
+
+private final class CLGeocoderAdapter: LocationStateGeocoding {
+    private let base = CLGeocoder()
+
+    func cancelGeocode() {
+        base.cancelGeocode()
+    }
+
+    func reverseGeocodeLocation(
+        _ location: CLLocation,
+        completionHandler: @escaping ([CLPlacemark]?, Error?) -> Void
+    ) {
+        base.reverseGeocodeLocation(location, completionHandler: completionHandler)
+    }
+}
+
 /// Unified manager for location-based channel state including:
 /// - CoreLocation permissions and one-shot location retrieval
 /// - Geohash channel computation from coordinates
@@ -26,8 +99,8 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl
 
     // MARK: - Private Properties (CoreLocation)
 
-    private let cl = CLLocationManager()
+    private let cl: LocationStateManaging
-    private let geocoder = CLGeocoder()
+    private let geocoder: LocationStateGeocoding
     private var lastLocation: CLLocation?
     private var refreshTimer: Timer?
     private var isGeocoding: Bool = false
@@ -73,6 +146,8 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl
 
     private override init() {
         self.storage = .standard
+        self.cl = CLLocationManagerAdapter()
+        self.geocoder = CLGeocoderAdapter()
         super.init()
 
         // Skip CoreLocation setup in test environments
@@ -92,10 +167,30 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl
     /// Internal initializer for testing with custom storage
     init(storage: UserDefaults) {
         self.storage = storage
+        self.cl = CLLocationManagerAdapter()
+        self.geocoder = CLGeocoderAdapter()
         super.init()
         loadPersistedState()
     }
 
+    internal init(
+        storage: UserDefaults,
+        locationManager: LocationStateManaging,
+        geocoder: LocationStateGeocoding,
+        shouldInitializeCoreLocation: Bool
+    ) {
+        self.storage = storage
+        self.cl = locationManager
+        self.geocoder = geocoder
+        super.init()
+        loadPersistedState()
+        guard shouldInitializeCoreLocation else { return }
+        cl.delegate = self
+        cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
+        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters
+        initializePermissionState()
+    }
+
     private func loadPersistedState() {
         // Load selected channel
         if let data = storage.data(forKey: selectedChannelKey),
@@ -132,12 +227,7 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl
     }
 
     private func initializePermissionState() {
-        let status: CLAuthorizationStatus
+        let status = cl.authorizationStatus
-        if #available(iOS 14.0, macOS 11.0, *) {
-            status = cl.authorizationStatus
-        } else {
-            status = CLLocationManager.authorizationStatus()
-        }
         updatePermissionState(from: status)
 
         // Fall back to persisted teleport state if no location authorization
@@ -156,12 +246,7 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl
     // MARK: - Public API (Permissions & Location)
 
     func enableLocationChannels() {
-        let status: CLAuthorizationStatus
+        let status = cl.authorizationStatus
-        if #available(iOS 14.0, macOS 11.0, *) {
-            status = cl.authorizationStatus
-        } else {
-            status = CLLocationManager.authorizationStatus()
-        }
         switch status {
         case .notDetermined:
             cl.requestWhenInUseAuthorization()
@@ -512,7 +597,7 @@ final class LocationStateManager: NSObject, CLLocationManagerDelegate, Observabl
     private static func normalizeGeohash(_ s: String) -> String {
         let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
         return s
-            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .trimmed
             .lowercased()
             .replacingOccurrences(of: "#", with: "")
             .filter { allowed.contains($0) }

bitchat/Services/MeshTopologyTracker.swift

@@ -6,104 +6,114 @@ final class MeshTopologyTracker {
 
     private let queue = DispatchQueue(label: "mesh.topology", attributes: .concurrent)
     private let hopSize = 8
-    private var adjacency: [RoutingID: Set<RoutingID>] = [:]
+    // Directed claims: Key claims to see Value (neighbors)
+    private var claims: [RoutingID: Set<RoutingID>] = [:]
+    // Last time we received an update from a node
+    private var lastSeen: [RoutingID: Date] = [:]
+
+    // Maximum age for topology claims to be considered fresh for routing
+    // Routes computed using stale topology can fail when the network has changed
+    private static let routeFreshnessThreshold: TimeInterval = 60 // 60 seconds
 
     func reset() {
         queue.sync(flags: .barrier) {
-            self.adjacency.removeAll()
+            self.claims.removeAll()
+            self.lastSeen.removeAll()
         }
     }
 
-    func recordDirectLink(between a: Data?, and b: Data?) {
+    /// Update the topology with a node's self-reported neighbor list
-        guard let left = sanitize(a), let right = sanitize(b), left != right else { return }
+    func updateNeighbors(for sourceData: Data?, neighbors: [Data]) {
+        guard let source = sanitize(sourceData) else { return }
+        // Sanitize neighbors and exclude self-loops
+        let validNeighbors = Set(neighbors.compactMap { sanitize($0) }).subtracting([source])
+        
         queue.sync(flags: .barrier) {
-            var setA = self.adjacency[left] ?? []
+            self.claims[source] = validNeighbors
-            setA.insert(right)
+            self.lastSeen[source] = Date()
-            self.adjacency[left] = setA
-
-            var setB = self.adjacency[right] ?? []
-            setB.insert(left)
-            self.adjacency[right] = setB
-        }
-    }
-
-    func removeDirectLink(between a: Data?, and b: Data?) {
-        guard let left = sanitize(a), let right = sanitize(b), left != right else { return }
-        queue.sync(flags: .barrier) {
-            if var setA = self.adjacency[left] {
-                setA.remove(right)
-                self.adjacency[left] = setA.isEmpty ? nil : setA
-            }
-            if var setB = self.adjacency[right] {
-                setB.remove(left)
-                self.adjacency[right] = setB.isEmpty ? nil : setB
-            }
         }
     }
 
     func removePeer(_ data: Data?) {
         guard let peer = sanitize(data) else { return }
         queue.sync(flags: .barrier) {
-            guard let neighbors = self.adjacency.removeValue(forKey: peer) else { return }
+            self.claims.removeValue(forKey: peer)
-            for neighbor in neighbors {
+            self.lastSeen.removeValue(forKey: peer)
-                if var set = self.adjacency[neighbor] {
-                    set.remove(peer)
-                    self.adjacency[neighbor] = set.isEmpty ? nil : set
-                }
-            }
         }
     }
-
+    
-    func recordRoute(_ hops: [Data]) {
+    /// Prune nodes that haven't updated their topology in `age` seconds
-        let sanitized = hops.compactMap { sanitize($0) }
+    func prune(olderThan age: TimeInterval) {
-        guard sanitized.count >= 2 else { return }
+        let deadline = Date().addingTimeInterval(-age)
         queue.sync(flags: .barrier) {
-            for idx in 0..<(sanitized.count - 1) {
+            let stale = self.lastSeen.filter { $0.value < deadline }
-                let left = sanitized[idx]
+            for (peer, _) in stale {
-                let right = sanitized[idx + 1]
+                self.claims.removeValue(forKey: peer)
-                guard left != right else { continue }
+                self.lastSeen.removeValue(forKey: peer)
-
-                var setA = self.adjacency[left] ?? []
-                setA.insert(right)
-                self.adjacency[left] = setA
-
-                var setB = self.adjacency[right] ?? []
-                setB.insert(left)
-                self.adjacency[right] = setB
             }
         }
     }
 
-    func computeRoute(from start: Data?, to goal: Data?, maxHops: Int = 255) -> [Data]? {
+    func computeRoute(from start: Data?, to goal: Data?, maxHops: Int = 10) -> [Data]? {
         guard let source = sanitize(start), let target = sanitize(goal) else { return nil }
-        if source == target { return [source] }
+        if source == target { return [] } // Direct connection, no intermediate hops
 
-        let graph = queue.sync { adjacency }
+        return queue.sync {
-        guard graph[source] != nil, graph[target] != nil else { return nil }
+            let now = Date()
+            let freshnessDeadline = now.addingTimeInterval(-Self.routeFreshnessThreshold)
 
-        var visited: Set<RoutingID> = [source]
+            // BFS
-        var queuePaths: [[RoutingID]] = [[source]]
+            var visited: Set<RoutingID> = [source]
-        var index = 0
+            // Queue stores paths: [Start, Hop1, Hop2, ..., Current]
+            var queuePaths: [[RoutingID]] = [[source]]
 
-        while index < queuePaths.count {
+            while !queuePaths.isEmpty {
-            let path = queuePaths[index]
+                let path = queuePaths.removeFirst()
-            index += 1
+                // Limit path length (path contains source + maxHops + target) -> maxHops intermediate
-            guard path.count <= maxHops else { continue }
+                // If maxHops = 10, max edges = 11, max nodes = 12.
-            guard let last = path.last, let neighbors = graph[last] else { continue }
+                if path.count > maxHops + 1 { continue }
 
-            for neighbor in neighbors {
+                guard let last = path.last else { continue }
-                if visited.contains(neighbor) { continue }
+
-                var nextPath = path
+                // Get neighbors that 'last' claims to see
-                nextPath.append(neighbor)
+                guard let neighbors = claims[last] else { continue }
-                if neighbor == target { return nextPath }
+
-                if nextPath.count <= maxHops {
+                // Check if 'last' node's topology info is fresh
+                guard let lastSeenTime = lastSeen[last], lastSeenTime > freshnessDeadline else {
+                    continue // Skip stale nodes
+                }
+
+                for neighbor in neighbors {
+                    if visited.contains(neighbor) { continue }
+
+                    // CONFIRMED EDGE CHECK:
+                    // 'last' claims 'neighbor' (checked above)
+                    // Does 'neighbor' claim 'last'?
+                    guard let neighborClaims = claims[neighbor],
+                          neighborClaims.contains(last) else {
+                        continue
+                    }
+
+                    // Check if 'neighbor' node's topology info is fresh
+                    guard let neighborSeenTime = lastSeen[neighbor], neighborSeenTime > freshnessDeadline else {
+                        continue // Skip edges to stale nodes
+                    }
+
+                    var nextPath = path
+                    nextPath.append(neighbor)
+
+                    if neighbor == target {
+                        // Return only intermediate hops
+                        // Path: [Source, I1, I2, Target] -> [I1, I2]
+                        return Array(nextPath.dropFirst().dropLast())
+                    }
+
+                    visited.insert(neighbor)
                     queuePaths.append(nextPath)
                 }
-                visited.insert(neighbor)
             }
+            return nil
         }
-
-        return nil
     }
 
     // MARK: - Helpers

bitchat/Services/MessageDeduplicationService.swift

@@ -145,7 +145,7 @@ enum ContentNormalizer {
         }
 
         // Trim and collapse whitespace
-        let trimmed = simplified.trimmingCharacters(in: .whitespacesAndNewlines)
+        let trimmed = simplified.trimmed
         let collapsed = trimmed.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression)
 
         // Take prefix and hash

bitchat/Services/MessageRouter.swift

@@ -5,7 +5,20 @@ import Foundation
 @MainActor
 final class MessageRouter {
     private let transports: [Transport]
-    private var outbox: [PeerID: [(content: String, nickname: String, messageID: String)]] = [:] // peerID -> queued messages
+
+    // Outbox entry with timestamp for TTL-based eviction
+    private struct QueuedMessage {
+        let content: String
+        let nickname: String
+        let messageID: String
+        let timestamp: Date
+    }
+
+    private var outbox: [PeerID: [QueuedMessage]] = [:]
+
+    // Outbox limits to prevent unbounded memory growth
+    private static let maxMessagesPerPeer = 100
+    private static let messageTTLSeconds: TimeInterval = 24 * 60 * 60 // 24 hours
 
     init(transports: [Transport]) {
         self.transports = transports
@@ -34,52 +47,60 @@ final class MessageRouter {
         }
     }
 
+    // MARK: - Transport Selection
+
+    private func reachableTransport(for peerID: PeerID) -> Transport? {
+        transports.first { $0.isPeerReachable(peerID) }
+    }
+
+    private func connectedTransport(for peerID: PeerID) -> Transport? {
+        transports.first { $0.isPeerConnected(peerID) }
+    }
+
+    // MARK: - Message Sending
+
     func sendPrivate(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String) {
-        // Try to find a reachable transport
+        if let transport = reachableTransport(for: peerID) {
-        if let transport = transports.first(where: { $0.isPeerReachable(peerID) }) {
             SecureLogger.debug("Routing PM via \(type(of: transport)) to \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
             transport.sendPrivateMessage(content, to: peerID, recipientNickname: recipientNickname, messageID: messageID)
         } else {
-            // Queue for later
+            // Queue for later with timestamp for TTL tracking
             if outbox[peerID] == nil { outbox[peerID] = [] }
-            outbox[peerID]?.append((content, recipientNickname, messageID))
+
-            SecureLogger.debug("Queued PM for \(peerID.id.prefix(8))… (no reachable transport) id=\(messageID.prefix(8))…", category: .session)
+            let message = QueuedMessage(content: content, nickname: recipientNickname, messageID: messageID, timestamp: Date())
+            outbox[peerID]?.append(message)
+
+            // Enforce per-peer size limit with FIFO eviction
+            if let count = outbox[peerID]?.count, count > Self.maxMessagesPerPeer {
+                let evicted = outbox[peerID]?.removeFirst()
+                SecureLogger.warning("📤 Outbox overflow for \(peerID.id.prefix(8))… - evicted oldest message: \(evicted?.messageID.prefix(8) ?? "?")…", category: .session)
+            }
+
+            SecureLogger.debug("Queued PM for \(peerID.id.prefix(8))… (no reachable transport) id=\(messageID.prefix(8))… queue=\(outbox[peerID]?.count ?? 0)", category: .session)
         }
     }
 
     func sendReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID) {
-        if let transport = transports.first(where: { $0.isPeerReachable(peerID) }) {
+        if let transport = reachableTransport(for: peerID) {
             SecureLogger.debug("Routing READ ack via \(type(of: transport)) to \(peerID.id.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…", category: .session)
             transport.sendReadReceipt(receipt, to: peerID)
         } else if !transports.isEmpty {
-            // Fallback to last transport (usually Nostr) if neither is explicitly reachable?
-            // Or better: just try the first one that supports it?
-            // Existing logic preferred mesh, then nostr.
-            // If neither reachable, existing logic queued it (via mesh usually) or sent via nostr.
-            // Let's stick to "try reachable". If none, maybe pick the first one to queue?
-            // Actually, for READ receipts, we might want to just fire-and-forget on the "best effort" transport.
-            // But let's stick to the reachable check.
             SecureLogger.debug("No reachable transport for READ ack to \(peerID.id.prefix(8))…", category: .session)
         }
     }
 
     func sendDeliveryAck(_ messageID: String, to peerID: PeerID) {
-        if let transport = transports.first(where: { $0.isPeerReachable(peerID) }) {
+        if let transport = reachableTransport(for: peerID) {
             SecureLogger.debug("Routing DELIVERED ack via \(type(of: transport)) to \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
             transport.sendDeliveryAck(for: messageID, to: peerID)
         }
     }
 
     func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool) {
-        if let transport = transports.first(where: { $0.isPeerConnected(peerID) }) {
+        if let transport = connectedTransport(for: peerID) {
+            transport.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
+        } else if let transport = reachableTransport(for: peerID) {
             transport.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
-        } else if let transport = transports.first(where: { $0.isPeerReachable(peerID) }) {
-             transport.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
-        } else {
-            // Fallback: try all? or just the last one?
-            // Old logic: if mesh connected, mesh. Else nostr.
-            // Note: NostrTransport.isPeerReachable now returns true if mapped.
-            // If not mapped, we can't send via Nostr anyway.
         }
     }
 
@@ -88,17 +109,25 @@ final class MessageRouter {
     func flushOutbox(for peerID: PeerID) {
         guard let queued = outbox[peerID], !queued.isEmpty else { return }
         SecureLogger.debug("Flushing outbox for \(peerID.id.prefix(8))… count=\(queued.count)", category: .session)
-        var remaining: [(content: String, nickname: String, messageID: String)] = []
+
-        
+        let now = Date()
-        for (content, nickname, messageID) in queued {
+        var remaining: [QueuedMessage] = []
-            if let transport = transports.first(where: { $0.isPeerReachable(peerID) }) {
+
-                SecureLogger.debug("Outbox -> \(type(of: transport)) for \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+        for message in queued {
-                transport.sendPrivateMessage(content, to: peerID, recipientNickname: nickname, messageID: messageID)
+            // Skip expired messages (TTL exceeded)
+            if now.timeIntervalSince(message.timestamp) > Self.messageTTLSeconds {
+                SecureLogger.debug("⏰ Expired queued message for \(peerID.id.prefix(8))… id=\(message.messageID.prefix(8))… (age: \(Int(now.timeIntervalSince(message.timestamp)))s)", category: .session)
+                continue
+            }
+
+            if let transport = reachableTransport(for: peerID) {
+                SecureLogger.debug("Outbox -> \(type(of: transport)) for \(peerID.id.prefix(8))… id=\(message.messageID.prefix(8))…", category: .session)
+                transport.sendPrivateMessage(message.content, to: peerID, recipientNickname: message.nickname, messageID: message.messageID)
             } else {
-                remaining.append((content, nickname, messageID))
+                remaining.append(message)
             }
         }
-        
+
         if remaining.isEmpty {
             outbox.removeValue(forKey: peerID)
         } else {
@@ -109,4 +138,15 @@ final class MessageRouter {
     func flushAllOutbox() {
         for key in Array(outbox.keys) { flushOutbox(for: key) }
     }
+
+    /// Periodically clean up expired messages from all outboxes
+    func cleanupExpiredMessages() {
+        let now = Date()
+        for peerID in Array(outbox.keys) {
+            outbox[peerID]?.removeAll { now.timeIntervalSince($0.timestamp) > Self.messageTTLSeconds }
+            if outbox[peerID]?.isEmpty == true {
+                outbox.removeValue(forKey: peerID)
+            }
+        }
+    }
 }

bitchat/Services/NetworkActivationService.swift

@@ -3,6 +3,27 @@ import BitLogger
 import Combine
 import Tor
 
+@MainActor
+protocol NetworkActivationTorControlling: AnyObject {
+    func setAutoStartAllowed(_ allowed: Bool)
+    func startIfNeeded()
+    func shutdownCompletely()
+}
+
+@MainActor
+protocol NetworkActivationRelayControlling: AnyObject {
+    func connect()
+    func disconnect()
+}
+
+protocol NetworkActivationProxyControlling: AnyObject {
+    func setProxyMode(useTor: Bool)
+}
+
+extension TorManager: NetworkActivationTorControlling {}
+extension NostrRelayManager: NetworkActivationRelayControlling {}
+extension TorURLSession: NetworkActivationProxyControlling {}
+
 /// Coordinates when the app is allowed to start Tor and connect to Nostr relays.
 /// Policy: permit start when either location permissions are authorized OR
 /// there exists at least one mutual favorite. Otherwise, do not start.
@@ -17,14 +38,55 @@ final class NetworkActivationService: ObservableObject {
     private var started = false
     private let torPreferenceKey = "networkActivationService.userTorEnabled"
     private var torAutoStartDesired: Bool = false
+    private let storage: UserDefaults
+    private let locationPermissionPublisher: AnyPublisher<LocationChannelManager.PermissionState, Never>
+    private let mutualFavoritesPublisher: AnyPublisher<Set<Data>, Never>
+    private let permissionProvider: () -> LocationChannelManager.PermissionState
+    private let mutualFavoritesProvider: () -> Set<Data>
+    private let torController: NetworkActivationTorControlling
+    private let relayController: NetworkActivationRelayControlling
+    private let proxyController: NetworkActivationProxyControlling
+    private let notificationCenter: NotificationCenter
 
-    private init() {}
+    private init() {
+        storage = .standard
+        locationPermissionPublisher = LocationChannelManager.shared.$permissionState.eraseToAnyPublisher()
+        mutualFavoritesPublisher = FavoritesPersistenceService.shared.$mutualFavorites.eraseToAnyPublisher()
+        permissionProvider = { LocationChannelManager.shared.permissionState }
+        mutualFavoritesProvider = { FavoritesPersistenceService.shared.mutualFavorites }
+        torController = TorManager.shared
+        relayController = NostrRelayManager.shared
+        proxyController = TorURLSession.shared
+        notificationCenter = .default
+    }
+
+    internal init(
+        storage: UserDefaults,
+        locationPermissionPublisher: AnyPublisher<LocationChannelManager.PermissionState, Never>,
+        mutualFavoritesPublisher: AnyPublisher<Set<Data>, Never>,
+        permissionProvider: @escaping () -> LocationChannelManager.PermissionState,
+        mutualFavoritesProvider: @escaping () -> Set<Data>,
+        torController: NetworkActivationTorControlling,
+        relayController: NetworkActivationRelayControlling,
+        proxyController: NetworkActivationProxyControlling,
+        notificationCenter: NotificationCenter = .default
+    ) {
+        self.storage = storage
+        self.locationPermissionPublisher = locationPermissionPublisher
+        self.mutualFavoritesPublisher = mutualFavoritesPublisher
+        self.permissionProvider = permissionProvider
+        self.mutualFavoritesProvider = mutualFavoritesProvider
+        self.torController = torController
+        self.relayController = relayController
+        self.proxyController = proxyController
+        self.notificationCenter = notificationCenter
+    }
 
     func start() {
         guard !started else { return }
         started = true
 
-        if let stored = UserDefaults.standard.object(forKey: torPreferenceKey) as? Bool {
+        if let stored = storage.object(forKey: torPreferenceKey) as? Bool {
             userTorEnabled = stored
         } else {
             userTorEnabled = true
@@ -34,16 +96,16 @@ final class NetworkActivationService: ObservableObject {
         let allowed = basePolicyAllowed()
         activationAllowed = allowed
         torAutoStartDesired = allowed && userTorEnabled
-        TorManager.shared.setAutoStartAllowed(torAutoStartDesired)
+        torController.setAutoStartAllowed(torAutoStartDesired)
         applyTorState(torDesired: torAutoStartDesired)
         if allowed {
-            NostrRelayManager.shared.connect()
+            relayController.connect()
         } else {
-            NostrRelayManager.shared.disconnect()
+            relayController.disconnect()
         }
 
         // React to location permission changes
-        LocationChannelManager.shared.$permissionState
+        locationPermissionPublisher
             .receive(on: DispatchQueue.main)
             .sink { [weak self] _ in
                 self?.reevaluate()
@@ -51,7 +113,7 @@ final class NetworkActivationService: ObservableObject {
             .store(in: &cancellables)
 
         // React to mutual favorites changes
-        FavoritesPersistenceService.shared.$mutualFavorites
+        mutualFavoritesPublisher
             .receive(on: DispatchQueue.main)
             .sink { [weak self] _ in
                 self?.reevaluate()
@@ -62,8 +124,8 @@ final class NetworkActivationService: ObservableObject {
     func setUserTorEnabled(_ enabled: Bool) {
         guard enabled != userTorEnabled else { return }
         userTorEnabled = enabled
-        UserDefaults.standard.set(enabled, forKey: torPreferenceKey)
+        storage.set(enabled, forKey: torPreferenceKey)
-        NotificationCenter.default.post(
+        notificationCenter.post(
             name: .TorUserPreferenceChanged,
             object: nil,
             userInfo: ["enabled": enabled]
@@ -82,33 +144,33 @@ final class NetworkActivationService: ObservableObject {
         }
         if statusChanged || torChanged {
             torAutoStartDesired = torDesired
-            TorManager.shared.setAutoStartAllowed(torDesired)
+            torController.setAutoStartAllowed(torDesired)
             applyTorState(torDesired: torDesired)
         }
 
         if allowed {
             if torChanged {
                 // Reset relay sockets when switching transport path (Tor ↔︎ direct)
-                NostrRelayManager.shared.disconnect()
+                relayController.disconnect()
             }
-            NostrRelayManager.shared.connect()
+            relayController.connect()
         } else if statusChanged {
-            NostrRelayManager.shared.disconnect()
+            relayController.disconnect()
         }
     }
 
     private func basePolicyAllowed() -> Bool {
-        let permOK = LocationChannelManager.shared.permissionState == .authorized
+        let permOK = permissionProvider() == .authorized
-        let hasMutual = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
+        let hasMutual = !mutualFavoritesProvider().isEmpty
         return permOK || hasMutual
     }
 
     private func applyTorState(torDesired: Bool) {
-        TorURLSession.shared.setProxyMode(useTor: torDesired)
+        proxyController.setProxyMode(useTor: torDesired)
         if torDesired {
-            TorManager.shared.startIfNeeded()
+            torController.startIfNeeded()
         } else {
-            TorManager.shared.shutdownCompletely()
+            torController.shutdownCompletely()
         }
     }
 }

bitchat/Services/NoiseEncryptionService.swift

@@ -199,64 +199,153 @@ final class NoiseEncryptionService {
     
     init(keychain: KeychainManagerProtocol) {
         self.keychain = keychain
-        
+
-        // Load or create static identity key (ONLY from keychain)
+        // BCH-01-009: Load or create static identity key with proper error handling
         let loadedKey: Curve25519.KeyAgreement.PrivateKey
-        
+
-        // Try to load from keychain
+        // Try to load from keychain with proper error classification
-        if let identityData = keychain.getIdentityKey(forKey: "noiseStaticKey"),
+        let noiseKeyResult = keychain.getIdentityKeyWithResult(forKey: "noiseStaticKey")
-           let key = try? Curve25519.KeyAgreement.PrivateKey(rawRepresentation: identityData) {
+
-            loadedKey = key
+        switch noiseKeyResult {
-            SecureLogger.logKeyOperation(.load, keyType: "noiseStaticKey", success: true)
+        case .success(let identityData):
-        }
+            if let key = try? Curve25519.KeyAgreement.PrivateKey(rawRepresentation: identityData) {
-        // If no identity exists, create new one
+                loadedKey = key
-        else {
+                SecureLogger.logKeyOperation(.load, keyType: "noiseStaticKey", success: true)
+            } else {
+                // Data corrupted, regenerate
+                SecureLogger.warning("Noise static key data corrupted, regenerating", category: .keychain)
+                loadedKey = Self.generateAndSaveNoiseKey(keychain: keychain)
+            }
+
+        case .itemNotFound:
+            // Expected case: no key exists yet, create new one
+            loadedKey = Self.generateAndSaveNoiseKey(keychain: keychain)
+
+        case .accessDenied:
+            // Critical error - log but proceed with ephemeral key (will be lost on restart)
+            SecureLogger.error(NSError(domain: "Keychain", code: -1),
+                               context: "Keychain access denied - using ephemeral identity", category: .keychain)
+            loadedKey = Curve25519.KeyAgreement.PrivateKey()
+
+        case .deviceLocked, .authenticationFailed:
+            // Recoverable error - use ephemeral key and warn
+            SecureLogger.warning("Device locked or auth failed - using ephemeral identity until unlocked", category: .keychain)
+            loadedKey = Curve25519.KeyAgreement.PrivateKey()
+
+        case .otherError(let status):
+            // Unexpected error - log and use ephemeral key
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Unexpected keychain error - using ephemeral identity", category: .keychain)
             loadedKey = Curve25519.KeyAgreement.PrivateKey()
-            let keyData = loadedKey.rawRepresentation
-            
-            // Save to keychain
-            let saved = keychain.saveIdentityKey(keyData, forKey: "noiseStaticKey")
-            SecureLogger.logKeyOperation(.create, keyType: "noiseStaticKey", success: saved)
         }
-        
+
         // Now assign the final value
         self.staticIdentityKey = loadedKey
         self.staticIdentityPublicKey = staticIdentityKey.publicKey
-        
+
-        // Load or create signing key pair
+        // BCH-01-009: Load or create signing key pair with proper error handling
         let loadedSigningKey: Curve25519.Signing.PrivateKey
-        
+
-        // Try to load from keychain
+        let signingKeyResult = keychain.getIdentityKeyWithResult(forKey: "ed25519SigningKey")
-        if let signingData = keychain.getIdentityKey(forKey: "ed25519SigningKey"),
+
-           let key = try? Curve25519.Signing.PrivateKey(rawRepresentation: signingData) {
+        switch signingKeyResult {
-            loadedSigningKey = key
+        case .success(let signingData):
-            SecureLogger.logKeyOperation(.load, keyType: "ed25519SigningKey", success: true)
+            if let key = try? Curve25519.Signing.PrivateKey(rawRepresentation: signingData) {
-        }
+                loadedSigningKey = key
-        // If no signing key exists, create new one
+                SecureLogger.logKeyOperation(.load, keyType: "ed25519SigningKey", success: true)
-        else {
+            } else {
+                // Data corrupted, regenerate
+                SecureLogger.warning("Ed25519 signing key data corrupted, regenerating", category: .keychain)
+                loadedSigningKey = Self.generateAndSaveSigningKey(keychain: keychain)
+            }
+
+        case .itemNotFound:
+            // Expected case: no key exists yet, create new one
+            loadedSigningKey = Self.generateAndSaveSigningKey(keychain: keychain)
+
+        case .accessDenied:
+            // Critical error - log but proceed with ephemeral key
+            SecureLogger.error(NSError(domain: "Keychain", code: -1),
+                               context: "Keychain access denied - using ephemeral signing key", category: .keychain)
+            loadedSigningKey = Curve25519.Signing.PrivateKey()
+
+        case .deviceLocked, .authenticationFailed:
+            // Recoverable error - use ephemeral key and warn
+            SecureLogger.warning("Device locked or auth failed - using ephemeral signing key until unlocked", category: .keychain)
+            loadedSigningKey = Curve25519.Signing.PrivateKey()
+
+        case .otherError(let status):
+            // Unexpected error - log and use ephemeral key
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Unexpected keychain error - using ephemeral signing key", category: .keychain)
             loadedSigningKey = Curve25519.Signing.PrivateKey()
-            let keyData = loadedSigningKey.rawRepresentation
-            
-            // Save to keychain
-            let saved = keychain.saveIdentityKey(keyData, forKey: "ed25519SigningKey")
-            SecureLogger.logKeyOperation(.create, keyType: "ed25519SigningKey", success: saved)
         }
-        
+
         // Now assign the signing keys
         self.signingKey = loadedSigningKey
         self.signingPublicKey = signingKey.publicKey
-        
+
         // Initialize session manager
         self.sessionManager = NoiseSessionManager(localStaticKey: staticIdentityKey, keychain: keychain)
-        
+
         // Set up session callbacks
         sessionManager.onSessionEstablished = { [weak self] peerID, remoteStaticKey in
             self?.handleSessionEstablished(peerID: peerID, remoteStaticKey: remoteStaticKey)
         }
-        
+
         // Start session maintenance timer
         startRekeyTimer()
     }
+
+    // MARK: - BCH-01-009: Key Generation Helpers with Save Verification
+
+    /// Generate and save a new Noise static key, verifying the save succeeds
+    private static func generateAndSaveNoiseKey(keychain: KeychainManagerProtocol) -> Curve25519.KeyAgreement.PrivateKey {
+        let newKey = Curve25519.KeyAgreement.PrivateKey()
+        let keyData = newKey.rawRepresentation
+
+        // Save to keychain and verify success
+        let saveResult = keychain.saveIdentityKeyWithResult(keyData, forKey: "noiseStaticKey")
+
+        switch saveResult {
+        case .success:
+            SecureLogger.logKeyOperation(.create, keyType: "noiseStaticKey", success: true)
+        case .duplicateItem:
+            // This shouldn't happen since we just tried to load, but handle it
+            SecureLogger.warning("Noise key already exists (race condition?)", category: .keychain)
+        default:
+            // Save failed - log but continue with the key (it will be ephemeral)
+            SecureLogger.error(NSError(domain: "Keychain", code: -1),
+                               context: "Failed to persist noise static key - identity will be lost on restart",
+                               category: .keychain)
+        }
+
+        return newKey
+    }
+
+    /// Generate and save a new Ed25519 signing key, verifying the save succeeds
+    private static func generateAndSaveSigningKey(keychain: KeychainManagerProtocol) -> Curve25519.Signing.PrivateKey {
+        let newKey = Curve25519.Signing.PrivateKey()
+        let keyData = newKey.rawRepresentation
+
+        // Save to keychain and verify success
+        let saveResult = keychain.saveIdentityKeyWithResult(keyData, forKey: "ed25519SigningKey")
+
+        switch saveResult {
+        case .success:
+            SecureLogger.logKeyOperation(.create, keyType: "ed25519SigningKey", success: true)
+        case .duplicateItem:
+            // This shouldn't happen since we just tried to load, but handle it
+            SecureLogger.warning("Signing key already exists (race condition?)", category: .keychain)
+        default:
+            // Save failed - log but continue with the key (it will be ephemeral)
+            SecureLogger.error(NSError(domain: "Keychain", code: -1),
+                               context: "Failed to persist signing key - identity will be lost on restart",
+                               category: .keychain)
+        }
+
+        return newKey
+    }
     
     // MARK: - Public Interface
     
@@ -527,6 +616,17 @@ final class NoiseEncryptionService {
         }
         rateLimiter.resetAll()
     }
+
+    /// Clear session for a specific peer (e.g., on decryption failure to allow re-handshake)
+    func clearSession(for peerID: PeerID) {
+        sessionManager.removeSession(for: peerID)
+        serviceQueue.sync(flags: .barrier) {
+            if let fingerprint = peerFingerprints.removeValue(forKey: peerID) {
+                fingerprintToPeerID.removeValue(forKey: fingerprint)
+            }
+        }
+        SecureLogger.debug("🔓 Cleared Noise session for \(peerID)", category: .session)
+    }
     
     // MARK: - Private Helpers
     

bitchat/Services/NostrTransport.swift

@@ -4,6 +4,32 @@ import Combine
 
 // Minimal Nostr transport conforming to Transport for offline sending
 final class NostrTransport: Transport, @unchecked Sendable {
+    struct Dependencies {
+        let notificationCenter: NotificationCenter
+        let loadFavorites: @MainActor () -> [Data: FavoritesPersistenceService.FavoriteRelationship]
+        let favoriteStatusForNoiseKey: @MainActor (Data) -> FavoritesPersistenceService.FavoriteRelationship?
+        let favoriteStatusForPeerID: @MainActor (PeerID) -> FavoritesPersistenceService.FavoriteRelationship?
+        let currentIdentity: @MainActor () throws -> NostrIdentity?
+        let registerPendingGiftWrap: @MainActor (String) -> Void
+        let sendEvent: @MainActor (NostrEvent) -> Void
+        let scheduleAfter: @Sendable (TimeInterval, @escaping @Sendable () -> Void) -> Void
+
+        static func live(idBridge: NostrIdentityBridge) -> Dependencies {
+            Dependencies(
+                notificationCenter: .default,
+                loadFavorites: { FavoritesPersistenceService.shared.favorites },
+                favoriteStatusForNoiseKey: { FavoritesPersistenceService.shared.getFavoriteStatus(for: $0) },
+                favoriteStatusForPeerID: { FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: $0) },
+                currentIdentity: { try idBridge.getCurrentNostrIdentity() },
+                registerPendingGiftWrap: { NostrRelayManager.registerPendingGiftWrap(id: $0) },
+                sendEvent: { NostrRelayManager.shared.sendEvent($0) },
+                scheduleAfter: { delay, action in
+                    DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: action)
+                }
+            )
+        }
+    }
+
     // Provide BLE short peer ID for BitChat embedding
     var senderPeerID = PeerID(str: "")
 
@@ -17,20 +43,27 @@ final class NostrTransport: Transport, @unchecked Sendable {
     private let readAckInterval: TimeInterval = TransportConfig.nostrReadAckInterval
     private let keychain: KeychainManagerProtocol
     private let idBridge: NostrIdentityBridge
+    private let dependencies: Dependencies
+    private var favoriteStatusObserver: NSObjectProtocol?
 
     // Reachability Cache (thread-safe)
     private var reachablePeers: Set<PeerID> = []
     private let queue = DispatchQueue(label: "nostr.transport.state", attributes: .concurrent)
 
     @MainActor
-    init(keychain: KeychainManagerProtocol, idBridge: NostrIdentityBridge) {
+    init(
+        keychain: KeychainManagerProtocol,
+        idBridge: NostrIdentityBridge,
+        dependencies: Dependencies? = nil
+    ) {
         self.keychain = keychain
         self.idBridge = idBridge
+        self.dependencies = dependencies ?? .live(idBridge: idBridge)
         
         setupObservers()
         
         // Synchronously warm the cache to avoid startup race
-        let favorites = FavoritesPersistenceService.shared.favorites
+        let favorites = self.dependencies.loadFavorites()
         let reachable = favorites.values
             .filter { $0.peerNostrPublicKey != nil }
             .map { PeerID(publicKey: $0.peerNoisePublicKey) }
@@ -40,8 +73,14 @@ final class NostrTransport: Transport, @unchecked Sendable {
         }
     }
 
+    deinit {
+        if let favoriteStatusObserver {
+            dependencies.notificationCenter.removeObserver(favoriteStatusObserver)
+        }
+    }
+
     private func setupObservers() {
-        NotificationCenter.default.addObserver(
+        favoriteStatusObserver = dependencies.notificationCenter.addObserver(
             forName: .favoriteStatusChanged,
             object: nil,
             queue: nil
@@ -52,7 +91,7 @@ final class NostrTransport: Transport, @unchecked Sendable {
 
     private func refreshReachablePeers() {
         Task { @MainActor in
-            let favorites = FavoritesPersistenceService.shared.favorites
+            let favorites = dependencies.loadFavorites()
             let reachable = favorites.values
                 .filter { $0.peerNostrPublicKey != nil }
                 .map { PeerID(publicKey: $0.peerNoisePublicKey) }
@@ -118,32 +157,15 @@ final class NostrTransport: Transport, @unchecked Sendable {
 
     func sendPrivateMessage(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String) {
         Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
+            guard let recipientNpub = resolveRecipientNpub(for: peerID),
-            guard let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
+                  let recipientHex = npubToHex(recipientNpub),
-            SecureLogger.debug("NostrTransport: preparing PM to \(recipientNpub.prefix(16))… for peerID \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+                  let senderIdentity = try? dependencies.currentIdentity() else { return }
-            // Convert recipient npub -> hex (x-only)
+            SecureLogger.debug("NostrTransport: preparing PM to \(recipientNpub.prefix(16))… id=\(messageID.prefix(8))…", category: .session)
-            let recipientHex: String
-            do {
-                let (hrp, data) = try Bech32.decode(recipientNpub)
-                guard hrp == "npub" else {
-                    SecureLogger.error("NostrTransport: recipient key not npub (hrp=\(hrp))", category: .session)
-                    return
-                }
-                recipientHex = data.hexEncodedString()
-            } catch {
-                SecureLogger.error("NostrTransport: failed to decode npub -> hex: \(error)", category: .session)
-                return
-            }
             guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed PM packet", category: .session)
                 return
             }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: senderIdentity)
-                SecureLogger.error("NostrTransport: failed to build Nostr event for PM", category: .session)
-                return
-            }
-            SecureLogger.debug("NostrTransport: sending PM giftWrap id=\(event.id.prefix(16))…", category: .session)
-            NostrRelayManager.shared.sendEvent(event)
         }
     }
 
@@ -158,58 +180,31 @@ final class NostrTransport: Transport, @unchecked Sendable {
 
     func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool) {
         Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
+            guard let recipientNpub = resolveRecipientNpub(for: peerID),
-            guard let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
+                  let recipientHex = npubToHex(recipientNpub),
+                  let senderIdentity = try? dependencies.currentIdentity() else { return }
             let content = isFavorite ? "[FAVORITED]:\(senderIdentity.npub)" : "[UNFAVORITED]:\(senderIdentity.npub)"
             SecureLogger.debug("NostrTransport: preparing FAVORITE(\(isFavorite)) to \(recipientNpub.prefix(16))…", category: .session)
-            // Convert recipient npub -> hex
-            let recipientHex: String
-            do {
-                let (hrp, data) = try Bech32.decode(recipientNpub)
-                guard hrp == "npub" else { return }
-                recipientHex = data.hexEncodedString()
-            } catch {
-                SecureLogger.error("NostrTransport: failed to decode recipient npub for favorite notification: \(error.localizedDescription)", category: .session)
-                return
-            }
             guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: UUID().uuidString, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed favorite notification", category: .session)
                 return
             }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: senderIdentity)
-                SecureLogger.error("NostrTransport: failed to build Nostr event for favorite notification", category: .session)
-                return
-            }
-            SecureLogger.debug("NostrTransport: sending favorite giftWrap id=\(event.id.prefix(16))…", category: .session)
-            NostrRelayManager.shared.sendEvent(event)
         }
     }
 
     func sendBroadcastAnnounce() { /* no-op for Nostr */ }
     func sendDeliveryAck(for messageID: String, to peerID: PeerID) {
         Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
+            guard let recipientNpub = resolveRecipientNpub(for: peerID),
-            guard let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
+                  let recipientHex = npubToHex(recipientNpub),
-            SecureLogger.debug("NostrTransport: preparing DELIVERED ack for id=\(messageID.prefix(8))… to \(recipientNpub.prefix(16))…", category: .session)
+                  let senderIdentity = try? dependencies.currentIdentity() else { return }
-            let recipientHex: String
+            SecureLogger.debug("NostrTransport: preparing DELIVERED ack id=\(messageID.prefix(8))…", category: .session)
-            do {
-                let (hrp, data) = try Bech32.decode(recipientNpub)
-                guard hrp == "npub" else { return }
-                recipientHex = data.hexEncodedString()
-            } catch {
-                SecureLogger.error("NostrTransport: failed to decode recipient npub for delivery ack: \(error.localizedDescription)", category: .session)
-                return
-            }
             guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .delivered, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed DELIVERED ack", category: .session)
                 return
             }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: ack, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
+            sendWrappedMessage(content: ack, recipientHex: recipientHex, senderIdentity: senderIdentity)
-                SecureLogger.error("NostrTransport: failed to build Nostr event for DELIVERED ack", category: .session)
-                return
-            }
-            SecureLogger.debug("NostrTransport: sending DELIVERED ack giftWrap id=\(event.id.prefix(16))…", category: .session)
-            NostrRelayManager.shared.sendEvent(event)
         }
     }
 }
@@ -221,21 +216,17 @@ extension NostrTransport {
     // MARK: Geohash ACK helpers
     func sendDeliveryAckGeohash(for messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
         Task { @MainActor in
-            SecureLogger.debug("GeoDM: send DELIVERED -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
+            SecureLogger.debug("GeoDM: send DELIVERED mid=\(messageID.prefix(8))…", category: .session)
             guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID) else { return }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: identity) else { return }
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: identity, registerPending: true)
-            NostrRelayManager.registerPendingGiftWrap(id: event.id)
-            NostrRelayManager.shared.sendEvent(event)
         }
     }
 
     func sendReadReceiptGeohash(_ messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
         Task { @MainActor in
-            SecureLogger.debug("GeoDM: send READ -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
+            SecureLogger.debug("GeoDM: send READ mid=\(messageID.prefix(8))…", category: .session)
             guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID) else { return }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: identity) else { return }
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: identity, registerPending: true)
-            NostrRelayManager.registerPendingGiftWrap(id: event.id)
-            NostrRelayManager.shared.sendEvent(event)
         }
     }
 
@@ -243,19 +234,12 @@ extension NostrTransport {
     func sendPrivateMessageGeohash(content: String, toRecipientHex recipientHex: String, from identity: NostrIdentity, messageID: String) {
         Task { @MainActor in
             guard !recipientHex.isEmpty else { return }
-            SecureLogger.debug("GeoDM: send PM -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
+            SecureLogger.debug("GeoDM: send PM mid=\(messageID.prefix(8))…", category: .session)
-            // Build embedded BitChat packet without recipient peer ID
             guard let embedded = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(content: content, messageID: messageID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed geohash PM packet", category: .session)
                 return
             }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: identity) else {
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: identity, registerPending: true)
-                SecureLogger.error("NostrTransport: failed to build Nostr event for geohash PM", category: .session)
-                return
-            }
-            SecureLogger.debug("NostrTransport: sending geohash PM giftWrap id=\(event.id.prefix(16))…", category: .session)
-            NostrRelayManager.registerPendingGiftWrap(id: event.id)
-            NostrRelayManager.shared.sendEvent(event)
         }
     }
 }
@@ -263,6 +247,32 @@ extension NostrTransport {
 // MARK: - Private Helpers
 
 extension NostrTransport {
+    /// Converts npub bech32 string to hex pubkey
+    @MainActor
+    private func npubToHex(_ npub: String) -> String? {
+        do {
+            let (hrp, data) = try Bech32.decode(npub)
+            guard hrp == "npub" else { return nil }
+            return data.hexEncodedString()
+        } catch {
+            SecureLogger.error("NostrTransport: failed to decode npub -> hex: \(error)", category: .session)
+            return nil
+        }
+    }
+
+    /// Creates and sends a gift-wrapped private message event
+    @MainActor
+    private func sendWrappedMessage(content: String, recipientHex: String, senderIdentity: NostrIdentity, registerPending: Bool = false) {
+        guard let event = try? NostrProtocol.createPrivateMessage(content: content, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
+            SecureLogger.error("NostrTransport: failed to build Nostr event", category: .session)
+            return
+        }
+        if registerPending {
+            dependencies.registerPendingGiftWrap(event.id)
+        }
+        dependencies.sendEvent(event)
+    }
+
     /// Must be called within a barrier on `queue`
     private func processReadQueueIfNeeded() {
         guard !isSendingReadAcks else { return }
@@ -275,36 +285,21 @@ extension NostrTransport {
     /// Sends a single read ack item (called after extraction from queue within barrier)
     private func sendReadAckItem(_ item: QueuedRead) {
         Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: item.peerID) else { scheduleNextReadAck(); return }
+            defer { scheduleNextReadAck() }
-            guard let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { scheduleNextReadAck(); return }
+            guard let recipientNpub = resolveRecipientNpub(for: item.peerID),
-            SecureLogger.debug("NostrTransport: preparing READ ack for id=\(item.receipt.originalMessageID.prefix(8))… to \(recipientNpub.prefix(16))…", category: .session)
+                  let recipientHex = npubToHex(recipientNpub),
-            // Convert recipient npub -> hex
+                  let senderIdentity = try? dependencies.currentIdentity() else { return }
-            let recipientHex: String
+            SecureLogger.debug("NostrTransport: preparing READ ack id=\(item.receipt.originalMessageID.prefix(8))…", category: .session)
-            do {
-                let (hrp, data) = try Bech32.decode(recipientNpub)
-                guard hrp == "npub" else { scheduleNextReadAck(); return }
-                recipientHex = data.hexEncodedString()
-            } catch {
-                SecureLogger.error("NostrTransport: failed to decode recipient npub for read ack: \(error.localizedDescription)", category: .session)
-                scheduleNextReadAck()
-                return
-            }
             guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .readReceipt, messageID: item.receipt.originalMessageID, recipientPeerID: item.peerID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed READ ack", category: .session)
-                scheduleNextReadAck(); return
+                return
             }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: ack, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
+            sendWrappedMessage(content: ack, recipientHex: recipientHex, senderIdentity: senderIdentity)
-                SecureLogger.error("NostrTransport: failed to build Nostr event for READ ack", category: .session)
-                scheduleNextReadAck(); return
-            }
-            SecureLogger.debug("NostrTransport: sending READ ack giftWrap id=\(event.id.prefix(16))…", category: .session)
-            NostrRelayManager.shared.sendEvent(event)
-            scheduleNextReadAck()
         }
     }
 
     private func scheduleNextReadAck() {
-        DispatchQueue.main.asyncAfter(deadline: .now() + readAckInterval) { [weak self] in
+        dependencies.scheduleAfter(readAckInterval) { [weak self] in
             self?.queue.async(flags: .barrier) { [weak self] in
                 self?.isSendingReadAcks = false
                 self?.processReadQueueIfNeeded()
@@ -315,12 +310,12 @@ extension NostrTransport {
     @MainActor
     private func resolveRecipientNpub(for peerID: PeerID) -> String? {
         if let noiseKey = Data(hexString: peerID.id),
-           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
+           let fav = dependencies.favoriteStatusForNoiseKey(noiseKey),
            let npub = fav.peerNostrPublicKey {
             return npub
         }
         if peerID.id.count == 16,
-           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID),
+           let fav = dependencies.favoriteStatusForPeerID(peerID),
            let npub = fav.peerNostrPublicKey {
             return npub
         }

bitchat/Services/NotificationService.swift

@@ -14,24 +14,103 @@ import UIKit
 import AppKit
 #endif
 
+protocol NotificationAuthorizing {
+    func requestAuthorization(
+        options: UNAuthorizationOptions,
+        completionHandler: @escaping (Bool, Error?) -> Void
+    )
+}
+
+protocol NotificationRequestDelivering {
+    func add(_ request: UNNotificationRequest)
+}
+
+private final class NotificationCenterAuthorizerAdapter: NotificationAuthorizing {
+    private let center: UNUserNotificationCenter
+
+    init(center: UNUserNotificationCenter) {
+        self.center = center
+    }
+
+    func requestAuthorization(
+        options: UNAuthorizationOptions,
+        completionHandler: @escaping (Bool, Error?) -> Void
+    ) {
+        center.requestAuthorization(options: options, completionHandler: completionHandler)
+    }
+}
+
+private final class NotificationCenterRequestDelivererAdapter: NotificationRequestDelivering {
+    private let center: UNUserNotificationCenter
+
+    init(center: UNUserNotificationCenter) {
+        self.center = center
+    }
+
+    func add(_ request: UNNotificationRequest) {
+        Task {
+            try? await center.add(request)
+        }
+    }
+}
+
+private struct NoopNotificationAuthorizer: NotificationAuthorizing {
+    func requestAuthorization(
+        options: UNAuthorizationOptions,
+        completionHandler: @escaping (Bool, Error?) -> Void
+    ) {
+        completionHandler(false, nil)
+    }
+}
+
+private struct NoopNotificationRequestDeliverer: NotificationRequestDelivering {
+    func add(_ request: UNNotificationRequest) {}
+}
+
 final class NotificationService {
     static let shared = NotificationService()
 
+    private let isRunningTestsProvider: () -> Bool
+    private let authorizer: NotificationAuthorizing
+    private let requestDeliverer: NotificationRequestDelivering
+
     /// Returns true if running in test environment (XCTest, Swift Testing, or CI)
     private var isRunningTests: Bool {
-        let env = ProcessInfo.processInfo.environment
+        isRunningTestsProvider()
-        return NSClassFromString("XCTestCase") != nil ||
-               env["XCTestConfigurationFilePath"] != nil ||
-               env["XCTestBundlePath"] != nil ||
-               env["GITHUB_ACTIONS"] != nil ||
-               env["CI"] != nil
     }
 
-    private init() {}
+    private init() {
+        self.isRunningTestsProvider = {
+            let env = ProcessInfo.processInfo.environment
+            return NSClassFromString("XCTestCase") != nil ||
+                   env["XCTestConfigurationFilePath"] != nil ||
+                   env["XCTestBundlePath"] != nil ||
+                   env["GITHUB_ACTIONS"] != nil ||
+                   env["CI"] != nil
+        }
+        if isRunningTestsProvider() {
+            self.authorizer = NoopNotificationAuthorizer()
+            self.requestDeliverer = NoopNotificationRequestDeliverer()
+        } else {
+            let center = UNUserNotificationCenter.current()
+            self.authorizer = NotificationCenterAuthorizerAdapter(center: center)
+            self.requestDeliverer = NotificationCenterRequestDelivererAdapter(center: center)
+        }
+    }
+
+    internal init(
+        isRunningTestsProvider: @escaping () -> Bool,
+        authorizer: NotificationAuthorizing,
+        requestDeliverer: NotificationRequestDelivering
+    ) {
+        self.isRunningTestsProvider = isRunningTestsProvider
+        self.authorizer = authorizer
+        self.requestDeliverer = requestDeliverer
+    }
 
     func requestAuthorization() {
         guard !isRunningTests else { return }
-        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+        authorizer.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
             if granted {
                 // Permission granted
             } else {
@@ -64,7 +143,7 @@ final class NotificationService {
             trigger: nil // Deliver immediately
         )
 
-        UNUserNotificationCenter.current().add(request)
+        requestDeliverer.add(request)
     }
     
     func sendMentionNotification(from sender: String, message: String) {
@@ -96,7 +175,8 @@ final class NotificationService {
     func sendNetworkAvailableNotification(peerCount: Int) {
         let title = "👥 bitchatters nearby!"
         let body = peerCount == 1 ? "1 person around" : "\(peerCount) people around"
-        let identifier = "network-available-\(Date().timeIntervalSince1970)"
+        // Fixed identifier so iOS updates the existing notification instead of creating new ones
+        let identifier = "network-available"
 
         sendLocalNotification(
             title: title,

bitchat/Services/NotificationStreamAssembler.swift

@@ -62,6 +62,7 @@ struct NotificationStreamAssembler {
             let hasRecipient = (flags & BinaryProtocol.Flags.hasRecipient) != 0
             let hasSignature = (flags & BinaryProtocol.Flags.hasSignature) != 0
             let isCompressed = (flags & BinaryProtocol.Flags.isCompressed) != 0
+            let hasRoute = (version >= 2) && (flags & BinaryProtocol.Flags.hasRoute) != 0
 
             let lengthOffset = 12
             let payloadLength: Int
@@ -80,6 +81,15 @@ struct NotificationStreamAssembler {
             var frameLength = framePrefix + payloadLength
             if hasRecipient { frameLength += BinaryProtocol.recipientIDSize }
             if hasSignature { frameLength += BinaryProtocol.signatureSize }
+            
+            if hasRoute {
+                let routeCountOffset = framePrefix + (hasRecipient ? BinaryProtocol.recipientIDSize : 0)
+                let routeCountIndex = buffer.startIndex + routeCountOffset
+                guard buffer.count > routeCountOffset else { break }
+                let routeCount = Int(buffer[routeCountIndex])
+                frameLength += 1 + (routeCount * BinaryProtocol.senderIDSize)
+            }
+            
             if isCompressed {
                 let rawLengthFieldBytes = (version == 2) ? 4 : 2
                 if payloadLength < rawLengthFieldBytes {

bitchat/Services/Transport.swift

@@ -58,6 +58,10 @@ protocol Transport: AnyObject {
     // QR verification (optional for transports)
     func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
     func sendVerifyResponse(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
+
+    // Pending file management (BCH-01-002: files held in memory until user accepts)
+    func acceptPendingFile(id: String) -> URL?
+    func declinePendingFile(id: String)
 }
 
 extension Transport {
@@ -70,6 +74,9 @@ extension Transport {
     func sendMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date) {
         sendMessage(content, mentions: mentions)
     }
+
+    func acceptPendingFile(id: String) -> URL? { nil }
+    func declinePendingFile(id: String) {}
 }
 
 protocol TransportPeerEventsDelegate: AnyObject {

bitchat/Services/TransportConfig.swift

@@ -21,6 +21,7 @@ enum TransportConfig {
 
     // Timers
     static let networkResetGraceSeconds: TimeInterval = 600 // 10 minutes
+    static let networkNotificationCooldownSeconds: TimeInterval = 300 // 5 minutes
     static let basePublicFlushInterval: TimeInterval = 0.08  // ~12.5 fps batching
 
     // BLE duty/announce/connect
@@ -96,11 +97,12 @@ enum TransportConfig {
     // Keep scanning fully ON when we saw traffic very recently
     static let bleRecentTrafficForceScanSeconds: TimeInterval = 10.0
     static let bleThreadSleepWriteShortDelaySeconds: TimeInterval = 0.05
-    static let bleExpectedWritePerFragmentMs: Int = 8
+    static let bleExpectedWritePerFragmentMs: Int = 20
-    static let bleExpectedWriteMaxMs: Int = 2000
+    static let bleExpectedWriteMaxMs: Int = 5000
-    // Faster fragment pacing; use slightly tighter spacing for directed trains
+    // Fragment pacing: Conservative spacing to prevent BLE buffer overflow
-    static let bleFragmentSpacingMs: Int = 5
+    // Aggressive pacing causes packet loss; needs 25-30ms between fragments for reliable delivery
-    static let bleFragmentSpacingDirectedMs: Int = 4
+    static let bleFragmentSpacingMs: Int = 30
+    static let bleFragmentSpacingDirectedMs: Int = 25
     static let bleAnnounceIntervalSeconds: TimeInterval = 4.0
     static let bleDutyOnDurationDense: TimeInterval = 3.0
     static let bleDutyOffDurationDense: TimeInterval = 15.0
@@ -162,6 +164,14 @@ enum TransportConfig {
     static let blePostAnnounceDelaySeconds: TimeInterval = 0.4
     static let bleForceAnnounceMinIntervalSeconds: TimeInterval = 0.15
 
+    // BCH-01-004: Rate-limiting for subscription-triggered announces
+    // Prevents rapid enumeration attacks by rate-limiting announce responses
+    static let bleSubscriptionRateLimitMinSeconds: TimeInterval = 2.0       // Minimum interval between announces per central
+    static let bleSubscriptionRateLimitBackoffFactor: Double = 2.0          // Exponential backoff multiplier
+    static let bleSubscriptionRateLimitMaxBackoffSeconds: TimeInterval = 30.0  // Maximum backoff period
+    static let bleSubscriptionRateLimitWindowSeconds: TimeInterval = 60.0   // Window for tracking subscription attempts
+    static let bleSubscriptionRateLimitMaxAttempts: Int = 5                 // Max attempts before extended cooldown
+
     // Store-and-forward for directed packets at relays
     static let bleDirectedSpoolWindowSeconds: TimeInterval = 15.0
 
@@ -203,4 +213,18 @@ enum TransportConfig {
     static let uiShareExtensionDismissDelaySeconds: TimeInterval = 2.0
     static let uiShareAcceptWindowSeconds: TimeInterval = 30.0
     static let uiMigrationCutoffSeconds: TimeInterval = 24 * 60 * 60
+
+    // Gossip Sync Configuration
+    static let syncSeenCapacity: Int = 1000
+    static let syncGCSMaxBytes: Int = 400
+    static let syncGCSTargetFpr: Double = 0.01
+    static let syncMaxMessageAgeSeconds: TimeInterval = 900
+    static let syncMaintenanceIntervalSeconds: TimeInterval = 30.0
+    static let syncStalePeerCleanupIntervalSeconds: TimeInterval = 60.0
+    static let syncStalePeerTimeoutSeconds: TimeInterval = 60.0
+    static let syncFragmentCapacity: Int = 600
+    static let syncFileTransferCapacity: Int = 200
+    static let syncFragmentIntervalSeconds: TimeInterval = 30.0
+    static let syncFileTransferIntervalSeconds: TimeInterval = 60.0
+    static let syncMessageIntervalSeconds: TimeInterval = 15.0
 }

bitchat/Sync/GossipSyncManager.swift

@@ -1,4 +1,5 @@
 import Foundation
+import BitLogger
 
 // Gossip-based sync manager using on-demand GCS filters
 final class GossipSyncManager {
@@ -6,6 +7,7 @@ final class GossipSyncManager {
         func sendPacket(_ packet: BitchatPacket)
         func sendPacket(to peerID: PeerID, packet: BitchatPacket)
         func signPacketForBroadcast(_ packet: BitchatPacket) -> BitchatPacket
+        func getConnectedPeers() -> [PeerID]
     }
 
     private struct PacketStore {
@@ -74,6 +76,7 @@ final class GossipSyncManager {
 
     private let myPeerID: PeerID
     private let config: Config
+    private let requestSyncManager: RequestSyncManager
     weak var delegate: Delegate?
 
     // Storage: broadcast packets by type, and latest announce per sender
@@ -88,9 +91,10 @@ final class GossipSyncManager {
     private var lastStalePeerCleanup: Date = .distantPast
     private var syncSchedules: [SyncSchedule] = []
 
-    init(myPeerID: PeerID, config: Config = Config()) {
+    init(myPeerID: PeerID, config: Config = Config(), requestSyncManager: RequestSyncManager) {
         self.myPeerID = myPeerID
         self.config = config
+        self.requestSyncManager = requestSyncManager
         var schedules: [SyncSchedule] = []
         if config.seenCapacity > 0 && config.messageSyncIntervalSeconds > 0 {
             schedules.append(SyncSchedule(types: .publicMessages, interval: config.messageSyncIntervalSeconds, lastSent: .distantPast))
@@ -202,6 +206,19 @@ final class GossipSyncManager {
         }
     }
 
+    private func sendPeriodicSync(for types: SyncTypeFlags) {
+        // Unicast sync to connected peers to allow RSR attribution
+        if let connectedPeers = delegate?.getConnectedPeers(), !connectedPeers.isEmpty {
+            SecureLogger.debug("Sending periodic sync to \(connectedPeers.count) connected peers", category: .sync)
+            for peerID in connectedPeers {
+                sendRequestSync(to: peerID, types: types)
+            }
+        } else {
+            // Fallback to broadcast (discovery phase)
+            sendRequestSync(for: types)
+        }
+    }
+
     private func sendRequestSync(for types: SyncTypeFlags) {
         let payload = buildGcsPayload(for: types)
         let pkt = BitchatPacket(
@@ -218,6 +235,9 @@ final class GossipSyncManager {
     }
 
     private func sendRequestSync(to peerID: PeerID, types: SyncTypeFlags) {
+        // Register the request for RSR validation
+        requestSyncManager.registerRequest(to: peerID)
+        
         let payload = buildGcsPayload(for: types)
         var recipient = Data()
         var temp = peerID.id
@@ -262,6 +282,7 @@ final class GossipSyncManager {
                 if !mightContain(idBytes) {
                     var toSend = pkt
                     toSend.ttl = 0
+                    toSend.isRSR = true // Mark as solicited response
                     delegate?.sendPacket(to: peerID, packet: toSend)
                 }
             }
@@ -274,6 +295,7 @@ final class GossipSyncManager {
                 if !mightContain(idBytes) {
                     var toSend = pkt
                     toSend.ttl = 0
+                    toSend.isRSR = true // Mark as solicited response
                     delegate?.sendPacket(to: peerID, packet: toSend)
                 }
             }
@@ -286,6 +308,7 @@ final class GossipSyncManager {
                 if !mightContain(idBytes) {
                     var toSend = pkt
                     toSend.ttl = 0
+                    toSend.isRSR = true // Mark as solicited response
                     delegate?.sendPacket(to: peerID, packet: toSend)
                 }
             }
@@ -298,6 +321,7 @@ final class GossipSyncManager {
                 if !mightContain(idBytes) {
                     var toSend = pkt
                     toSend.ttl = 0
+                    toSend.isRSR = true // Mark as solicited response
                     delegate?.sendPacket(to: peerID, packet: toSend)
                 }
             }
@@ -366,11 +390,13 @@ final class GossipSyncManager {
     private func performPeriodicMaintenance(now: Date = Date()) {
         cleanupExpiredMessages()
         cleanupStaleAnnouncementsIfNeeded(now: now)
+        requestSyncManager.cleanup() // Cleanup expired sync requests
+        
         for index in syncSchedules.indices {
             guard syncSchedules[index].interval > 0 else { continue }
             if syncSchedules[index].lastSent == .distantPast || now.timeIntervalSince(syncSchedules[index].lastSent) >= syncSchedules[index].interval {
                 syncSchedules[index].lastSent = now
-                sendRequestSync(for: syncSchedules[index].types)
+                sendPeriodicSync(for: syncSchedules[index].types)
             }
         }
     }

bitchat/Sync/RequestSyncManager.swift

@@ -0,0 +1,85 @@
+//
+// RequestSyncManager.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+import BitLogger
+
+/// Manages outgoing sync requests and validates incoming responses.
+///
+/// Allows attributing RSR (Request-Sync Response) packets to specific peers
+/// that we have actively requested sync from.
+final class RequestSyncManager {
+    
+    private let queue = DispatchQueue(label: "request.sync.manager", attributes: .concurrent)
+    private var pendingRequests: [PeerID: TimeInterval] = [:]
+    private let responseWindow: TimeInterval
+    private let now: () -> TimeInterval
+    
+    init(
+        responseWindow: TimeInterval = 30.0,
+        now: @escaping () -> TimeInterval = { Date().timeIntervalSince1970 }
+    ) {
+        self.responseWindow = responseWindow
+        self.now = now
+    }
+    
+    /// Register that we are sending a sync request to a peer.
+    /// - Parameter peerID: The peer we are requesting sync from
+    func registerRequest(to peerID: PeerID) {
+        let now = self.now()
+        queue.async(flags: .barrier) {
+            SecureLogger.debug("Registering sync request to \(peerID.id.prefix(8))…", category: .sync)
+            self.pendingRequests[peerID] = now
+        }
+    }
+    
+    /// Check if a packet from a peer is a valid response to a sync request.
+    ///
+    /// - Parameters:
+    ///   - peerID: The sender of the packet
+    ///   - isRSR: Whether the packet is marked as a Request-Sync Response
+    /// - Returns: true if we have a pending request for this peer and the window is open
+    func isValidResponse(from peerID: PeerID, isRSR: Bool) -> Bool {
+        guard isRSR else { return false }
+        
+        return queue.sync {
+            guard let requestTime = pendingRequests[peerID] else {
+                SecureLogger.warning("Received unsolicited RSR packet from \(peerID.id.prefix(8))…", category: .security)
+                return false
+            }
+            
+            let now = self.now()
+            if now - requestTime > responseWindow {
+                SecureLogger.warning("Received RSR packet from \(peerID.id.prefix(8))… outside of response window", category: .security)
+                // We don't remove here because we might receive multiple packets for one request
+                return false
+            }
+            
+            return true
+        }
+    }
+    
+    /// Periodic cleanup of expired requests
+    func cleanup() {
+        let now = self.now()
+        queue.async(flags: .barrier) {
+            let originalCount = self.pendingRequests.count
+            self.pendingRequests = self.pendingRequests.filter { _, timestamp in
+                now - timestamp <= self.responseWindow
+            }
+            let removed = originalCount - self.pendingRequests.count
+            if removed > 0 {
+                SecureLogger.debug("Cleaned up \(removed) expired sync requests", category: .sync)
+            }
+        }
+    }
+
+    var debugPendingRequestCount: Int {
+        queue.sync { pendingRequests.count }
+    }
+}

bitchat/Utils/InputValidator.swift

@@ -21,9 +21,7 @@ struct InputValidator {
     /// Rejects strings containing control characters to prevent potential security issues
     /// and UI rendering problems. This strict approach ensures data integrity at input time.
     static func validateUserString(_ string: String, maxLength: Int) -> String? {
-        let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let trimmed = string.trimmedOrNilIfEmpty, trimmed.count <= maxLength else { return nil }
-        guard !trimmed.isEmpty else { return nil }
-        guard trimmed.count <= maxLength else { return nil }
 
         // Reject control characters outright instead of rewriting the string.
         // This prevents injection attacks and ensures consistent UI rendering.
@@ -52,11 +50,13 @@ struct InputValidator {
     // MessageType/NoisePayloadType enums; keeping validator free of stale lists.
 
     /// Validates timestamp is reasonable (not too far in past or future)
+    /// BCH-01-011: Reduced from ±1 hour to ±5 minutes to limit replay attack window
     static func validateTimestamp(_ timestamp: Date) -> Bool {
         let now = Date()
-        let oneHourAgo = now.addingTimeInterval(-3600)
+        // 5 minutes = 300 seconds (industry standard for replay protection)
-        let oneHourFromNow = now.addingTimeInterval(3600)
+        let fiveMinutesAgo = now.addingTimeInterval(-300)
-        return timestamp >= oneHourAgo && timestamp <= oneHourFromNow
+        let fiveMinutesFromNow = now.addingTimeInterval(300)
+        return timestamp >= fiveMinutesAgo && timestamp <= fiveMinutesFromNow
     }
 
 }

bitchat/Utils/String+Ext.swift

@@ -0,0 +1,22 @@
+//
+// String+Ext.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+extension StringProtocol {
+    var trimmed: String {
+        trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    var trimmedOrNilIfEmpty: String? {
+        let trimmed = self.trimmed
+        return trimmed.isEmpty ? nil : trimmed
+    }
+
+    var nilIfEmpty: Self? {
+        isEmpty ? nil : self
+    }
+}

bitchat/Utils/SystemSettings.swift

@@ -0,0 +1,44 @@
+//
+// SystemSettings.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+#if os(iOS)
+import UIKit
+#elseif os(macOS)
+import AppKit
+#endif
+
+enum SystemSettings {
+    case bluetooth
+    case location
+    case microphone
+
+    #if os(macOS)
+    private static let baseURL = "x-apple.systempreferences:com.apple.preference.security"
+
+    private var macPrivacyAnchor: String {
+        switch self {
+        case .bluetooth: "Privacy_Bluetooth"
+        case .location: "Privacy_LocationServices"
+        case .microphone: "Privacy_Microphone"
+        }
+    }
+    #endif
+
+    func open() {
+        #if os(iOS)
+        if let url = URL(string: UIApplication.openSettingsURLString) {
+            UIApplication.shared.open(url)
+        }
+        #elseif os(macOS)
+        let urlString = "\(Self.baseURL)?\(macPrivacyAnchor)"
+        if let url = URL(string: urlString) {
+            NSWorkspace.shared.open(url)
+        }
+        #endif
+    }
+}

bitchat/ViewModels/ChatViewModel.swift

@@ -144,10 +144,11 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
     private let networkResetGraceSeconds: TimeInterval = TransportConfig.networkResetGraceSeconds // avoid refiring on short drops/reconnects
     @Published var nickname: String = "" {
         didSet {
-            // Trim whitespace whenever nickname is set
+            // Trim whitespace whenever nickname is set; whitespace-only becomes ""
-            let trimmed = nickname.trimmingCharacters(in: .whitespacesAndNewlines)
+            let trimmed = nickname.trimmedOrNilIfEmpty ?? ""
             if trimmed != nickname {
                 nickname = trimmed
+                return
             }
             // Update mesh service nickname if it's initialized
             if !meshService.myPeerID.isEmpty {
@@ -279,8 +280,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
     var geoNicknames: [String: String] = [:] // pubkeyHex(lowercased) -> nickname
     // Show Tor status once per app launch
     var torStatusAnnounced = false
-    private var torProgressCancellable: AnyCancellable?
-    private var lastTorProgressAnnounced = -1
     // Track whether a Tor restart is pending so we only announce
     // "tor restarted" after an actual restart, not the first launch.
     var torRestartPending: Bool = false
@@ -323,8 +322,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
     )
     // Channel activity tracking for background nudges
     var lastPublicActivityAt: [String: Date] = [:]   // channelKey -> last activity time
-    private var lastPublicActivityNotifyAt: [String: Date] = [:]
-    private let channelInactivityThreshold: TimeInterval = TransportConfig.uiChannelInactivityThresholdSeconds
     // Geohash participant tracker
     let participantTracker = GeohashParticipantTracker(activityCutoff: -TransportConfig.uiRecentCutoffFiveMinutesSeconds)
     // Participants who indicated they teleported (by tag in their events)
@@ -448,7 +445,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
         self.deduplicationService = MessageDeduplicationService()
 
         // Wire up dependencies
-        self.commandProcessor.chatViewModel = self
+        self.commandProcessor.contextProvider = self
         self.participantTracker.configure(context: self)
         
         // Subscribe to privateChatManager changes to trigger UI updates
@@ -503,8 +500,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
             addGeohashOnlySystemMessage(
                 String(localized: "system.tor.starting", comment: "System message when Tor is starting")
             )
-            // Suppress incremental Tor progress messages
-            torProgressCancellable = nil
         } else if !TorManager.shared.torEnforced && !torStatusAnnounced {
             torStatusAnnounced = true
             addGeohashOnlySystemMessage(
@@ -631,8 +626,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
             object: nil
         )
         
-        // Listen for delivery acknowledgments
-                
         // When app becomes active, send read receipts for visible messages
         #if os(macOS)
         NotificationCenter.default.addObserver(
@@ -755,8 +748,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
     
     private func loadNickname() {
         if let savedNickname = userDefaults.string(forKey: nicknameKey) {
-            // Trim whitespace when loading
+            nickname = savedNickname.trimmed
-            nickname = savedNickname.trimmingCharacters(in: .whitespacesAndNewlines)
         } else {
             nickname = "anon\(Int.random(in: 1000...9999))"
             saveNickname()
@@ -772,20 +764,10 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
     }
     
     func validateAndSaveNickname() {
-        // Trim whitespace from nickname
+        nickname = nickname.trimmedOrNilIfEmpty ?? "anon\(Int.random(in: 1000...9999))"
-        let trimmed = nickname.trimmingCharacters(in: .whitespacesAndNewlines)
-        
-        // Check if nickname is empty after trimming
-        if trimmed.isEmpty {
-            nickname = "anon\(Int.random(in: 1000...9999))"
-        } else {
-            nickname = trimmed
-        }
         saveNickname()
     }
-    
+
-    // MARK: - Favorites Management
-    
     // MARK: - Blocked Users Management (Delegated to PeerStateManager)
     
     
@@ -1006,8 +988,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
     @MainActor
     func sendMessage(_ content: String) {
         // Ignore messages that are empty or whitespace-only to prevent blank lines
-        let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let trimmed = content.trimmedOrNilIfEmpty else { return }
-        guard !trimmed.isEmpty else { return }
 
         // Check for commands
         if content.hasPrefix("/") {
@@ -1468,56 +1449,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
         selectedPrivateChatFingerprint = nil
     }
     
-    // MARK: - Nostr Message Handling
-    
-    @MainActor
-    @objc private func handleNostrMessage(_ notification: Notification) {
-        guard let message = notification.userInfo?["message"] as? BitchatMessage else { return }
-        
-        // Store the Nostr pubkey if provided (for messages from unknown senders)
-        if let nostrPubkey = notification.userInfo?["nostrPubkey"] as? String,
-           let senderPeerID = message.senderPeerID {
-            // Store mapping for read receipts
-            nostrKeyMapping[senderPeerID] = nostrPubkey
-        }
-        
-        // Process the Nostr message through the same flow as Bluetooth messages
-        didReceiveMessage(message)
-    }
-    
-    @objc private func handleDeliveryAcknowledgment(_ notification: Notification) {
-        guard let messageId = notification.userInfo?["messageId"] as? String else { return }
-        
-        
-        
-        // Update the delivery status for the message
-        if let index = messages.firstIndex(where: { $0.id == messageId }) {
-            // Update delivery status to delivered
-            messages[index].deliveryStatus = DeliveryStatus.delivered(to: "nostr", at: Date())
-            
-            // Schedule UI update for delivery status
-            // UI will update automatically
-        }
-        
-        // Also update in private chats if it's a private message
-        for (peerID, chatMessages) in privateChats {
-            if let index = chatMessages.firstIndex(where: { $0.id == messageId }) {
-                privateChats[peerID]?[index].deliveryStatus = DeliveryStatus.delivered(to: "nostr", at: Date())
-                // UI will update automatically
-                break
-            }
-        }
-    }
-    
-    @objc private func handleNostrReadReceipt(_ notification: Notification) {
-        guard let receipt = notification.userInfo?["receipt"] as? ReadReceipt else { return }
-        
-        SecureLogger.info("📖 Handling read receipt for message \(receipt.originalMessageID) from Nostr", category: .session)
-        
-        // Process the read receipt through the same flow as Bluetooth read receipts
-        didReceiveReadReceipt(receipt)
-    }
-    
     @MainActor
     @objc private func handlePeerStatusUpdate(_ notification: Notification) {
         // Update private chat peer if needed when peer status changes
@@ -1868,7 +1799,15 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
             }
         }
     }
-    
+
+    func getMessages(for peerID: PeerID?) -> [BitchatMessage] {
+        if let peerID {
+            return getPrivateChatMessages(for: peerID)
+        } else {
+            return messages
+        }
+    }
+
     @MainActor
     func getPrivateChatMessages(for peerID: PeerID) -> [BitchatMessage] {
         var combined: [BitchatMessage] = []
@@ -2055,13 +1994,42 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
             } catch {
                 SecureLogger.error("Failed to clear media files during panic: \(error)", category: .session)
             }
+
+            // BCH-01-013: Clear iOS app switcher snapshots
+            // These are stored in Library/Caches/Snapshots/<bundle_id>/
+            #if os(iOS)
+            Self.clearAppSwitcherSnapshots()
+            #endif
         }
 
         // Force immediate UI update for panic mode
         // UI updates immediately - no flushing needed
 
     }
-    
+
+    /// BCH-01-013: Clear iOS app switcher snapshots during panic mode
+    /// iOS stores preview screenshots in Library/Caches/Snapshots/<bundle_id>/
+    /// These could reveal sensitive information visible in the app at the time
+    #if os(iOS)
+    private nonisolated static func clearAppSwitcherSnapshots() {
+        do {
+            let cacheDir = try FileManager.default.url(for: .cachesDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
+            let snapshotsDir = cacheDir.appendingPathComponent("Snapshots", isDirectory: true)
+
+            // Clear all snapshots (iOS stores them in subdirectories by bundle ID and scene)
+            if FileManager.default.fileExists(atPath: snapshotsDir.path) {
+                let contents = try FileManager.default.contentsOfDirectory(at: snapshotsDir, includingPropertiesForKeys: nil)
+                for item in contents {
+                    try FileManager.default.removeItem(at: item)
+                }
+                SecureLogger.info("🗑️ Cleared app switcher snapshots during panic clear", category: .session)
+            }
+        } catch {
+            SecureLogger.error("Failed to clear app switcher snapshots: \(error)", category: .session)
+        }
+    }
+    #endif
+
     // MARK: - Autocomplete
     
     func updateAutocomplete(for text: String, cursorPosition: Int) {
@@ -3031,7 +2999,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
         Task { @MainActor in
             // Early validation
             guard !isMessageBlocked(message) else { return }
-            guard !message.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || message.isPrivate else { return }
+            guard !message.content.trimmed.isEmpty || message.isPrivate else { return }
             
             // Route to appropriate handler
             if message.isPrivate {
@@ -3046,46 +3014,91 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
         }
     }
 
+    /// Find message index trying both short (16-hex) and long (64-hex) peer ID formats.
+    /// Returns the peer ID where the message was found and its index, or nil if not found.
+    private func findMessageIndex(messageID: String, peerID: PeerID) -> (peerID: PeerID, index: Int)? {
+        // Try direct lookup first
+        if let messages = privateChats[peerID],
+           let idx = messages.firstIndex(where: { $0.id == messageID }) {
+            return (peerID, idx)
+        }
+
+        // Try with full noise key if peerID is short (16 hex chars)
+        if peerID.bare.count == 16,
+           let peer = unifiedPeerService.getPeer(by: peerID),
+           !peer.noisePublicKey.isEmpty {
+            let longID = PeerID(hexData: peer.noisePublicKey)
+            if let messages = privateChats[longID],
+               let idx = messages.firstIndex(where: { $0.id == messageID }) {
+                return (longID, idx)
+            }
+        }
+
+        // Try with short form if peerID is long (64 hex = noise key)
+        if peerID.bare.count == 64 {
+            let shortID = peerID.toShort()
+            if let messages = privateChats[shortID],
+               let idx = messages.firstIndex(where: { $0.id == messageID }) {
+                return (shortID, idx)
+            }
+        }
+
+        return nil
+    }
+
     // Low-level BLE events
     func didReceiveNoisePayload(from peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date) {
         Task { @MainActor in
             switch type {
             case .privateMessage:
                 guard let pm = PrivateMessagePacket.decode(from: payload) else { return }
+
+                // BCH-01-012: Check blocking before processing private message to prevent notification bypass
+                if isPeerBlocked(peerID) {
+                    SecureLogger.debug("🚫 Ignoring Noise payload from blocked peer: \(peerID)", category: .security)
+                    return
+                }
+
                 let senderName = unifiedPeerService.getPeer(by: peerID)?.nickname ?? "Unknown"
-            let pmMentions = parseMentions(from: pm.content)
+                let pmMentions = parseMentions(from: pm.content)
-            let msg = BitchatMessage(
+                let msg = BitchatMessage(
-                id: pm.messageID,
+                    id: pm.messageID,
-                sender: senderName,
+                    sender: senderName,
-                content: pm.content,
+                    content: pm.content,
-                timestamp: timestamp,
+                    timestamp: timestamp,
-                isRelay: false,
+                    isRelay: false,
-                originalSender: nil,
+                    originalSender: nil,
-                isPrivate: true,
+                    isPrivate: true,
-                recipientNickname: nickname,
+                    recipientNickname: nickname,
-                senderPeerID: peerID,
+                    senderPeerID: peerID,
-                mentions: pmMentions.isEmpty ? nil : pmMentions
+                    mentions: pmMentions.isEmpty ? nil : pmMentions
-            )
+                )
                 handlePrivateMessage(msg)
                 // Send delivery ACK back over BLE
                 meshService.sendDeliveryAck(for: pm.messageID, to: peerID)
 
             case .delivered:
                 guard let messageID = String(data: payload, encoding: .utf8) else { return }
-                if let name = unifiedPeerService.getPeer(by: peerID)?.nickname {
+                guard let name = unifiedPeerService.getPeer(by: peerID)?.nickname,
-                    if let messages = privateChats[peerID], let idx = messages.firstIndex(where: { $0.id == messageID }) {
+                      let (foundPeerID, idx) = findMessageIndex(messageID: messageID, peerID: peerID) else { return }
-                        privateChats[peerID]?[idx].deliveryStatus = .delivered(to: name, at: Date())
+
-                        objectWillChange.send()
+                // Don't downgrade from .read to .delivered
-                    }
+                if case .read = privateChats[foundPeerID]?[idx].deliveryStatus { return }
-                }
+
+                privateChats[foundPeerID]?[idx].deliveryStatus = .delivered(to: name, at: Date())
+                objectWillChange.send()
 
             case .readReceipt:
                 guard let messageID = String(data: payload, encoding: .utf8) else { return }
-                if let name = unifiedPeerService.getPeer(by: peerID)?.nickname {
+                guard let name = unifiedPeerService.getPeer(by: peerID)?.nickname,
-                    if let messages = privateChats[peerID], let idx = messages.firstIndex(where: { $0.id == messageID }) {
+                      let (foundPeerID, idx) = findMessageIndex(messageID: messageID, peerID: peerID) else { return }
-                        privateChats[peerID]?[idx].deliveryStatus = .read(by: name, at: Date())
+
-                        objectWillChange.send()
+                // Explicitly unwrap and re-assign to ensure the @Published setter is called
-                    }
+                if let messages = privateChats[foundPeerID], idx < messages.count {
+                    messages[idx].deliveryStatus = .read(by: name, at: Date())
+                    privateChats[foundPeerID] = messages
+                    privateChatManager.objectWillChange.send()
+                    objectWillChange.send()
                 }
             case .verifyChallenge:
                 // Parse and respond
@@ -3159,7 +3172,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
 
     func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {
         Task { @MainActor in
-            let normalized = content.trimmingCharacters(in: .whitespacesAndNewlines)
+            let normalized = content.trimmed
             let publicMentions = parseMentions(from: normalized)
             let msg = BitchatMessage(
                 id: messageID,
@@ -3332,18 +3345,25 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
                 self.scheduleNetworkEmptyTimer()
             } else {
                 self.invalidateNetworkEmptyTimer()
-                // Trim out peers we no longer observe before comparing for new arrivals
+                // Don't trim recentlySeenPeers here - let timers handle cleanup.
-                self.recentlySeenPeers.formIntersection(meshPeerSet)
+                // Trimming immediately causes peers to be treated as "new" when they
+                // briefly drop and reconnect, triggering notification floods.
                 let newPeers = meshPeerSet.subtracting(self.recentlySeenPeers)
-                
+
                 if !newPeers.isEmpty {
-                    self.lastNetworkNotificationTime = Date()
+                    // Rate limit: max one notification per 5 minutes
-                    self.recentlySeenPeers.formUnion(newPeers)
+                    let cooldown = TransportConfig.networkNotificationCooldownSeconds
-                    NotificationService.shared.sendNetworkAvailableNotification(peerCount: meshPeers.count)
+                    if Date().timeIntervalSince(self.lastNetworkNotificationTime) >= cooldown {
-                    SecureLogger.info(
+                        // Only mark peers as seen when we actually notify about them
-                        "👥 Sent bitchatters nearby notification for \(meshPeers.count) mesh peers (new: \(newPeers.count))",
+                        // This ensures peers arriving during cooldown will be included in the next notification
-                        category: .session
+                        self.recentlySeenPeers.formUnion(newPeers)
-                    )
+                        self.lastNetworkNotificationTime = Date()
+                        NotificationService.shared.sendNetworkAvailableNotification(peerCount: meshPeers.count)
+                        SecureLogger.info(
+                            "👥 Sent bitchatters nearby notification for \(meshPeers.count) mesh peers (new: \(newPeers.count))",
+                            category: .session
+                        )
+                    }
                     self.scheduleNetworkResetTimer()
                 }
             }
@@ -3760,10 +3780,8 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, CommandContextProv
         // Removed background nudge notification for generic "new chats!"
 
         // Append via batching buffer (skip empty content) with simple dedup by ID
-        if !finalMessage.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+        if !finalMessage.content.trimmed.isEmpty, !messages.contains(where: { $0.id == finalMessage.id }) {
-            if !messages.contains(where: { $0.id == finalMessage.id }) {
+            publicMessagePipeline.enqueue(finalMessage)
-                publicMessagePipeline.enqueue(finalMessage)
-            }
         }
     }
     

bitchat/ViewModels/Extensions/ChatViewModel+Nostr.swift

@@ -56,7 +56,9 @@ extension ChatViewModel {
     }
     
     func subscribeNostrEvent(_ event: NostrEvent) {
-        guard event.kind == NostrProtocol.EventKind.ephemeralEvent.rawValue,
+        guard event.isValidSignature() else { return }
+        guard (event.kind == NostrProtocol.EventKind.ephemeralEvent.rawValue || 
+               event.kind == NostrProtocol.EventKind.geohashPresence.rawValue),
               !deduplicationService.hasProcessedNostrEvent(event.id)
         else {
             return
@@ -75,7 +77,7 @@ extension ChatViewModel {
         }
         
         if let nickTag = event.tags.first(where: { $0.first == "n" }), nickTag.count >= 2 {
-            let nick = nickTag[1].trimmingCharacters(in: .whitespacesAndNewlines)
+            let nick = nickTag[1].trimmed
             geoNicknames[event.pubkey.lowercased()] = nick
         }
         
@@ -86,6 +88,11 @@ extension ChatViewModel {
         // Update participants last-seen for this pubkey
         participantTracker.recordParticipant(pubkeyHex: event.pubkey)
         
+        // If presence heartbeat (Kind 20001), stop here - no content to display
+        if event.kind == NostrProtocol.EventKind.geohashPresence.rawValue {
+            return
+        }
+        
         // Track teleported tag (only our format ["t","teleport"]) for icon state
         let hasTeleportTag = event.tags.contains(where: { tag in
             tag.count >= 2 && tag[0].lowercased() == "t" && tag[1].lowercased() == "teleport"
@@ -108,8 +115,8 @@ extension ChatViewModel {
         }
         
         let senderName = displayNameForNostrPubkey(event.pubkey)
-        let content = event.content.trimmingCharacters(in: .whitespacesAndNewlines)
+        let content = event.content.trimmed
-        
+
         // Clamp future timestamps to now to avoid future-dated messages skewing order
         let rawTs = Date(timeIntervalSince1970: TimeInterval(event.created_at))
         let timestamp = min(rawTs, Date())
@@ -124,20 +131,28 @@ extension ChatViewModel {
             mentions: mentions.isEmpty ? nil : mentions
         )
         Task { @MainActor in
+            // BCH-01-012: Check blocking before any notifications
+            // handlePublicMessage has its own blocking check but returns silently,
+            // so we must also guard checkForMentions to prevent notification bypass
+            let isBlocked = identityManager.isNostrBlocked(pubkeyHexLowercased: event.pubkey.lowercased())
+
             handlePublicMessage(msg)
-            checkForMentions(msg)
+
-            sendHapticFeedback(for: msg)
+            // Only check mentions and send haptic if sender is not blocked
+            if !isBlocked {
+                checkForMentions(msg)
+                sendHapticFeedback(for: msg)
+            }
         }
     }
-    
+
     func subscribeGiftWrap(_ giftWrap: NostrEvent, id: NostrIdentity) {
+        guard giftWrap.isValidSignature() else { return }
         guard !deduplicationService.hasProcessedNostrEvent(giftWrap.id) else { return }
         deduplicationService.recordNostrEvent(giftWrap.id)
         
         guard let (content, senderPubkey, rumorTs) = try? NostrProtocol.decryptPrivateMessage(giftWrap: giftWrap, recipientIdentity: id),
-              content.hasPrefix("bitchat1:"),
+              let packet = Self.decodeEmbeddedBitChatPacket(from: content),
-              let packetData = Self.base64URLDecode(String(content.dropFirst("bitchat1:".count))),
-              let packet = BitchatPacket.from(packetData),
               packet.type == MessageType.noiseEncrypted.rawValue,
               let noisePayload = NoisePayload.decode(packet.payload)
         else {
@@ -177,7 +192,7 @@ extension ChatViewModel {
         case .mesh:
             refreshVisibleMessages(from: .mesh)
             // Debug: log if any empty messages are present
-            let emptyMesh = messages.filter { $0.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }.count
+            let emptyMesh = messages.filter { $0.content.trimmed.isEmpty }.count
             if emptyMesh > 0 {
                 SecureLogger.debug("RenderGuard: mesh timeline contains \(emptyMesh) empty messages", category: .session)
             }
@@ -239,8 +254,10 @@ extension ChatViewModel {
     }
     
     func handleNostrEvent(_ event: NostrEvent) {
-        // Only handle ephemeral kind 20000 with matching tag
+        guard event.isValidSignature() else { return }
-        guard event.kind == NostrProtocol.EventKind.ephemeralEvent.rawValue else { return }
+        // Only handle ephemeral kind 20000 or presence kind 20001 with matching tag
+        guard (event.kind == NostrProtocol.EventKind.ephemeralEvent.rawValue ||
+               event.kind == NostrProtocol.EventKind.geohashPresence.rawValue) else { return }
         
         // Deduplicate
         if deduplicationService.hasProcessedNostrEvent(event.id) { return }
@@ -250,6 +267,11 @@ extension ChatViewModel {
         let tagSummary = event.tags.map { "[" + $0.joined(separator: ",") + "]" }.joined(separator: ",")
         SecureLogger.debug("GeoTeleport: recv pub=\(event.pubkey.prefix(8))… tags=\(tagSummary)", category: .session)
         
+        // If this pubkey is blocked, skip mapping, participants, and timeline
+        if identityManager.isNostrBlocked(pubkeyHexLowercased: event.pubkey) {
+            return
+        }
+        
         // Track teleport tag for participants – only our format ["t", "teleport"]
         let hasTeleportTag: Bool = event.tags.contains { tag in
             tag.count >= 2 && tag[0].lowercased() == "t" && tag[1].lowercased() == "teleport"
@@ -273,6 +295,9 @@ extension ChatViewModel {
             }
         }
         
+        // Update participants last-seen for this pubkey
+        participantTracker.recordParticipant(pubkeyHex: event.pubkey)
+
         // Skip only very recent self-echo from relay; include older self events for hydration
         if isSelf {
             let eventTime = Date(timeIntervalSince1970: TimeInterval(event.created_at))
@@ -283,28 +308,26 @@ extension ChatViewModel {
         
         // Cache nickname from tag if present
         if let nickTag = event.tags.first(where: { $0.first == "n" }), nickTag.count >= 2 {
-            let nick = nickTag[1].trimmingCharacters(in: .whitespacesAndNewlines)
+            geoNicknames[event.pubkey.lowercased()] = nickTag[1].trimmed
-            geoNicknames[event.pubkey.lowercased()] = nick
-        }
-        
-        // If this pubkey is blocked, skip mapping, participants, and timeline
-        if identityManager.isNostrBlocked(pubkeyHexLowercased: event.pubkey) {
-            return
         }
         
         // Store mapping for geohash DM initiation
         nostrKeyMapping[PeerID(nostr_: event.pubkey)] = event.pubkey
         nostrKeyMapping[PeerID(nostr: event.pubkey)] = event.pubkey
         
-        // Update participants last-seen for this pubkey
+        // If presence heartbeat (Kind 20001), stop here - no content to display
-        participantTracker.recordParticipant(pubkeyHex: event.pubkey)
+        if event.kind == NostrProtocol.EventKind.geohashPresence.rawValue {
+            return
+        }
         
         let senderName = displayNameForNostrPubkey(event.pubkey)
         let content = event.content
         
         // If this is a teleport presence event (no content), don't add to timeline
-        if let teleTag = event.tags.first(where: { $0.first == "t" }), teleTag.count >= 2, (teleTag[1] == "teleport"),
+        if let teleTag = event.tags.first(where: { $0.first == "t" }),
-           content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+           teleTag.count >= 2,
+           teleTag[1] == "teleport",
+           content.trimmed.isEmpty {
             return
         }
         
@@ -346,6 +369,7 @@ extension ChatViewModel {
     }
     
     func handleGiftWrap(_ giftWrap: NostrEvent, id: NostrIdentity) {
+        guard giftWrap.isValidSignature() else { return }
         if deduplicationService.hasProcessedNostrEvent(giftWrap.id) {
             return
         }
@@ -359,9 +383,7 @@ extension ChatViewModel {
         
         SecureLogger.debug("GeoDM: decrypted gift-wrap id=\(giftWrap.id.prefix(16))... from=\(senderPubkey.prefix(8))...", category: .session)
         
-        guard content.hasPrefix("bitchat1:"),
+        guard let packet = Self.decodeEmbeddedBitChatPacket(from: content),
-              let packetData = Self.base64URLDecode(String(content.dropFirst("bitchat1:".count))),
-              let packet = BitchatPacket.from(packetData),
               packet.type == MessageType.noiseEncrypted.rawValue,
               let payload = NoisePayload.decode(packet.payload)
         else {
@@ -464,7 +486,9 @@ extension ChatViewModel {
     }
     
     func subscribeNostrEvent(_ event: NostrEvent, gh: String) {
-        guard event.kind == NostrProtocol.EventKind.ephemeralEvent.rawValue else { return }
+        guard event.isValidSignature() else { return }
+        guard (event.kind == NostrProtocol.EventKind.ephemeralEvent.rawValue ||
+               event.kind == NostrProtocol.EventKind.geohashPresence.rawValue) else { return }
 
         // Compute current participant count (5-minute window) BEFORE updating with this event
         let existingCount = participantTracker.participantCount(for: gh)
@@ -473,9 +497,8 @@ extension ChatViewModel {
         participantTracker.recordParticipant(pubkeyHex: event.pubkey, geohash: gh)
         
         // Notify only on rising-edge: previously zero people, now someone sends a chat
-        let content = event.content.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let content = event.content.trimmedOrNilIfEmpty else { return }
-        guard !content.isEmpty else { return }
+
-        
         // Respect geohash blocks
         if identityManager.isNostrBlocked(pubkeyHexLowercased: event.pubkey.lowercased()) { return }
         
@@ -580,6 +603,7 @@ extension ChatViewModel {
     }
     
     func processNostrMessage(_ giftWrap: NostrEvent) async {
+        guard giftWrap.isValidSignature() else { return }
         guard let currentIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
         
         do {
@@ -597,8 +621,7 @@ extension ChatViewModel {
             
             // Check if it's a BitChat packet embedded in the content (bitchat1:...)
             if content.hasPrefix("bitchat1:") {
-                guard let packetData = Self.base64URLDecode(String(content.dropFirst("bitchat1:".count))),
+                guard let packet = Self.decodeEmbeddedBitChatPacket(from: content) else {
-                      let packet = BitchatPacket.from(packetData) else {
                     SecureLogger.error("Failed to decode embedded BitChat packet from Nostr DM", category: .session)
                     return
                 }
@@ -609,24 +632,23 @@ extension ChatViewModel {
                 // Stable target ID if we know Noise key; otherwise temporary Nostr-based peer
                 let targetPeerID = PeerID(str: actualSenderNoiseKey?.hexEncodedString()) ?? PeerID(nostr_: senderPubkey)
                 
-                if packet.type == MessageType.noiseEncrypted.rawValue {
+                if packet.type == MessageType.noiseEncrypted.rawValue,
-                    if let payload = NoisePayload.decode(packet.payload) {
+                   let payload = NoisePayload.decode(packet.payload) {
-                        let messageTimestamp = Date(timeIntervalSince1970: TimeInterval(rumorTimestamp))
+                    let messageTimestamp = Date(timeIntervalSince1970: TimeInterval(rumorTimestamp))
-                        // Store Nostr mapping
+                    // Store Nostr mapping
-                        await MainActor.run {
+                    await MainActor.run {
-                            nostrKeyMapping[targetPeerID] = senderPubkey
+                        nostrKeyMapping[targetPeerID] = senderPubkey
-                            
+                        
-                            // Handle packet types
+                        // Handle packet types
-                            switch payload.type {
+                        switch payload.type {
-                            case .privateMessage:
+                        case .privateMessage:
-                                handlePrivateMessage(payload, senderPubkey: senderPubkey, convKey: targetPeerID, id: currentIdentity, messageTimestamp: messageTimestamp)
+                            handlePrivateMessage(payload, senderPubkey: senderPubkey, convKey: targetPeerID, id: currentIdentity, messageTimestamp: messageTimestamp)
-                            case .delivered:
+                        case .delivered:
-                                handleDelivered(payload, senderPubkey: senderPubkey, convKey: targetPeerID)
+                            handleDelivered(payload, senderPubkey: senderPubkey, convKey: targetPeerID)
-                            case .readReceipt:
+                        case .readReceipt:
-                                handleReadReceipt(payload, senderPubkey: senderPubkey, convKey: targetPeerID)
+                            handleReadReceipt(payload, senderPubkey: senderPubkey, convKey: targetPeerID)
-                            case .verifyChallenge, .verifyResponse:
+                        case .verifyChallenge, .verifyResponse:
-                                break
+                            break
-                            }
                         }
                     }
                 }
@@ -779,6 +801,19 @@ extension ChatViewModel {
         messageRouter.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
     }
 
+    private static func decodeEmbeddedBitChatPacket(from content: String) -> BitchatPacket? {
+        guard content.hasPrefix("bitchat1:") else { return nil }
+        let encoded = String(content.dropFirst("bitchat1:".count))
+        let maxBytes = FileTransferLimits.maxFramedFileBytes
+        // Base64url length upper bound for maxBytes (padded length; unpadded is <= this).
+        let maxEncoded = ((maxBytes + 2) / 3) * 4
+        guard encoded.count <= maxEncoded else { return nil }
+        guard let packetData = Self.base64URLDecode(encoded),
+              packetData.count <= maxBytes
+        else { return nil }
+        return BitchatPacket.from(packetData)
+    }
+
     // MARK: - Geohash Nickname Resolution (for /block in geohash)
 
     func nostrPubkeyForDisplayName(_ name: String) -> String? {

bitchat/ViewModels/Extensions/ChatViewModel+PrivateChat.swift

@@ -319,7 +319,7 @@ extension ChatViewModel {
         }
 
         let targetPeer = selectedPrivateChatPeer
-        let message = enqueueMediaMessage(content: "[voice] \(url.lastPathComponent)", targetPeer: targetPeer)
+        let message = enqueueMediaMessage(content: "\(MimeType.Category.audio.messagePrefix)\(url.lastPathComponent)", targetPeer: targetPeer)
         let messageID = message.id
         let transferId = makeTransferID(messageID: messageID)
 
@@ -364,6 +364,36 @@ extension ChatViewModel {
         }
     }
 
+    #if os(iOS)
+    func processThenSendImage(_ image: UIImage?) {
+        guard let image else { return }
+        Task.detached {
+            do {
+                let processedURL = try ImageUtils.processImage(image)
+                await MainActor.run {
+                    self.sendImage(from: processedURL)
+                }
+            } catch {
+                SecureLogger.error("Image processing failed: \(error)", category: .session)
+            }
+        }
+    }
+    #elseif os(macOS)
+    func processThenSendImage(from url: URL?) {
+        guard let url else { return }
+        Task.detached {
+            do {
+                let processedURL = try ImageUtils.processImage(at: url)
+                await MainActor.run {
+                    self.sendImage(from: processedURL)
+                }
+            } catch {
+                SecureLogger.error("Image processing failed: \(error)", category: .session)
+            }
+        }
+    }
+    #endif
+
     @MainActor
     func sendImage(from sourceURL: URL, cleanup: (() -> Void)? = nil) {
         guard canSendMediaInCurrentContext else {
@@ -398,7 +428,7 @@ extension ChatViewModel {
                 )
                 guard packet.encode() != nil else { throw MediaSendError.encodingFailed }
                 await MainActor.run {
-                    let message = self.enqueueMediaMessage(content: "[image] \(outputURL.lastPathComponent)", targetPeer: targetPeer)
+                    let message = self.enqueueMediaMessage(content: "\(MimeType.Category.image.messagePrefix)\(outputURL.lastPathComponent)", targetPeer: targetPeer)
                     let messageID = message.id
                     let transferId = self.makeTransferID(messageID: messageID)
                     self.registerTransfer(transferId: transferId, messageID: messageID)
@@ -517,20 +547,19 @@ extension ChatViewModel {
 
     func cleanupLocalFile(forMessage message: BitchatMessage) {
         // Check both outgoing and incoming directories for thorough cleanup
-        let prefixes = ["[voice] ", "[image] ", "[file] "]
+        let categories: [MimeType.Category] = [.audio, .image, .file]
-        let subdirs = ["voicenotes/outgoing", "voicenotes/incoming",
+        guard let category = categories.first(where: { message.content.hasPrefix($0.messagePrefix) }),
-                       "images/outgoing", "images/incoming",
+              let rawFilename = String(message.content.dropFirst(category.messagePrefix.count)).trimmedOrNilIfEmpty,
-                       "files/outgoing", "files/incoming"]
+              let base = try? applicationFilesDirectory(),
-
+              // Security: Extract only the last path component to prevent directory traversal
-        guard let prefix = prefixes.first(where: { message.content.hasPrefix($0) }) else { return }
+              let safeFilename = (rawFilename as NSString).lastPathComponent.nilIfEmpty,
-        let rawFilename = String(message.content.dropFirst(prefix.count)).trimmingCharacters(in: .whitespacesAndNewlines)
+              safeFilename != "." && safeFilename != ".."
-        guard !rawFilename.isEmpty, let base = try? applicationFilesDirectory() else { return }
+        else {
-
+            return
-        // Security: Extract only the last path component to prevent directory traversal
+        }
-        let safeFilename = (rawFilename as NSString).lastPathComponent
-        guard !safeFilename.isEmpty && safeFilename != "." && safeFilename != ".." else { return }
 
         // Try all possible locations (outgoing and incoming)
+        let subdirs = categories.flatMap { ["\($0.mediaDir)/outgoing", "\($0.mediaDir)/incoming"] }
         for subdir in subdirs {
             let target = base.appendingPathComponent(subdir, isDirectory: true).appendingPathComponent(safeFilename)
 
@@ -740,15 +769,11 @@ extension ChatViewModel {
         
         if isViewing {
             // Mark read immediately if viewing
-            // Use router to send read receipt
+            // Use the incoming peerID directly - it has the established Noise session.
+            // Don't use PeerID(hexData: noiseKey) as that creates a 64-hex ID without a session.
+            // Use meshService directly (not messageRouter) so it queues if peer disconnects.
             let receipt = ReadReceipt(originalMessageID: message.id, readerID: meshService.myPeerID, readerNickname: nickname)
-            if let key = noiseKey {
+            meshService.sendReadReceipt(receipt, to: peerID)
-                 // Send via router to stable key if available (preferred for persistence/Nostr fallback)
-                 messageRouter.sendReadReceipt(receipt, to: PeerID(hexData: key))
-            } else {
-                 // Fallback to mesh direct
-                 meshService.sendReadReceipt(receipt, to: peerID)
-            }
             sentReadReceipts.insert(message.id)
         } else {
             // Notify

bitchat/ViewModels/Extensions/ChatViewModel+Tor.swift

@@ -24,7 +24,7 @@ extension ChatViewModel {
             }
         }
     }
-    
+
     @objc func handleTorWillRestart() {
         Task { @MainActor in
             self.torRestartPending = true

bitchat/ViewModels/VoiceRecordingViewModel.swift

@@ -0,0 +1,142 @@
+//
+// VoiceRecordingViewModel.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import BitLogger
+import Foundation
+
+@MainActor
+final class VoiceRecordingViewModel: ObservableObject {
+    enum State: Equatable {
+        case idle
+        case requestingPermission
+        case permissionDenied
+        case preparing
+        case recording(startDate: Date)
+        case error(message: String)
+
+        var isActive: Bool {
+            switch self {
+            case .preparing, .recording: true
+            case .idle, .requestingPermission, .permissionDenied, .error: false
+            }
+        }
+
+        var alertMessage: String {
+            switch self {
+            case .error(let message): message
+            case .permissionDenied: "Microphone access is required to record voice notes."
+            case .idle, .requestingPermission, .preparing, .recording: ""
+            }
+        }
+
+        fileprivate func duration(for date: Date) -> TimeInterval {
+            switch self {
+            case .idle, .requestingPermission, .preparing, .permissionDenied, .error: 0
+            case .recording(let startDate): date.timeIntervalSince(startDate)
+            }
+        }
+    }
+
+    var showAlert: Bool {
+        get {
+            switch state {
+            case .permissionDenied, .error:   true
+            case .idle, .requestingPermission, .preparing, .recording: false
+            }
+        }
+        set {
+            if !newValue { state = .idle }
+        }
+    }
+
+    @Published private(set) var state = State.idle
+
+    func formattedDuration(for date: Date) -> String {
+        let clamped = max(0, state.duration(for: date))
+        let totalMilliseconds = Int(clamped * 1000)
+        let minutes = totalMilliseconds / 60_000
+        let seconds = (totalMilliseconds % 60_000) / 1_000
+        let centiseconds = (totalMilliseconds % 1_000) / 10
+        return String(format: "%02d:%02d.%02d", minutes, seconds, centiseconds)
+    }
+
+    func start(shouldShow: Bool) {
+        guard shouldShow, state == .idle else { return }
+        state = .requestingPermission
+        Task {
+            let granted = await VoiceRecorder.shared.requestPermission()
+            guard state == .requestingPermission else { return }
+            guard granted else {
+                state = .permissionDenied
+                return
+            }
+            state = .preparing
+            do {
+                try await VoiceRecorder.shared.startRecording()
+                guard state == .preparing else {
+                    cancel()
+                    return
+                }
+                state = .recording(startDate: Date())
+            } catch {
+                SecureLogger.error("Voice recording failed to start: \(error)", category: .session)
+                await VoiceRecorder.shared.cancelRecording()
+                guard state == .preparing else { return }
+                state = .error(message: "Could not start recording.")
+            }
+        }
+    }
+
+    func finish(completion: ((URL) -> Void)?) {
+        let previousState = state
+
+        switch previousState {
+        case .permissionDenied, .error:
+            return
+        case .idle, .requestingPermission, .preparing, .recording:
+            break
+        }
+
+        state = .idle
+
+        guard case .recording(let startDate) = previousState, let completion else {
+            Task { await VoiceRecorder.shared.cancelRecording() }
+            return
+        }
+
+        Task {
+            let finalDuration = Date().timeIntervalSince(startDate)
+            if let url = await VoiceRecorder.shared.stopRecording(),
+               isValidRecording(at: url, duration: finalDuration) {
+                completion(url)
+            } else {
+                guard state == .idle else { return }
+                state = .error(
+                    message: finalDuration < VoiceRecorder.minRecordingDuration
+                    ? "Recording is too short."
+                    : "Recording failed to save."
+                )
+            }
+        }
+    }
+
+    func cancel() {
+        finish(completion: nil)
+    }
+
+    private func isValidRecording(at url: URL, duration: TimeInterval) -> Bool {
+        if let attributes = try? FileManager.default.attributesOfItem(atPath: url.path),
+           let fileSize = attributes[.size] as? NSNumber,
+           fileSize.intValue > 0,
+           duration >= VoiceRecorder.minRecordingDuration {
+            return true
+        }
+        try? FileManager.default.removeItem(at: url)
+        return false
+    }
+}

bitchat/Views/AppInfoView.swift

@@ -86,10 +86,6 @@ struct AppInfoView: View {
             ]
         }
 
-        enum Warning {
-            static let title: LocalizedStringKey = "app_info.warning.title"
-            static let message: LocalizedStringKey = "app_info.warning.message"
-        }
     }
     
     var body: some View {
@@ -192,24 +188,6 @@ struct AppInfoView: View {
 
                 FeatureRow(info: Strings.Privacy.panic)
             }
-
-            // Warning
-            VStack(alignment: .leading, spacing: 6) {
-                SectionHeader(Strings.Warning.title)
-                    .foregroundColor(Color.red)
-                
-                Text(Strings.Warning.message)
-                    .font(.bitchatSystem(size: 14, design: .monospaced))
-                    .foregroundColor(Color.red)
-                    .fixedSize(horizontal: false, vertical: true)
-            }
-            .padding(.top, 6)
-            .padding(.bottom, 16)
-            .padding(.horizontal)
-            .background(Color.red.opacity(0.1))
-            .cornerRadius(8)
-            
-            .padding(.top)
         }
         .padding()
     }

bitchat/Views/Components/PaymentChipView.swift

@@ -15,10 +15,22 @@ struct PaymentChipView: View {
     enum PaymentType {
         case cashu(String)
         case lightning(String)
-        
+
+        private static let cashuAllowedCharacters = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-_"))
+
+        private static func cashuURL(from link: String) -> URL? {
+            if let url = URL(string: link), url.scheme != nil {
+                return url
+            }
+            let enc = link.addingPercentEncoding(withAllowedCharacters: cashuAllowedCharacters) ?? link
+            return URL(string: "cashu:\(enc)")
+        }
+
         var url: URL? {
             switch self {
-            case .cashu(let link), .lightning(let link):
+            case .cashu(let link):
+                return Self.cashuURL(from: link)
+            case .lightning(let link):
                 return URL(string: link)
             }
         }

bitchat/Views/Components/TextMessageView.swift

@@ -13,7 +13,7 @@ struct TextMessageView: View {
     @EnvironmentObject private var viewModel: ChatViewModel
     
     let message: BitchatMessage
-    @Binding var expandedMessageIDs: Set<String>
+    @State private var expandedMessageIDs: Set<String> = []
     
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
@@ -66,14 +66,12 @@ struct TextMessageView: View {
     }
 }
 
-@available(macOS 14, iOS 17, *)
 #Preview {
-    @Previewable @State var ids: Set<String> = []
     let keychain = PreviewKeychainManager()
     
     Group {
         List {
-            TextMessageView(message: .preview, expandedMessageIDs: $ids)
+            TextMessageView(message: .preview)
                 .listRowSeparator(.hidden)
                 .listRowInsets(EdgeInsets())
                 .listRowBackground(EmptyView())
@@ -81,7 +79,7 @@ struct TextMessageView: View {
         .environment(\.colorScheme, .light)
         
         List {
-            TextMessageView(message: .preview, expandedMessageIDs: $ids)
+            TextMessageView(message: .preview)
                 .listRowSeparator(.hidden)
                 .listRowInsets(EdgeInsets())
                 .listRowBackground(EmptyView())

bitchat/Views/Image Viewers/ImagePickerView.swift

@@ -0,0 +1,79 @@
+//
+// ImagePickerView.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+#if os(iOS)
+
+import SwiftUI
+
+/// Camera or Photo Library
+struct ImagePickerView: UIViewControllerRepresentable {
+    let sourceType: UIImagePickerController.SourceType
+    let completion: (UIImage?) -> Void
+
+    func makeUIViewController(context: Context) -> UIImagePickerController {
+        let picker = UIImagePickerController()
+        picker.sourceType = sourceType
+        picker.delegate = context.coordinator
+        picker.allowsEditing = false
+
+        // Use standard full screen - iOS handles safe areas automatically
+        picker.modalPresentationStyle = .fullScreen
+
+        // Force dark mode to make safe area bars black instead of white
+        picker.overrideUserInterfaceStyle = .dark
+
+        return picker
+    }
+
+    func updateUIViewController(_ uiViewController: UIImagePickerController, context: Context) {}
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator(completion: completion)
+    }
+
+    class Coordinator: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
+        let completion: (UIImage?) -> Void
+
+        init(completion: @escaping (UIImage?) -> Void) {
+            self.completion = completion
+        }
+
+        func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
+            let image = info[.originalImage] as? UIImage
+            completion(image)
+        }
+
+        func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
+            completion(nil)
+        }
+    }
+}
+
+@available(iOS 17, *)
+#Preview {
+    @Previewable @State var isPresented = true
+    @Previewable @State var selectedImage: UIImage?
+    VStack {
+        if let selectedImage {
+            Image(uiImage: selectedImage)
+                .resizable()
+                .scaledToFit()
+        } else {
+            Text("No image selected")
+        }
+        Button("Show") { isPresented = true }
+    }
+    .sheet(isPresented: $isPresented) {
+        ImagePickerView(sourceType: .photoLibrary) { image in
+            selectedImage = image
+            isPresented = false
+        }
+    }
+}
+
+#endif

bitchat/Views/Image Viewers/ImagePreviewView.swift

@@ -0,0 +1,147 @@
+//
+// ImagePreviewView.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import SwiftUI
+#if os(macOS)
+import BitLogger
+#endif
+
+struct ImagePreviewView: View {
+    let url: URL
+
+    @Environment(\.dismiss) private var dismiss
+    #if os(iOS)
+    @State private var showExporter = false
+    @State private var platformImage: UIImage?
+    #else
+    @State private var platformImage: NSImage?
+    #endif
+
+    var body: some View {
+        ZStack {
+            Color.black.ignoresSafeArea()
+            VStack {
+                Spacer()
+                if let image = platformImage {
+                    #if os(iOS)
+                    Image(uiImage: image)
+                        .resizable()
+                        .aspectRatio(contentMode: .fit)
+                        .padding()
+                    #else
+                    Image(nsImage: image)
+                        .resizable()
+                        .aspectRatio(contentMode: .fit)
+                        .padding()
+                    #endif
+                } else {
+                    ProgressView()
+                        .progressViewStyle(.circular)
+                        .tint(.white)
+                }
+                Spacer()
+                HStack {
+                    Button(action: { dismiss() }) {
+                        Text("close", comment: "Button to dismiss fullscreen media viewer")
+                            .font(.bitchatSystem(size: 15, weight: .semibold))
+                            .foregroundColor(.white)
+                            .padding(.horizontal, 16)
+                            .padding(.vertical, 8)
+                            .background(RoundedRectangle(cornerRadius: 12).stroke(Color.white.opacity(0.5), lineWidth: 1))
+                    }
+                    Spacer()
+                    Button(action: saveCopy) {
+                        Text("save", comment: "Button to save media to device")
+                            .font(.bitchatSystem(size: 15, weight: .semibold))
+                            .foregroundColor(.white)
+                            .padding(.horizontal, 16)
+                            .padding(.vertical, 8)
+                            .background(RoundedRectangle(cornerRadius: 12).fill(Color.blue.opacity(0.6)))
+                    }
+                }
+                .padding([.horizontal, .bottom], 24)
+            }
+        }
+        .onAppear(perform: loadImage)
+        #if os(iOS)
+        .sheet(isPresented: $showExporter) {
+            FileExportWrapper(url: url)
+        }
+        #endif
+    }
+
+    private func loadImage() {
+        DispatchQueue.global(qos: .userInitiated).async {
+            #if os(iOS)
+            guard let image = UIImage(contentsOfFile: url.path) else { return }
+            #else
+            guard let image = NSImage(contentsOf: url) else { return }
+            #endif
+            DispatchQueue.main.async {
+                self.platformImage = image
+            }
+        }
+    }
+
+    private func saveCopy() {
+        #if os(iOS)
+        showExporter = true
+        #else
+        Task { @MainActor in
+            let panel = NSSavePanel()
+            panel.canCreateDirectories = true
+            panel.nameFieldStringValue = url.lastPathComponent
+            panel.prompt = "save"
+            if panel.runModal() == .OK, let destination = panel.url {
+                do {
+                    if FileManager.default.fileExists(atPath: destination.path) {
+                        try FileManager.default.removeItem(at: destination)
+                    }
+                    try FileManager.default.copyItem(at: url, to: destination)
+                } catch {
+                    SecureLogger.error("Failed to save image preview copy: \(error)", category: .session)
+                }
+            }
+        }
+        #endif
+    }
+
+    #if os(iOS)
+    private struct FileExportWrapper: UIViewControllerRepresentable {
+        let url: URL
+
+        func makeUIViewController(context: Context) -> UIDocumentPickerViewController {
+            let controller = UIDocumentPickerViewController(forExporting: [url])
+            controller.shouldShowFileExtensions = true
+            return controller
+        }
+
+        func updateUIViewController(_ uiViewController: UIDocumentPickerViewController, context: Context) {}
+    }
+    #endif
+}
+
+#Preview {
+    let tempURL = FileManager.default.temporaryDirectory.appendingPathComponent("dummy.jpg")
+    if !FileManager.default.fileExists(atPath: tempURL.path(percentEncoded: false)) {
+        #if os(iOS)
+        let image = UIImage(named: "dummy")
+        let data = image?.jpegData(compressionQuality: 0.8)
+        let _ = try? data?.write(to: tempURL)
+        #elseif os(macOS)
+        let image = NSImage(named: "dummy")
+        var rect = NSRect(origin: .zero, size: image?.size ?? .zero)
+        if let cgImage = image?.cgImage(forProposedRect: &rect, context: nil, hints: nil) {
+            let rep = NSBitmapImageRep(cgImage: cgImage)
+            let jpegData = rep.representation(using: .jpeg, properties: [.compressionFactor: 0.8])
+            let _ = try? jpegData?.write(to: tempURL)
+        }
+        #endif
+    }
+    ImagePreviewView(url: tempURL)
+}

bitchat/Views/Image Viewers/MacImagePickerView.swift

@@ -0,0 +1,71 @@
+//
+// MacImagePickerView.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+#if os(macOS)
+
+import SwiftUI
+
+struct MacImagePickerView: View {
+    let completion: (URL?) -> Void
+    @Environment(\.dismiss) private var dismiss
+
+    var body: some View {
+        VStack(spacing: 16) {
+            Text("Choose an image")
+                .font(.headline)
+
+            Button("Select Image") {
+                let panel = NSOpenPanel()
+                panel.allowsMultipleSelection = false
+                panel.canChooseDirectories = false
+                panel.canChooseFiles = true
+                panel.allowedContentTypes = [.image, .png, .jpeg, .heic]
+                panel.message = "Choose an image to send"
+
+                if panel.runModal() == .OK {
+                    completion(panel.url)
+                } else {
+                    dismiss()
+                }
+            }
+            .buttonStyle(.borderedProminent)
+
+            Button("Cancel") {
+                completion(nil)
+            }
+            .buttonStyle(.bordered)
+        }
+        .padding(40)
+        .frame(minWidth: 300, minHeight: 150)
+    }
+}
+
+@available(OSX 14, *)
+#Preview {
+    @Previewable @State var isPresented = true
+    @Previewable @State var selectedImage: NSImage?
+
+    VStack {
+        if let selectedImage {
+            Image(nsImage: selectedImage)
+                .resizable()
+                .scaledToFit()
+        } else {
+            Text("No image selected")
+        }
+        Button("Show") { isPresented = true }
+    }
+    .sheet(isPresented: $isPresented) {
+        MacImagePickerView { url in
+            selectedImage = url.map(NSImage.init)
+            isPresented = false
+        }
+    }
+}
+
+#endif

bitchat/Views/LocationChannelsSheet.swift

@@ -40,10 +40,31 @@ struct LocationChannelsSheet: View {
         }
 
         static func levelTitle(for level: GeohashChannelLevel, count: Int) -> String {
+            // High-precision uncertainty: if count is 0 for high-precision levels,
+            // show "?" because presence broadcasting is disabled for privacy.
+            let isHighPrecision = (level == .neighborhood || level == .block || level == .building)
+            if isHighPrecision && count == 0 {
+                return String(
+                    format: String(localized: "location_channels.row_title_unknown", defaultValue: "%@ [? people]"),
+                    locale: .current,
+                    level.displayName
+                )
+            }
             return rowTitle(label: level.displayName, count: count)
         }
 
         static func bookmarkTitle(geohash: String, count: Int) -> String {
+            // Check precision for bookmarks too
+            let len = geohash.count
+            // Neighborhood=6, Block=7, Building=8+
+            let isHighPrecision = (len >= 6)
+            if isHighPrecision && count == 0 {
+                return String(
+                    format: String(localized: "location_channels.row_title_unknown", defaultValue: "%@ [? people]"),
+                    locale: .current,
+                    "#\(geohash)"
+                )
+            }
             return rowTitle(label: "#\(geohash)", count: count)
         }
 
@@ -104,7 +125,7 @@ struct LocationChannelsSheet: View {
                             Text(Strings.permissionDenied)
                                 .font(.bitchatSystem(size: 12, design: .monospaced))
                                 .foregroundColor(.secondary)
-                            Button(Strings.openSettings) { openSystemLocationSettings() }
+                            Button(Strings.openSettings, action: SystemSettings.location.open)
                             .buttonStyle(.plain)
                         }
                     case LocationChannelManager.PermissionState.authorized:
@@ -225,9 +246,7 @@ struct LocationChannelsSheet: View {
                     sectionDivider
                     torToggleSection
                         .padding(.top, 12)
-                    Button(action: {
+                    Button(action: SystemSettings.location.open) {
-                        openSystemLocationSettings()
-                    }) {
                         Text(Strings.removeAccess)
                             .font(.bitchatSystem(size: 12, design: .monospaced))
                             .foregroundColor(Color(red: 0.75, green: 0.1, blue: 0.1))
@@ -283,7 +302,7 @@ struct LocationChannelsSheet: View {
                         }
                     }
                 let normalized = customGeohash
-                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                    .trimmed
                     .lowercased()
                     .replacingOccurrences(of: "#", with: "")
                 let isValid = validateGeohash(normalized)
@@ -430,7 +449,7 @@ struct LocationChannelsSheet: View {
     // Split a title like "#mesh [3 people]" into base and suffix "[3 people]"
     private func splitTitleAndCount(_ s: String) -> (base: String, countSuffix: String?) {
         guard let idx = s.lastIndex(of: "[") else { return (s, nil) }
-        let prefix = String(s[..<idx]).trimmingCharacters(in: .whitespaces)
+        let prefix = String(s[..<idx]).trimmed
         let suffix = String(s[idx...])
         return (prefix, suffix)
     }
@@ -601,18 +620,3 @@ extension LocationChannelsSheet {
         }
     }
 }
-
-// MARK: - Open Settings helper
-private func openSystemLocationSettings() {
-    #if os(iOS)
-    if let url = URL(string: UIApplication.openSettingsURLString) {
-        UIApplication.shared.open(url)
-    }
-    #else
-    if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_LocationServices") {
-        NSWorkspace.shared.open(url)
-    } else if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security") {
-        NSWorkspace.shared.open(url)
-    }
-    #endif
-}

bitchat/Views/LocationNotesView.swift

@@ -12,11 +12,15 @@ struct LocationNotesView: View {
     @Environment(\.dismiss) private var dismiss
     @State private var draft: String = ""
 
-    init(geohash: String, onNotesCountChanged: ((Int) -> Void)? = nil) {
+    init(
+        geohash: String,
+        onNotesCountChanged: ((Int) -> Void)? = nil,
+        manager: LocationNotesManager? = nil
+    ) {
         let gh = geohash.lowercased()
         self.geohash = gh
         self.onNotesCountChanged = onNotesCountChanged
-        _manager = StateObject(wrappedValue: LocationNotesManager(geohash: gh))
+        _manager = StateObject(wrappedValue: manager ?? LocationNotesManager(geohash: gh))
     }
 
     private var backgroundColor: Color { colorScheme == .dark ? .black : .white }
@@ -260,14 +264,13 @@ struct LocationNotesView: View {
     }
 
     private func send() {
-        let content = draft.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let content = draft.trimmedOrNilIfEmpty else { return }
-        guard !content.isEmpty else { return }
         manager.send(content: content, nickname: viewModel.nickname)
         draft = ""
     }
 
     private var sendButtonEnabled: Bool {
-        !draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty && manager.state != .noRelays
+        !draft.trimmed.isEmpty && manager.state != .noRelays
     }
 
     // MARK: - Timestamp Formatting

bitchat/Views/Media/MediaMessageView.swift

@@ -0,0 +1,87 @@
+//
+//  MediaMessageView.swift
+//  bitchat
+//
+//  Created by Islam on 30/03/2026.
+//
+
+import SwiftUI
+
+struct MediaMessageView: View {
+    @Environment(\.colorScheme) private var colorScheme
+
+    @EnvironmentObject var viewModel: ChatViewModel
+    let message: BitchatMessage
+    let media: BitchatMessage.Media
+
+    @Binding var imagePreviewURL: URL?
+
+    var body: some View {
+        let state = mediaSendState(for: message)
+        let isFromMe = message.sender == viewModel.nickname || message.senderPeerID == viewModel.meshService.myPeerID
+        let cancelAction: (() -> Void)? = state.canCancel ? { viewModel.cancelMediaSend(messageID: message.id) } : nil
+
+        VStack(alignment: .leading, spacing: 2) {
+            HStack(alignment: .center, spacing: 4) {
+                Text(viewModel.formatMessageHeader(message, colorScheme: colorScheme))
+                    .fixedSize(horizontal: false, vertical: true)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                if message.isPrivate && message.sender == viewModel.nickname,
+                   let status = message.deliveryStatus {
+                    DeliveryStatusView(status: status)
+                        .padding(.leading, 4)
+                }
+            }
+
+            Group {
+                switch media {
+                case .voice(let url):
+                    VoiceNoteView(
+                        url: url,
+                        isSending: state.isSending,
+                        sendProgress: state.progress,
+                        onCancel: cancelAction
+                    )
+                case .image(let url):
+                    BlockRevealImageView(
+                        url: url,
+                        revealProgress: state.progress,
+                        isSending: state.isSending,
+                        onCancel: cancelAction,
+                        initiallyBlurred: !isFromMe,
+                        onOpen: {
+                            if !state.isSending {
+                                imagePreviewURL = url
+                            }
+                        },
+                        onDelete: !isFromMe ? { viewModel.deleteMediaMessage(messageID: message.id) } : nil
+                    )
+                    .frame(maxWidth: 280)
+                }
+            }
+        }
+        .padding(.vertical, 4)
+    }
+
+    private func mediaSendState(for message: BitchatMessage) -> (isSending: Bool, progress: Double?, canCancel: Bool) {
+        var isSending = false
+        var progress: Double?
+        if let status = message.deliveryStatus {
+            switch status {
+            case .sending:
+                isSending = true
+                progress = 0
+            case .partiallyDelivered(let reached, let total):
+                if total > 0 {
+                    isSending = true
+                    progress = Double(reached) / Double(total)
+                }
+            case .sent, .read, .delivered, .failed:
+                break
+            }
+        }
+        let canCancel = isSending && message.sender == viewModel.nickname
+        let clamped = progress.map { max(0, min(1, $0)) }
+        return (isSending, isSending ? clamped : nil, canCancel)
+    }
+}

bitchat/Views/Media/VoiceNoteView.swift

@@ -34,24 +34,10 @@ struct VoiceNoteView: View {
         colorScheme == .dark ? Color.green.opacity(0.3) : Color.green.opacity(0.2)
     }
 
-    private var durationText: String {
-        let duration = playback.duration
-        guard duration.isFinite, duration > 0 else { return "--:--" }
-        let minutes = Int(duration) / 60
-        let seconds = Int(duration) % 60
-        return String(format: "%02d:%02d", minutes, seconds)
-    }
-
-    private var currentText: String {
-        let current = playback.currentTime
-        guard current.isFinite, current > 0 else { return "00:00" }
-        let minutes = Int(current) / 60
-        let seconds = Int(current) % 60
-        return String(format: "%02d:%02d", minutes, seconds)
-    }
-
     private var playbackLabel: String {
-        playback.isPlaying ? currentText + "/" + durationText : durationText
+        guard playback.duration.isFinite else { return "--:--" }
+        let seconds = playback.isPlaying ? playback.remainingSeconds : playback.roundedDuration
+        return String(format: "%02d:%02d", seconds / 60, seconds % 60)
     }
 
     var body: some View {

bitchat/Views/MessageListView.swift

@@ -0,0 +1,448 @@
+//
+//  MessageListView.swift
+//  bitchat
+//
+//  Created by Islam on 30/03/2026.
+//
+
+import SwiftUI
+
+private struct MessageDisplayItem: Identifiable {
+    let id: String
+    let message: BitchatMessage
+}
+
+struct MessageListView: View {
+    @EnvironmentObject private var viewModel: ChatViewModel
+    @ObservedObject private var locationManager = LocationChannelManager.shared
+
+    @Environment(\.colorScheme) private var colorScheme
+
+    let privatePeer: PeerID?
+    @Binding var isAtBottom: Bool
+    @Binding var messageText: String
+    @Binding var selectedMessageSender: String?
+    @Binding var selectedMessageSenderID: PeerID?
+    @Binding var imagePreviewURL: URL?
+    @Binding var windowCountPublic: Int
+    @Binding var windowCountPrivate: [PeerID: Int]
+    @Binding var showSidebar: Bool
+
+    var isTextFieldFocused: FocusState<Bool>.Binding
+
+    @State private var showMessageActions = false
+    @State private var lastScrollTime: Date = .distantPast
+    @State private var scrollThrottleTimer: Timer?
+
+    var body: some View {
+        let currentWindowCount: Int = {
+            if let peer = privatePeer {
+                return windowCountPrivate[peer] ?? TransportConfig.uiWindowInitialCountPrivate
+            }
+            return windowCountPublic
+        }()
+
+        let messages = viewModel.getMessages(for: privatePeer)
+        let windowedMessages = Array(messages.suffix(currentWindowCount))
+
+        let contextKey: String = {
+            if let peer = privatePeer {
+                "dm:\(peer)"
+            } else {
+                locationManager.selectedChannel.contextKey
+            }
+        }()
+
+        let messageItems: [MessageDisplayItem] = windowedMessages.compactMap { message in
+            guard !message.content.trimmed.isEmpty else { return nil }
+            return MessageDisplayItem(id: "\(contextKey)|\(message.id)", message: message)
+        }
+
+        ScrollViewReader { proxy in
+            ScrollView {
+                LazyVStack(alignment: .leading, spacing: 0) {
+                    ForEach(messageItems) { item in
+                        let message = item.message
+                        messageRow(for: message)
+                            .onAppear {
+                                if message.id == windowedMessages.last?.id {
+                                    isAtBottom = true
+                                }
+                                if message.id == windowedMessages.first?.id,
+                                   messages.count > windowedMessages.count {
+                                    expandWindow(
+                                        ifNeededFor: message,
+                                        allMessages: messages,
+                                        privatePeer: privatePeer,
+                                        proxy: proxy
+                                    )
+                                }
+                            }
+                            .onDisappear {
+                                if message.id == windowedMessages.last?.id {
+                                    isAtBottom = false
+                                }
+                            }
+                            .contentShape(Rectangle())
+                            .onTapGesture {
+                                if message.sender != "system" {
+                                    messageText = "@\(message.sender) "
+                                    isTextFieldFocused.wrappedValue = true
+                                }
+                            }
+                            .contextMenu {
+                                Button("content.message.copy") {
+                                    #if os(iOS)
+                                    UIPasteboard.general.string = message.content
+                                    #else
+                                    let pb = NSPasteboard.general
+                                    pb.clearContents()
+                                    pb.setString(message.content, forType: .string)
+                                    #endif
+                                }
+                            }
+                            .padding(.horizontal, 12)
+                            .padding(.vertical, 1)
+                    }
+                }
+                .transaction { tx in if viewModel.isBatchingPublic { tx.disablesAnimations = true } }
+                .padding(.vertical, 2)
+            }
+            .onOpenURL(perform: handleOpenURL)
+            .onTapGesture(count: 3) {
+                viewModel.sendMessage("/clear")
+            }
+            .onAppear {
+                scrollToBottom(on: proxy)
+            }
+            .onChange(of: privatePeer) { _ in
+                scrollToBottom(on: proxy)
+            }
+            .onChange(of: viewModel.messages.count) { _ in
+                onMessagesChange(proxy: proxy)
+            }
+            .onChange(of: viewModel.privateChats) { _ in
+                onPrivateChatsChange(proxy: proxy)
+            }
+            .onChange(of: locationManager.selectedChannel) { newChannel in
+                onSelectedChannelChange(newChannel, proxy: proxy)
+            }
+            .confirmationDialog(
+                selectedMessageSender.map { "@\($0)" } ?? String(localized: "content.actions.title", comment: "Fallback title for the message action sheet"),
+                isPresented: $showMessageActions,
+                titleVisibility: .visible
+            ) {
+                Button("content.actions.mention") {
+                    if let sender = selectedMessageSender {
+                        // Pre-fill the input with an @mention and focus the field
+                        messageText = "@\(sender) "
+                        isTextFieldFocused.wrappedValue = true
+                    }
+                }
+
+                Button("content.actions.direct_message") {
+                    if let peerID = selectedMessageSenderID {
+                        if peerID.isGeoChat {
+                            if let full = viewModel.fullNostrHex(forSenderPeerID: peerID) {
+                                viewModel.startGeohashDM(withPubkeyHex: full)
+                            }
+                        } else {
+                            viewModel.startPrivateChat(with: peerID)
+                        }
+                        withAnimation(.easeInOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
+                            showSidebar = true
+                        }
+                    }
+                }
+
+                Button("content.actions.hug") {
+                    if let sender = selectedMessageSender {
+                        viewModel.sendMessage("/hug @\(sender)")
+                    }
+                }
+
+                Button("content.actions.slap") {
+                    if let sender = selectedMessageSender {
+                        viewModel.sendMessage("/slap @\(sender)")
+                    }
+                }
+
+                Button("content.actions.block", role: .destructive) {
+                    // Prefer direct geohash block when we have a Nostr sender ID
+                    if let peerID = selectedMessageSenderID, peerID.isGeoChat,
+                       let full = viewModel.fullNostrHex(forSenderPeerID: peerID),
+                       let sender = selectedMessageSender {
+                        viewModel.blockGeohashUser(pubkeyHexLowercased: full, displayName: sender)
+                    } else if let sender = selectedMessageSender {
+                        viewModel.sendMessage("/block \(sender)")
+                    }
+                }
+
+                Button("common.cancel", role: .cancel) {}
+            }
+            .onAppear {
+                // Also check when view appears
+                if let peerID = privatePeer {
+                    // Try multiple times to ensure read receipts are sent
+                    viewModel.markPrivateMessagesAsRead(from: peerID)
+
+                    DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiReadReceiptRetryShortSeconds) {
+                        viewModel.markPrivateMessagesAsRead(from: peerID)
+                    }
+
+                    DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiReadReceiptRetryLongSeconds) {
+                        viewModel.markPrivateMessagesAsRead(from: peerID)
+                    }
+                }
+            }
+            .onDisappear {
+                scrollThrottleTimer?.invalidate()
+            }
+        }
+        .environment(\.openURL, OpenURLAction { url in
+            // Intercept custom cashu: links created in attributed text
+            if let scheme = url.scheme?.lowercased(), scheme == "cashu" || scheme == "lightning" {
+                #if os(iOS)
+                UIApplication.shared.open(url)
+                return .handled
+                #else
+                // On non-iOS platforms, let the system handle or ignore
+                return .systemAction
+                #endif
+            }
+            return .systemAction
+        })
+    }
+}
+
+private extension MessageListView {
+    @ViewBuilder
+    func messageRow(for message: BitchatMessage) -> some View {
+        Group {
+            if message.sender == "system" {
+                systemMessageRow(message)
+            } else if let media = message.mediaAttachment(for: viewModel.nickname) {
+                MediaMessageView(message: message, media: media, imagePreviewURL: $imagePreviewURL)
+            } else {
+                TextMessageView(message: message)
+            }
+        }
+    }
+
+    @ViewBuilder
+    func systemMessageRow(_ message: BitchatMessage) -> some View {
+        Text(viewModel.formatMessageAsText(message, colorScheme: colorScheme))
+            .fixedSize(horizontal: false, vertical: true)
+            .frame(maxWidth: .infinity, alignment: .leading)
+    }
+
+    func expandWindow(ifNeededFor message: BitchatMessage,
+                      allMessages: [BitchatMessage],
+                      privatePeer: PeerID?,
+                      proxy: ScrollViewProxy) {
+        let step = TransportConfig.uiWindowStepCount
+        let contextKey: String = {
+            if let peer = privatePeer {
+                "dm:\(peer)"
+            } else {
+                locationManager.selectedChannel.contextKey
+            }
+        }()
+        let preserveID = "\(contextKey)|\(message.id)"
+
+        if let peer = privatePeer {
+            let current = windowCountPrivate[peer] ?? TransportConfig.uiWindowInitialCountPrivate
+            let newCount = min(allMessages.count, current + step)
+            guard newCount != current else { return }
+            windowCountPrivate[peer] = newCount
+            DispatchQueue.main.async {
+                proxy.scrollTo(preserveID, anchor: .top)
+            }
+        } else {
+            let current = windowCountPublic
+            let newCount = min(allMessages.count, current + step)
+            guard newCount != current else { return }
+            windowCountPublic = newCount
+            DispatchQueue.main.async {
+                proxy.scrollTo(preserveID, anchor: .top)
+            }
+        }
+    }
+
+    func handleOpenURL(_ url: URL) {
+        guard url.scheme == "bitchat" else { return }
+        switch url.host {
+        case "user":
+            let id = url.path.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+            let peerID = PeerID(str: id.removingPercentEncoding ?? id)
+            selectedMessageSenderID = peerID
+
+            if peerID.isGeoDM || peerID.isGeoChat {
+                selectedMessageSender = viewModel.geohashDisplayName(for: peerID)
+            } else if let name = viewModel.meshService.peerNickname(peerID: peerID) {
+                selectedMessageSender = name
+            } else {
+                selectedMessageSender = viewModel.messages.last(where: { $0.senderPeerID == peerID && $0.sender != "system" })?.sender
+            }
+
+            if viewModel.isSelfSender(peerID: peerID, displayName: selectedMessageSender) {
+                selectedMessageSender = nil
+                selectedMessageSenderID = nil
+            } else {
+                showMessageActions = true
+            }
+
+        case "geohash":
+            let gh = url.path.trimmingCharacters(in: CharacterSet(charactersIn: "/")).lowercased()
+            let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
+            guard (2...12).contains(gh.count), gh.allSatisfy({ allowed.contains($0) }) else { return }
+
+            func levelForLength(_ len: Int) -> GeohashChannelLevel {
+                switch len {
+                case 0...2: return .region
+                case 3...4: return .province
+                case 5: return .city
+                case 6: return .neighborhood
+                case 7: return .block
+                default: return .block
+                }
+            }
+
+            let level = levelForLength(gh.count)
+            let channel = GeohashChannel(level: level, geohash: gh)
+
+            let inRegional = LocationChannelManager.shared.availableChannels.contains { $0.geohash == gh }
+            if !inRegional && !LocationChannelManager.shared.availableChannels.isEmpty {
+                LocationChannelManager.shared.markTeleported(for: gh, true)
+            }
+            LocationChannelManager.shared.select(ChannelID.location(channel))
+
+        default:
+            return
+        }
+    }
+
+    func scrollToBottom(on proxy: ScrollViewProxy) {
+        isAtBottom = true
+        if let targetPeerID {
+            proxy.scrollTo(targetPeerID, anchor: .bottom)
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
+            if let secondTarget = self.targetPeerID {
+                proxy.scrollTo(secondTarget, anchor: .bottom)
+            }
+        }
+    }
+
+    var targetPeerID: String? {
+        if let peer = privatePeer,
+           let last = viewModel.getPrivateChatMessages(for: peer).suffix(300).last?.id {
+            return "dm:\(peer)|\(last)"
+        }
+        if let last = viewModel.messages.suffix(300).last?.id {
+            return "\(locationManager.selectedChannel.contextKey)|\(last)"
+        }
+        return nil
+    }
+
+    func onMessagesChange(proxy: ScrollViewProxy) {
+        guard privatePeer == nil, let lastMsg = viewModel.messages.last else { return }
+
+        // If the newest message is from me, always scroll to bottom
+        let isFromSelf = (lastMsg.sender == viewModel.nickname) || lastMsg.sender.hasPrefix(viewModel.nickname + "#")
+        if !isFromSelf && !isAtBottom { // Only autoscroll when user is at/near bottom
+            return
+        } else { // Ensure we consider ourselves at bottom for subsequent messages
+            isAtBottom = true
+        }
+
+        func scrollIfNeeded(date: Date) {
+            lastScrollTime = date
+            let contextKey = locationManager.selectedChannel.contextKey
+            if let target = viewModel.messages.suffix(windowCountPublic).last.map({ "\(contextKey)|\($0.id)" }) {
+                proxy.scrollTo(target, anchor: .bottom)
+            }
+        }
+
+        // Throttle scroll animations to prevent excessive UI updates
+        let now = Date()
+        if now.timeIntervalSince(lastScrollTime) > TransportConfig.uiScrollThrottleSeconds {
+            // Immediate scroll if enough time has passed
+            scrollIfNeeded(date: now)
+        } else {
+            // Schedule a delayed scroll
+            scrollThrottleTimer?.invalidate()
+            scrollThrottleTimer = Timer.scheduledTimer(withTimeInterval: TransportConfig.uiScrollThrottleSeconds, repeats: false) { _ in
+                Task { @MainActor in
+                    scrollIfNeeded(date: Date())
+                }
+            }
+        }
+    }
+
+    func onPrivateChatsChange(proxy: ScrollViewProxy) {
+        guard let peerID = privatePeer, let messages = viewModel.privateChats[peerID], let lastMsg = messages.last else {
+            return
+        }
+
+        // If the newest private message is from me, always scroll
+        let isFromSelf = (lastMsg.sender == viewModel.nickname) || lastMsg.sender.hasPrefix(viewModel.nickname + "#")
+        if !isFromSelf && !isAtBottom { // Only autoscroll when user is at/near bottom
+            return
+        } else {
+            isAtBottom = true
+        }
+
+        func scrollIfNeeded(date: Date) {
+            lastScrollTime = date
+            let contextKey = "dm:\(peerID)"
+            let count = windowCountPrivate[peerID] ?? 300
+            if let target = messages.suffix(count).last.map({ "\(contextKey)|\($0.id)" }){
+                proxy.scrollTo(target, anchor: .bottom)
+            }
+        }
+
+        // Same throttling for private chats
+        let now = Date()
+        if now.timeIntervalSince(lastScrollTime) > TransportConfig.uiScrollThrottleSeconds {
+            scrollIfNeeded(date: now)
+        } else {
+            scrollThrottleTimer?.invalidate()
+            scrollThrottleTimer = Timer.scheduledTimer(withTimeInterval: TransportConfig.uiScrollThrottleSeconds, repeats: false) { _ in
+                Task { @MainActor in
+                    scrollIfNeeded(date: Date())
+                }
+            }
+        }
+    }
+
+    func onSelectedChannelChange(_ channel: ChannelID, proxy: ScrollViewProxy) {
+        // When switching to a new geohash channel, scroll to the bottom
+        guard privatePeer == nil else { return }
+        switch channel {
+        case .mesh:
+            break
+        case .location(let ch):
+            // Reset window size
+            isAtBottom = true
+            windowCountPublic = TransportConfig.uiWindowInitialCountPublic
+            let contextKey = "geo:\(ch.geohash)"
+            if let target = viewModel.messages.suffix(windowCountPublic).last?.id.map({ "\(contextKey)|\($0)" }) {
+                proxy.scrollTo(target, anchor: .bottom)
+            }
+        }
+    }
+}
+
+private extension ChannelID {
+    var contextKey: String {
+        switch self {
+        case .mesh:             "mesh"
+        case .location(let ch): "geo:\(ch.geohash)"
+        }
+    }
+}
+
+//#Preview {
+//    MessageListView()
+//}

bitchat/Views/MessageTextHelpers.swift

@@ -5,21 +5,6 @@
 
 import Foundation
 
-private enum RegexCache {
-    static let cashu: NSRegularExpression = {
-        try! NSRegularExpression(pattern: "\\bcashu[AB][A-Za-z0-9._-]{40,}\\b", options: [])
-    }()
-    static let lightningScheme: NSRegularExpression = {
-        try! NSRegularExpression(pattern: "(?i)\\blightning:[^\\s]+", options: [])
-    }()
-    static let bolt11: NSRegularExpression = {
-        try! NSRegularExpression(pattern: "(?i)\\bln(bc|tb|bcrt)[0-9][a-z0-9]{50,}\\b", options: [])
-    }()
-    static let lnurl: NSRegularExpression = {
-        try! NSRegularExpression(pattern: "(?i)\\blnurl1[a-z0-9]{20,}\\b", options: [])
-    }()
-}
-
 extension String {
     // Detect if there is an extremely long token (no whitespace/newlines) that could break layout
     func hasVeryLongToken(threshold: Int) -> Bool {
@@ -38,7 +23,7 @@ extension String {
 
     // Extract up to `max` Cashu tokens (cashuA/cashuB). Allow dot '.' and shorter lengths.
     func extractCashuLinks(max: Int = 3) -> [String] {
-        let regex = RegexCache.cashu
+        let regex = MessageFormattingEngine.Patterns.cashu
         let ns = self as NSString
         let range = NSRange(location: 0, length: ns.length)
         var found: [String] = []
@@ -59,19 +44,19 @@ extension String {
         let ns = self as NSString
         let full = NSRange(location: 0, length: ns.length)
         // lightning: scheme
-        for m in RegexCache.lightningScheme.matches(in: self, range: full) {
+        for m in MessageFormattingEngine.Patterns.lightningScheme.matches(in: self, range: full) {
             let s = ns.substring(with: m.range(at: 0))
             results.append(s)
             if results.count >= max { return results }
         }
         // BOLT11
-        for m in RegexCache.bolt11.matches(in: self, range: full) {
+        for m in MessageFormattingEngine.Patterns.bolt11.matches(in: self, range: full) {
             let s = ns.substring(with: m.range(at: 0))
             results.append("lightning:\(s)")
             if results.count >= max { return results }
         }
         // LNURL bech32
-        for m in RegexCache.lnurl.matches(in: self, range: full) {
+        for m in MessageFormattingEngine.Patterns.lnurl.matches(in: self, range: full) {
             let s = ns.substring(with: m.range(at: 0))
             results.append("lightning:\(s)")
             if results.count >= max { return results }

bitchat/_PreviewHelpers/PreviewAssets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

bitchat/_PreviewHelpers/PreviewAssets.xcassets/dummy.imageset/Contents.json

@@ -0,0 +1,21 @@
+{
+  "images" : [
+    {
+      "filename" : "dummy.jpg",
+      "idiom" : "universal",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "universal",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "universal",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

bitchat/_PreviewHelpers/PreviewKeychainManager.swift

@@ -41,6 +41,19 @@ final class PreviewKeychainManager: KeychainManagerProtocol {
         storage["identity_noiseStaticKey"] != nil
     }
 
+    // BCH-01-009: New methods with proper error classification
+    func getIdentityKeyWithResult(forKey key: String) -> KeychainReadResult {
+        if let data = storage[key] {
+            return .success(data)
+        }
+        return .itemNotFound
+    }
+
+    func saveIdentityKeyWithResult(_ keyData: Data, forKey key: String) -> KeychainSaveResult {
+        storage[key] = keyData
+        return .success
+    }
+
     // MARK: - Generic Data Storage (consolidated from KeychainHelper)
 
     func save(key: String, data: Data, service: String, accessible: CFString?) {

bitchat/bitchat-macOS.entitlements

@@ -6,7 +6,7 @@
 	<true/>
 	<key>com.apple.security.application-groups</key>
 	<array>
-		<string>group.chat.bitchat</string>
+		<string>$(APP_GROUP_ID)</string>
 	</array>
 	<key>com.apple.security.device.bluetooth</key>
 	<true/>

bitchat/bitchat.entitlements

@@ -6,7 +6,7 @@
 	<true/>
 	<key>com.apple.security.application-groups</key>
 	<array>
-		<string>group.chat.bitchat</string>
+		<string>$(APP_GROUP_ID)</string>
 	</array>
 	<key>com.apple.security.device.bluetooth</key>
 	<true/>

bitchatShareExtension/Info.plist

@@ -2,6 +2,8 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>AppGroupID</key>
+	<string>$(APP_GROUP_ID)</string>
 	<key>CFBundleDevelopmentRegion</key>
 	<string>$(DEVELOPMENT_LANGUAGE)</string>
 	<key>CFBundleDisplayName</key>

bitchatShareExtension/ShareViewController.swift

@@ -13,7 +13,7 @@ import UniformTypeIdentifiers
 /// Avoids deprecated Social framework and SLComposeServiceViewController.
 final class ShareViewController: UIViewController {
     // Bundle.main.bundleIdentifier would get the extension's bundleID
-    private static let groupID = "group.chat.bitchat"
+    private static let groupID = Bundle.main.object(forInfoDictionaryKey: "AppGroupID") as? String ?? "group.chat.bitchat"
 
     private enum Strings {
         static let nothingToShare = String(localized: "share.status.nothing_to_share", comment: "Shown when the share extension receives no content")

bitchatShareExtension/bitchatShareExtension.entitlements

@@ -6,7 +6,7 @@
 	<true/>
 	<key>com.apple.security.application-groups</key>
 	<array>
-		<string>group.chat.bitchat</string>
+		<string>$(APP_GROUP_ID)</string>
 	</array>
 </dict>
 </plist>

bitchatTests/BLEServiceCoreTests.swift

@@ -0,0 +1,153 @@
+//
+// BLEServiceCoreTests.swift
+// bitchatTests
+//
+// Focused BLEService tests for packet handling behavior.
+//
+
+import Testing
+import Foundation
+import CoreBluetooth
+@testable import bitchat
+
+struct BLEServiceCoreTests {
+
+    @Test
+    func duplicatePacket_isDeduped() async {
+        let ble = makeService()
+        let delegate = PublicCaptureDelegate()
+        ble.delegate = delegate
+
+        let sender = PeerID(str: "1122334455667788")
+        let timestamp = UInt64(Date().timeIntervalSince1970 * 1000)
+        let packet = makePublicPacket(content: "Hello", sender: sender, timestamp: timestamp)
+
+        ble._test_handlePacket(packet, fromPeerID: sender)
+        let receivedFirst = await TestHelpers.waitUntil(
+            { delegate.publicMessagesSnapshot().count == 1 },
+            timeout: TestConstants.defaultTimeout
+        )
+        #expect(receivedFirst)
+
+        ble._test_handlePacket(packet, fromPeerID: sender)
+        let receivedDuplicate = await TestHelpers.waitUntil(
+            { delegate.publicMessagesSnapshot().count > 1 },
+            timeout: TestConstants.shortTimeout
+        )
+        #expect(!receivedDuplicate)
+
+        let messages = delegate.publicMessagesSnapshot()
+        #expect(messages.count == 1)
+        #expect(messages.first?.content == "Hello")
+    }
+
+    @Test
+    func staleBroadcast_isIgnored() async {
+        let ble = makeService()
+        let delegate = PublicCaptureDelegate()
+        ble.delegate = delegate
+
+        let sender = PeerID(str: "A1B2C3D4E5F60708")
+        let oldTimestamp = UInt64(Date().addingTimeInterval(-901).timeIntervalSince1970 * 1000)
+        let packet = makePublicPacket(content: "Old", sender: sender, timestamp: oldTimestamp)
+
+        ble._test_handlePacket(packet, fromPeerID: sender)
+
+        let didReceive = await TestHelpers.waitUntil({ !delegate.publicMessagesSnapshot().isEmpty }, timeout: 0.3)
+        #expect(!didReceive)
+        #expect(delegate.publicMessagesSnapshot().isEmpty)
+    }
+
+    @Test
+    func announceSenderMismatch_isRejected() async throws {
+        let ble = makeService()
+
+        let signer = NoiseEncryptionService(keychain: MockKeychain())
+        let announcement = AnnouncementPacket(
+            nickname: "Spoof",
+            noisePublicKey: signer.getStaticPublicKeyData(),
+            signingPublicKey: signer.getSigningPublicKeyData(),
+            directNeighbors: nil
+        )
+        let payload = try #require(announcement.encode(), "Failed to encode announcement")
+
+        let derivedPeerID = PeerID(publicKey: announcement.noisePublicKey)
+        let wrongFirst = derivedPeerID.bare.first == "0" ? "1" : "0"
+        let wrongBare = String(wrongFirst) + String(derivedPeerID.bare.dropFirst())
+        let wrongPeerID = PeerID(str: wrongBare)
+        let packet = BitchatPacket(
+            type: MessageType.announce.rawValue,
+            senderID: Data(hexString: wrongPeerID.id) ?? Data(),
+            recipientID: nil,
+            timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
+            payload: payload,
+            signature: nil,
+            ttl: 7
+        )
+        let signed = try #require(signer.signPacket(packet), "Failed to sign announce packet")
+
+        ble._test_handlePacket(signed, fromPeerID: wrongPeerID, preseedPeer: false)
+
+        _ = await TestHelpers.waitUntil({ !ble.currentPeerSnapshots().isEmpty }, timeout: 0.3)
+        #expect(ble.currentPeerSnapshots().isEmpty)
+    }
+}
+
+private func makeService() -> BLEService {
+    let keychain = MockKeychain()
+    let identityManager = MockIdentityManager(keychain)
+    let idBridge = NostrIdentityBridge(keychain: MockKeychainHelper())
+    return BLEService(
+        keychain: keychain,
+        idBridge: idBridge,
+        identityManager: identityManager,
+        initializeBluetoothManagers: false
+    )
+}
+
+private func makePublicPacket(content: String, sender: PeerID, timestamp: UInt64) -> BitchatPacket {
+    BitchatPacket(
+        type: MessageType.message.rawValue,
+        senderID: Data(hexString: sender.id) ?? Data(),
+        recipientID: nil,
+        timestamp: timestamp,
+        payload: Data(content.utf8),
+        signature: nil,
+        ttl: 3
+    )
+}
+
+private final class PublicCaptureDelegate: BitchatDelegate {
+    private let lock = NSLock()
+    private(set) var publicMessages: [BitchatMessage] = []
+
+    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {
+        let message = BitchatMessage(
+            id: messageID,
+            sender: nickname,
+            content: content,
+            timestamp: timestamp,
+            isRelay: false,
+            originalSender: nil,
+            isPrivate: false,
+            recipientNickname: nil,
+            senderPeerID: peerID,
+            mentions: nil
+        )
+        lock.lock()
+        publicMessages.append(message)
+        lock.unlock()
+    }
+
+    func didReceiveMessage(_ message: BitchatMessage) {}
+    func didConnectToPeer(_ peerID: PeerID) {}
+    func didDisconnectFromPeer(_ peerID: PeerID) {}
+    func didUpdatePeerList(_ peers: [PeerID]) {}
+    func didUpdateBluetoothState(_ state: CBManagerState) {}
+
+    func publicMessagesSnapshot() -> [BitchatMessage] {
+        lock.lock()
+        defer { lock.unlock() }
+        return publicMessages
+    }
+}

bitchatTests/BLEServiceTests.swift

@@ -73,7 +73,7 @@ struct BLEServiceTests {
             service.sendMessage("Hello, world!")
             
             // Allow async processing
-            try await sleep(0.5)
+            try await sleep(1.0)
         }
         #expect(service.sentMessages.count == 1)
     }
@@ -97,7 +97,7 @@ struct BLEServiceTests {
             )
             
             // Allow async processing
-            try await sleep(0.5)
+            try await sleep(1.0)
         }
         #expect(service.sentMessages.count == 1)
     }
@@ -113,7 +113,7 @@ struct BLEServiceTests {
             service.sendMessage("@alice @bob check this out", mentions: ["alice", "bob"])
             
             // Allow async processing
-            try await sleep(0.5)
+            try await sleep(1.0)
         }
     }
     
@@ -146,7 +146,7 @@ struct BLEServiceTests {
             service.simulateIncomingMessage(incomingMessage)
             
             // Allow async processing
-            try await sleep(0.5)
+            try await sleep(1.0)
         }
     }
     
@@ -189,7 +189,7 @@ struct BLEServiceTests {
             service.simulateIncomingPacket(packet)
             
             // Allow async processing
-            try await sleep(0.5)
+            try await sleep(1.0)
         }
     }
     
@@ -231,7 +231,7 @@ struct BLEServiceTests {
             service.sendMessage("Test delivery")
             
             // Allow async processing
-            try await sleep(0.5)
+            try await sleep(1.0)
         }
     }
     
@@ -273,7 +273,7 @@ struct BLEServiceTests {
             service.simulateIncomingPacket(packet)
             
             // Allow async processing
-            try await sleep(0.5)
+            try await sleep(1.0)
         }
     }
 }

bitchatTests/BitchatPeerTests.swift

@@ -0,0 +1,83 @@
+import Foundation
+import Testing
+@testable import bitchat
+
+@Suite("BitchatPeer Tests")
+struct BitchatPeerTests {
+    typealias FavoriteRelationship = FavoritesPersistenceService.FavoriteRelationship
+
+    @Test("Connection state prioritizes bluetooth, mesh, nostr, then offline")
+    func connectionStatePriorityIsCorrect() {
+        let peerID = PeerID(str: "0123456789abcdef")
+        let noiseKey = Data((0..<32).map(UInt8.init))
+        let mutual = makeRelationship(isFavorite: true, theyFavoritedUs: true)
+
+        let bluetooth = BitchatPeer(peerID: peerID, noisePublicKey: noiseKey, nickname: "A", isConnected: true, isReachable: true)
+        let mesh = BitchatPeer(peerID: peerID, noisePublicKey: noiseKey, nickname: "A", isConnected: false, isReachable: true)
+        var nostr = BitchatPeer(peerID: peerID, noisePublicKey: noiseKey, nickname: "A", isConnected: false, isReachable: false)
+        nostr.favoriteStatus = mutual
+        let offline = BitchatPeer(peerID: peerID, noisePublicKey: noiseKey, nickname: "A", isConnected: false, isReachable: false)
+
+        #expect(bluetooth.connectionState == .bluetoothConnected)
+        #expect(mesh.connectionState == .meshReachable)
+        #expect(nostr.connectionState == .nostrAvailable)
+        #expect(offline.connectionState == .offline)
+    }
+
+    @Test("Display name falls back to peer prefix and offline icon reflects inbound favorite")
+    func displayNameAndOfflineIconUseDerivedState() {
+        let peerID = PeerID(str: "fedcba9876543210")
+        let noiseKey = Data((32..<64).map(UInt8.init))
+        var peer = BitchatPeer(peerID: peerID, noisePublicKey: noiseKey, nickname: "", isConnected: false, isReachable: false)
+        peer.favoriteStatus = makeRelationship(isFavorite: false, theyFavoritedUs: true)
+
+        #expect(peer.displayName == String(peerID.id.prefix(8)))
+        #expect(peer.statusIcon == "🌙")
+    }
+
+    @Test("Mutual offline peers show Nostr icon")
+    func mutualFavoriteOfflinePeerShowsNostrIcon() {
+        let peerID = PeerID(str: "0011223344556677")
+        let noiseKey = Data((64..<96).map(UInt8.init))
+        var peer = BitchatPeer(peerID: peerID, noisePublicKey: noiseKey, nickname: "Peer", isConnected: false, isReachable: false)
+        peer.favoriteStatus = makeRelationship(isFavorite: true, theyFavoritedUs: true)
+
+        #expect(peer.statusIcon == "🌐")
+        #expect(peer.isFavorite)
+        #expect(peer.isMutualFavorite)
+        #expect(peer.theyFavoritedUs)
+    }
+
+    @Test("Equality is based only on peer ID")
+    func equalityUsesPeerIDOnly() {
+        let peerID = PeerID(str: "8899aabbccddeeff")
+        let first = BitchatPeer(
+            peerID: peerID,
+            noisePublicKey: Data(repeating: 1, count: 32),
+            nickname: "First",
+            isConnected: false,
+            isReachable: false
+        )
+        let second = BitchatPeer(
+            peerID: peerID,
+            noisePublicKey: Data(repeating: 2, count: 32),
+            nickname: "Second",
+            isConnected: true,
+            isReachable: true
+        )
+
+        #expect(first == second)
+    }
+
+    private func makeRelationship(isFavorite: Bool, theyFavoritedUs: Bool) -> FavoriteRelationship {
+        FavoriteRelationship(
+            peerNoisePublicKey: Data(repeating: 7, count: 32),
+            peerNostrPublicKey: "npub1example",
+            peerNickname: "Peer",
+            isFavorite: isFavorite,
+            theyFavoritedUs: theyFavoritedUs,
+            favoritedAt: Date(timeIntervalSince1970: 1),
+            lastUpdated: Date(timeIntervalSince1970: 2)
+        )
+    }
+}

bitchatTests/ChatViewModelDeliveryStatusTests.swift

@@ -0,0 +1,228 @@
+//
+// ChatViewModelDeliveryStatusTests.swift
+// bitchatTests
+//
+// Tests for ChatViewModel delivery status state machine.
+//
+
+import Testing
+import Foundation
+@testable import bitchat
+
+// MARK: - Test Helpers
+
+@MainActor
+private func makeTestableViewModel() -> (viewModel: ChatViewModel, transport: MockTransport) {
+    let keychain = MockKeychain()
+    let keychainHelper = MockKeychainHelper()
+    let idBridge = NostrIdentityBridge(keychain: keychainHelper)
+    let identityManager = MockIdentityManager(keychain)
+    let transport = MockTransport()
+
+    let viewModel = ChatViewModel(
+        keychain: keychain,
+        idBridge: idBridge,
+        identityManager: identityManager,
+        transport: transport
+    )
+
+    return (viewModel, transport)
+}
+
+// MARK: - Delivery Status Tests
+
+struct ChatViewModelDeliveryStatusTests {
+
+    // MARK: - Status Transition Tests
+
+    @Test @MainActor
+    func deliveryStatus_noDowngrade_readToDelivered() async {
+        let (viewModel, transport) = makeTestableViewModel()
+        let peerID = PeerID(str: "0102030405060708")
+        let messageID = "test-msg-1"
+
+        // Setup: create a message with .read status
+        let message = BitchatMessage(
+            id: messageID,
+            sender: viewModel.nickname,
+            content: "Test message",
+            timestamp: Date(),
+            isRelay: false,
+            isPrivate: true,
+            recipientNickname: "Peer",
+            senderPeerID: transport.myPeerID,
+            deliveryStatus: .read(by: "Peer", at: Date())
+        )
+        viewModel.privateChats[peerID] = [message]
+
+        // Action: try to downgrade to .delivered
+        viewModel.didUpdateMessageDeliveryStatus(messageID, status: .delivered(to: "Peer", at: Date()))
+
+        // Assert: status should remain .read (no downgrade)
+        let currentStatus = viewModel.privateChats[peerID]?.first?.deliveryStatus
+        #expect({
+            if case .read = currentStatus { return true }
+            return false
+        }())
+    }
+
+    @Test @MainActor
+    func deliveryStatus_upgrade_sentToDelivered() async {
+        let (viewModel, transport) = makeTestableViewModel()
+        let peerID = PeerID(str: "0102030405060708")
+        let messageID = "test-msg-2"
+
+        // Setup: create a message with .sent status
+        let message = BitchatMessage(
+            id: messageID,
+            sender: viewModel.nickname,
+            content: "Test message",
+            timestamp: Date(),
+            isRelay: false,
+            isPrivate: true,
+            recipientNickname: "Peer",
+            senderPeerID: transport.myPeerID,
+            deliveryStatus: .sent
+        )
+        viewModel.privateChats[peerID] = [message]
+
+        // Action: upgrade to .delivered
+        viewModel.didUpdateMessageDeliveryStatus(messageID, status: .delivered(to: "Peer", at: Date()))
+
+        // Assert: status should be .delivered
+        let currentStatus = viewModel.privateChats[peerID]?.first?.deliveryStatus
+        #expect({
+            if case .delivered = currentStatus { return true }
+            return false
+        }())
+    }
+
+    @Test @MainActor
+    func deliveryStatus_upgrade_deliveredToRead() async {
+        let (viewModel, transport) = makeTestableViewModel()
+        let peerID = PeerID(str: "0102030405060708")
+        let messageID = "test-msg-3"
+
+        // Setup: create a message with .delivered status
+        let message = BitchatMessage(
+            id: messageID,
+            sender: viewModel.nickname,
+            content: "Test message",
+            timestamp: Date(),
+            isRelay: false,
+            isPrivate: true,
+            recipientNickname: "Peer",
+            senderPeerID: transport.myPeerID,
+            deliveryStatus: .delivered(to: "Peer", at: Date().addingTimeInterval(-60))
+        )
+        viewModel.privateChats[peerID] = [message]
+
+        // Action: upgrade to .read
+        viewModel.didUpdateMessageDeliveryStatus(messageID, status: .read(by: "Peer", at: Date()))
+
+        // Assert: status should be .read
+        let currentStatus = viewModel.privateChats[peerID]?.first?.deliveryStatus
+        #expect({
+            if case .read = currentStatus { return true }
+            return false
+        }())
+    }
+
+    // MARK: - Read Receipt Handling
+
+    @Test @MainActor
+    func didReceiveReadReceipt_updatesMessageStatus() async {
+        let (viewModel, transport) = makeTestableViewModel()
+        let peerID = PeerID(str: "0102030405060708")
+        let messageID = "test-msg-4"
+
+        // Setup: create a message with .sent status
+        let message = BitchatMessage(
+            id: messageID,
+            sender: viewModel.nickname,
+            content: "Test message",
+            timestamp: Date(),
+            isRelay: false,
+            isPrivate: true,
+            recipientNickname: "Peer",
+            senderPeerID: transport.myPeerID,
+            deliveryStatus: .sent
+        )
+        viewModel.privateChats[peerID] = [message]
+
+        // Action: receive read receipt
+        let receipt = ReadReceipt(
+            originalMessageID: messageID,
+            readerID: peerID,
+            readerNickname: "Peer"
+        )
+        viewModel.didReceiveReadReceipt(receipt)
+
+        // Assert: status should be .read
+        let currentStatus = viewModel.privateChats[peerID]?.first?.deliveryStatus
+        #expect({
+            if case .read = currentStatus { return true }
+            return false
+        }())
+    }
+
+    // MARK: - Public Timeline Status Tests
+
+    @Test @MainActor
+    func deliveryStatus_publicTimeline_updatesCorrectly() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let messageID = "public-msg-1"
+
+        // Setup: add a message to public timeline with .sending status
+        let message = BitchatMessage(
+            id: messageID,
+            sender: viewModel.nickname,
+            content: "Public message",
+            timestamp: Date(),
+            isRelay: false,
+            isPrivate: false,
+            deliveryStatus: .sending
+        )
+        viewModel.messages.append(message)
+
+        // Action: update to .sent
+        viewModel.didUpdateMessageDeliveryStatus(messageID, status: .sent)
+
+        // Assert
+        let updatedMessage = viewModel.messages.first(where: { $0.id == messageID })
+        #expect({
+            if case .sent = updatedMessage?.deliveryStatus { return true }
+            return false
+        }())
+    }
+
+    // MARK: - Status Rank Tests (for deduplication)
+
+    @Test @MainActor
+    func statusRank_orderingIsCorrect() async {
+        // This tests the implicit ordering used in refreshVisibleMessages
+        // failed < sending < sent < partiallyDelivered < delivered < read
+
+        let statuses: [DeliveryStatus] = [
+            .failed(reason: "test"),
+            .sending,
+            .sent,
+            .partiallyDelivered(reached: 1, total: 3),
+            .delivered(to: "B", at: Date()),
+            .read(by: "C", at: Date())
+        ]
+
+        // Verify each status has a logical progression
+        // This is more of a documentation test to ensure the ranking logic is understood
+        for (index, status) in statuses.enumerated() {
+            switch status {
+            case .failed: #expect(index == 0)
+            case .sending: #expect(index == 1)
+            case .sent: #expect(index == 2)
+            case .partiallyDelivered: #expect(index == 3)
+            case .delivered: #expect(index == 4)
+            case .read: #expect(index == 5)
+            }
+        }
+    }
+}

bitchatTests/ChatViewModelExtensionsTests.swift

@@ -8,6 +8,11 @@
 import Testing
 import Foundation
 import Combine
+#if os(iOS)
+import UIKit
+#else
+import AppKit
+#endif
 @testable import bitchat
 
 // MARK: - Test Helpers
@@ -64,6 +69,22 @@ struct ChatViewModelPrivateChatExtensionTests {
         // MockTransport.sendPrivateMessage is what MessageRouter calls for connected peers
         // Check MockTransport implementation... it might need update or verification
     }
+
+    @Test @MainActor
+    func sendPrivateMessage_unreachable_setsFailedStatus() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let validHex = "0102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f10"
+        let peerID = PeerID(str: validHex)
+
+        viewModel.sendPrivateMessage("Hello", to: peerID)
+
+        #expect(viewModel.privateChats[peerID]?.count == 1)
+        let status = viewModel.privateChats[peerID]?.last?.deliveryStatus
+        #expect({
+            if case .failed = status { return true }
+            return false
+        }())
+    }
     
     @Test @MainActor
     func handlePrivateMessage_storesMessage() async {
@@ -249,37 +270,872 @@ struct ChatViewModelNostrExtensionTests {
     }
     
     @Test @MainActor
-    func subscribeNostrEvent_addsToTimeline_ifMatchesGeohash() async {
+    func subscribeNostrEvent_addsToTimeline_ifMatchesGeohash() async throws {
-        let (viewModel, _) = makeTestableViewModel()
         let geohash = "u4pruydq"
+        let channel = ChannelID.location(GeohashChannel(level: .city, geohash: geohash))
+
+        LocationChannelManager.shared.select(channel)
+        defer { LocationChannelManager.shared.select(.mesh) }
+
+        _ = await TestHelpers.waitUntil({ LocationChannelManager.shared.selectedChannel == channel })
+
+        let (viewModel, _) = makeTestableViewModel()
         
-        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+        _ = await TestHelpers.waitUntil({ viewModel.activeChannel == channel })
         
-        var event = NostrEvent(
+        let signer = try NostrIdentity.generate()
-            pubkey: "pub1",
+        let event = NostrEvent(
+            pubkey: signer.publicKeyHex,
             createdAt: Date(),
             kind: .ephemeralEvent,
             tags: [["g", geohash]],
             content: "Hello Geo"
         )
-        event.id = "evt1"
+        let signed = try event.sign(with: signer.schnorrSigningKey())
-        event.sig = "sig"
+        viewModel.handleNostrEvent(signed)
         
-        viewModel.handleNostrEvent(event)
+        let didAppend = await TestHelpers.waitUntil({
-        
+            viewModel.publicMessagePipeline.flushIfNeeded()
-        // Allow async processing
+            return viewModel.messages.contains { $0.content == "Hello Geo" }
+        })
+        #expect(didAppend)
+    }
+
+    @Test @MainActor
+    func handleNostrEvent_ignoresRecentSelfEcho() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+        let identity = try viewModel.idBridge.deriveIdentity(forGeohash: geohash)
+
+        let event = NostrEvent(
+            pubkey: identity.publicKeyHex,
+            createdAt: Date(),
+            kind: .ephemeralEvent,
+            tags: [["g", geohash]],
+            content: "Self echo"
+        )
+        let signed = try event.sign(with: identity.schnorrSigningKey())
+        viewModel.handleNostrEvent(signed)
+
         try? await Task.sleep(nanoseconds: 100_000_000)
-        
+        viewModel.publicMessagePipeline.flushIfNeeded()
-        // Check timeline
+
-        // This depends on `handlePublicMessage` being called and updating `messages`
+        #expect(!viewModel.messages.contains { $0.content == "Self echo" })
-        // Since `handlePublicMessage` delegates to `timelineStore` and updates `messages`...
+    }
-        // And we are in the correct channel...
+
-        
+    @Test @MainActor
-        // However, `handleNostrEvent` in the extension now calls `handlePublicMessage`.
+    func handleNostrEvent_skipsBlockedSender() async throws {
-        // Let's verify if the message appears.
+        let (viewModel, _) = makeTestableViewModel()
-        // Note: `handleNostrEvent` logic was refactored.
+        let geohash = "u4pruydq"
-        // The new logic in `ChatViewModel+Nostr.swift` calls `handlePublicMessage`.
+        let blockedIdentity = try NostrIdentity.generate()
-        
+        let blockedPubkey = blockedIdentity.publicKeyHex
-        // We need to ensure `deduplicationService` doesn't block it (new instance, so empty).
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+        viewModel.identityManager.setNostrBlocked(blockedPubkey, isBlocked: true)
+
+        let event = NostrEvent(
+            pubkey: blockedPubkey,
+            createdAt: Date(),
+            kind: .ephemeralEvent,
+            tags: [["g", geohash]],
+            content: "Blocked"
+        )
+        let signed = try event.sign(with: blockedIdentity.schnorrSigningKey())
+        viewModel.handleNostrEvent(signed)
+
+        try? await Task.sleep(nanoseconds: 100_000_000)
+        viewModel.publicMessagePipeline.flushIfNeeded()
+
+        #expect(!viewModel.messages.contains { $0.content == "Blocked" })
+    }
+
+    @Test @MainActor
+    func handleNostrEvent_rejectsInvalidSignature() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+        let identity = try NostrIdentity.generate()
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+
+        let event = NostrEvent(
+            pubkey: identity.publicKeyHex,
+            createdAt: Date(),
+            kind: .ephemeralEvent,
+            tags: [["g", geohash]],
+            content: "Valid"
+        )
+        var signed = try event.sign(with: identity.schnorrSigningKey())
+        signed.id = "deadbeef"
+
+        viewModel.handleNostrEvent(signed)
+
+        try? await Task.sleep(nanoseconds: 100_000_000)
+        viewModel.publicMessagePipeline.flushIfNeeded()
+
+        #expect(!viewModel.messages.contains { $0.content == "Tampered" })
+    }
+
+    @Test @MainActor
+    func subscribeGiftWrap_rejectsOversizedEmbeddedPacket() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let sender = try NostrIdentity.generate()
+        let recipient = try NostrIdentity.generate()
+
+        let oversized = Data(repeating: 0x41, count: FileTransferLimits.maxFramedFileBytes + 1)
+        let content = "bitchat1:" + base64URLEncode(oversized)
+        let giftWrap = try NostrProtocol.createPrivateMessage(
+            content: content,
+            recipientPubkey: recipient.publicKeyHex,
+            senderIdentity: sender
+        )
+
+        viewModel.subscribeGiftWrap(giftWrap, id: recipient)
+
+        try? await Task.sleep(nanoseconds: 100_000_000)
+        #expect(viewModel.privateChats.isEmpty)
+    }
+
+    @Test @MainActor
+    func switchLocationChannel_clearsNostrDedupCache() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+
+        viewModel.deduplicationService.recordNostrEvent("evt-cache")
+        #expect(viewModel.deduplicationService.hasProcessedNostrEvent("evt-cache"))
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+
+        #expect(!viewModel.deduplicationService.hasProcessedNostrEvent("evt-cache"))
+    }
+
+    @Test @MainActor
+    func handleNostrEvent_presenceTracksParticipantWithoutTimelineMessage() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+        let identity = try NostrIdentity.generate()
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+
+        let event = NostrEvent(
+            pubkey: identity.publicKeyHex,
+            createdAt: Date(),
+            kind: .geohashPresence,
+            tags: [["g", geohash]],
+            content: ""
+        )
+        let signed = try event.sign(with: identity.schnorrSigningKey())
+
+        viewModel.handleNostrEvent(signed)
+
+        try? await Task.sleep(nanoseconds: 50_000_000)
+        #expect(viewModel.geohashParticipantCount(for: geohash) >= 1)
+        viewModel.publicMessagePipeline.flushIfNeeded()
+        #expect(viewModel.messages.isEmpty)
+    }
+
+    @Test @MainActor
+    func subscribeGiftWrap_deliveredAckUpdatesExistingMessage() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let sender = try NostrIdentity.generate()
+        let recipient = try NostrIdentity.generate()
+        let convKey = PeerID(nostr_: sender.publicKeyHex)
+        let messageID = "geo-ack-delivered"
+
+        viewModel.privateChats[convKey] = [
+            BitchatMessage(
+                id: messageID,
+                sender: viewModel.nickname,
+                content: "Hello",
+                timestamp: Date(),
+                isRelay: false,
+                isPrivate: true,
+                recipientNickname: "Friend",
+                senderPeerID: viewModel.meshService.myPeerID,
+                deliveryStatus: .sent
+            )
+        ]
+
+        let content = try ackContent(type: .delivered, messageID: messageID, senderPeerID: PeerID(str: "0123456789abcdef"))
+        let giftWrap = try NostrProtocol.createPrivateMessage(
+            content: content,
+            recipientPubkey: recipient.publicKeyHex,
+            senderIdentity: sender
+        )
+
+        viewModel.subscribeGiftWrap(giftWrap, id: recipient)
+
+        let didUpdate = await TestHelpers.waitUntil(
+            { isDelivered(status: deliveryStatus(in: viewModel, peerID: convKey, messageID: messageID)) },
+            timeout: 0.5
+        )
+        #expect(didUpdate)
+    }
+
+    @Test @MainActor
+    func subscribeGiftWrap_readAckUpdatesExistingMessage() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let sender = try NostrIdentity.generate()
+        let recipient = try NostrIdentity.generate()
+        let convKey = PeerID(nostr_: sender.publicKeyHex)
+        let messageID = "geo-ack-read"
+
+        viewModel.privateChats[convKey] = [
+            BitchatMessage(
+                id: messageID,
+                sender: viewModel.nickname,
+                content: "Hello",
+                timestamp: Date(),
+                isRelay: false,
+                isPrivate: true,
+                recipientNickname: "Friend",
+                senderPeerID: viewModel.meshService.myPeerID,
+                deliveryStatus: .delivered(to: "Friend", at: Date())
+            )
+        ]
+
+        let content = try ackContent(type: .readReceipt, messageID: messageID, senderPeerID: PeerID(str: "0123456789abcdef"))
+        let giftWrap = try NostrProtocol.createPrivateMessage(
+            content: content,
+            recipientPubkey: recipient.publicKeyHex,
+            senderIdentity: sender
+        )
+
+        viewModel.subscribeGiftWrap(giftWrap, id: recipient)
+
+        let didUpdate = await TestHelpers.waitUntil(
+            { isRead(status: deliveryStatus(in: viewModel, peerID: convKey, messageID: messageID)) },
+            timeout: 0.5
+        )
+        #expect(didUpdate)
+    }
+
+    @Test @MainActor
+    func handleGiftWrap_privateMessageStoresConversationAndMapping() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let sender = try NostrIdentity.generate()
+        let recipient = try NostrIdentity.generate()
+        let messageID = "gift-private"
+        let convKey = PeerID(nostr_: sender.publicKeyHex)
+
+        let content = try privateMessageContent(
+            text: "Hello from gift wrap",
+            messageID: messageID,
+            senderPeerID: PeerID(str: "0123456789abcdef")
+        )
+        let giftWrap = try NostrProtocol.createPrivateMessage(
+            content: content,
+            recipientPubkey: recipient.publicKeyHex,
+            senderIdentity: sender
+        )
+
+        viewModel.handleGiftWrap(giftWrap, id: recipient)
+
+        let didStore = await TestHelpers.waitUntil(
+            { viewModel.privateChats[convKey]?.first?.content == "Hello from gift wrap" },
+            timeout: 0.5
+        )
+        #expect(didStore)
+        #expect(viewModel.nostrKeyMapping[convKey] == sender.publicKeyHex)
+        #expect(viewModel.sentGeoDeliveryAcks.contains(messageID))
+    }
+
+    @Test @MainActor
+    func handleGiftWrap_blockedSenderSkipsMessageStorage() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let sender = try NostrIdentity.generate()
+        let recipient = try NostrIdentity.generate()
+        let messageID = "gift-blocked"
+        let convKey = PeerID(nostr_: sender.publicKeyHex)
+
+        viewModel.identityManager.setNostrBlocked(sender.publicKeyHex, isBlocked: true)
+
+        let content = try privateMessageContent(
+            text: "Blocked",
+            messageID: messageID,
+            senderPeerID: PeerID(str: "0123456789abcdef")
+        )
+        let giftWrap = try NostrProtocol.createPrivateMessage(
+            content: content,
+            recipientPubkey: recipient.publicKeyHex,
+            senderIdentity: sender
+        )
+
+        viewModel.handleGiftWrap(giftWrap, id: recipient)
+
+        try? await Task.sleep(nanoseconds: 50_000_000)
+        #expect(viewModel.privateChats[convKey] == nil)
+        #expect(viewModel.sentGeoDeliveryAcks.contains(messageID))
+    }
+
+    @Test @MainActor
+    func handleGiftWrap_deliveredAckUpdatesExistingMessage() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let sender = try NostrIdentity.generate()
+        let recipient = try NostrIdentity.generate()
+        let convKey = PeerID(nostr_: sender.publicKeyHex)
+        let messageID = "gift-delivered"
+
+        viewModel.privateChats[convKey] = [
+            BitchatMessage(
+                id: messageID,
+                sender: viewModel.nickname,
+                content: "Hello",
+                timestamp: Date(),
+                isRelay: false,
+                isPrivate: true,
+                recipientNickname: "Friend",
+                senderPeerID: viewModel.meshService.myPeerID,
+                deliveryStatus: .sent
+            )
+        ]
+
+        let content = try ackContent(type: .delivered, messageID: messageID, senderPeerID: PeerID(str: "0123456789abcdef"))
+        let giftWrap = try NostrProtocol.createPrivateMessage(
+            content: content,
+            recipientPubkey: recipient.publicKeyHex,
+            senderIdentity: sender
+        )
+
+        viewModel.handleGiftWrap(giftWrap, id: recipient)
+
+        let didUpdate = await TestHelpers.waitUntil(
+            { isDelivered(status: deliveryStatus(in: viewModel, peerID: convKey, messageID: messageID)) },
+            timeout: 0.5
+        )
+        #expect(didUpdate)
+    }
+
+    @Test @MainActor
+    func findNoiseKey_matchesFavoriteStoredAsNpub() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let identity = try NostrIdentity.generate()
+        let noiseKey = Data((0..<32).map { UInt8(($0 + 80) & 0xFF) })
+
+        FavoritesPersistenceService.shared.addFavorite(
+            peerNoisePublicKey: noiseKey,
+            peerNostrPublicKey: identity.npub,
+            peerNickname: "Alice"
+        )
+        defer { FavoritesPersistenceService.shared.removeFavorite(peerNoisePublicKey: noiseKey) }
+
+        #expect(viewModel.findNoiseKey(for: identity.publicKeyHex) == noiseKey)
+    }
+
+    @Test @MainActor
+    func findNoiseKey_matchesFavoriteStoredAsHex() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let nostrHex = String(repeating: "ab", count: 32)
+        let noiseKey = Data((0..<32).map { UInt8(($0 + 112) & 0xFF) })
+
+        FavoritesPersistenceService.shared.addFavorite(
+            peerNoisePublicKey: noiseKey,
+            peerNostrPublicKey: nostrHex,
+            peerNickname: "Bob"
+        )
+        defer { FavoritesPersistenceService.shared.removeFavorite(peerNoisePublicKey: noiseKey) }
+
+        #expect(viewModel.findNoiseKey(for: nostrHex) == noiseKey)
+    }
+
+    @Test @MainActor
+    func handleFavoriteNotification_updatesFavoriteAssociation() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let identity = try NostrIdentity.generate()
+        let noiseKey = Data((0..<32).map { UInt8(($0 + 144) & 0xFF) })
+
+        FavoritesPersistenceService.shared.addFavorite(
+            peerNoisePublicKey: noiseKey,
+            peerNostrPublicKey: identity.npub,
+            peerNickname: "Before"
+        )
+        defer { FavoritesPersistenceService.shared.removeFavorite(peerNoisePublicKey: noiseKey) }
+
+        viewModel.handleFavoriteNotification(
+            content: "FAVORITE:TRUE|NPUB:\(identity.npub)|Alice",
+            from: identity.publicKeyHex
+        )
+
+        let relationship = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey)
+        #expect(relationship?.peerNickname == "Alice")
+        #expect(relationship?.peerNostrPublicKey == identity.npub)
+        #expect(relationship?.isFavorite == true)
+    }
+
+    @Test @MainActor
+    func geohashDMHelpers_exposeMappingAndDisplayName() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let nostrHex = String(repeating: "cd", count: 32)
+        let convKey = PeerID(nostr_: nostrHex)
+
+        viewModel.geoNicknames[nostrHex] = "Alice"
+        viewModel.startGeohashDM(withPubkeyHex: nostrHex)
+
+        #expect(viewModel.selectedPrivateChatPeer == convKey)
+        #expect(viewModel.fullNostrHex(forSenderPeerID: convKey) == nostrHex)
+        #expect(viewModel.geohashDisplayName(for: convKey).hasPrefix("Alice"))
+        #expect(viewModel.nostrPubkeyForDisplayName("Alice") == nostrHex)
     }
 }
+
+// MARK: - Geohash Queue Tests
+
+struct ChatViewModelGeohashQueueTests {
+
+    @Test @MainActor
+    func addGeohashOnlySystemMessage_queuesUntilLocationChannel() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+
+        viewModel.addGeohashOnlySystemMessage("Queued system")
+        #expect(!viewModel.messages.contains { $0.content == "Queued system" })
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+
+        #expect(viewModel.messages.contains { $0.content == "Queued system" })
+    }
+}
+
+// MARK: - GeoDM Tests
+
+struct ChatViewModelGeoDMTests {
+
+    @Test @MainActor
+    func handlePrivateMessage_geohash_dedupsAndTracksAck() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+        let senderPubkey = "0000000000000000000000000000000000000000000000000000000000000001"
+        let messageID = "pm-1"
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+        let identity = try viewModel.idBridge.deriveIdentity(forGeohash: geohash)
+
+        let convKey = PeerID(nostr_: senderPubkey)
+        let packet = PrivateMessagePacket(messageID: messageID, content: "Hello")
+        let payloadData = try #require(packet.encode(), "Failed to encode private message")
+        let payload = NoisePayload(type: .privateMessage, data: payloadData)
+
+        viewModel.handlePrivateMessage(payload, senderPubkey: senderPubkey, convKey: convKey, id: identity, messageTimestamp: Date())
+        viewModel.handlePrivateMessage(payload, senderPubkey: senderPubkey, convKey: convKey, id: identity, messageTimestamp: Date())
+
+        #expect(viewModel.privateChats[convKey]?.count == 1)
+        #expect(viewModel.sentGeoDeliveryAcks.contains(messageID))
+    }
+
+    @Test @MainActor
+    func sendGeohashDM_requiresActiveLocationChannel() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let convKey = PeerID(nostr_: "0000000000000000000000000000000000000000000000000000000000000001")
+
+        viewModel.sendGeohashDM("hello", to: convKey)
+
+        #expect(viewModel.privateChats[convKey] == nil)
+        #expect(viewModel.messages.count == 1)
+        #expect(viewModel.messages.last?.sender == "system")
+    }
+
+    @Test @MainActor
+    func sendGeohashDM_missingRecipientMapping_marksFailed() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+        let convKey = PeerID(nostr_: "0000000000000000000000000000000000000000000000000000000000000002")
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+        viewModel.sendGeohashDM("hello", to: convKey)
+
+        #expect(viewModel.privateChats[convKey]?.count == 1)
+        #expect(isFailed(status: viewModel.privateChats[convKey]?.last?.deliveryStatus))
+    }
+
+    @Test @MainActor
+    func sendGeohashDM_blockedRecipient_marksFailedAndAddsSystemMessage() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+        let recipientHex = "0000000000000000000000000000000000000000000000000000000000000003"
+        let convKey = PeerID(nostr_: recipientHex)
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+        viewModel.nostrKeyMapping[convKey] = recipientHex
+        viewModel.identityManager.setNostrBlocked(recipientHex, isBlocked: true)
+
+        viewModel.sendGeohashDM("hello", to: convKey)
+
+        #expect(viewModel.privateChats[convKey]?.count == 1)
+        #expect(isFailed(status: viewModel.privateChats[convKey]?.last?.deliveryStatus))
+        #expect(viewModel.messages.contains(where: { $0.sender == "system" }))
+    }
+
+    @Test @MainActor
+    func handlePrivateMessage_geohashViewingConversationRecordsReadReceipt() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+        let senderPubkey = "0000000000000000000000000000000000000000000000000000000000000004"
+        let convKey = PeerID(nostr_: senderPubkey)
+        let messageID = "pm-viewing"
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+        viewModel.selectedPrivateChatPeer = convKey
+
+        let identity = try viewModel.idBridge.deriveIdentity(forGeohash: geohash)
+        let packet = PrivateMessagePacket(messageID: messageID, content: "Hello")
+        let payloadData = try #require(packet.encode(), "Failed to encode private message")
+        let payload = NoisePayload(type: .privateMessage, data: payloadData)
+
+        viewModel.handlePrivateMessage(
+            payload,
+            senderPubkey: senderPubkey,
+            convKey: convKey,
+            id: identity,
+            messageTimestamp: Date()
+        )
+
+        #expect(viewModel.sentGeoDeliveryAcks.contains(messageID))
+        #expect(viewModel.sentReadReceipts.contains(messageID))
+        #expect(!viewModel.unreadPrivateMessages.contains(convKey))
+    }
+}
+
+struct ChatViewModelMediaTransferTests {
+
+    @Test @MainActor
+    func handleTransferEvent_updatesPrivateMessageProgressAndClearsMappingOnCompletion() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let peerID = PeerID(str: "0102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f10")
+        let message = viewModel.enqueueMediaMessage(content: "[voice] clip.m4a", targetPeer: peerID)
+        let transferID = "transfer-1"
+
+        viewModel.registerTransfer(transferId: transferID, messageID: message.id)
+        viewModel.handleTransferEvent(.started(id: transferID, totalFragments: 4))
+        #expect(isPartiallyDelivered(status: deliveryStatus(in: viewModel, peerID: peerID, messageID: message.id), reached: 0, total: 4))
+
+        viewModel.handleTransferEvent(.updated(id: transferID, sentFragments: 2, totalFragments: 4))
+        #expect(isPartiallyDelivered(status: deliveryStatus(in: viewModel, peerID: peerID, messageID: message.id), reached: 2, total: 4))
+
+        viewModel.handleTransferEvent(.completed(id: transferID, totalFragments: 4))
+        #expect(isSent(status: deliveryStatus(in: viewModel, peerID: peerID, messageID: message.id)))
+        #expect(viewModel.messageIDToTransferId[message.id] == nil)
+        #expect(viewModel.transferIdToMessageIDs[transferID] == nil)
+    }
+
+    @Test @MainActor
+    func handleTransferEvent_cancelledRemovesOutgoingMessage() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let peerID = PeerID(str: "1111111111111111111111111111111111111111111111111111111111111111")
+        let message = viewModel.enqueueMediaMessage(content: "[image] pic.jpg", targetPeer: peerID)
+        let transferID = "transfer-2"
+
+        viewModel.registerTransfer(transferId: transferID, messageID: message.id)
+        viewModel.handleTransferEvent(.cancelled(id: transferID, sentFragments: 1, totalFragments: 3))
+
+        #expect(viewModel.privateChats[peerID]?.contains(where: { $0.id == message.id }) != true)
+        #expect(viewModel.messageIDToTransferId[message.id] == nil)
+    }
+
+    @Test @MainActor
+    func sendVoiceNote_outsideAllowedContextDeletesTempFile() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+        let url = FileManager.default.temporaryDirectory.appendingPathComponent("voice-\(UUID().uuidString).m4a")
+
+        try Data("voice".utf8).write(to: url)
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+
+        viewModel.sendVoiceNote(at: url)
+
+        #expect(!FileManager.default.fileExists(atPath: url.path))
+        #expect(viewModel.messages.contains(where: { $0.sender == "system" }))
+    }
+
+    @Test @MainActor
+    func sendImage_outsideAllowedContextRunsCleanup() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+        var cleanupCalled = false
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+        viewModel.sendImage(from: URL(fileURLWithPath: "/tmp/ignored.jpg")) {
+            cleanupCalled = true
+        }
+
+        #expect(cleanupCalled)
+        #expect(viewModel.messages.contains(where: { $0.sender == "system" }))
+    }
+
+    @Test @MainActor
+    func sendVoiceNote_privateChatUsesPrivateFileTransfer() async throws {
+        let (viewModel, transport) = makeTestableViewModel()
+        let peerID = PeerID(str: "2222222222222222222222222222222222222222222222222222222222222222")
+        let url = FileManager.default.temporaryDirectory.appendingPathComponent("voice-\(UUID().uuidString).m4a")
+        try Data("voice payload".utf8).write(to: url, options: .atomic)
+        defer { try? FileManager.default.removeItem(at: url) }
+
+        viewModel.selectedPrivateChatPeer = peerID
+        viewModel.sendVoiceNote(at: url)
+
+        let didSend = await TestHelpers.waitUntil({ transport.sentPrivateFiles.count == 1 }, timeout: 0.5)
+        #expect(didSend)
+        #expect(transport.sentPrivateFiles.first?.peerID == peerID)
+        #expect(viewModel.privateChats[peerID]?.last?.content.contains("[voice]") == true)
+        #expect(viewModel.messageIDToTransferId.count == 1)
+        #expect(viewModel.transferIdToMessageIDs.count == 1)
+    }
+
+    @Test @MainActor
+    func sendVoiceNote_oversizedFileFailsAndDeletesTempFile() async throws {
+        let (viewModel, transport) = makeTestableViewModel()
+        let peerID = PeerID(str: "3333333333333333333333333333333333333333333333333333333333333333")
+        let url = FileManager.default.temporaryDirectory.appendingPathComponent("voice-too-large-\(UUID().uuidString).m4a")
+        try Data(repeating: 0x55, count: FileTransferLimits.maxVoiceNoteBytes + 1).write(to: url, options: .atomic)
+
+        viewModel.selectedPrivateChatPeer = peerID
+        viewModel.sendVoiceNote(at: url)
+
+        let didFail = await TestHelpers.waitUntil({
+            isFailed(status: viewModel.privateChats[peerID]?.last?.deliveryStatus)
+        }, timeout: 0.5)
+        #expect(didFail)
+        #expect(!FileManager.default.fileExists(atPath: url.path))
+        #expect(transport.sentPrivateFiles.isEmpty)
+    }
+
+    @Test @MainActor
+    func sendImage_privateChatProcessesAndTransfersImage() async throws {
+        let (viewModel, transport) = makeTestableViewModel()
+        let peerID = PeerID(str: "4444444444444444444444444444444444444444444444444444444444444444")
+        let sourceURL = try makeTemporaryImageURL()
+        defer { try? FileManager.default.removeItem(at: sourceURL) }
+
+        viewModel.selectedPrivateChatPeer = peerID
+        viewModel.sendImage(from: sourceURL)
+
+        let didSend = await TestHelpers.waitUntil({ transport.sentPrivateFiles.count == 1 }, timeout: 1.0)
+        #expect(didSend)
+        #expect(transport.sentPrivateFiles.first?.peerID == peerID)
+        #expect(transport.sentPrivateFiles.first?.packet.mimeType == "image/jpeg")
+        #expect(viewModel.privateChats[peerID]?.last?.content.contains("[image]") == true)
+        #expect(viewModel.messageIDToTransferId.count == 1)
+    }
+
+    @Test @MainActor
+    func sendImage_invalidSourceAddsFailureSystemMessage() async throws {
+        let (viewModel, transport) = makeTestableViewModel()
+        let peerID = PeerID(str: "5555555555555555555555555555555555555555555555555555555555555555")
+        let url = FileManager.default.temporaryDirectory.appendingPathComponent("invalid-\(UUID().uuidString).jpg")
+        try Data("not-an-image".utf8).write(to: url, options: .atomic)
+        defer { try? FileManager.default.removeItem(at: url) }
+
+        viewModel.selectedPrivateChatPeer = peerID
+        viewModel.sendImage(from: url)
+
+        let didNotify = await TestHelpers.waitUntil({
+            viewModel.messages.contains(where: { $0.sender == "system" && $0.content.contains("Failed to prepare image") })
+        }, timeout: 2.0)
+        #expect(didNotify)
+        #expect(transport.sentPrivateFiles.isEmpty)
+        #expect(viewModel.privateChats[peerID]?.isEmpty != false)
+    }
+
+    @Test @MainActor
+    func clearTransferMapping_promotesQueuedTransferForSameID() async {
+        let (viewModel, _) = makeTestableViewModel()
+        viewModel.registerTransfer(transferId: "transfer-queue", messageID: "first")
+        viewModel.registerTransfer(transferId: "transfer-queue", messageID: "second")
+
+        viewModel.clearTransferMapping(for: "first")
+
+        #expect(viewModel.messageIDToTransferId["first"] == nil)
+        #expect(viewModel.transferIdToMessageIDs["transfer-queue"] == ["second"])
+        #expect(viewModel.messageIDToTransferId["second"] == "transfer-queue")
+    }
+
+    @Test @MainActor
+    func cancelMediaSend_cancelsActiveTransferRemovesMessageAndDeletesFile() async throws {
+        let (viewModel, transport) = makeTestableViewModel()
+        let peerID = PeerID(str: "6666666666666666666666666666666666666666666666666666666666666666")
+        let fileName = "cancel-\(UUID().uuidString).m4a"
+        let fileURL = try mediaFileURL(subdirectory: "voicenotes/outgoing", fileName: fileName)
+        try Data("cancel me".utf8).write(to: fileURL, options: .atomic)
+
+        let message = BitchatMessage(
+            id: "cancel-msg",
+            sender: viewModel.nickname,
+            content: "[voice] \(fileName)",
+            timestamp: Date(),
+            isRelay: false,
+            isPrivate: true,
+            recipientNickname: "Peer",
+            senderPeerID: viewModel.meshService.myPeerID,
+            deliveryStatus: .sending
+        )
+        viewModel.privateChats[peerID] = [message]
+        viewModel.registerTransfer(transferId: "transfer-cancel", messageID: message.id)
+
+        viewModel.cancelMediaSend(messageID: message.id)
+
+        #expect(transport.cancelledTransfers == ["transfer-cancel"])
+        #expect(viewModel.privateChats[peerID] == nil)
+        #expect(!FileManager.default.fileExists(atPath: fileURL.path))
+    }
+
+    @Test @MainActor
+    func deleteMediaMessage_removesStoredMessageAndCleansImageFile() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let peerID = PeerID(str: "7777777777777777777777777777777777777777777777777777777777777777")
+        let fileName = "delete-\(UUID().uuidString).jpg"
+        let fileURL = try mediaFileURL(subdirectory: "images/outgoing", fileName: fileName)
+        try Data("image bytes".utf8).write(to: fileURL, options: .atomic)
+
+        let message = BitchatMessage(
+            id: "delete-msg",
+            sender: viewModel.nickname,
+            content: "[image] \(fileName)",
+            timestamp: Date(),
+            isRelay: false,
+            isPrivate: true,
+            recipientNickname: "Peer",
+            senderPeerID: viewModel.meshService.myPeerID,
+            deliveryStatus: .sent
+        )
+        viewModel.privateChats[peerID] = [message]
+        viewModel.registerTransfer(transferId: "transfer-delete", messageID: message.id)
+
+        viewModel.deleteMediaMessage(messageID: message.id)
+
+        #expect(viewModel.privateChats[peerID] == nil)
+        #expect(viewModel.messageIDToTransferId[message.id] == nil)
+        #expect(!FileManager.default.fileExists(atPath: fileURL.path))
+    }
+
+    @Test @MainActor
+    func makeTransferID_isPrefixedByMessageIDAndUnique() async {
+        let (viewModel, _) = makeTestableViewModel()
+
+        let first = viewModel.makeTransferID(messageID: "base")
+        let second = viewModel.makeTransferID(messageID: "base")
+
+        #expect(first.hasPrefix("base-"))
+        #expect(second.hasPrefix("base-"))
+        #expect(first != second)
+    }
+}
+
+private func base64URLEncode(_ data: Data) -> String {
+    data.base64EncodedString()
+        .replacingOccurrences(of: "+", with: "-")
+        .replacingOccurrences(of: "/", with: "_")
+        .replacingOccurrences(of: "=", with: "")
+}
+
+private func ackContent(type: NoisePayloadType, messageID: String, senderPeerID: PeerID) throws -> String {
+    if let content = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(
+        type: type,
+        messageID: messageID,
+        senderPeerID: senderPeerID
+    ) {
+        return content
+    }
+    throw ChatViewModelExtensionsTestError.invalidAckContent
+}
+
+private func privateMessageContent(text: String, messageID: String, senderPeerID: PeerID) throws -> String {
+    if let content = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(
+        content: text,
+        messageID: messageID,
+        senderPeerID: senderPeerID
+    ) {
+        return content
+    }
+    throw ChatViewModelExtensionsTestError.invalidPrivateMessageContent
+}
+
+@MainActor
+private func deliveryStatus(in viewModel: ChatViewModel, peerID: PeerID, messageID: String) -> DeliveryStatus? {
+    viewModel.privateChats[peerID]?.first(where: { $0.id == messageID })?.deliveryStatus
+}
+
+private func isFailed(status: DeliveryStatus?) -> Bool {
+    if case .failed = status {
+        return true
+    }
+    return false
+}
+
+private func isDelivered(status: DeliveryStatus?) -> Bool {
+    if case .delivered = status {
+        return true
+    }
+    return false
+}
+
+private func isRead(status: DeliveryStatus?) -> Bool {
+    if case .read = status {
+        return true
+    }
+    return false
+}
+
+private func isSent(status: DeliveryStatus?) -> Bool {
+    if case .sent = status {
+        return true
+    }
+    return false
+}
+
+private func isPartiallyDelivered(status: DeliveryStatus?, reached: Int, total: Int) -> Bool {
+    if case .partiallyDelivered(let actualReached, let actualTotal) = status {
+        return actualReached == reached && actualTotal == total
+    }
+    return false
+}
+
+private enum ChatViewModelExtensionsTestError: Error {
+    case invalidAckContent
+    case invalidPrivateMessageContent
+}
+
+private func mediaFileURL(subdirectory: String, fileName: String) throws -> URL {
+    let base = try FileManager.default.url(
+        for: .applicationSupportDirectory,
+        in: .userDomainMask,
+        appropriateFor: nil,
+        create: true
+    ).appendingPathComponent("files", isDirectory: true)
+    let directory = base.appendingPathComponent(subdirectory, isDirectory: true)
+    try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+    return directory.appendingPathComponent(fileName)
+}
+
+private func makeTemporaryImageURL() throws -> URL {
+    let url = FileManager.default.temporaryDirectory.appendingPathComponent("image-\(UUID().uuidString).png")
+    let data = try makeImageData()
+    try data.write(to: url, options: .atomic)
+    return url
+}
+
+private func makeImageData() throws -> Data {
+    #if os(iOS)
+    let image = UIGraphicsImageRenderer(size: CGSize(width: 64, height: 64)).image { context in
+        UIColor.systemTeal.setFill()
+        context.fill(CGRect(x: 0, y: 0, width: 64, height: 64))
+    }
+    guard let data = image.pngData() else {
+        throw ChatViewModelExtensionsTestError.invalidPrivateMessageContent
+    }
+    return data
+    #else
+    let image = NSImage(size: CGSize(width: 64, height: 64))
+    image.lockFocus()
+    NSColor.systemTeal.setFill()
+    NSBezierPath(rect: CGRect(x: 0, y: 0, width: 64, height: 64)).fill()
+    image.unlockFocus()
+    guard
+        let tiffData = image.tiffRepresentation,
+        let bitmap = NSBitmapImageRep(data: tiffData),
+        let data = bitmap.representation(using: .png, properties: [:])
+    else {
+        throw ChatViewModelExtensionsTestError.invalidPrivateMessageContent
+    }
+    return data
+    #endif
+}

bitchatTests/ChatViewModelRefactoringTests.swift

@@ -0,0 +1,148 @@
+//
+// ChatViewModelRefactoringTests.swift
+// bitchatTests
+//
+// Pinning tests to characterize ChatViewModel behavior before refactoring.
+// These tests act as a safety net to ensure we don't break existing functionality.
+//
+
+import Testing
+import Foundation
+@testable import bitchat
+
+struct ChatViewModelRefactoringTests {
+
+    // Helper to setup the environment
+    @MainActor
+    private func makePinnedViewModel() -> (viewModel: ChatViewModel, transport: MockTransport, identity: MockIdentityManager) {
+        let keychain = MockKeychain()
+        let keychainHelper = MockKeychainHelper()
+        let idBridge = NostrIdentityBridge(keychain: keychainHelper)
+        let identityManager = MockIdentityManager(keychain)
+        let transport = MockTransport()
+
+        let viewModel = ChatViewModel(
+            keychain: keychain,
+            idBridge: idBridge,
+            identityManager: identityManager,
+            transport: transport
+        )
+
+        return (viewModel, transport, identityManager)
+    }
+
+    // MARK: - Command Processor Integration "Pinning"
+    
+    @Test @MainActor
+    func command_msg_routesToTransport() async throws {
+        let (viewModel, transport, _) = makePinnedViewModel()
+        
+        // Setup: Use simulateConnect so ChatViewModel and UnifiedPeerService are notified
+        let peerID = PeerID(str: "0000000000000001")
+        transport.simulateConnect(peerID, nickname: "alice")
+
+        let didResolve = await TestHelpers.waitUntil({ viewModel.getPeerIDForNickname("alice") != nil },
+                                                     timeout: TestConstants.shortTimeout)
+        #expect(didResolve)
+        
+        // Action: User types /msg command
+        viewModel.sendMessage("/msg @alice Hello Private World")
+
+        let didSend = await TestHelpers.waitUntil({ transport.sentPrivateMessages.count == 1 },
+                                                  timeout: TestConstants.shortTimeout)
+        #expect(didSend)
+        
+        // Assert:
+        // 1. Should NOT go to public transport
+        #expect(transport.sentMessages.isEmpty, "Command should not be sent as public message")
+        
+        // 2. Should go to private transport logic
+        #expect(transport.sentPrivateMessages.count == 1)
+        #expect(transport.sentPrivateMessages.first?.content == "Hello Private World")
+        #expect(transport.sentPrivateMessages.first?.peerID == peerID)
+    }
+
+    @Test @MainActor
+    func command_block_updatesIdentity() async throws {
+        let (viewModel, transport, identity) = makePinnedViewModel()
+        
+        // Setup: Use simulateConnect
+        let peerID = PeerID(str: "0000000000000002")
+        // Mock the fingerprint so the block command finds it
+        transport.peerFingerprints[peerID] = "fingerprint_123"
+        transport.simulateConnect(peerID, nickname: "troll")
+
+        let didResolve = await TestHelpers.waitUntil({ viewModel.getPeerIDForNickname("troll") != nil },
+                                                     timeout: TestConstants.shortTimeout)
+        #expect(didResolve)
+        
+        // Action
+        viewModel.sendMessage("/block @troll")
+        
+        // Assert
+        // Verify identity manager was called to block "fingerprint_123"
+        let didBlock = await TestHelpers.waitUntil({ identity.isBlocked(fingerprint: "fingerprint_123") },
+                                                   timeout: TestConstants.shortTimeout)
+        #expect(didBlock)
+    }
+
+    // MARK: - Message Routing Logic
+
+    @Test @MainActor
+    func routing_incomingPrivateMessage_addsToPrivateChats() async {
+        let (viewModel, _, _) = makePinnedViewModel()
+        let senderID = PeerID(str: "sender_1")
+
+        // Setup
+        let message = BitchatMessage(
+            id: "msg_1",
+            sender: "bob",
+            content: "Secret",
+            timestamp: Date(),
+            isRelay: false,
+            originalSender: nil,
+            isPrivate: true,
+            recipientNickname: "me",
+            senderPeerID: senderID,
+            mentions: nil
+        )
+
+        // Action: Simulate incoming private message
+        viewModel.didReceiveMessage(message)
+
+        // Wait for async processing with proper timeout
+        let found = await TestHelpers.waitUntil(
+            { viewModel.privateChats[senderID]?.first?.content == "Secret" },
+            timeout: TestConstants.defaultTimeout
+        )
+
+        // Assert
+        #expect(found)
+    }
+
+    @Test @MainActor
+    func routing_incomingPublicMessage_addsToPublicTimeline() async {
+        let (viewModel, _, _) = makePinnedViewModel()
+        let senderID = PeerID(str: "sender_2")
+
+        // Action
+        viewModel.didReceivePublicMessage(
+            from: senderID,
+            nickname: "charlie",
+            content: "Public Hi",
+            timestamp: Date(),
+            messageID: "msg_2"
+        )
+
+        // Wait for async processing with proper timeout
+        let found = await TestHelpers.waitUntil(
+            {
+                viewModel.timelineStore.messages(for: .mesh).contains(where: { $0.content == "Public Hi" })
+            },
+            timeout: TestConstants.defaultTimeout
+        )
+
+        // Assert
+        #expect(found)
+    }
+}

bitchatTests/ChatViewModelTests.swift

@@ -114,6 +114,44 @@ struct ChatViewModelSendingTests {
     }
 }
 
+// MARK: - Command Handling Tests
+
+struct ChatViewModelCommandTests {
+
+    @Test @MainActor
+    func sendMessage_commandsNotSentToTransport() async {
+        let (viewModel, transport) = makeTestableViewModel()
+        let commands = ["/nick bob", "/who", "/help", "/clear"]
+
+        for command in commands {
+            transport.resetRecordings()
+            viewModel.sendMessage(command)
+            try? await Task.sleep(nanoseconds: 100_000_000)
+
+            #expect(transport.sentMessages.isEmpty)
+            #expect(transport.sentPrivateMessages.isEmpty)
+        }
+    }
+}
+
+// MARK: - Timeline Cap Tests
+
+struct ChatViewModelTimelineCapTests {
+
+    @Test @MainActor
+    func sendMessage_trimsTimelineToCap() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let total = TransportConfig.meshTimelineCap + 5
+
+        for i in 0..<total {
+            viewModel.sendMessage("cap-msg-\(i)")
+        }
+
+        #expect(viewModel.messages.count == TransportConfig.meshTimelineCap)
+        #expect(viewModel.messages.last?.content == "cap-msg-\(total - 1)")
+    }
+}
+
 // MARK: - Message Receiving Tests
 
 struct ChatViewModelReceivingTests {
@@ -157,10 +195,45 @@ struct ChatViewModelReceivingTests {
             messageID: "pub-001"
         )
 
-        // Give time for async Task and pipeline processing
+        let found = await TestHelpers.waitUntil({
-        try? await Task.sleep(nanoseconds: 500_000_000)
+            viewModel.timelineStore.messages(for: .mesh).contains { $0.content == "Public hello from Bob" }
+        }, timeout: TestConstants.defaultTimeout)
 
-        #expect(viewModel.messages.contains { $0.content == "Public hello from Bob" })
+        #expect(found)
+    }
+}
+
+// MARK: - Rate Limiting Tests
+
+struct ChatViewModelRateLimitingTests {
+
+    @Test @MainActor
+    func handlePublicMessage_rateLimitsBurstBySender() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let senderID = PeerID(str: "1122334455667788")
+        let now = Date()
+
+        for i in 0..<6 {
+            let message = BitchatMessage(
+                id: "rate-\(i)",
+                sender: "Spammer",
+                content: "rate-msg-\(i)",
+                timestamp: now,
+                isRelay: false,
+                originalSender: nil,
+                isPrivate: false,
+                recipientNickname: nil,
+                senderPeerID: senderID,
+                mentions: nil
+            )
+            viewModel.handlePublicMessage(message)
+        }
+
+        viewModel.publicMessagePipeline.flushIfNeeded()
+
+        let burstMessages = viewModel.messages.filter { $0.content.hasPrefix("rate-msg-") }
+        #expect(burstMessages.count == 5)
+        #expect(!burstMessages.contains { $0.content == "rate-msg-5" })
     }
 }
 
@@ -258,6 +331,94 @@ struct ChatViewModelPrivateChatTests {
     }
 }
 
+// MARK: - Private Chat Selection Tests
+
+struct ChatViewModelPrivateChatSelectionTests {
+
+    @Test @MainActor
+    func openMostRelevantPrivateChat_prefersUnreadMostRecent() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let peerA = PeerID(str: "PEER_A")
+        let peerB = PeerID(str: "PEER_B")
+
+        let older = Date().addingTimeInterval(-120)
+        let newer = Date().addingTimeInterval(-30)
+
+        viewModel.privateChats = [
+            peerA: [
+                BitchatMessage(
+                    id: "a-1",
+                    sender: "A",
+                    content: "Old",
+                    timestamp: older,
+                    isRelay: false,
+                    isPrivate: true,
+                    recipientNickname: "Me",
+                    senderPeerID: peerA
+                )
+            ],
+            peerB: [
+                BitchatMessage(
+                    id: "b-1",
+                    sender: "B",
+                    content: "New",
+                    timestamp: newer,
+                    isRelay: false,
+                    isPrivate: true,
+                    recipientNickname: "Me",
+                    senderPeerID: peerB
+                )
+            ]
+        ]
+        viewModel.unreadPrivateMessages = [peerA, peerB]
+
+        viewModel.openMostRelevantPrivateChat()
+
+        #expect(viewModel.selectedPrivateChatPeer == peerB)
+    }
+
+    @Test @MainActor
+    func openMostRelevantPrivateChat_fallsBackToMostRecentChat() async {
+        let (viewModel, _) = makeTestableViewModel()
+        let peerA = PeerID(str: "PEER_A")
+        let peerB = PeerID(str: "PEER_B")
+
+        let older = Date().addingTimeInterval(-200)
+        let newer = Date().addingTimeInterval(-20)
+
+        viewModel.privateChats = [
+            peerA: [
+                BitchatMessage(
+                    id: "a-1",
+                    sender: "A",
+                    content: "Old",
+                    timestamp: older,
+                    isRelay: false,
+                    isPrivate: true,
+                    recipientNickname: "Me",
+                    senderPeerID: peerA
+                )
+            ],
+            peerB: [
+                BitchatMessage(
+                    id: "b-1",
+                    sender: "B",
+                    content: "New",
+                    timestamp: newer,
+                    isRelay: false,
+                    isPrivate: true,
+                    recipientNickname: "Me",
+                    senderPeerID: peerB
+                )
+            ]
+        ]
+
+        viewModel.openMostRelevantPrivateChat()
+
+        #expect(viewModel.selectedPrivateChatPeer == peerB)
+    }
+}
+
 // MARK: - Bluetooth State Tests
 
 struct ChatViewModelBluetoothTests {
@@ -309,11 +470,37 @@ struct ChatViewModelPanicTests {
 
         // Set up some state
         transport.connectedPeers.insert(PeerID(str: "PEER1"))
+        viewModel.messages = [
+            BitchatMessage(
+                id: "panic-1",
+                sender: "Tester",
+                content: "Before",
+                timestamp: Date(),
+                isRelay: false
+            )
+        ]
+        viewModel.privateChats[PeerID(str: "PEER1")] = [
+            BitchatMessage(
+                id: "pm-1",
+                sender: "Peer",
+                content: "Secret",
+                timestamp: Date(),
+                isRelay: false,
+                isPrivate: true,
+                recipientNickname: "Me",
+                senderPeerID: PeerID(str: "PEER1")
+            )
+        ]
+        viewModel.unreadPrivateMessages.insert(PeerID(str: "PEER1"))
 
         viewModel.panicClearAllData()
 
         // After panic, emergency disconnect should be called
         #expect(transport.emergencyDisconnectCallCount == 1)
+        #expect(viewModel.messages.isEmpty)
+        #expect(viewModel.privateChats.isEmpty)
+        #expect(viewModel.unreadPrivateMessages.isEmpty)
+        #expect(viewModel.selectedPrivateChatPeer == nil)
     }
 }
 

bitchatTests/ChatViewModelTorTests.swift

@@ -0,0 +1,178 @@
+//
+// ChatViewModelTorTests.swift
+// bitchatTests
+//
+// Tests for ChatViewModel+Tor.swift Tor lifecycle notification handlers.
+//
+
+import Testing
+import Foundation
+@testable import bitchat
+
+// MARK: - Test Helpers
+
+@MainActor
+private func makeTestableViewModel() -> (viewModel: ChatViewModel, transport: MockTransport) {
+    let keychain = MockKeychain()
+    let keychainHelper = MockKeychainHelper()
+    let idBridge = NostrIdentityBridge(keychain: keychainHelper)
+    let identityManager = MockIdentityManager(keychain)
+    let transport = MockTransport()
+
+    let viewModel = ChatViewModel(
+        keychain: keychain,
+        idBridge: idBridge,
+        identityManager: identityManager,
+        transport: transport
+    )
+
+    return (viewModel, transport)
+}
+
+// MARK: - Tor Notification Handler Tests
+
+struct ChatViewModelTorTests {
+
+    // MARK: - handleTorWillStart Tests
+
+    @Test @MainActor
+    func handleTorWillStart_whenEnforced_setsAnnouncedFlag() async {
+        let (viewModel, _) = makeTestableViewModel()
+
+        // Precondition: flag should start false
+        #expect(!viewModel.torStatusAnnounced)
+
+        // Action: simulate Tor starting notification
+        viewModel.handleTorWillStart()
+
+        // Wait for Task to complete
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        // Assert: flag should be set (torEnforced is true in tests)
+        #expect(viewModel.torStatusAnnounced)
+    }
+
+    @Test @MainActor
+    func handleTorWillStart_whenAlreadyAnnounced_doesNotDuplicate() async {
+        let (viewModel, _) = makeTestableViewModel()
+
+        // Setup: pre-set the flag
+        viewModel.torStatusAnnounced = true
+
+        // Switch to a geohash channel so messages would be visible
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: "u4pruydq")))
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let initialMessageCount = viewModel.messages.count
+
+        // Action: call handler again
+        viewModel.handleTorWillStart()
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        // Assert: no new message added (flag was already true)
+        #expect(viewModel.messages.count == initialMessageCount)
+    }
+
+    // MARK: - handleTorWillRestart Tests
+
+    @Test @MainActor
+    func handleTorWillRestart_setsPendingFlag() async {
+        let (viewModel, _) = makeTestableViewModel()
+
+        // Precondition
+        #expect(!viewModel.torRestartPending)
+
+        // Action
+        viewModel.handleTorWillRestart()
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        // Assert
+        #expect(viewModel.torRestartPending)
+    }
+
+    @Test @MainActor
+    func handleTorWillRestart_setsFlag_regardlessOfChannel() async {
+        let (viewModel, _) = makeTestableViewModel()
+
+        // Action: call handler (works regardless of channel)
+        viewModel.handleTorWillRestart()
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        // Assert: flag should be set
+        #expect(viewModel.torRestartPending)
+    }
+
+    // MARK: - handleTorDidBecomeReady Tests
+
+    @Test @MainActor
+    func handleTorDidBecomeReady_afterRestart_clearsPendingFlag() async {
+        let (viewModel, _) = makeTestableViewModel()
+
+        // Setup: simulate restart pending state
+        viewModel.torRestartPending = true
+
+        // Action
+        viewModel.handleTorDidBecomeReady()
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        // Assert: should clear pending flag
+        #expect(!viewModel.torRestartPending)
+    }
+
+    @Test @MainActor
+    func handleTorDidBecomeReady_initialStart_setsAnnouncedFlag() async {
+        let (viewModel, _) = makeTestableViewModel()
+
+        // Setup: not restarting, but initial ready not announced yet
+        viewModel.torRestartPending = false
+        viewModel.torInitialReadyAnnounced = false
+
+        // Action
+        viewModel.handleTorDidBecomeReady()
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        // Assert: should set flag (torEnforced is true in tests)
+        #expect(viewModel.torInitialReadyAnnounced)
+    }
+
+    @Test @MainActor
+    func handleTorDidBecomeReady_alreadyAnnounced_noDuplicate() async {
+        let (viewModel, _) = makeTestableViewModel()
+
+        // Setup: already announced initial ready
+        viewModel.torRestartPending = false
+        viewModel.torInitialReadyAnnounced = true
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: "u4pruydq")))
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let initialMessageCount = viewModel.messages.count
+
+        // Action
+        viewModel.handleTorDidBecomeReady()
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        // Assert: no new message
+        #expect(viewModel.messages.count == initialMessageCount)
+    }
+
+    // MARK: - handleTorPreferenceChanged Tests
+
+    @Test @MainActor
+    func handleTorPreferenceChanged_resetsAllFlags() async {
+        let (viewModel, _) = makeTestableViewModel()
+
+        // Setup: set all flags
+        viewModel.torStatusAnnounced = true
+        viewModel.torInitialReadyAnnounced = true
+        viewModel.torRestartPending = true
+
+        // Action
+        viewModel.handleTorPreferenceChanged(Notification(name: .init("test")))
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        // Assert: all flags reset
+        #expect(!viewModel.torStatusAnnounced)
+        #expect(!viewModel.torInitialReadyAnnounced)
+        #expect(!viewModel.torRestartPending)
+    }
+}

bitchatTests/CommandProcessorTests.swift

@@ -1,12 +1,14 @@
+import Foundation
 import Testing
 @testable import bitchat
 
+@Suite(.serialized)
 struct CommandProcessorTests {
-    private var identityManager = MockIdentityManager(MockKeychain())
 
     @MainActor
     @Test func slapNotFoundGrammar() {
-        let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
+        let identityManager = MockIdentityManager(MockKeychain())
+        let processor = CommandProcessor(contextProvider: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/slap @system")
         switch result {
         case .error(let message):
@@ -18,7 +20,8 @@ struct CommandProcessorTests {
 
     @MainActor
     @Test func hugNotFoundGrammar() {
-        let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
+        let identityManager = MockIdentityManager(MockKeychain())
+        let processor = CommandProcessor(contextProvider: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/hug @system")
         switch result {
         case .error(let message):
@@ -30,7 +33,8 @@ struct CommandProcessorTests {
     
     @MainActor
     @Test func slapUsageMessage() {
-        let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
+        let identityManager = MockIdentityManager(MockKeychain())
+        let processor = CommandProcessor(contextProvider: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/slap")
         switch result {
         case .error(let message):
@@ -39,4 +43,389 @@ struct CommandProcessorTests {
             Issue.record("Expected error result for usage message")
         }
     }
+
+    @MainActor
+    @Test func msgStartsPrivateChatAndSendsMessage() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let context = MockCommandContextProvider()
+        let peerID = PeerID(str: "abcd1234abcd1234")
+        context.nicknameToPeerID["alice"] = peerID
+        let processor = CommandProcessor(contextProvider: context, meshService: nil, identityManager: identityManager)
+
+        let result = await withSelectedChannel(.mesh) {
+            processor.process("/msg @alice hello there")
+        }
+
+        switch result {
+        case .success(let message):
+            #expect(message == "started private chat with alice")
+        default:
+            Issue.record("Expected success result")
+        }
+        #expect(context.startedPrivateChats == [peerID])
+        #expect(context.sentPrivateMessages.count == 1)
+        #expect(context.sentPrivateMessages.first?.content == "hello there")
+        #expect(context.sentPrivateMessages.first?.peerID == peerID)
+    }
+
+    @MainActor
+    @Test func whoInMeshListsSortedPeerNicknames() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let transport = MockTransport()
+        transport.peerNicknames = [
+            PeerID(str: "b"): "bob",
+            PeerID(str: "a"): "alice"
+        ]
+        let processor = CommandProcessor(contextProvider: MockCommandContextProvider(), meshService: transport, identityManager: identityManager)
+
+        let result = await withSelectedChannel(.mesh) {
+            processor.process("/who")
+        }
+
+        switch result {
+        case .success(let message):
+            #expect(message == "online: alice, bob")
+        default:
+            Issue.record("Expected success result")
+        }
+    }
+
+    @MainActor
+    @Test func whoInGeohashListsVisibleParticipantsExcludingSelf() async throws {
+        let bridge = NostrIdentityBridge(keychain: MockKeychain())
+        let identityManager = MockIdentityManager(MockKeychain())
+        let context = MockCommandContextProvider(idBridge: bridge)
+        let geohash = "u4pruy"
+        let selfPubkey = try bridge.deriveIdentity(forGeohash: geohash).publicKeyHex.lowercased()
+        context.visibleGeoParticipants = [
+            CommandGeoParticipant(id: selfPubkey, displayName: "me"),
+            CommandGeoParticipant(id: String(repeating: "b", count: 64), displayName: "bob")
+        ]
+        let processor = CommandProcessor(contextProvider: context, meshService: MockTransport(), identityManager: identityManager)
+        let channel = ChannelID.location(GeohashChannel(level: .city, geohash: geohash))
+
+        let result = await withSelectedChannel(channel) {
+            processor.process("/who")
+        }
+
+        switch result {
+        case .success(let message):
+            #expect(message == "online: bob")
+        default:
+            Issue.record("Expected success result")
+        }
+    }
+
+    @MainActor
+    @Test func clearInPrivateChatRemovesOnlySelectedConversation() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let context = MockCommandContextProvider()
+        let activePeer = PeerID(str: "active")
+        let otherPeer = PeerID(str: "other")
+        context.selectedPrivateChatPeer = activePeer
+        context.privateChats = [
+            activePeer: [makeMessage(sender: "alice", content: "secret")],
+            otherPeer: [makeMessage(sender: "bob", content: "keep")]
+        ]
+        let processor = CommandProcessor(contextProvider: context, meshService: nil, identityManager: identityManager)
+
+        let result = await withSelectedChannel(.mesh) {
+            processor.process("/clear")
+        }
+
+        switch result {
+        case .handled:
+            break
+        default:
+            Issue.record("Expected handled result")
+        }
+        #expect(context.privateChats[activePeer] == [])
+        #expect(context.privateChats[otherPeer]?.count == 1)
+    }
+
+    @MainActor
+    @Test func clearInPublicChatClearsTimeline() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let context = MockCommandContextProvider()
+        let processor = CommandProcessor(contextProvider: context, meshService: nil, identityManager: identityManager)
+
+        let result = await withSelectedChannel(.mesh) {
+            processor.process("/clear")
+        }
+
+        switch result {
+        case .handled:
+            break
+        default:
+            Issue.record("Expected handled result")
+        }
+        #expect(context.clearCurrentPublicTimelineCallCount == 1)
+    }
+
+    @MainActor
+    @Test func hugInPrivateChatSendsPersonalizedMessageAndLocalEcho() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let context = MockCommandContextProvider(nickname: "me")
+        let transport = MockTransport()
+        let peerID = PeerID(str: "abcd1234abcd1234")
+        context.selectedPrivateChatPeer = peerID
+        context.nicknameToPeerID["bob"] = peerID
+        transport.peerNicknames[peerID] = "Bob"
+        let processor = CommandProcessor(contextProvider: context, meshService: transport, identityManager: identityManager)
+
+        let result = await withSelectedChannel(.mesh) {
+            processor.process("/hug @bob")
+        }
+
+        switch result {
+        case .handled:
+            break
+        default:
+            Issue.record("Expected handled result")
+        }
+        #expect(transport.sentPrivateMessages.count == 1)
+        #expect(transport.sentPrivateMessages.first?.content == "* 🫂 me hugs you *")
+        #expect(context.localPrivateSystemMessages.first?.content == "🫂 you hugged bob")
+        #expect(context.localPrivateSystemMessages.first?.peerID == peerID)
+    }
+
+    @MainActor
+    @Test func slapInPublicChatSendsPublicRawAndEcho() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let context = MockCommandContextProvider(nickname: "me")
+        let peerID = PeerID(str: "abcd1234abcd1234")
+        context.nicknameToPeerID["bob"] = peerID
+        let processor = CommandProcessor(contextProvider: context, meshService: MockTransport(), identityManager: identityManager)
+
+        let result = await withSelectedChannel(.mesh) {
+            processor.process("/slap @bob")
+        }
+
+        switch result {
+        case .handled:
+            break
+        default:
+            Issue.record("Expected handled result")
+        }
+        #expect(context.sentPublicRawMessages == ["* 🐟 me slaps bob around a bit with a large trout *"])
+        #expect(context.publicSystemMessages == ["🐟 me slaps bob around a bit with a large trout"])
+    }
+
+    @MainActor
+    @Test func blockWithoutArgsListsMeshAndGeohashBlocks() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let context = MockCommandContextProvider()
+        let transport = MockTransport()
+        let peerID = PeerID(str: "abcd1234abcd1234")
+        transport.peerNicknames[peerID] = "bob"
+        transport.peerFingerprints[peerID] = "fp-bob"
+        context.blockedUsers = ["fp-bob"]
+        context.visibleGeoParticipants = [
+            CommandGeoParticipant(id: String(repeating: "c", count: 64), displayName: "carol")
+        ]
+        identityManager.setNostrBlocked(String(repeating: "c", count: 64), isBlocked: true)
+        let processor = CommandProcessor(contextProvider: context, meshService: transport, identityManager: identityManager)
+
+        let result = await withSelectedChannel(.mesh) {
+            processor.process("/block")
+        }
+
+        switch result {
+        case .success(let message):
+            #expect(message == "blocked peers: bob | geohash blocks: carol")
+        default:
+            Issue.record("Expected success result")
+        }
+    }
+
+    @MainActor
+    @Test func blockAndUnblockMeshPeerUpdateIdentityState() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let context = MockCommandContextProvider()
+        let transport = MockTransport()
+        let peerID = PeerID(str: "abcd1234abcd1234")
+        transport.peerFingerprints[peerID] = "fp-bob"
+        context.nicknameToPeerID["bob"] = peerID
+        let processor = CommandProcessor(contextProvider: context, meshService: transport, identityManager: identityManager)
+
+        let blockResult = await withSelectedChannel(.mesh) {
+            processor.process("/block @bob")
+        }
+        switch blockResult {
+        case .success(let message):
+            #expect(message == "blocked bob. you will no longer receive messages from them")
+        default:
+            Issue.record("Expected success result")
+        }
+        #expect(identityManager.isBlocked(fingerprint: "fp-bob"))
+
+        let unblockResult = await withSelectedChannel(.mesh) {
+            processor.process("/unblock bob")
+        }
+        switch unblockResult {
+        case .success(let message):
+            #expect(message == "unblocked bob")
+        default:
+            Issue.record("Expected success result")
+        }
+        #expect(!identityManager.isBlocked(fingerprint: "fp-bob"))
+    }
+
+    @MainActor
+    @Test func blockAndUnblockGeohashPeerUseNostrBlockList() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let context = MockCommandContextProvider()
+        context.displayNameToNostrPubkey["carol"] = String(repeating: "d", count: 64)
+        let processor = CommandProcessor(contextProvider: context, meshService: MockTransport(), identityManager: identityManager)
+
+        let blockResult = await withSelectedChannel(.mesh) {
+            processor.process("/block carol")
+        }
+        switch blockResult {
+        case .success(let message):
+            #expect(message == "blocked carol in geohash chats")
+        default:
+            Issue.record("Expected success result")
+        }
+        #expect(identityManager.isNostrBlocked(pubkeyHexLowercased: String(repeating: "d", count: 64)))
+
+        let unblockResult = await withSelectedChannel(.mesh) {
+            processor.process("/unblock @carol")
+        }
+        switch unblockResult {
+        case .success(let message):
+            #expect(message == "unblocked carol in geohash chats")
+        default:
+            Issue.record("Expected success result")
+        }
+        #expect(!identityManager.isNostrBlocked(pubkeyHexLowercased: String(repeating: "d", count: 64)))
+    }
+
+    @MainActor
+    @Test func favoriteCommandIsRejectedOutsideMesh() async {
+        let identityManager = MockIdentityManager(MockKeychain())
+        let processor = CommandProcessor(
+            contextProvider: MockCommandContextProvider(),
+            meshService: MockTransport(),
+            identityManager: identityManager
+        )
+        let channel = ChannelID.location(GeohashChannel(level: .city, geohash: "u4pruy"))
+
+        let result = await withSelectedChannel(channel) {
+            processor.process("/fav alice")
+        }
+
+        switch result {
+        case .error(let message):
+            #expect(message == "favorites are only for mesh peers in #mesh")
+        default:
+            Issue.record("Expected error result")
+        }
+    }
+
+    @MainActor
+    private func withSelectedChannel<T>(_ channel: ChannelID, perform work: @escaping () throws -> T) async rethrows -> T {
+        let originalChannel = LocationChannelManager.shared.selectedChannel
+        await setSelectedChannel(channel)
+        do {
+            let result = try work()
+            await setSelectedChannel(originalChannel)
+            return result
+        } catch {
+            await setSelectedChannel(originalChannel)
+            throw error
+        }
+    }
+
+    @MainActor
+    private func setSelectedChannel(_ channel: ChannelID) async {
+        LocationChannelManager.shared.select(channel)
+        for _ in 0..<40 {
+            if LocationChannelManager.shared.selectedChannel == channel {
+                return
+            }
+            await Task.yield()
+            try? await Task.sleep(nanoseconds: 5_000_000)
+        }
+    }
+
+    private func makeMessage(sender: String, content: String) -> BitchatMessage {
+        BitchatMessage(
+            sender: sender,
+            content: content,
+            timestamp: Date(timeIntervalSince1970: 1_700_000_000),
+            isRelay: false
+        )
+    }
+}
+
+@MainActor
+private final class MockCommandContextProvider: CommandContextProvider {
+    var nickname: String
+    var selectedPrivateChatPeer: PeerID?
+    var blockedUsers: Set<String> = []
+    var privateChats: [PeerID: [BitchatMessage]] = [:]
+    let idBridge: NostrIdentityBridge
+
+    var nicknameToPeerID: [String: PeerID] = [:]
+    var visibleGeoParticipants: [CommandGeoParticipant] = []
+    var displayNameToNostrPubkey: [String: String] = [:]
+
+    private(set) var startedPrivateChats: [PeerID] = []
+    private(set) var sentPrivateMessages: [(content: String, peerID: PeerID)] = []
+    private(set) var clearCurrentPublicTimelineCallCount = 0
+    private(set) var sentPublicRawMessages: [String] = []
+    private(set) var localPrivateSystemMessages: [(content: String, peerID: PeerID)] = []
+    private(set) var publicSystemMessages: [String] = []
+    private(set) var toggledFavorites: [PeerID] = []
+    private(set) var favoriteNotifications: [(peerID: PeerID, isFavorite: Bool)] = []
+
+    init(nickname: String = "tester", idBridge: NostrIdentityBridge = NostrIdentityBridge(keychain: MockKeychain())) {
+        self.nickname = nickname
+        self.idBridge = idBridge
+    }
+
+    func getPeerIDForNickname(_ nickname: String) -> PeerID? {
+        nicknameToPeerID[nickname]
+    }
+
+    func getVisibleGeoParticipants() -> [CommandGeoParticipant] {
+        visibleGeoParticipants
+    }
+
+    func nostrPubkeyForDisplayName(_ displayName: String) -> String? {
+        displayNameToNostrPubkey[displayName]
+    }
+
+    func startPrivateChat(with peerID: PeerID) {
+        startedPrivateChats.append(peerID)
+    }
+
+    func sendPrivateMessage(_ content: String, to peerID: PeerID) {
+        sentPrivateMessages.append((content, peerID))
+    }
+
+    func clearCurrentPublicTimeline() {
+        clearCurrentPublicTimelineCallCount += 1
+    }
+
+    func sendPublicRaw(_ content: String) {
+        sentPublicRawMessages.append(content)
+    }
+
+    func addLocalPrivateSystemMessage(_ content: String, to peerID: PeerID) {
+        localPrivateSystemMessages.append((content, peerID))
+    }
+
+    func addPublicSystemMessage(_ content: String) {
+        publicSystemMessages.append(content)
+    }
+
+    func toggleFavorite(peerID: PeerID) {
+        toggledFavorites.append(peerID)
+    }
+
+    func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool) {
+        favoriteNotifications.append((peerID, isFavorite))
+    }
 }

bitchatTests/Features/ImageUtilsTests.swift

@@ -0,0 +1,67 @@
+import Testing
+import Foundation
+#if os(iOS)
+import UIKit
+#else
+import AppKit
+#endif
+@testable import bitchat
+
+private func makeTemporaryFileURL(_ name: String) -> URL {
+    FileManager.default.temporaryDirectory.appendingPathComponent(name)
+}
+
+#if os(iOS)
+private func makePlatformImage(size: CGSize) -> UIImage {
+    UIGraphicsImageRenderer(size: size).image { context in
+        UIColor.systemTeal.setFill()
+        context.fill(CGRect(origin: .zero, size: size))
+    }
+}
+#else
+private func makePlatformImage(size: CGSize) -> NSImage {
+    let image = NSImage(size: size)
+    image.lockFocus()
+    NSColor.systemTeal.setFill()
+    NSBezierPath(rect: CGRect(origin: .zero, size: size)).fill()
+    image.unlockFocus()
+    return image
+}
+#endif
+
+struct ImageUtilsTests {
+    @Test
+    func processImage_rejectsOversizedSourceFile() throws {
+        let url = makeTemporaryFileURL("image-too-large.bin")
+        try Data(repeating: 0xFF, count: 10 * 1024 * 1024 + 1).write(to: url, options: .atomic)
+        defer { try? FileManager.default.removeItem(at: url) }
+
+        #expect(throws: ImageUtilsError.self) {
+            try ImageUtils.processImage(at: url)
+        }
+    }
+
+    @Test
+    func processImage_rejectsInvalidImageData() throws {
+        let url = makeTemporaryFileURL("image-invalid.bin")
+        try Data("not-an-image".utf8).write(to: url, options: .atomic)
+        defer { try? FileManager.default.removeItem(at: url) }
+
+        #expect(throws: ImageUtilsError.self) {
+            try ImageUtils.processImage(at: url)
+        }
+    }
+
+    @Test
+    func processImage_writesCompressedJpeg() throws {
+        let image = makePlatformImage(size: CGSize(width: 1024, height: 768))
+        let outputURL = try ImageUtils.processImage(image, maxDimension: 256)
+        defer { try? FileManager.default.removeItem(at: outputURL) }
+
+        let data = try Data(contentsOf: outputURL)
+
+        #expect(outputURL.pathExtension.lowercased() == "jpg")
+        #expect(data.starts(with: Data([0xFF, 0xD8])))
+        #expect(data.count > 0)
+    }
+}

bitchatTests/Fragmentation/FragmentationTests.swift

@@ -28,33 +28,33 @@ struct FragmentationTests {
         let ble = BLEService(
             keychain: mockKeychain,
             idBridge: idBridge,
-            identityManager: mockIdentityManager
+            identityManager: mockIdentityManager,
+            initializeBluetoothManagers: false
         )
         let capture = CaptureDelegate()
         ble.delegate = capture
-        
+
         // Construct a big packet (3KB) from a remote sender (not our own ID)
         let remoteShortID = PeerID(str: "1122334455667788")
         let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 3_000)
-        
+
         // Use a small fragment size to ensure multiple pieces
         let fragments = fragmentPacket(original, fragmentSize: 400)
-        
+
         // Shuffle fragments to simulate out-of-order arrival
         let shuffled = fragments.shuffled()
-        
+
-        // Inject fragments spaced out to avoid concurrent mutation inside BLEService
+        // Send fragments sequentially with small delays (no fire-and-forget Tasks)
         for (i, fragment) in shuffled.enumerated() {
-            let delay = 5 * Double(i) * 0.001
+            if i > 0 {
-            Task {
+                try await Task.sleep(for: .milliseconds(5))
-                try await sleep(delay)
-                ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
             }
+            ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
         }
-        
+
-        // Allow async processing
+        // Wait for delegate callback with proper timeout
-        try await sleep(0.5)
+        try await capture.waitForPublicMessages(count: 1, timeout: .seconds(2))
-        
+
         #expect(capture.publicMessages.count == 1)
         #expect(capture.publicMessages.first?.content.count == 3_000)
     }
@@ -64,30 +64,31 @@ struct FragmentationTests {
         let ble = BLEService(
             keychain: mockKeychain,
             idBridge: idBridge,
-            identityManager: mockIdentityManager
+            identityManager: mockIdentityManager,
+            initializeBluetoothManagers: false
         )
         let capture = CaptureDelegate()
         ble.delegate = capture
-        
+
         let remoteShortID = PeerID(str: "A1B2C3D4E5F60708")
         let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 2048)
         var frags = fragmentPacket(original, fragmentSize: 300)
-        
+
         // Duplicate one fragment
         if let dup = frags.first {
             frags.insert(dup, at: 1)
         }
-        
+
+        // Send fragments sequentially with small delays (no fire-and-forget Tasks)
         for (i, fragment) in frags.enumerated() {
-            let delay = 5 * Double(i) * 0.001
+            if i > 0 {
-            Task {
+                try await Task.sleep(for: .milliseconds(5))
-                try await sleep(delay)
-                ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
             }
+            ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
         }
-        
+
-        // Allow async processing
+        // Wait for delegate callback with proper timeout
-        try await sleep(0.5)
+        try await capture.waitForPublicMessages(count: 1, timeout: .seconds(2))
 
         #expect(capture.publicMessages.count == 1)
         #expect(capture.publicMessages.first?.content.count == 2048)
@@ -98,7 +99,8 @@ struct FragmentationTests {
         let ble = BLEService(
             keychain: mockKeychain,
             idBridge: idBridge,
-            identityManager: mockIdentityManager
+            identityManager: mockIdentityManager,
+            initializeBluetoothManagers: false
         )
         let capture = CaptureDelegate()
         ble.delegate = capture
@@ -135,7 +137,7 @@ struct FragmentationTests {
             }
         }
 
-        try await sleep(1.0)
+        try await capture.waitForReceivedMessages(count: 1, timeout: .seconds(2))
 
         let message = try #require(capture.receivedMessages.first, "Expected file transfer message")
         #expect(message.content.hasPrefix("[file]"))
@@ -154,7 +156,8 @@ struct FragmentationTests {
         let ble = BLEService(
             keychain: mockKeychain,
             idBridge: idBridge,
-            identityManager: mockIdentityManager
+            identityManager: mockIdentityManager,
+            initializeBluetoothManagers: false
         )
         let capture = CaptureDelegate()
         ble.delegate = capture
@@ -196,12 +199,140 @@ struct FragmentationTests {
 }
 
 extension FragmentationTests {
-    private final class CaptureDelegate: BitchatDelegate {
+    /// Thread-safe delegate that supports awaiting message delivery
-        var publicMessages: [(peerID: PeerID, nickname: String, content: String)] = []
+    private final class CaptureDelegate: BitchatDelegate, @unchecked Sendable {
-        var receivedMessages: [BitchatMessage] = []
+        private let lock = NSLock()
-        func didReceiveMessage(_ message: BitchatMessage) {
+        private var _publicMessages: [(peerID: PeerID, nickname: String, content: String)] = []
-            receivedMessages.append(message)
+        private var _receivedMessages: [BitchatMessage] = []
+        private var publicMessageContinuation: CheckedContinuation<Void, Never>?
+        private var receivedMessageContinuation: CheckedContinuation<Void, Never>?
+        private var expectedPublicMessageCount: Int = 0
+        private var expectedReceivedMessageCount: Int = 0
+
+        private func withLock<T>(_ body: () -> T) -> T {
+            lock.lock()
+            defer { lock.unlock() }
+            return body()
         }
+
+        var publicMessages: [(peerID: PeerID, nickname: String, content: String)] {
+            withLock { _publicMessages }
+        }
+
+        var receivedMessages: [BitchatMessage] {
+            withLock { _receivedMessages }
+        }
+
+        func didReceiveMessage(_ message: BitchatMessage) {
+            lock.lock()
+            _receivedMessages.append(message)
+            let count = _receivedMessages.count
+            let expected = expectedReceivedMessageCount
+            let continuation = receivedMessageContinuation
+            lock.unlock()
+
+            if count >= expected, let cont = continuation {
+                lock.lock()
+                receivedMessageContinuation = nil
+                lock.unlock()
+                cont.resume()
+            }
+        }
+
+        func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {
+            lock.lock()
+            _publicMessages.append((peerID, nickname, content))
+            let count = _publicMessages.count
+            let expected = expectedPublicMessageCount
+            let continuation = publicMessageContinuation
+            lock.unlock()
+
+            if count >= expected, let cont = continuation {
+                lock.lock()
+                publicMessageContinuation = nil
+                lock.unlock()
+                cont.resume()
+            }
+        }
+
+        /// Waits for the specified number of public messages to be received
+        func waitForPublicMessages(count: Int, timeout: Duration = .seconds(2)) async throws {
+            let isAlreadySatisfied = withLock { () -> Bool in
+                if _publicMessages.count >= count {
+                    return true
+                }
+                expectedPublicMessageCount = count
+                return false
+            }
+            if isAlreadySatisfied {
+                return
+            }
+
+            try await withThrowingTaskGroup(of: Void.self) { group in
+                group.addTask {
+                    await withCheckedContinuation { continuation in
+                        let shouldResumeImmediately = self.withLock {
+                            // Recheck count after acquiring lock to avoid race condition
+                            // where message arrives between initial check and continuation install
+                            if self._publicMessages.count >= count {
+                                return true
+                            }
+                            self.publicMessageContinuation = continuation
+                            return false
+                        }
+                        if shouldResumeImmediately {
+                            continuation.resume()
+                        }
+                    }
+                }
+                group.addTask {
+                    try await Task.sleep(for: timeout)
+                    throw CancellationError()
+                }
+                try await group.next()
+                group.cancelAll()
+            }
+        }
+
+        /// Waits for the specified number of received messages
+        func waitForReceivedMessages(count: Int, timeout: Duration = .seconds(2)) async throws {
+            let isAlreadySatisfied = withLock { () -> Bool in
+                if _receivedMessages.count >= count {
+                    return true
+                }
+                expectedReceivedMessageCount = count
+                return false
+            }
+            if isAlreadySatisfied {
+                return
+            }
+
+            try await withThrowingTaskGroup(of: Void.self) { group in
+                group.addTask {
+                    await withCheckedContinuation { continuation in
+                        let shouldResumeImmediately = self.withLock {
+                            // Recheck count after acquiring lock to avoid race condition
+                            // where message arrives between initial check and continuation install
+                            if self._receivedMessages.count >= count {
+                                return true
+                            }
+                            self.receivedMessageContinuation = continuation
+                            return false
+                        }
+                        if shouldResumeImmediately {
+                            continuation.resume()
+                        }
+                    }
+                }
+                group.addTask {
+                    try await Task.sleep(for: timeout)
+                    throw CancellationError()
+                }
+                try await group.next()
+                group.cancelAll()
+            }
+        }
+
         func didConnectToPeer(_ peerID: PeerID) {}
         func didDisconnectFromPeer(_ peerID: PeerID) {}
         func didUpdatePeerList(_ peers: [PeerID]) {}
@@ -209,9 +340,6 @@ extension FragmentationTests {
         func didUpdateMessageDeliveryStatus(_ messageID: String, status: DeliveryStatus) {}
         func didReceiveNoisePayload(from peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date) {}
         func didUpdateBluetoothState(_ state: CBManagerState) {}
-        func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {
-            publicMessages.append((peerID, nickname, content))
-        }
         func didReceiveRegionalPublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date) {}
     }
 

bitchatTests/GeohashPresenceTests.swift

@@ -0,0 +1,567 @@
+//
+// GeohashPresenceTests.swift
+// bitchatTests
+//
+// Tests for the Geohash Presence (Kind 20001) feature.
+// This is free and unencumbered software released into the public domain.
+//
+
+import Testing
+import Foundation
+import Combine
+@testable import bitchat
+
+// MARK: - NostrProtocol Presence Event Tests
+
+struct NostrProtocolPresenceTests {
+
+    @Test func createGeohashPresenceEvent_hasCorrectKind() throws {
+        let identity = try makeTestIdentity()
+        let event = try NostrProtocol.createGeohashPresenceEvent(
+            geohash: "u4pruydq",
+            senderIdentity: identity
+        )
+
+        #expect(event.kind == NostrProtocol.EventKind.geohashPresence.rawValue)
+        #expect(event.kind == 20001)
+    }
+
+    @Test func createGeohashPresenceEvent_hasEmptyContent() throws {
+        let identity = try makeTestIdentity()
+        let event = try NostrProtocol.createGeohashPresenceEvent(
+            geohash: "u4pruydq",
+            senderIdentity: identity
+        )
+
+        #expect(event.content == "")
+    }
+
+    @Test func createGeohashPresenceEvent_hasOnlyGeohashTag() throws {
+        let identity = try makeTestIdentity()
+        let event = try NostrProtocol.createGeohashPresenceEvent(
+            geohash: "u4pruydq",
+            senderIdentity: identity
+        )
+
+        // Should have exactly one tag: ["g", geohash]
+        #expect(event.tags.count == 1)
+        #expect(event.tags[0] == ["g", "u4pruydq"])
+    }
+
+    @Test func createGeohashPresenceEvent_noNicknameTag() throws {
+        let identity = try makeTestIdentity()
+        let event = try NostrProtocol.createGeohashPresenceEvent(
+            geohash: "u4pruydq",
+            senderIdentity: identity
+        )
+
+        // Should NOT contain nickname tag
+        let hasNicknameTag = event.tags.contains { $0.first == "n" }
+        #expect(!hasNicknameTag)
+    }
+
+    @Test func createGeohashPresenceEvent_usesSenderPubkey() throws {
+        let identity = try makeTestIdentity()
+        let event = try NostrProtocol.createGeohashPresenceEvent(
+            geohash: "u4pruydq",
+            senderIdentity: identity
+        )
+
+        #expect(event.pubkey == identity.publicKeyHex)
+    }
+
+    @Test func createGeohashPresenceEvent_isSigned() throws {
+        let identity = try makeTestIdentity()
+        let event = try NostrProtocol.createGeohashPresenceEvent(
+            geohash: "u4pruydq",
+            senderIdentity: identity
+        )
+
+        #expect(event.sig != nil && !event.sig!.isEmpty)
+        #expect(!event.id.isEmpty)
+    }
+
+    @Test func createGeohashPresenceEvent_differentGeohashes() throws {
+        let identity = try makeTestIdentity()
+
+        let event1 = try NostrProtocol.createGeohashPresenceEvent(geohash: "87", senderIdentity: identity)
+        let event2 = try NostrProtocol.createGeohashPresenceEvent(geohash: "87yw", senderIdentity: identity)
+        let event3 = try NostrProtocol.createGeohashPresenceEvent(geohash: "87yw7", senderIdentity: identity)
+
+        #expect(event1.tags[0][1] == "87")
+        #expect(event2.tags[0][1] == "87yw")
+        #expect(event3.tags[0][1] == "87yw7")
+    }
+
+    // MARK: - Helper
+
+    private func makeTestIdentity() throws -> NostrIdentity {
+        // Generate a fresh test identity
+        return try NostrIdentity.generate()
+    }
+}
+
+// MARK: - NostrFilter Presence Tests
+
+struct NostrFilterPresenceTests {
+
+    @Test func geohashEphemeral_includesBothKinds() {
+        let filter = NostrFilter.geohashEphemeral("u4pruydq")
+
+        #expect(filter.kinds?.contains(20000) == true)
+        #expect(filter.kinds?.contains(20001) == true)
+    }
+
+    @Test func geohashEphemeral_hasLimit1000() {
+        let filter = NostrFilter.geohashEphemeral("u4pruydq")
+
+        #expect(filter.limit == 1000)
+    }
+
+    @Test func geohashEphemeral_respectsSinceParameter() {
+        let since = Date(timeIntervalSince1970: 1700000000)
+        let filter = NostrFilter.geohashEphemeral("u4pruydq", since: since)
+
+        #expect(filter.since == 1700000000)
+    }
+}
+
+// MARK: - ChatViewModel Presence Handling Tests
+
+@MainActor
+struct ChatViewModelPresenceHandlingTests {
+
+    @Test func handleNostrEvent_presenceUpdatesParticipantTracker() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+
+        // Set up the channel
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+
+        // Create a presence event (kind 20001)
+        let identity = try NostrIdentity.generate()
+        let event = NostrEvent(
+            pubkey: identity.publicKeyHex,
+            createdAt: Date(),
+            kind: .geohashPresence,
+            tags: [["g", geohash]],
+            content: ""
+        )
+        let signed = try event.sign(with: identity.schnorrSigningKey())
+
+        // Handle the event
+        viewModel.handleNostrEvent(signed)
+
+        // Allow async processing
+        try? await Task.sleep(nanoseconds: 50_000_000)
+
+        // Participant should be recorded
+        let count = viewModel.geohashParticipantCount(for: geohash)
+        #expect(count >= 1)
+    }
+
+    @Test func handleNostrEvent_presenceDoesNotAddToTimeline() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+
+        let initialMessageCount = viewModel.messages.count
+
+        // Create a presence event (kind 20001)
+        let identity = try NostrIdentity.generate()
+        let event = NostrEvent(
+            pubkey: identity.publicKeyHex,
+            createdAt: Date(),
+            kind: .geohashPresence,
+            tags: [["g", geohash]],
+            content: ""
+        )
+        let signed = try event.sign(with: identity.schnorrSigningKey())
+
+        viewModel.handleNostrEvent(signed)
+
+        try? await Task.sleep(nanoseconds: 50_000_000)
+
+        // Message count should NOT increase
+        #expect(viewModel.messages.count == initialMessageCount)
+    }
+
+    @Test func handleNostrEvent_chatMessageUpdatesParticipant() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+
+        // Create a chat event (kind 20000) - NOT presence
+        let identity = try NostrIdentity.generate()
+        let event = NostrEvent(
+            pubkey: identity.publicKeyHex,
+            createdAt: Date(),
+            kind: .ephemeralEvent,
+            tags: [["g", geohash]],
+            content: "Hello world"
+        )
+        let signed = try event.sign(with: identity.schnorrSigningKey())
+
+        viewModel.handleNostrEvent(signed)
+
+        try? await Task.sleep(nanoseconds: 50_000_000)
+
+        // Chat messages should also update participant count (not just presence)
+        let count = viewModel.geohashParticipantCount(for: geohash)
+        #expect(count >= 1)
+    }
+
+    @Test func presenceEvent_hasDifferentKindThanChat() {
+        // Verify the two event kinds are distinct
+        let presenceKind = NostrProtocol.EventKind.geohashPresence.rawValue
+        let chatKind = NostrProtocol.EventKind.ephemeralEvent.rawValue
+
+        #expect(presenceKind != chatKind)
+        #expect(presenceKind == 20001)
+        #expect(chatKind == 20000)
+    }
+
+    @Test func subscribeNostrEvent_acceptsPresenceKind() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let geohash = "u4pruydq"
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
+
+        // Create presence event
+        let identity = try NostrIdentity.generate()
+        let event = NostrEvent(
+            pubkey: identity.publicKeyHex,
+            createdAt: Date(),
+            kind: .geohashPresence,
+            tags: [["g", geohash]],
+            content: ""
+        )
+        let signed = try event.sign(with: identity.schnorrSigningKey())
+
+        // subscribeNostrEvent should accept kind 20001
+        viewModel.subscribeNostrEvent(signed)
+
+        try? await Task.sleep(nanoseconds: 50_000_000)
+
+        // Should record participant
+        let count = viewModel.geohashParticipantCount(for: geohash)
+        #expect(count >= 1)
+    }
+
+    @Test func subscribeNostrEvent_presenceForNonActiveGeohash() async throws {
+        let (viewModel, _) = makeTestableViewModel()
+        let activeGeohash = "u4pruydq"
+        let otherGeohash = "87yw7"
+
+        viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: activeGeohash)))
+
+        // Create presence event for a DIFFERENT geohash
+        let identity = try NostrIdentity.generate()
+        let event = NostrEvent(
+            pubkey: identity.publicKeyHex,
+            createdAt: Date(),
+            kind: .geohashPresence,
+            tags: [["g", otherGeohash]],
+            content: ""
+        )
+        let signed = try event.sign(with: identity.schnorrSigningKey())
+
+        // Use subscribeNostrEvent with geohash parameter
+        viewModel.subscribeNostrEvent(signed, gh: otherGeohash)
+
+        try? await Task.sleep(nanoseconds: 50_000_000)
+
+        // Should record for the other geohash
+        let count = viewModel.geohashParticipantCount(for: otherGeohash)
+        #expect(count >= 1)
+    }
+
+    // MARK: - Test Helper
+
+    private func makeTestableViewModel() -> (viewModel: ChatViewModel, transport: MockTransport) {
+        let keychain = MockKeychain()
+        let keychainHelper = MockKeychainHelper()
+        let idBridge = NostrIdentityBridge(keychain: keychainHelper)
+        let identityManager = MockIdentityManager(keychain)
+        let transport = MockTransport()
+
+        let viewModel = ChatViewModel(
+            keychain: keychain,
+            idBridge: idBridge,
+            identityManager: identityManager,
+            transport: transport
+        )
+
+        return (viewModel, transport)
+    }
+}
+
+// MARK: - Presence Privacy Tests
+
+struct GeohashPresencePrivacyTests {
+
+    @Test func allowedPrecisions_onlyLowPrecision() {
+        // The allowed precisions for presence broadcasting should be:
+        // Region (2), Province (4), City (5)
+        // NOT Neighborhood (6), Block (7), Building (8+)
+
+        let regionPrecision = GeohashChannelLevel.region.precision
+        let provincePrecision = GeohashChannelLevel.province.precision
+        let cityPrecision = GeohashChannelLevel.city.precision
+        let neighborhoodPrecision = GeohashChannelLevel.neighborhood.precision
+        let blockPrecision = GeohashChannelLevel.block.precision
+        let buildingPrecision = GeohashChannelLevel.building.precision
+
+        #expect(regionPrecision == 2)
+        #expect(provincePrecision == 4)
+        #expect(cityPrecision == 5)
+        #expect(neighborhoodPrecision == 6)
+        #expect(blockPrecision == 7)
+        #expect(buildingPrecision == 8)
+
+        // High precision channels should NOT receive presence broadcasts
+        #expect(neighborhoodPrecision > 5)
+        #expect(blockPrecision > 5)
+        #expect(buildingPrecision > 5)
+    }
+
+    @Test func geohashLengthDeterminesPrecision() {
+        // Verify geohash length maps to expected precision
+        #expect("87".count == GeohashChannelLevel.region.precision)
+        #expect("87yw".count == GeohashChannelLevel.province.precision)
+        #expect("87yw7".count == GeohashChannelLevel.city.precision)
+        #expect("87yw7t".count == GeohashChannelLevel.neighborhood.precision)
+        #expect("87yw7tc".count == GeohashChannelLevel.block.precision)
+        #expect("87yw7tcx".count == GeohashChannelLevel.building.precision)
+    }
+
+    @Test func highPrecisionGeohash_isPrivacySensitive() {
+        // Helper to check if a geohash is "high precision" (privacy sensitive)
+        func isHighPrecision(_ geohash: String) -> Bool {
+            geohash.count >= 6
+        }
+
+        // Low precision - OK to broadcast presence
+        #expect(!isHighPrecision("87"))      // region
+        #expect(!isHighPrecision("87yw"))    // province
+        #expect(!isHighPrecision("87yw7"))   // city
+
+        // High precision - should NOT broadcast presence
+        #expect(isHighPrecision("87yw7t"))   // neighborhood
+        #expect(isHighPrecision("87yw7tc"))  // block
+        #expect(isHighPrecision("87yw7tcx")) // building
+    }
+}
+
+// MARK: - Display Logic Tests
+
+struct LocationChannelsDisplayLogicTests {
+
+    @Test func displayLogic_highPrecisionZeroCount_showsUnknown() {
+        // Test the logic that determines "?" vs actual count
+        // High precision + count 0 = "?"
+
+        let shouldShowUnknown = shouldShowUnknownCount(
+            level: .neighborhood,
+            count: 0
+        )
+        #expect(shouldShowUnknown)
+    }
+
+    @Test func displayLogic_highPrecisionNonZeroCount_showsActual() {
+        // High precision + count > 0 = show actual
+        let shouldShowUnknown = shouldShowUnknownCount(
+            level: .neighborhood,
+            count: 5
+        )
+        #expect(!shouldShowUnknown)
+    }
+
+    @Test func displayLogic_lowPrecisionZeroCount_showsActual() {
+        // Low precision + count 0 = show "0" (not "?")
+        let shouldShowUnknown = shouldShowUnknownCount(
+            level: .city,
+            count: 0
+        )
+        #expect(!shouldShowUnknown)
+    }
+
+    @Test func displayLogic_lowPrecisionNonZeroCount_showsActual() {
+        // Low precision + count > 0 = show actual
+        let shouldShowUnknown = shouldShowUnknownCount(
+            level: .region,
+            count: 10
+        )
+        #expect(!shouldShowUnknown)
+    }
+
+    @Test func displayLogic_allHighPrecisionLevels() {
+        // All high precision levels with 0 should show "?"
+        let highPrecisionLevels: [GeohashChannelLevel] = [.neighborhood, .block, .building]
+
+        for level in highPrecisionLevels {
+            let shouldShowUnknown = shouldShowUnknownCount(level: level, count: 0)
+            #expect(shouldShowUnknown, "Level \(level) with count 0 should show unknown")
+        }
+    }
+
+    @Test func displayLogic_allLowPrecisionLevels() {
+        // All low precision levels with 0 should show actual count
+        let lowPrecisionLevels: [GeohashChannelLevel] = [.region, .province, .city]
+
+        for level in lowPrecisionLevels {
+            let shouldShowUnknown = shouldShowUnknownCount(level: level, count: 0)
+            #expect(!shouldShowUnknown, "Level \(level) with count 0 should show actual count")
+        }
+    }
+
+    @Test func displayLogic_bookmarkHighPrecision() {
+        // Bookmarks use geohash length to determine precision
+        #expect(shouldShowUnknownForBookmark(geohash: "87yw7t", count: 0))   // len 6
+        #expect(shouldShowUnknownForBookmark(geohash: "87yw7tc", count: 0))  // len 7
+        #expect(shouldShowUnknownForBookmark(geohash: "87yw7tcx", count: 0)) // len 8
+    }
+
+    @Test func displayLogic_bookmarkLowPrecision() {
+        #expect(!shouldShowUnknownForBookmark(geohash: "87", count: 0))     // len 2
+        #expect(!shouldShowUnknownForBookmark(geohash: "87yw", count: 0))   // len 4
+        #expect(!shouldShowUnknownForBookmark(geohash: "87yw7", count: 0))  // len 5
+    }
+
+    // MARK: - Helpers (mirror the logic from LocationChannelsSheet)
+
+    private func shouldShowUnknownCount(level: GeohashChannelLevel, count: Int) -> Bool {
+        let isHighPrecision = (level == .neighborhood || level == .block || level == .building)
+        return isHighPrecision && count == 0
+    }
+
+    private func shouldShowUnknownForBookmark(geohash: String, count: Int) -> Bool {
+        let isHighPrecision = (geohash.count >= 6)
+        return isHighPrecision && count == 0
+    }
+}
+
+// MARK: - Event Kind Tests
+
+struct NostrEventKindTests {
+
+    @Test func eventKind_geohashPresence_is20001() {
+        #expect(NostrProtocol.EventKind.geohashPresence.rawValue == 20001)
+    }
+
+    @Test func eventKind_ephemeralEvent_is20000() {
+        #expect(NostrProtocol.EventKind.ephemeralEvent.rawValue == 20000)
+    }
+
+    @Test func eventKind_presenceIsEphemeral() {
+        // Both 20000 and 20001 are in the ephemeral range (20000-29999)
+        let presenceKind = NostrProtocol.EventKind.geohashPresence.rawValue
+        let chatKind = NostrProtocol.EventKind.ephemeralEvent.rawValue
+
+        #expect(presenceKind >= 20000 && presenceKind < 30000)
+        #expect(chatKind >= 20000 && chatKind < 30000)
+    }
+}
+
+// MARK: - Participant Tracker Presence Integration Tests
+
+@MainActor
+struct ParticipantTrackerPresenceTests {
+
+    @Test func recordParticipant_fromPresenceEvent_countsParticipant() async {
+        let tracker = GeohashParticipantTracker()
+        let context = PresenceTestParticipantContext()
+        tracker.configure(context: context)
+
+        let geohash = "87yw7"
+        tracker.setActiveGeohash(geohash)
+
+        // Simulate recording from a presence event
+        tracker.recordParticipant(pubkeyHex: "presence_user_1")
+
+        #expect(tracker.participantCount(for: geohash) == 1)
+    }
+
+    @Test func recordParticipant_multiplePresenceEvents_countsUnique() async {
+        let tracker = GeohashParticipantTracker()
+        let context = PresenceTestParticipantContext()
+        tracker.configure(context: context)
+
+        let geohash = "87yw7"
+        tracker.setActiveGeohash(geohash)
+
+        // Multiple presence events from same user = 1 participant
+        tracker.recordParticipant(pubkeyHex: "user_a")
+        tracker.recordParticipant(pubkeyHex: "user_a")
+        tracker.recordParticipant(pubkeyHex: "user_a")
+
+        #expect(tracker.participantCount(for: geohash) == 1)
+
+        // Different user = 2 participants
+        tracker.recordParticipant(pubkeyHex: "user_b")
+
+        #expect(tracker.participantCount(for: geohash) == 2)
+    }
+
+    @Test func recordParticipant_nonActiveGeohash_stillCounts() async {
+        let tracker = GeohashParticipantTracker()
+        let context = PresenceTestParticipantContext()
+        tracker.configure(context: context)
+
+        // Active geohash is different from where we're recording
+        tracker.setActiveGeohash("active_gh")
+
+        // Record to a non-active geohash (like when sampling nearby channels)
+        tracker.recordParticipant(pubkeyHex: "nearby_user", geohash: "other_gh")
+
+        #expect(tracker.participantCount(for: "other_gh") == 1)
+        #expect(tracker.participantCount(for: "active_gh") == 0)
+    }
+
+    @Test func objectWillChange_firesOnNonActiveGeohashUpdate() async {
+        let tracker = GeohashParticipantTracker()
+        let context = PresenceTestParticipantContext()
+        tracker.configure(context: context)
+
+        tracker.setActiveGeohash("active_gh")
+
+        var changeCount = 0
+        let cancellable = tracker.objectWillChange.sink { _ in
+            changeCount += 1
+        }
+
+        // Record to non-active geohash
+        tracker.recordParticipant(pubkeyHex: "user1", geohash: "other_gh")
+
+        // Should fire objectWillChange even for non-active geohash
+        #expect(changeCount >= 1)
+
+        _ = cancellable // Keep alive
+    }
+}
+
+// MARK: - Mock for Participant Context (Presence Tests)
+
+@MainActor
+private final class PresenceTestParticipantContext: GeohashParticipantContext {
+    var blockedPubkeys: Set<String> = []
+    var nicknameMap: [String: String] = [:]
+    var selfPubkey: String?
+
+    func displayNameForPubkey(_ pubkeyHex: String) -> String {
+        let suffix = String(pubkeyHex.suffix(4))
+        if let s = selfPubkey, pubkeyHex.lowercased() == s.lowercased() {
+            return "me#\(suffix)"
+        }
+        if let nick = nicknameMap[pubkeyHex.lowercased()] {
+            return "\(nick)#\(suffix)"
+        }
+        return "anon#\(suffix)"
+    }
+
+    func isBlocked(_ pubkeyHexLowercased: String) -> Bool {
+        blockedPubkeys.contains(pubkeyHexLowercased.lowercased())
+    }
+}

bitchatTests/GossipSyncManagerTests.swift

@@ -7,12 +7,14 @@ struct GossipSyncManagerTests {
     private let myPeerID = PeerID(str: "0102030405060708")
     
     @Test func concurrentPacketIntakeAndSyncRequest() async throws {
-        let manager = GossipSyncManager(myPeerID: myPeerID)
+        let requestSyncManager = RequestSyncManager()
+        let manager = GossipSyncManager(myPeerID: myPeerID, requestSyncManager: requestSyncManager)
         let delegate = RecordingDelegate()
         manager.delegate = delegate
 
         try await confirmation("sync request sent") { sent in
             delegate.onSend = {
+                delegate.onSend = nil
                 sent()
             }
 
@@ -34,7 +36,7 @@ struct GossipSyncManagerTests {
             }
 
             manager.scheduleInitialSyncToPeer(PeerID(str: "FFFFFFFFFFFFFFFF"), delaySeconds: 0.0)
-            try await sleep(0.002)
+            try await TestHelpers.waitFor({ delegate.lastPacket != nil }, timeout: TestConstants.shortTimeout)
         }
 
         let lastPacket = try #require(delegate.lastPacket, "Expected sync packet to be sent")
@@ -47,7 +49,8 @@ struct GossipSyncManagerTests {
         config.stalePeerCleanupIntervalSeconds = 0
         config.stalePeerTimeoutSeconds = 5
 
-        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
+        let requestSyncManager = RequestSyncManager()
+        let manager = GossipSyncManager(myPeerID: myPeerID, config: config, requestSyncManager: requestSyncManager)
         let peerHex = "0011223344556677"
         let senderData = try #require(Data(hexString: peerHex))
         let initialTimestampMs = UInt64(Date().timeIntervalSince1970 * 1000)
@@ -92,7 +95,8 @@ struct GossipSyncManagerTests {
         config.stalePeerTimeoutSeconds = 5
         config.maxMessageAgeSeconds = 100
 
-        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
+        let requestSyncManager = RequestSyncManager()
+        let manager = GossipSyncManager(myPeerID: myPeerID, config: config, requestSyncManager: requestSyncManager)
         let peerHex = "8899aabbccddeeff"
         let senderData = try #require(Data(hexString: peerHex))
         let staleTimestampMs = UInt64(Date().addingTimeInterval(-(config.stalePeerTimeoutSeconds + 1)).timeIntervalSince1970 * 1000)
@@ -136,7 +140,8 @@ struct GossipSyncManagerTests {
         config.fileTransferSyncIntervalSeconds = 1
         config.maintenanceIntervalSeconds = 0
 
-        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
+        let requestSyncManager = RequestSyncManager()
+        let manager = GossipSyncManager(myPeerID: myPeerID, config: config, requestSyncManager: requestSyncManager)
         let delegate = RecordingDelegate()
         manager.delegate = delegate
 
@@ -206,7 +211,8 @@ struct GossipSyncManagerTests {
         config.fragmentSyncIntervalSeconds = 0
         config.fileTransferSyncIntervalSeconds = 0
 
-        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
+        let requestSyncManager = RequestSyncManager()
+        let manager = GossipSyncManager(myPeerID: myPeerID, config: config, requestSyncManager: requestSyncManager)
         let delegate = RecordingDelegate()
         manager.delegate = delegate
 
@@ -240,7 +246,7 @@ struct GossipSyncManagerTests {
         let request = RequestSyncPacket(p: 4, m: 1, data: Data(), types: .fragment)
         manager.handleRequestSync(from: peer, request: request)
 
-        try await sleep(0.01)
+        try await TestHelpers.waitFor({ delegate.packets.count == 1 }, timeout: TestConstants.shortTimeout)
         let sentPackets = delegate.packets
         #expect(sentPackets.count == 1)
         #expect(sentPackets[0].type == MessageType.fragment.rawValue)
@@ -268,4 +274,8 @@ private final class RecordingDelegate: GossipSyncManager.Delegate {
     func signPacketForBroadcast(_ packet: BitchatPacket) -> BitchatPacket {
         packet
     }
+    
+    func getConnectedPeers() -> [PeerID] {
+        return []
+    }
 }

bitchatTests/InputValidatorTests.swift

@@ -131,6 +131,7 @@ struct InputValidatorTests {
     }
 
     // MARK: - Timestamp Validation Tests
+    // BCH-01-011: Window reduced from ±1 hour to ±5 minutes
 
     @Test func currentTimestampIsValid() throws {
         let now = Date()
@@ -138,31 +139,48 @@ struct InputValidatorTests {
         #expect(result == true)
     }
 
-    @Test func timestampWithinOneHourIsValid() throws {
+    @Test func timestampWithinFiveMinutesIsValid() throws {
+        // 2 minutes ago should be valid (within 5-minute window)
+        let twoMinutesAgo = Date().addingTimeInterval(-2 * 60)
+        let result = InputValidator.validateTimestamp(twoMinutesAgo)
+        #expect(result == true)
+    }
+
+    @Test func timestampThirtyMinutesAgoIsInvalid() throws {
+        // BCH-01-011: 30 minutes is now outside the 5-minute window
         let thirtyMinutesAgo = Date().addingTimeInterval(-30 * 60)
         let result = InputValidator.validateTimestamp(thirtyMinutesAgo)
-        #expect(result == true)
-    }
-
-    @Test func timestampTwoHoursAgoIsInvalid() throws {
-        let twoHoursAgo = Date().addingTimeInterval(-2 * 3600)
-        let result = InputValidator.validateTimestamp(twoHoursAgo)
         #expect(result == false)
     }
 
-    @Test func timestampTwoHoursInFutureIsInvalid() throws {
+    @Test func timestampTenMinutesAgoIsInvalid() throws {
-        let twoHoursFromNow = Date().addingTimeInterval(2 * 3600)
+        // 10 minutes is outside the 5-minute window
-        let result = InputValidator.validateTimestamp(twoHoursFromNow)
+        let tenMinutesAgo = Date().addingTimeInterval(-10 * 60)
+        let result = InputValidator.validateTimestamp(tenMinutesAgo)
         #expect(result == false)
     }
 
-    @Test func timestampAtOneHourBoundaryIsValid() throws {
+    @Test func timestampTenMinutesInFutureIsInvalid() throws {
-        // Just slightly within the one-hour window
+        // 10 minutes in future is outside the 5-minute window
-        let almostOneHourAgo = Date().addingTimeInterval(-3599)
+        let tenMinutesFromNow = Date().addingTimeInterval(10 * 60)
-        let result = InputValidator.validateTimestamp(almostOneHourAgo)
+        let result = InputValidator.validateTimestamp(tenMinutesFromNow)
+        #expect(result == false)
+    }
+
+    @Test func timestampAtFiveMinuteBoundaryIsValid() throws {
+        // Just slightly within the five-minute window (299 seconds)
+        let almostFiveMinutesAgo = Date().addingTimeInterval(-299)
+        let result = InputValidator.validateTimestamp(almostFiveMinutesAgo)
         #expect(result == true)
     }
 
+    @Test func timestampJustOutsideFiveMinuteWindowIsInvalid() throws {
+        // Just outside the five-minute window (301 seconds)
+        let justOverFiveMinutesAgo = Date().addingTimeInterval(-301)
+        let result = InputValidator.validateTimestamp(justOverFiveMinutesAgo)
+        #expect(result == false)
+    }
+
     // MARK: - Edge Cases
 
     @Test func singleCharacterStringIsAccepted() throws {

bitchatTests/KeychainErrorHandlingTests.swift

@@ -0,0 +1,216 @@
+//
+// KeychainErrorHandlingTests.swift
+// bitchatTests
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+// BCH-01-009: Tests for proper keychain error classification and handling
+
+import Testing
+import Foundation
+@testable import bitchat
+
+struct KeychainErrorHandlingTests {
+
+    // MARK: - Error Classification Tests
+
+    @Test func keychainReadResult_successIsNotRecoverable() throws {
+        let result = KeychainReadResult.success(Data([1, 2, 3]))
+        #expect(result.isRecoverableError == false)
+    }
+
+    @Test func keychainReadResult_itemNotFoundIsNotRecoverable() throws {
+        let result = KeychainReadResult.itemNotFound
+        #expect(result.isRecoverableError == false)
+    }
+
+    @Test func keychainReadResult_deviceLockedIsRecoverable() throws {
+        let result = KeychainReadResult.deviceLocked
+        #expect(result.isRecoverableError == true)
+    }
+
+    @Test func keychainReadResult_authenticationFailedIsRecoverable() throws {
+        let result = KeychainReadResult.authenticationFailed
+        #expect(result.isRecoverableError == true)
+    }
+
+    @Test func keychainReadResult_accessDeniedIsNotRecoverable() throws {
+        let result = KeychainReadResult.accessDenied
+        #expect(result.isRecoverableError == false)
+    }
+
+    @Test func keychainSaveResult_successIsNotRecoverable() throws {
+        let result = KeychainSaveResult.success
+        #expect(result.isRecoverableError == false)
+    }
+
+    @Test func keychainSaveResult_duplicateItemIsRecoverable() throws {
+        let result = KeychainSaveResult.duplicateItem
+        #expect(result.isRecoverableError == true)
+    }
+
+    @Test func keychainSaveResult_deviceLockedIsRecoverable() throws {
+        let result = KeychainSaveResult.deviceLocked
+        #expect(result.isRecoverableError == true)
+    }
+
+    @Test func keychainSaveResult_storageFullIsNotRecoverable() throws {
+        let result = KeychainSaveResult.storageFull
+        #expect(result.isRecoverableError == false)
+    }
+
+    // MARK: - Mock Keychain Error Simulation Tests
+
+    @Test func mockKeychain_canSimulateReadErrors() throws {
+        let keychain = MockKeychain()
+
+        // Simulate access denied error
+        keychain.simulatedReadError = .accessDenied
+        let result = keychain.getIdentityKeyWithResult(forKey: "testKey")
+
+        switch result {
+        case .accessDenied:
+            // Expected
+            break
+        default:
+            throw KeychainTestError("Expected accessDenied, got \(result)")
+        }
+    }
+
+    @Test func mockKeychain_canSimulateSaveErrors() throws {
+        let keychain = MockKeychain()
+
+        // Simulate storage full error
+        keychain.simulatedSaveError = .storageFull
+        let result = keychain.saveIdentityKeyWithResult(Data([1, 2, 3]), forKey: "testKey")
+
+        switch result {
+        case .storageFull:
+            // Expected
+            break
+        default:
+            throw KeychainTestError("Expected storageFull, got \(result)")
+        }
+    }
+
+    @Test func mockKeychain_returnsItemNotFoundForMissingKey() throws {
+        let keychain = MockKeychain()
+        let result = keychain.getIdentityKeyWithResult(forKey: "nonExistentKey")
+
+        switch result {
+        case .itemNotFound:
+            // Expected
+            break
+        default:
+            throw KeychainTestError("Expected itemNotFound, got \(result)")
+        }
+    }
+
+    @Test func mockKeychain_returnsSuccessForExistingKey() throws {
+        let keychain = MockKeychain()
+        let testData = Data([1, 2, 3, 4, 5])
+
+        // First save the key
+        _ = keychain.saveIdentityKey(testData, forKey: "existingKey")
+
+        // Now read it back
+        let result = keychain.getIdentityKeyWithResult(forKey: "existingKey")
+
+        switch result {
+        case .success(let data):
+            #expect(data == testData)
+        default:
+            throw KeychainTestError("Expected success, got \(result)")
+        }
+    }
+
+    @Test func mockKeychain_saveWithResultStoresData() throws {
+        let keychain = MockKeychain()
+        let testData = Data([10, 20, 30])
+
+        let saveResult = keychain.saveIdentityKeyWithResult(testData, forKey: "newKey")
+
+        switch saveResult {
+        case .success:
+            // Verify data was stored
+            let readResult = keychain.getIdentityKeyWithResult(forKey: "newKey")
+            switch readResult {
+            case .success(let data):
+                #expect(data == testData)
+            default:
+                throw KeychainTestError("Expected to read back saved data")
+            }
+        default:
+            throw KeychainTestError("Expected save success, got \(saveResult)")
+        }
+    }
+
+    // MARK: - NoiseEncryptionService Integration Tests
+
+    @Test func noiseEncryptionService_generatesNewIdentityWhenMissing() throws {
+        let keychain = MockKeychain()
+
+        // Create service with empty keychain - should generate new identity
+        let service = NoiseEncryptionService(keychain: keychain)
+
+        // Should have generated and saved keys
+        #expect(service.getStaticPublicKeyData().count == 32)
+        #expect(service.getSigningPublicKeyData().count == 32)
+
+        // Keys should be persisted
+        let noiseKeyResult = keychain.getIdentityKeyWithResult(forKey: "noiseStaticKey")
+        switch noiseKeyResult {
+        case .success:
+            // Expected - key was saved
+            break
+        default:
+            throw KeychainTestError("Expected noise key to be saved")
+        }
+    }
+
+    @Test func noiseEncryptionService_loadsExistingIdentity() throws {
+        let keychain = MockKeychain()
+
+        // Create first service to generate identity
+        let service1 = NoiseEncryptionService(keychain: keychain)
+        let originalPublicKey = service1.getStaticPublicKeyData()
+        let originalSigningKey = service1.getSigningPublicKeyData()
+
+        // Create second service - should load same identity
+        let service2 = NoiseEncryptionService(keychain: keychain)
+
+        #expect(service2.getStaticPublicKeyData() == originalPublicKey)
+        #expect(service2.getSigningPublicKeyData() == originalSigningKey)
+    }
+
+    @Test func noiseEncryptionService_handlesAccessDeniedGracefully() throws {
+        let keychain = MockKeychain()
+        keychain.simulatedReadError = .accessDenied
+
+        // Service should still initialize with ephemeral key
+        let service = NoiseEncryptionService(keychain: keychain)
+
+        // Should have an identity (ephemeral)
+        #expect(service.getStaticPublicKeyData().count == 32)
+        #expect(service.getSigningPublicKeyData().count == 32)
+    }
+
+    @Test func noiseEncryptionService_handlesDeviceLockedGracefully() throws {
+        let keychain = MockKeychain()
+        keychain.simulatedReadError = .deviceLocked
+
+        // Service should still initialize with ephemeral key
+        let service = NoiseEncryptionService(keychain: keychain)
+
+        // Should have an identity (ephemeral)
+        #expect(service.getStaticPublicKeyData().count == 32)
+    }
+}
+
+// Helper error type for tests
+private struct KeychainTestError: Error, CustomStringConvertible {
+    let message: String
+    init(_ message: String) { self.message = message }
+    var description: String { message }
+}

bitchatTests/LocalizationCatalogTests.swift

@@ -1,530 +0,0 @@
-//import Foundation
-//import XCTest
-//@testable import bitchat
-//
-//private let localizationTestsDirectoryURL = URL(fileURLWithPath: #filePath).deletingLastPathComponent()
-//private let testsRootURL = localizationTestsDirectoryURL.deletingLastPathComponent()
-//private let repoRootURL = testsRootURL.deletingLastPathComponent()
-//
-//final class LocalizationCatalogTests: XCTestCase {
-//  // Ensures every app locale includes exactly the same keys as Base.
-//  func testAppCatalogLocaleParity() throws {
-//    let context = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
-//    assertLocaleParity(context: context, catalogName: "App")
-//  }
-//
-//  // Verifies format placeholders stay consistent across app locales.
-//  func testAppCatalogPlaceholderConsistency() throws {
-//    let context = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
-//    assertPlaceholderConsistency(context: context, catalogName: "App")
-//  }
-//
-//  // Guards a core set of app strings from going empty per locale.
-//  func testAppPrimaryKeysNonEmpty() throws {
-//    let context = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
-//    let primaryKeys = try loadPrimaryKeys().app
-//    assertPrimaryKeysPresent(context: context, keys: primaryKeys, catalogName: "App")
-//  }
-//
-//  // Ensures every share extension locale matches Base key coverage.
-//  func testShareExtensionCatalogLocaleParity() throws {
-//    let context = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
-//    assertLocaleParity(context: context, catalogName: "ShareExtension")
-//  }
-//
-//  // Verifies share extension placeholders align across locales.
-//  func testShareExtensionCatalogPlaceholderConsistency() throws {
-//    let context = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
-//    assertPlaceholderConsistency(context: context, catalogName: "ShareExtension")
-//  }
-//
-//  // Confirms critical share extension strings remain non-empty per locale.
-//  func testShareExtensionPrimaryKeysNonEmpty() throws {
-//    let context = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
-//    let primaryKeys = try loadPrimaryKeys().shareExtension
-//    assertPrimaryKeysPresent(context: context, keys: primaryKeys, catalogName: "ShareExtension")
-//  }
-//
-//  // Validates that configured locales contain expected string values.
-//  func testLocalizationExpectedValues() throws {
-//    let appContext = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
-//    let shareContext = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
-//    let config = try loadPrimaryKeys()
-//    
-//    guard let testLocales = config.testLocales else {
-//      // If no testLocales specified, skip this test
-//      return
-//    }
-//    
-//    guard let expectedValues = config.expectedValues else {
-//      XCTFail("No expectedValues configured in PrimaryLocalizationKeys.json")
-//      return
-//    }
-//    
-//    // Loop through each locale to test
-//    for locale in testLocales {
-//      guard let localeExpectedValues = expectedValues[locale] else {
-//        XCTFail("No expected values configured for locale '\(locale)' in PrimaryLocalizationKeys.json")
-//        continue
-//      }
-//      
-//      // Test each expected key/value pair for this locale
-//      for (key, expectedValue) in localeExpectedValues {
-//        if config.app.contains(key) {
-//          assertLocaleStringValue(context: appContext, locale: locale, key: key, expectedValue: expectedValue, catalogName: "App")
-//        } else if config.shareExtension.contains(key) {
-//          assertLocaleStringValue(context: shareContext, locale: locale, key: key, expectedValue: expectedValue, catalogName: "ShareExtension")
-//        }
-//      }
-//    }
-//  }
-//
-//  // Ensures configured test locales are present and complete.
-//  func testConfiguredLocalesCompleteness() throws {
-//    let appContext = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
-//    let shareContext = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
-//    let config = try loadPrimaryKeys()
-//    
-//    guard let testLocales = config.testLocales else {
-//      // If no testLocales specified, skip this test
-//      return
-//    }
-//    
-//    let baseLocale = appContext.baseLocale
-//    let baseAppKeys = appContext.keysByLocale[baseLocale] ?? Set()
-//    let baseShareKeys = shareContext.keysByLocale[baseLocale] ?? Set()
-//    
-//    for locale in testLocales {
-//      // Skip base locale comparison with itself
-//      if locale == baseLocale { continue }
-//      
-//      // Verify locale is present in both catalogs
-//      XCTAssertTrue(appContext.locales.contains(locale), "Locale '\(locale)' missing from app catalog")
-//      XCTAssertTrue(shareContext.locales.contains(locale), "Locale '\(locale)' missing from share extension catalog")
-//      
-//      // Verify locale has same number of keys as base locale
-//      let appLocaleKeys = appContext.keysByLocale[locale] ?? Set()
-//      XCTAssertEqual(appLocaleKeys.count, baseAppKeys.count, "Locale '\(locale)' app catalog missing keys compared to \(baseLocale)")
-//      
-//      let shareLocaleKeys = shareContext.keysByLocale[locale] ?? Set()
-//      XCTAssertEqual(shareLocaleKeys.count, baseShareKeys.count, "Locale '\(locale)' share extension catalog missing keys compared to \(baseLocale)")
-//    }
-//  }
-//
-//  // MARK: - Assertions
-//
-//  private func assertLocaleParity(context: CatalogContext, catalogName: String, file: StaticString = #filePath, line: UInt = #line) {
-//    let baseLocale = context.baseLocale
-//    guard let baseKeys = context.keysByLocale[baseLocale] else {
-//      return XCTFail("Missing base locale \(baseLocale) in \(catalogName) catalog", file: file, line: line)
-//    }
-//
-//    for (locale, keys) in context.keysByLocale.sorted(by: { $0.key < $1.key }) {
-//      XCTAssertEqual(keys, baseKeys, "Locale \(locale) has key mismatch in \(catalogName) catalog", file: file, line: line)
-//    }
-//  }
-//
-//  private func assertPlaceholderConsistency(context: CatalogContext, catalogName: String, file: StaticString = #filePath, line: UInt = #line) {
-//    let baseLocale = context.baseLocale
-//    guard let baseSignatures = context.placeholderSignature[baseLocale] else {
-//      return XCTFail("Missing base placeholder signature for \(catalogName)", file: file, line: line)
-//    }
-//
-//    for (locale, localeSignatures) in context.placeholderSignature.sorted(by: { $0.key < $1.key }) {
-//      guard locale != baseLocale else { continue }
-//      for key in baseSignatures.keys.sorted() {
-//        guard let baseMap = baseSignatures[key] else {
-//          continue
-//        }
-//        guard let localeMap = localeSignatures[key] else {
-//          return XCTFail("Key \(key) missing for locale \(locale) in \(catalogName) catalog", file: file, line: line)
-//        }
-//        for path in baseMap.keys.sorted() {
-//          let expected = normalizedPlaceholders(baseMap[path, default: []])
-//          let actual = normalizedPlaceholders(localeMap[path, default: []])
-//          XCTAssertEqual(actual, expected, "Placeholder mismatch for key \(key) at \(path) in locale \(locale) (\(catalogName))", file: file, line: line)
-//        }
-//        for (localePath, localeTokens) in localeMap {
-//          guard baseMap[localePath] == nil else { continue }
-//          guard let fallback = fallbackPath(for: localePath, baseMap: baseMap) else {
-//            XCTFail("Unexpected variation \(localePath) for key \(key) in locale \(locale) (\(catalogName))", file: file, line: line)
-//            continue
-//          }
-//          let expected = normalizedPlaceholders(baseMap[fallback, default: []])
-//          let actual = normalizedPlaceholders(localeTokens)
-//          XCTAssertEqual(actual, expected, "Placeholder mismatch for key \(key) at \(localePath) (fallback \(fallback)) in locale \(locale) (\(catalogName))", file: file, line: line)
-//        }
-//      }
-//    }
-//  }
-//
-//  private func assertPrimaryKeysPresent(context: CatalogContext, keys: [String], catalogName: String, file: StaticString = #filePath, line: UInt = #line) {
-//    for key in keys {
-//      guard let entry = context.catalog.strings[key] else {
-//        XCTFail("Missing primary key \(key) in \(catalogName) catalog", file: file, line: line)
-//        continue
-//      }
-//      for locale in context.locales.sorted() {
-//        guard let localization = entry.localizations[locale], let unit = localization.stringUnit else {
-//          XCTFail("Missing localization for key \(key) in locale \(locale) (\(catalogName))", file: file, line: line)
-//          continue
-//        }
-//        let segments = gatherSegments(from: unit)
-//        XCTAssertFalse(segments.isEmpty, "No content for key \(key) in locale \(locale) (\(catalogName))", file: file, line: line)
-//        for segment in segments {
-//          let trimmed = segment.value.trimmingCharacters(in: .whitespacesAndNewlines)
-//          XCTAssertFalse(trimmed.isEmpty, "Empty translation for key \(key) at \(segment.path) in locale \(locale) (\(catalogName))", file: file, line: line)
-//        }
-//      }
-//    }
-//  }
-//
-//  private func assertLocaleStringValue(context: CatalogContext, locale: String, key: String, expectedValue: String, catalogName: String, file: StaticString = #filePath, line: UInt = #line) {
-//    guard let entry = context.catalog.strings[key] else {
-//      XCTFail("Missing key \(key) in \(catalogName) catalog", file: file, line: line)
-//      return
-//    }
-//    
-//    guard let localization = entry.localizations[locale], let unit = localization.stringUnit else {
-//      XCTFail("Missing \(locale) localization for key \(key) in \(catalogName) catalog", file: file, line: line)
-//      return
-//    }
-//    
-//    // For simple strings (non-pluralized)
-//    if let actualValue = unit.value {
-//      XCTAssertEqual(actualValue, expectedValue, "\(locale) translation mismatch for key \(key) in \(catalogName) catalog. Expected: '\(expectedValue)', Actual: '\(actualValue)'", file: file, line: line)
-//    } else {
-//      XCTFail("Key \(key) has no value in \(locale) localization for \(catalogName) catalog", file: file, line: line)
-//    }
-//  }
-//
-//  // MARK: - Loading
-//
-//  private func loadContext(relativePath: String) throws -> CatalogContext {
-//    let catalog = try loadCatalog(relativePath: relativePath)
-//    let locales = catalog.locales
-//    let baseLocale = catalog.sourceLanguage
-//    var keysByLocale: [String: Set<String>] = [:]
-//    var placeholderSignature: [String: [String: [String: [String]]]] = [:]
-//
-//    for locale in locales {
-//      var localeKeys: Set<String> = []
-//      var localePlaceholders: [String: [String: [String]]] = [:]
-//      for (key, entry) in catalog.strings {
-//        guard let localization = entry.localizations[locale], let unit = localization.stringUnit else {
-//          continue
-//        }
-//        localeKeys.insert(key)
-//        let segments = gatherSegments(from: unit)
-//        var pathMap: [String: [String]] = [:]
-//        for segment in segments {
-//          pathMap[segment.path] = placeholders(in: segment.value)
-//        }
-//        localePlaceholders[key] = pathMap
-//      }
-//      keysByLocale[locale] = localeKeys
-//      placeholderSignature[locale] = localePlaceholders
-//    }
-//
-//    return CatalogContext(catalog: catalog, locales: locales, baseLocale: baseLocale, keysByLocale: keysByLocale, placeholderSignature: placeholderSignature)
-//  }
-//
-//  private func loadCatalog(relativePath: String) throws -> StringCatalog {
-//    let url = repoRootURL.appendingPathComponent(relativePath)
-//    let data = try Data(contentsOf: url)
-//    return try JSONDecoder().decode(StringCatalog.self, from: data)
-//  }
-//
-//  private func loadPrimaryKeys() throws -> PrimaryKeyConfig {
-//    let url = localizationTestsDirectoryURL.appendingPathComponent("PrimaryLocalizationKeys.json")
-//    let data = try Data(contentsOf: url)
-//    return try JSONDecoder().decode(PrimaryKeyConfig.self, from: data)
-//  }
-//
-//  // MARK: - Regression Tests
-//  
-//  /// Helper method to access the app bundle for localization testing.
-//  /// This ensures tests use the actual app's Localizable.xcstrings instead of 
-//  /// the test bundle, preventing false positives where localization keys are 
-//  /// returned instead of translated strings.
-//  private func appBundle() -> Bundle {
-//    Bundle(for: ChatViewModel.self)
-//  }
-//
-//  /// Tests to prevent regression of the pluralization format string issue
-//  /// These tests ensure that String(localized:) properly handles
-//  /// pluralized format strings with %#@variable@ syntax
-//  func testPluralizedFormatStringsDoNotCrash() {
-//    // These are the exact calls that were causing runtime errors
-//    
-//    // Test 1: content.accessibility.people_count with Int argument
-//    XCTAssertNoThrow({
-//      let result = String(
-//        localized: "content.accessibility.people_count",
-//        bundle: appBundle(),
-//        comment: "Accessibility label announcing number of people in header"
-//      )
-//      XCTAssertFalse(result.isEmpty, "Should return formatted string")
-//      // Verify we're getting actual localized content, not just the key
-//      XCTAssertNotEqual(result, "content.accessibility.people_count", "Should return localized string, not key")
-//    }(), "People count localization should not throw")
-//    
-//    // Test 2: location_notes.header with String and Int arguments  
-//    XCTAssertNoThrow({
-//      let result = String(
-//        localized: "location_notes.header",
-//        bundle: appBundle(),
-//        comment: "Header displaying the geohash and localized note count"
-//      )
-//      XCTAssertFalse(result.isEmpty, "Should return formatted string")
-//      // Verify we're getting actual localized content, not just the key
-//      XCTAssertNotEqual(result, "location_notes.header", "Should return localized string, not key")
-//    }(), "Location notes header localization should not throw")
-//  }
-//
-//  func testFormatStringArgumentMatching() {
-//    // Verify that the format strings properly handle their expected arguments
-//    
-//    // People count expects: %#@people@ format with Int
-//    let peopleResult = String(
-//      localized: "content.accessibility.people_count",
-//      bundle: appBundle(),
-//      comment: "Test"
-//    )
-//    
-//    // Should not show format specifiers in the base string
-//    XCTAssertFalse(peopleResult.isEmpty, "Should return non-empty string")
-//    
-//    // Location notes expects: #%@ • %#@note_count@ format with String, Int
-//    let notesResult = String(
-//      localized: "location_notes.header",
-//      bundle: appBundle(),
-//      comment: "Test"
-//    )
-//    
-//    XCTAssertFalse(notesResult.isEmpty, "Should return non-empty string")
-//  }
-//
-//  func testPluralizedStringsWithArguments() {
-//    // Test the pluralized strings with actual format arguments
-//    
-//    // Test people count with different values
-//    let testCases = [0, 1, 2, 5]
-//    
-//    for count in testCases {
-//      let result = String(
-//        format: String(localized: "content.accessibility.people_count", bundle: appBundle(), comment: "Test"),
-//        locale: .current,
-//        count
-//      )
-//      
-//      // Just verify it doesn't crash and returns a reasonable string
-//      XCTAssertFalse(result.isEmpty, 
-//        "People count should return non-empty string for count \(count)")
-//      XCTAssertTrue(result.contains("\(count)"), 
-//        "Result should contain the count number for count \(count)")
-//    }
-//  }
-//
-//  func testLocationNotesHeaderWithArguments() {
-//    let geohash = "abc123"
-//    let testCases = [0, 1, 2, 10]
-//    
-//    for count in testCases {
-//      let result = String(
-//        format: String(localized: "location_notes.header", bundle: appBundle(), comment: "Test"),
-//        locale: .current,
-//        geohash, count
-//      )
-//      
-//      // Verify basic structure is maintained
-//      XCTAssertTrue(result.contains(geohash), 
-//        "Result should contain geohash for count \(count)")
-//      XCTAssertTrue(result.contains("\(count)"), 
-//        "Result should contain count for count \(count)")
-//    }
-//  }
-//
-//  func testLocationChannelsRowTitleWithArguments() {
-//    let label = "test-channel"
-//    let testCases = [0, 1, 2, 5]
-//    
-//    for count in testCases {
-//      let result = String(
-//        format: String(localized: "location_channels.row_title", bundle: appBundle(), comment: "Test"),
-//        locale: .current,
-//        label, count
-//      )
-//      
-//      // Verify basic structure is maintained
-//      XCTAssertTrue(result.contains(label), 
-//        "Result should contain label for count \(count)")
-//      XCTAssertTrue(result.contains("\(count)"), 
-//        "Result should contain count for count \(count)")
-//    }
-//  }
-//
-//  func testNoArgumentsLocalization() {
-//    // Test that strings without arguments still work
-//    let result = String(
-//      localized: "common.ok",
-//      bundle: appBundle(),
-//      comment: "OK button text"
-//    )
-//    
-//    XCTAssertFalse(result.isEmpty, "Simple localization should work")
-//  }
-//
-//  func testLocalizationEdgeCases() {
-//    // Test edge cases that might cause issues
-//    
-//    // Large numbers
-//    let largeNumberResult = String(
-//      format: String(localized: "content.accessibility.people_count", bundle: appBundle(), comment: "Test"),
-//      locale: .current,
-//      1000000
-//    )
-//    XCTAssertTrue(largeNumberResult.contains("1000000"), "Should handle large numbers")
-//    
-//    // Zero
-//    let zeroResult = String(
-//      format: String(localized: "content.accessibility.people_count", bundle: appBundle(), comment: "Test"),
-//      locale: .current,
-//      0
-//    )
-//    XCTAssertTrue(zeroResult.contains("0"), "Should handle zero")
-//    
-//    // Empty geohash (edge case)
-//    let emptyGeohashResult = String(
-//      format: String(localized: "location_notes.header", bundle: appBundle(), comment: "Test"),
-//      locale: .current,
-//      "", 1
-//    )
-//    XCTAssertFalse(emptyGeohashResult.isEmpty, "Should handle empty geohash")
-//  }
-//}
-//
-//// MARK: - Helpers
-//
-//private struct CatalogContext {
-//  let catalog: StringCatalog
-//  let locales: [String]
-//  let baseLocale: String
-//  let keysByLocale: [String: Set<String>]
-//  let placeholderSignature: [String: [String: [String: [String]]]]
-//}
-//
-//private struct StringCatalog: Decodable {
-//  let sourceLanguage: String
-//  let strings: [String: CatalogEntry]
-//
-//  var locales: [String] {
-//    var localeSet: Set<String> = []
-//    for entry in strings.values {
-//      localeSet.formUnion(entry.localizations.keys)
-//    }
-//    return localeSet.sorted()
-//  }
-//}
-//
-//private struct CatalogEntry: Decodable {
-//  let localizations: [String: CatalogLocalization]
-//}
-//
-//private struct CatalogLocalization: Decodable {
-//  let stringUnit: CatalogStringUnit?
-//}
-//
-//private struct CatalogStringUnit: Decodable {
-//  let state: String
-//  let value: String?
-//  let variations: CatalogVariations?
-//  let comment: String?
-//}
-//
-//private struct CatalogVariations: Decodable {
-//  let plural: [String: [String: CatalogVariationValue]]?
-//}
-//
-//private struct CatalogVariationValue: Decodable {
-//  let stringUnit: CatalogStringUnit?
-//}
-//
-//private struct Segment {
-//  let components: [String]
-//  let value: String
-//
-//  var path: String {
-//    components.isEmpty ? "base" : components.joined(separator: ".")
-//  }
-//}
-//
-//private func gatherSegments(from unit: CatalogStringUnit, prefix: [String] = []) -> [Segment] {
-//  var segments: [Segment] = []
-//  if let value = unit.value {
-//    segments.append(Segment(components: prefix, value: value))
-//  } else if prefix.isEmpty {
-//    segments.append(Segment(components: [], value: ""))
-//  }
-//  if let plural = unit.variations?.plural {
-//    for (variable, categories) in plural.sorted(by: { $0.key < $1.key }) {
-//      for (category, variation) in categories.sorted(by: { $0.key < $1.key }) {
-//        if let nested = variation.stringUnit {
-//          var nextPrefix = prefix
-//          nextPrefix.append("plural")
-//          nextPrefix.append(variable)
-//          nextPrefix.append(category)
-//          segments.append(contentsOf: gatherSegments(from: nested, prefix: nextPrefix))
-//        }
-//      }
-//    }
-//  }
-//  return segments
-//}
-//
-//private func normalizedPlaceholders(_ tokens: [String]) -> [String] {
-//  tokens.sorted()
-//}
-//
-//private func fallbackPath(for localePath: String, baseMap: [String: [String]]) -> String? {
-//  let parts = localePath.split(separator: ".")
-//  guard parts.count == 3, parts.first == "plural" else {
-//    return nil
-//  }
-//  let variable = parts[1]
-//  let otherKey = "plural.\(variable).other"
-//  if baseMap[otherKey] != nil {
-//    return otherKey
-//  }
-//  let oneKey = "plural.\(variable).one"
-//  if baseMap[oneKey] != nil {
-//    return oneKey
-//  }
-//  return nil
-//}
-//
-//private let placeholderRegex: NSRegularExpression = {
-//  let pattern = "%(?:\\d+\\$)?#@[A-Za-z0-9_]+@|%(?:\\d+\\$)?[#0\\- +'\"]*(?:\\d+|\\*)?(?:\\.\\d+)?(?:hh|h|ll|l|z|t|L)?[a-zA-Z@]"
-//  return try! NSRegularExpression(pattern: pattern, options: [])
-//}()
-//
-//private func placeholders(in string: String) -> [String] {
-//  let range = NSRange(location: 0, length: (string as NSString).length)
-//  let matches = placeholderRegex.matches(in: string, options: [], range: range)
-//  var tokens: [String] = []
-//  for match in matches {
-//    if let range = Range(match.range, in: string) {
-//      let token = String(string[range])
-//      if token == "%%" { continue }
-//      tokens.append(token)
-//    }
-//  }
-//  return tokens
-//}
-//
-//private struct PrimaryKeyConfig: Decodable {
-//  let app: [String]
-//  let shareExtension: [String]
-//  let expectedValues: [String: [String: String]]?
-//  let testLocales: [String]?
-//}

bitchatTests/LocationChannelsTests.swift

@@ -44,4 +44,12 @@ struct LocationChannelsTests {
         let id2 = try idBridge.deriveIdentity(forGeohash: gh)
         #expect(id1.publicKeyHex == id2.publicKeyHex)
     }
+
+    @Test func geohashNeighborsNearPoleSkipOutOfBoundsCells() {
+        let nearPole = Geohash.encode(latitude: 89.9999, longitude: 0.0, precision: 8)
+        let neighbors = Geohash.neighbors(of: nearPole)
+
+        #expect(neighbors.isEmpty == false)
+        #expect(neighbors.count < 8)
+    }
 }

bitchatTests/LocationNotesManagerTests.swift

@@ -4,51 +4,49 @@ import Foundation
 
 @MainActor
 struct LocationNotesManagerTests {
-//    func testSubscribeWithoutRelaysSetsNoRelaysState() {
+    @Test
-//        var subscribeCalled = false
+    func subscribeWithoutRelays_setsNoRelaysState() {
-//        let deps = LocationNotesDependencies(
+        var subscribeCalled = false
-//            relayLookup: { _, _ in [] },
+        let deps = LocationNotesDependencies(
-//            subscribe: { _, _, _, _, _ in
+            relayLookup: { _, _ in [] },
-//                subscribeCalled = true
+            subscribe: { _, _, _, _, _ in
-//            },
+                subscribeCalled = true
-//            unsubscribe: { _ in },
+            },
-//            sendEvent: { _, _ in },
+            unsubscribe: { _ in },
-//            deriveIdentity: { _ in fatalError("should not derive identity") },
+            sendEvent: { _, _ in },
-//            now: { Date() }
+            deriveIdentity: { _ in try NostrIdentity.generate() },
-//        )
+            now: { Date() }
-//
+        )
-//        let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
-//
-//        XCTAssertFalse(subscribeCalled)
-//        XCTAssertEqual(manager.state, .noRelays)
-//        XCTAssertTrue(manager.initialLoadComplete)
-//        XCTAssertEqual(manager.errorMessage, String(localized: "location_notes.error.no_relays"))
-//        // Make sure we're getting an actual translated value and not the localization key
-//        XCTAssertNotEqual(manager.errorMessage, "location_notes.error.no_relays")
-//    }
-//
-//    func testSendWhenNoRelaysSurfacesError() {
-//        var sendCalled = false
-//        let deps = LocationNotesDependencies(
-//            relayLookup: { _, _ in [] },
-//            subscribe: { _, _, _, _, _ in },
-//            unsubscribe: { _ in },
-//            sendEvent: { _, _ in sendCalled = true },
-//            deriveIdentity: { _ in throw TestError.shouldNotDerive },
-//            now: { Date() }
-//        )
-//
-//        let manager = LocationNotesManager(geohash: "zzzzzzzz", dependencies: deps)
-//        manager.send(content: "hello", nickname: "tester")
-//
-//        XCTAssertFalse(sendCalled)
-//        XCTAssertEqual(manager.state, .noRelays)
-//        XCTAssertEqual(manager.errorMessage, String(localized: "location_notes.error.no_relays"))
-//        // Make sure we're getting an actual translated value and not the localization key
-//        XCTAssertNotEqual(manager.errorMessage, "location_notes.error.no_relays")
-//    }
 
-    @Test func subscribeUsesGeoRelaysAndAppendsNotes() {
+        let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
+
+        #expect(subscribeCalled == false)
+        #expect(manager.state == .noRelays)
+        #expect(manager.initialLoadComplete)
+        #expect(manager.errorMessage == String(localized: "location_notes.error.no_relays"))
+    }
+
+    @Test
+    func sendWithoutRelays_surfacesNoRelaysError() {
+        var sendCalled = false
+        let deps = LocationNotesDependencies(
+            relayLookup: { _, _ in [] },
+            subscribe: { _, _, _, _, _ in },
+            unsubscribe: { _ in },
+            sendEvent: { _, _ in sendCalled = true },
+            deriveIdentity: { _ in throw TestError.shouldNotDerive },
+            now: { Date() }
+        )
+
+        let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
+        manager.send(content: "hello", nickname: "tester")
+
+        #expect(sendCalled == false)
+        #expect(manager.state == .noRelays)
+        #expect(manager.errorMessage == String(localized: "location_notes.error.no_relays"))
+    }
+
+    @Test func subscribeUsesGeoRelaysAndAppendsNotes() throws {
         var relaysCaptured: [String] = []
         var storedHandler: ((NostrEvent) -> Void)?
         var storedEOSE: (() -> Void)?
@@ -71,15 +69,16 @@ struct LocationNotesManagerTests {
         #expect(relaysCaptured == ["wss://relay.one"])
         #expect(manager.state == .loading)
 
-        var event = NostrEvent(
+        let identity = try NostrIdentity.generate()
-            pubkey: "pub",
+        let event = NostrEvent(
+            pubkey: identity.publicKeyHex,
             createdAt: Date(),
             kind: .textNote,
             tags: [["g", "u4pruydq"]],
             content: "hi"
         )
-        event.id = "event1"
+        let signed = try event.sign(with: identity.schnorrSigningKey())
-        storedHandler?(event)
+        storedHandler?(signed)
         storedEOSE?()
 
         #expect(manager.state == .ready)
@@ -87,6 +86,100 @@ struct LocationNotesManagerTests {
         #expect(manager.notes.first?.content == "hi")
     }
 
+    @Test
+    func setGeohash_invalidValueIsIgnored() {
+        var subscribeCount = 0
+        let deps = LocationNotesDependencies(
+            relayLookup: { _, _ in ["wss://relay.one"] },
+            subscribe: { _, _, _, _, _ in
+                subscribeCount += 1
+            },
+            unsubscribe: { _ in },
+            sendEvent: { _, _ in },
+            deriveIdentity: { _ in try NostrIdentity.generate() },
+            now: { Date() }
+        )
+
+        let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
+        manager.setGeohash("not-valid")
+
+        #expect(manager.geohash == "u4pruydq")
+        #expect(subscribeCount == 1)
+    }
+
+    @Test
+    func refreshAndCancel_manageSubscriptions() {
+        var subscribeIDs: [String] = []
+        var unsubscribedIDs: [String] = []
+        let deps = LocationNotesDependencies(
+            relayLookup: { _, _ in ["wss://relay.one"] },
+            subscribe: { _, id, _, _, _ in
+                subscribeIDs.append(id)
+            },
+            unsubscribe: { id in
+                unsubscribedIDs.append(id)
+            },
+            sendEvent: { _, _ in },
+            deriveIdentity: { _ in try NostrIdentity.generate() },
+            now: { Date() }
+        )
+
+        let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
+        manager.refresh()
+        manager.cancel()
+
+        #expect(subscribeIDs.count == 2)
+        #expect(unsubscribedIDs.count == 2)
+        #expect(manager.state == .idle)
+        #expect(manager.errorMessage == nil)
+    }
+
+    @Test
+    func send_successCreatesLocalEchoAndClearsError() throws {
+        var sentEvents: [NostrEvent] = []
+        let identity = try NostrIdentity.generate()
+        let deps = LocationNotesDependencies(
+            relayLookup: { _, _ in ["wss://relay.one"] },
+            subscribe: { _, _, _, _, _ in },
+            unsubscribe: { _ in },
+            sendEvent: { event, _ in
+                sentEvents.append(event)
+            },
+            deriveIdentity: { _ in identity },
+            now: { Date(timeIntervalSince1970: 123_456) }
+        )
+
+        let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
+        manager.send(content: "  hello note  ", nickname: "Builder")
+
+        #expect(sentEvents.count == 1)
+        #expect(manager.state == .ready)
+        #expect(manager.errorMessage == nil)
+        #expect(manager.notes.first?.content == "hello note")
+        #expect(manager.notes.first?.displayName.hasPrefix("Builder#") == true)
+    }
+
+    @Test
+    func send_failureFormatsErrorMessageAndClearErrorRemovesIt() {
+        let deps = LocationNotesDependencies(
+            relayLookup: { _, _ in ["wss://relay.one"] },
+            subscribe: { _, _, _, _, _ in },
+            unsubscribe: { _ in },
+            sendEvent: { _, _ in },
+            deriveIdentity: { _ in throw TestError.shouldNotDerive },
+            now: { Date() }
+        )
+
+        let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
+        manager.send(content: "hello", nickname: "Builder")
+
+        #expect(manager.errorMessage?.isEmpty == false)
+
+        manager.clearError()
+
+        #expect(manager.errorMessage == nil)
+    }
+
     private enum TestError: Error {
         case shouldNotDerive
     }

bitchatTests/MessageFormattingEngineTests.swift

@@ -12,6 +12,108 @@ import SwiftUI
 @testable import bitchat
 
 struct MessageFormattingEngineTests {
+    // MARK: - Formatting Behavior Tests
+
+    @MainActor
+    @Test func formatMessage_regularMessageFormatsHeaderContentAndTimestamp() {
+        let senderPeerID = PeerID(str: "abcdef1234567890")
+        let context = MockMessageFormattingContext(
+            nickname: "carol",
+            peerURLs: [senderPeerID: URL(string: "https://example.com/peers/alice")!]
+        )
+        let message = BitchatMessage(
+            id: "message-1",
+            sender: "alice#a1b2",
+            content: "hello #mesh https://example.com",
+            timestamp: Date(timeIntervalSince1970: 1_700_000_000),
+            isRelay: false,
+            senderPeerID: senderPeerID
+        )
+
+        let formatted = MessageFormattingEngine.formatMessage(message, context: context, colorScheme: .light)
+
+        #expect(String(formatted.characters) == "<@alice#a1b2> hello #mesh https://example.com [\(message.formattedTimestamp)]")
+        #expect(message.getCachedFormattedText(isDark: false, isSelf: false) != nil)
+    }
+
+    @MainActor
+    @Test func formatMessage_systemMessageUsesSystemLayout() {
+        let context = MockMessageFormattingContext(nickname: "carol")
+        let message = BitchatMessage(
+            id: "system-1",
+            sender: "system",
+            content: "connected",
+            timestamp: Date(timeIntervalSince1970: 1_700_000_123),
+            isRelay: false
+        )
+
+        let formatted = MessageFormattingEngine.formatMessage(message, context: context, colorScheme: .dark)
+
+        #expect(String(formatted.characters) == "* connected * [\(message.formattedTimestamp)]")
+        #expect(message.getCachedFormattedText(isDark: true, isSelf: false) != nil)
+    }
+
+    @MainActor
+    @Test func formatMessage_longSelfMessageFallsBackToPlainContentPath() {
+        let context = MockMessageFormattingContext(
+            nickname: "me",
+            selfMessageIDs: ["self-1"]
+        )
+        let longContent = String(repeating: "a", count: 4_500)
+        let message = BitchatMessage(
+            id: "self-1",
+            sender: "me#cafe",
+            content: longContent,
+            timestamp: Date(timeIntervalSince1970: 1_700_000_456),
+            isRelay: false
+        )
+
+        let formatted = MessageFormattingEngine.formatMessage(message, context: context, colorScheme: .light)
+
+        #expect(String(formatted.characters) == "<@me#cafe> \(longContent) [\(message.formattedTimestamp)]")
+        #expect(message.getCachedFormattedText(isDark: false, isSelf: true) != nil)
+    }
+
+    @MainActor
+    @Test func formatMessage_mentionsAreRenderedThroughMentionFormatter() {
+        let context = MockMessageFormattingContext(nickname: "carol")
+        let message = BitchatMessage(
+            id: "message-mention",
+            sender: "alice",
+            content: "hi @bob#a1b2",
+            timestamp: Date(timeIntervalSince1970: 1_700_000_789),
+            isRelay: false
+        )
+
+        let formatted = MessageFormattingEngine.formatMessage(message, context: context, colorScheme: .light)
+
+        #expect(String(formatted.characters) == "<@alice> hi bob#a1b2 [\(message.formattedTimestamp)]")
+    }
+
+    @MainActor
+    @Test func formatHeader_formatsNormalAndSystemSenders() {
+        let context = MockMessageFormattingContext(nickname: "carol")
+        let normalMessage = BitchatMessage(
+            id: "header-1",
+            sender: "alice#a1b2",
+            content: "hello",
+            timestamp: Date(timeIntervalSince1970: 1_700_001_000),
+            isRelay: false
+        )
+        let systemMessage = BitchatMessage(
+            id: "header-2",
+            sender: "system",
+            content: "notice",
+            timestamp: Date(timeIntervalSince1970: 1_700_001_111),
+            isRelay: false
+        )
+
+        let normalHeader = MessageFormattingEngine.formatHeader(normalMessage, context: context, colorScheme: .light)
+        let systemHeader = MessageFormattingEngine.formatHeader(systemMessage, context: context, colorScheme: .dark)
+
+        #expect(String(normalHeader.characters) == "<@alice#a1b2> ")
+        #expect(String(systemHeader.characters) == "system")
+    }
 
     // MARK: - Mention Extraction Tests
 
@@ -221,3 +323,32 @@ struct MessageFormattingEngineTests {
         #expect(content.hasVeryLongToken(threshold: 50))
     }
 }
+
+@MainActor
+private final class MockMessageFormattingContext: MessageFormattingContext {
+    let nickname: String
+    private let selfMessageIDs: Set<String>
+    private let peerURLs: [PeerID: URL]
+
+    init(
+        nickname: String,
+        selfMessageIDs: Set<String> = [],
+        peerURLs: [PeerID: URL] = [:]
+    ) {
+        self.nickname = nickname
+        self.selfMessageIDs = selfMessageIDs
+        self.peerURLs = peerURLs
+    }
+
+    func isSelfMessage(_ message: BitchatMessage) -> Bool {
+        selfMessageIDs.contains(message.id)
+    }
+
+    func senderColor(for message: BitchatMessage, isDark: Bool) -> Color {
+        .red
+    }
+
+    func peerURL(for peerID: PeerID) -> URL? {
+        peerURLs[peerID]
+    }
+}

bitchatTests/Mocks/MockBLEService.swift

@@ -108,6 +108,11 @@ final class MockBLEService: NSObject {
     func getPeers() -> [PeerID: String] {
         return getPeerNicknames()
     }
+
+    /// Keep local echo synchronous so Swift Testing confirmations observe it deterministically.
+    private func deliverLocalEcho(_ message: BitchatMessage) {
+        delegate?.didReceiveMessage(message)
+    }
     
     func sendMessage(_ content: String, mentions: [String] = [], to recipientID: String? = nil, messageID: String? = nil, timestamp: Date? = nil) {
         let message = BitchatMessage(
@@ -137,10 +142,7 @@ final class MockBLEService: NSObject {
             sentMessages.append((message, packet))
             sentPackets.append(packet)
             
-            // Simulate local echo
+            deliverLocalEcho(message)
-            DispatchQueue.main.async { [weak self] in
-                self?.delegate?.didReceiveMessage(message)
-            }
             
             // Surface raw packet to tests that intercept/relay/encrypt
             packetDeliveryHandler?(packet)
@@ -190,10 +192,7 @@ final class MockBLEService: NSObject {
             sentMessages.append((message, packet))
             sentPackets.append(packet)
             
-            // Simulate local echo
+            deliverLocalEcho(message)
-            DispatchQueue.main.async { [weak self] in
-                self?.delegate?.didReceiveMessage(message)
-            }
             
             // Surface raw packet to tests that intercept/relay/encrypt
             packetDeliveryHandler?(packet)

bitchatTests/Mocks/MockIdentityManager.swift

@@ -13,6 +13,7 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
     private let keychain: KeychainManagerProtocol
     private var blockedFingerprints: Set<String> = []
     private var blockedNostrPubkeys: Set<String> = []
+    private var socialIdentities: [String: SocialIdentity] = [:]
     
     init(_ keychain: KeychainManagerProtocol) {
         self.keychain = keychain
@@ -25,7 +26,7 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
     func forceSave() {}
     
     func getSocialIdentity(for fingerprint: String) -> SocialIdentity? {
-        nil
+        socialIdentities[fingerprint]
     }
     
     func upsertCryptographicIdentity(fingerprint: String, noisePublicKey: Data, signingPublicKey: Data?, claimedNickname: String?) {}
@@ -34,7 +35,14 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
         []
     }
     
-    func updateSocialIdentity(_ identity: SocialIdentity) {}
+    func updateSocialIdentity(_ identity: SocialIdentity) {
+        socialIdentities[identity.fingerprint] = identity
+        if identity.isBlocked {
+            blockedFingerprints.insert(identity.fingerprint)
+        } else {
+            blockedFingerprints.remove(identity.fingerprint)
+        }
+    }
     
     func getFavorites() -> Set<String> {
         Set()
@@ -47,10 +55,25 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
     }
     
     func isBlocked(fingerprint: String) -> Bool {
-        blockedFingerprints.contains(fingerprint)
+        blockedFingerprints.contains(fingerprint) || socialIdentities[fingerprint]?.isBlocked == true
     }
     
     func setBlocked(_ fingerprint: String, isBlocked: Bool) {
+        if var identity = socialIdentities[fingerprint] {
+            identity.isBlocked = isBlocked
+            socialIdentities[fingerprint] = identity
+        } else {
+            let identity = SocialIdentity(
+                fingerprint: fingerprint,
+                localPetname: nil,
+                claimedNickname: "",
+                trustLevel: .unknown,
+                isFavorite: false,
+                isBlocked: isBlocked,
+                notes: nil
+            )
+            socialIdentities[fingerprint] = identity
+        }
         if isBlocked {
             blockedFingerprints.insert(fingerprint)
         } else {

bitchatTests/Mocks/MockKeychain.swift

@@ -13,6 +13,10 @@ final class MockKeychain: KeychainManagerProtocol {
     private var storage: [String: Data] = [:]
     private var serviceStorage: [String: [String: Data]] = [:]
 
+    // BCH-01-009: Configurable error simulation for testing
+    var simulatedReadError: KeychainReadResult?
+    var simulatedSaveError: KeychainSaveResult?
+
     func saveIdentityKey(_ keyData: Data, forKey key: String) -> Bool {
         storage[key] = keyData
         return true
@@ -45,6 +49,25 @@ final class MockKeychain: KeychainManagerProtocol {
         storage["identity_noiseStaticKey"] != nil
     }
 
+    // BCH-01-009: New methods with proper error classification
+    func getIdentityKeyWithResult(forKey key: String) -> KeychainReadResult {
+        if let simulated = simulatedReadError {
+            return simulated
+        }
+        if let data = storage[key] {
+            return .success(data)
+        }
+        return .itemNotFound
+    }
+
+    func saveIdentityKeyWithResult(_ keyData: Data, forKey key: String) -> KeychainSaveResult {
+        if let simulated = simulatedSaveError {
+            return simulated
+        }
+        storage[key] = keyData
+        return .success
+    }
+
     // MARK: - Generic Data Storage (consolidated from KeychainHelper)
 
     func save(key: String, data: Data, service: String, accessible: CFString?) {
@@ -76,6 +99,10 @@ final class TrackingMockKeychain: KeychainManagerProtocol {
     private var _secureClearDataCallCount = 0
     private var _secureClearStringCallCount = 0
 
+    // BCH-01-009: Configurable error simulation for testing
+    var simulatedReadError: KeychainReadResult?
+    var simulatedSaveError: KeychainSaveResult?
+
     var secureClearDataCallCount: Int {
         lock.lock()
         defer { lock.unlock() }
@@ -137,6 +164,25 @@ final class TrackingMockKeychain: KeychainManagerProtocol {
         storage["identity_noiseStaticKey"] != nil
     }
 
+    // BCH-01-009: New methods with proper error classification
+    func getIdentityKeyWithResult(forKey key: String) -> KeychainReadResult {
+        if let simulated = simulatedReadError {
+            return simulated
+        }
+        if let data = storage[key] {
+            return .success(data)
+        }
+        return .itemNotFound
+    }
+
+    func saveIdentityKeyWithResult(_ keyData: Data, forKey key: String) -> KeychainSaveResult {
+        if let simulated = simulatedSaveError {
+            return simulated
+        }
+        storage[key] = keyData
+        return .success
+    }
+
     func save(key: String, data: Data, service: String, accessible: CFString?) {
         if serviceStorage[service] == nil {
             serviceStorage[service] = [:]

bitchatTests/Mocks/MockTransport.swift

@@ -35,6 +35,9 @@ final class MockTransport: Transport {
     private(set) var sentReadReceipts: [(receipt: ReadReceipt, peerID: PeerID)] = []
     private(set) var sentDeliveryAcks: [(messageID: String, peerID: PeerID)] = []
     private(set) var sentFavoriteNotifications: [(peerID: PeerID, isFavorite: Bool)] = []
+    private(set) var sentBroadcastFiles: [(packet: BitchatFilePacket, transferID: String)] = []
+    private(set) var sentPrivateFiles: [(packet: BitchatFilePacket, peerID: PeerID, transferID: String)] = []
+    private(set) var cancelledTransfers: [String] = []
     private(set) var sentVerifyChallenges: [(peerID: PeerID, noiseKeyHex: String, nonceA: Data)] = []
     private(set) var sentVerifyResponses: [(peerID: PeerID, noiseKeyHex: String, nonceA: Data)] = []
     private(set) var startServicesCallCount = 0
@@ -139,15 +142,15 @@ final class MockTransport: Transport {
     }
 
     func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String) {
-        // Not tracked for current tests
+        sentBroadcastFiles.append((packet, transferId))
     }
 
     func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {
-        // Not tracked for current tests
+        sentPrivateFiles.append((packet, peerID, transferId))
     }
 
     func cancelTransfer(_ transferId: String) {
-        // Not tracked for current tests
+        cancelledTransfers.append(transferId)
     }
 
     func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {
@@ -167,6 +170,9 @@ final class MockTransport: Transport {
         sentReadReceipts.removeAll()
         sentDeliveryAcks.removeAll()
         sentFavoriteNotifications.removeAll()
+        sentBroadcastFiles.removeAll()
+        sentPrivateFiles.removeAll()
+        cancelledTransfers.removeAll()
         sentVerifyChallenges.removeAll()
         sentVerifyResponses.removeAll()
         startServicesCallCount = 0
@@ -184,6 +190,7 @@ final class MockTransport: Transport {
         }
         delegate?.didConnectToPeer(peerID)
         delegate?.didUpdatePeerList(Array(connectedPeers))
+        publishPeerSnapshots()
     }
 
     /// Simulates a peer disconnecting
@@ -192,6 +199,7 @@ final class MockTransport: Transport {
         peerNicknames.removeValue(forKey: peerID)
         delegate?.didDisconnectFromPeer(peerID)
         delegate?.didUpdatePeerList(Array(connectedPeers))
+        publishPeerSnapshots()
     }
 
     /// Simulates receiving a message
@@ -224,5 +232,22 @@ final class MockTransport: Transport {
     /// Updates the peer snapshot publisher
     func updatePeerSnapshots(_ snapshots: [TransportPeerSnapshot]) {
         peerSnapshotSubject.send(snapshots)
+        Task { @MainActor [weak self] in
+            self?.peerEventsDelegate?.didUpdatePeerSnapshots(snapshots)
+        }
+    }
+
+    private func publishPeerSnapshots() {
+        let now = Date()
+        let snapshots = connectedPeers.map { peerID in
+            TransportPeerSnapshot(
+                peerID: peerID,
+                nickname: peerNicknames[peerID] ?? "",
+                isConnected: true,
+                noisePublicKey: Data(hexString: peerID.bare),
+                lastSeen: now
+            )
+        }
+        updatePeerSnapshots(snapshots)
     }
 }

bitchatTests/Noise/NoiseCoverageTests.swift

@@ -0,0 +1,867 @@
+import CryptoKit
+import Foundation
+import Testing
+
+@testable import bitchat
+
+@Suite("Noise Coverage Tests")
+struct NoiseCoverageTests {
+    private let keychain = MockKeychain()
+    private let aliceStaticKey = Curve25519.KeyAgreement.PrivateKey()
+    private let bobStaticKey = Curve25519.KeyAgreement.PrivateKey()
+    private let charlieStaticKey = Curve25519.KeyAgreement.PrivateKey()
+
+    private let alicePeerID = PeerID(str: "0011223344556677")
+    private let bobPeerID = PeerID(str: "8899aabbccddeeff")
+    private let charliePeerID = PeerID(str: "fedcba9876543210")
+
+    @Test("Protocol metadata and handshake patterns expose expected values")
+    func protocolMetadataAndHandshakePatterns() {
+        let ikName = NoiseProtocolName(pattern: NoisePattern.IK.patternName)
+        #expect(ikName.pattern == "IK")
+        #expect(ikName.dh == "25519")
+        #expect(ikName.cipher == "ChaChaPoly")
+        #expect(ikName.hash == "SHA256")
+        #expect(ikName.fullName == "Noise_IK_25519_ChaChaPoly_SHA256")
+
+        #expect(NoisePattern.XX.patternName == "XX")
+        #expect(NoisePattern.IK.patternName == "IK")
+        #expect(NoisePattern.NK.patternName == "NK")
+
+        let ikPatterns = NoisePattern.IK.messagePatterns
+        #expect(ikPatterns.count == 2)
+        #expect(ikPatterns[0] == [.e, .es, .s, .ss])
+        #expect(ikPatterns[1] == [.e, .ee, .se])
+
+        let nkPatterns = NoisePattern.NK.messagePatterns
+        #expect(nkPatterns.count == 2)
+        #expect(nkPatterns[0] == [.e, .es])
+        #expect(nkPatterns[1] == [.e, .ee])
+    }
+
+    @Test("Symmetric state supports long protocol names and mixKeyAndHash")
+    func symmetricStateLongNameAndMixKeyAndHash() {
+        let longName = String(repeating: "NoiseProtocol_", count: 3)
+        let symmetricState = NoiseSymmetricState(protocolName: longName)
+        let initialHash = symmetricState.getHandshakeHash()
+
+        #expect(initialHash.count == 32)
+        #expect(!symmetricState.hasCipherKey())
+
+        symmetricState.mixKeyAndHash(Data("input-key-material".utf8))
+
+        #expect(symmetricState.hasCipherKey())
+        #expect(symmetricState.getHandshakeHash() != initialHash)
+    }
+
+    @Test("Cipher state rejects duplicate and stale extracted nonces")
+    func cipherStateRejectsDuplicateAndStaleNonces() throws {
+        let key = SymmetricKey(size: .bits256)
+        let receiver = NoiseCipherState(key: key, useExtractedNonce: true)
+        let initialPayload = try makeExtractedNoncePayload(
+            key: key,
+            nonce: 0,
+            plaintext: Data("nonce-0".utf8)
+        )
+
+        let initialPlaintext = try receiver.decrypt(ciphertext: initialPayload)
+        #expect(initialPlaintext == Data("nonce-0".utf8))
+
+        #expect(throws: (any Error).self) {
+            try receiver.decrypt(ciphertext: initialPayload)
+        }
+
+        for nonce in 1...1024 {
+            let payload = try makeExtractedNoncePayload(
+                key: key,
+                nonce: UInt64(nonce),
+                plaintext: Data("nonce-\(nonce)".utf8)
+            )
+            let plaintext = try receiver.decrypt(ciphertext: payload)
+            #expect(plaintext == Data("nonce-\(nonce)".utf8))
+        }
+
+        #expect(throws: (any Error).self) {
+            try receiver.decrypt(ciphertext: initialPayload)
+        }
+    }
+
+    @Test("Cipher state handles large nonce jumps and associated-data mismatches")
+    func cipherStateHandlesLargeJumpsAndAADMismatch() throws {
+        let key = SymmetricKey(size: .bits256)
+        let extractedReceiver = NoiseCipherState(key: key, useExtractedNonce: true)
+
+        let jumped = try makeExtractedNoncePayload(
+            key: key,
+            nonce: 1500,
+            plaintext: Data("future".utf8)
+        )
+        let slightlyOlder = try makeExtractedNoncePayload(
+            key: key,
+            nonce: 1499,
+            plaintext: Data("older".utf8)
+        )
+        let tooOld = try makeExtractedNoncePayload(
+            key: key,
+            nonce: 100,
+            plaintext: Data("ancient".utf8)
+        )
+
+        #expect(try extractedReceiver.decrypt(ciphertext: jumped) == Data("future".utf8))
+        #expect(try extractedReceiver.decrypt(ciphertext: slightlyOlder) == Data("older".utf8))
+        #expect(throws: (any Error).self) {
+            try extractedReceiver.decrypt(ciphertext: tooOld)
+        }
+
+        let sender = NoiseCipherState(key: key)
+        let receiver = NoiseCipherState(key: key)
+        let plaintext = Data("associated-data".utf8)
+        let aad = Data("good-aad".utf8)
+        let ciphertext = try sender.encrypt(plaintext: plaintext, associatedData: aad)
+
+        #expect(throws: (any Error).self) {
+            try receiver.decrypt(ciphertext: ciphertext, associatedData: Data("bad-aad".utf8))
+        }
+        #expect(try receiver.decrypt(ciphertext: ciphertext, associatedData: aad) == plaintext)
+        #expect(throws: (any Error).self) {
+            try receiver.decrypt(ciphertext: Data(repeating: 0xAA, count: 15))
+        }
+    }
+
+    @Test("Cipher state covers nonce guard rails and extracted payload bounds")
+    func cipherStateCoversNonceGuardRailsAndExtractedPayloadBounds() throws {
+        let uninitializedCipher = NoiseCipherState()
+        #expect(throws: NoiseError.uninitializedCipher) {
+            try uninitializedCipher.encrypt(plaintext: Data("missing-key".utf8))
+        }
+        #expect(throws: NoiseError.uninitializedCipher) {
+            try uninitializedCipher.decrypt(ciphertext: Data(repeating: 0x00, count: 16))
+        }
+        #expect(try uninitializedCipher.extractNonceFromCiphertextPayloadForTesting(Data([0x00, 0x01, 0x02])) == nil)
+
+        let key = SymmetricKey(size: .bits256)
+
+        let highNonceCipher = NoiseCipherState(key: key)
+        highNonceCipher.setNonceForTesting(1_000_000_001)
+        #expect(throws: Never.self) {
+            _ = try highNonceCipher.encrypt(plaintext: Data("high-nonce".utf8))
+        }
+
+        let exhaustedCipher = NoiseCipherState(key: key)
+        exhaustedCipher.setNonceForTesting(UInt64(UInt32.max))
+        #expect(throws: NoiseError.nonceExceeded) {
+            try exhaustedCipher.encrypt(plaintext: Data("nonce-limit".utf8))
+        }
+    }
+
+    @Test("Handshake validation rejects malformed keys and messages")
+    func handshakeValidationRejectsMalformedInputs() throws {
+        let responder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        #expect(throws: (any Error).self) {
+            try responder.readMessage(Data(repeating: 0x00, count: 31))
+        }
+
+        let invalidKeys = [
+            Data(),
+            Data(repeating: 0x00, count: 32),
+            Data([0x01] + Array(repeating: 0x00, count: 31)),
+            Data(repeating: 0xFF, count: 32),
+        ]
+
+        for invalidKey in invalidKeys {
+            #expect(throws: (any Error).self) {
+                _ = try NoiseHandshakeState.validatePublicKey(invalidKey)
+            }
+        }
+
+        let valid = aliceStaticKey.publicKey.rawRepresentation
+        let roundTripped = try NoiseHandshakeState.validatePublicKey(valid)
+        #expect(roundTripped.rawRepresentation == valid)
+
+        let initiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey
+        )
+        let responderForTamper = NoiseHandshakeState(
+            role: .responder,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        let message1 = try initiator.writeMessage()
+        _ = try responderForTamper.readMessage(message1)
+        var message2 = try responderForTamper.writeMessage()
+        message2[40] ^= 0x01
+
+        #expect(throws: (any Error).self) {
+            try initiator.readMessage(message2)
+        }
+    }
+
+    @Test("Handshake readers reject invalid ephemeral and truncated static payloads")
+    func handshakeReadersRejectInvalidEphemeralAndTruncatedStaticPayloads() throws {
+        let invalidEphemeralResponder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        #expect(throws: NoiseError.invalidMessage) {
+            try invalidEphemeralResponder.readMessage(Data(repeating: 0x00, count: 32))
+        }
+
+        let truncatedStaticInitiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey
+        )
+        _ = try truncatedStaticInitiator.writeMessage()
+        let responderEphemeralOnly = Curve25519.KeyAgreement.PrivateKey().publicKey.rawRepresentation
+
+        #expect(throws: NoiseError.invalidMessage) {
+            try truncatedStaticInitiator.readMessage(responderEphemeralOnly)
+        }
+    }
+
+    @Test("IK handshake completes and supports transport messages")
+    func ikHandshakeCompletesAndSupportsTransportMessages() throws {
+        let initiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .IK,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey,
+            remoteStaticKey: bobStaticKey.publicKey
+        )
+        let responder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .IK,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        let outboundPayload = Data("ik-outbound".utf8)
+        let returnPayload = Data("ik-return".utf8)
+        let message1 = try initiator.writeMessage(payload: outboundPayload)
+
+        #expect(try responder.readMessage(message1) == outboundPayload)
+
+        let message2 = try responder.writeMessage(payload: returnPayload)
+        #expect(try initiator.readMessage(message2) == returnPayload)
+
+        #expect(initiator.isHandshakeComplete())
+        #expect(responder.isHandshakeComplete())
+
+        let (initiatorSend, initiatorReceive, initiatorHash) = try initiator.getTransportCiphers(
+            useExtractedNonce: true
+        )
+        let (responderSend, responderReceive, responderHash) = try responder.getTransportCiphers(
+            useExtractedNonce: true
+        )
+
+        #expect(initiatorHash == responderHash)
+
+        let clientCiphertext = try initiatorSend.encrypt(plaintext: Data("ik-transport".utf8))
+        #expect(try responderReceive.decrypt(ciphertext: clientCiphertext) == Data("ik-transport".utf8))
+
+        let serverCiphertext = try responderSend.encrypt(plaintext: Data("ik-response".utf8))
+        #expect(try initiatorReceive.decrypt(ciphertext: serverCiphertext) == Data("ik-response".utf8))
+    }
+
+    @Test("NK handshake requires a responder static key and supports transport messages")
+    func nkHandshakeRequiresStaticAndSupportsTransportMessages() throws {
+        let missingStaticInitiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .NK,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey
+        )
+
+        #expect(throws: (any Error).self) {
+            try missingStaticInitiator.writeMessage()
+        }
+
+        let initiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .NK,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey,
+            remoteStaticKey: bobStaticKey.publicKey
+        )
+        let responder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .NK,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        let outboundPayload = Data("nk-outbound".utf8)
+        let returnPayload = Data("nk-return".utf8)
+        let message1 = try initiator.writeMessage(payload: outboundPayload)
+        #expect(try responder.readMessage(message1) == outboundPayload)
+
+        let message2 = try responder.writeMessage(payload: returnPayload)
+        #expect(try initiator.readMessage(message2) == returnPayload)
+
+        #expect(initiator.isHandshakeComplete())
+        #expect(responder.isHandshakeComplete())
+
+        let (initiatorSend, initiatorReceive, initiatorHash) = try initiator.getTransportCiphers(
+            useExtractedNonce: true
+        )
+        let (responderSend, responderReceive, responderHash) = try responder.getTransportCiphers(
+            useExtractedNonce: true
+        )
+
+        #expect(initiatorHash == responderHash)
+
+        let clientCiphertext = try initiatorSend.encrypt(plaintext: Data("nk-transport".utf8))
+        #expect(try responderReceive.decrypt(ciphertext: clientCiphertext) == Data("nk-transport".utf8))
+
+        let serverCiphertext = try responderSend.encrypt(plaintext: Data("nk-response".utf8))
+        #expect(try initiatorReceive.decrypt(ciphertext: serverCiphertext) == Data("nk-response".utf8))
+    }
+
+    @Test("Responder-side NK writes require peer ephemeral input")
+    func responderWritesRequirePeerEphemeralInput() {
+        let nkResponder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .NK,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        #expect(throws: NoiseError.missingKeys) {
+            try nkResponder.writeMessage()
+        }
+    }
+
+    @Test("Direct DH helpers reject missing keys across all patterns")
+    func directDHHelpersRejectMissingKeysAcrossAllPatterns() throws {
+        let eeState = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey
+        )
+        #expect(throws: NoiseError.missingKeys) {
+            try eeState.performDHOperationForTesting(.ee)
+        }
+
+        let esInitiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey
+        )
+        #expect(throws: NoiseError.missingKeys) {
+            try esInitiator.performDHOperationForTesting(.es)
+        }
+
+        let esResponder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: nil
+        )
+        #expect(throws: NoiseError.missingKeys) {
+            try esResponder.performDHOperationForTesting(.es)
+        }
+
+        let seInitiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: nil
+        )
+        #expect(throws: NoiseError.missingKeys) {
+            try seInitiator.performDHOperationForTesting(.se)
+        }
+
+        let seResponder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+        #expect(throws: NoiseError.missingKeys) {
+            try seResponder.performDHOperationForTesting(.se)
+        }
+
+        let ssState = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: nil
+        )
+        #expect(throws: NoiseError.missingKeys) {
+            try ssState.performDHOperationForTesting(.ss)
+        }
+
+        #expect(throws: Never.self) {
+            try eeState.performDHOperationForTesting(.e)
+            try eeState.performDHOperationForTesting(.s)
+        }
+    }
+
+    @Test("Prepared handshake writers cover remaining missing-key branches")
+    func preparedHandshakeWritersCoverRemainingMissingKeyBranches() {
+        let eeResponder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .NK,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+        eeResponder.setCurrentPatternForTesting(1)
+        #expect(throws: NoiseError.missingKeys) {
+            try eeResponder.writeMessage()
+        }
+
+        let seInitiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey
+        )
+        seInitiator.setCurrentPatternForTesting(2)
+        #expect(throws: NoiseError.missingKeys) {
+            try seInitiator.writeMessage()
+        }
+
+        let seResponder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .IK,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+        seResponder.setCurrentPatternForTesting(1)
+        seResponder.setRemoteEphemeralPublicKeyForTesting(Curve25519.KeyAgreement.PrivateKey().publicKey)
+        #expect(throws: NoiseError.missingKeys) {
+            try seResponder.writeMessage()
+        }
+    }
+
+    @Test("Completed handshakes reject additional reads and writes")
+    func completedHandshakesRejectAdditionalReadsAndWrites() throws {
+        let initiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .IK,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey,
+            remoteStaticKey: bobStaticKey.publicKey
+        )
+        let responder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .IK,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        let message1 = try initiator.writeMessage(payload: Data("first".utf8))
+        _ = try responder.readMessage(message1)
+        let message2 = try responder.writeMessage(payload: Data("second".utf8))
+        _ = try initiator.readMessage(message2)
+
+        #expect(throws: NoiseError.handshakeComplete) {
+            try initiator.writeMessage()
+        }
+        #expect(throws: NoiseError.handshakeComplete) {
+            try responder.readMessage(message1)
+        }
+    }
+
+    @Test("XX final message requires a local static key")
+    func xxFinalMessageRequiresLocalStaticKey() throws {
+        let initiator = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: nil
+        )
+        let responder = NoiseHandshakeState(
+            role: .responder,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        let message1 = try initiator.writeMessage()
+        _ = try responder.readMessage(message1)
+        let message2 = try responder.writeMessage()
+        _ = try initiator.readMessage(message2)
+
+        #expect(throws: (any Error).self) {
+            try initiator.writeMessage()
+        }
+    }
+
+    @Test("Responder start handshake is empty and transport ciphers require completion")
+    func responderStartHandshakeAndIncompleteTransportCiphers() throws {
+        let responderSession = NoiseSession(
+            peerID: bobPeerID,
+            role: .responder,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+        let incompleteHandshake = NoiseHandshakeState(
+            role: .initiator,
+            pattern: .XX,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey
+        )
+
+        #expect(try responderSession.startHandshake().isEmpty)
+        #expect(responderSession.getState() == .handshaking)
+
+        #expect(throws: (any Error).self) {
+            _ = try incompleteHandshake.getTransportCiphers(useExtractedNonce: true)
+        }
+    }
+
+    @Test("Session manager callbacks establish and failed handshakes clean up state")
+    func sessionManagerCallbacksAndFailureCleanup() async throws {
+        let establishedRecorder = SessionCallbackRecorder()
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceStaticKey, keychain: keychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobStaticKey, keychain: keychain)
+
+        aliceManager.onSessionEstablished = establishedRecorder.recordEstablished(peerID:remoteKey:)
+        bobManager.onSessionEstablished = establishedRecorder.recordEstablished(peerID:remoteKey:)
+
+        try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
+
+        let didEstablish = await TestHelpers.waitUntil(
+            { establishedRecorder.establishedCount == 2 },
+            timeout: 0.5
+        )
+        #expect(didEstablish)
+        #expect(establishedRecorder.establishedPeerIDs.contains(alicePeerID))
+        #expect(establishedRecorder.establishedPeerIDs.contains(bobPeerID))
+
+        let failureRecorder = SessionCallbackRecorder()
+        let failingManager = NoiseSessionManager(localStaticKey: charlieStaticKey, keychain: keychain)
+        failingManager.onSessionFailed = failureRecorder.recordFailure(peerID:error:)
+
+        #expect(throws: (any Error).self) {
+            try failingManager.handleIncomingHandshake(
+                from: charliePeerID,
+                message: Data(repeating: 0x00, count: 31)
+            )
+        }
+
+        let didFail = await TestHelpers.waitUntil(
+            { failureRecorder.failureCount == 1 },
+            timeout: 0.5
+        )
+        #expect(didFail)
+        #expect(failingManager.getSession(for: charliePeerID) == nil)
+    }
+
+    @Test("Session manager cleans up initiator sessions after start-handshake failures")
+    func sessionManagerCleansUpInitiatorSessionsAfterStartHandshakeFailures() {
+        let manager = NoiseSessionManager(
+            localStaticKey: aliceStaticKey,
+            keychain: keychain,
+            sessionFactory: { peerID, role in
+                FailingNoiseSession(
+                    peerID: peerID,
+                    role: role,
+                    keychain: self.keychain,
+                    localStaticKey: self.aliceStaticKey
+                )
+            }
+        )
+
+        #expect(throws: FailingNoiseSession.Error.synthetic) {
+            try manager.initiateHandshake(with: alicePeerID)
+        }
+        #expect(manager.getSession(for: alicePeerID) == nil)
+    }
+
+    @Test("Session manager rekeys established sessions and replaces partial handshakes")
+    func sessionManagerRekeysAndReplacesSessions() throws {
+        let manager = NoiseSessionManager(localStaticKey: aliceStaticKey, keychain: keychain)
+
+        #expect(throws: NoiseSessionError.sessionNotFound) {
+            try manager.encrypt(Data("missing".utf8), for: alicePeerID)
+        }
+        #expect(throws: NoiseSessionError.sessionNotFound) {
+            try manager.decrypt(Data("missing".utf8), from: alicePeerID)
+        }
+
+        let initialHandshake = try manager.initiateHandshake(with: alicePeerID)
+        #expect(!initialHandshake.isEmpty)
+        let firstSession = try #require(manager.getSession(for: alicePeerID))
+
+        let restartedHandshake = try manager.initiateHandshake(with: alicePeerID)
+        let restartedSession = try #require(manager.getSession(for: alicePeerID))
+
+        #expect(!restartedHandshake.isEmpty)
+        #expect(restartedSession !== firstSession)
+
+        let restartedInitiator = NoiseSession(
+            peerID: alicePeerID,
+            role: .initiator,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+        let replacementMessage = try restartedInitiator.startHandshake()
+        let replacementResponse = try manager.handleIncomingHandshake(
+            from: alicePeerID,
+            message: replacementMessage
+        )
+        let replacementSession = try #require(manager.getSession(for: alicePeerID))
+
+        #expect(replacementResponse != nil)
+        #expect(replacementSession !== restartedSession)
+
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceStaticKey, keychain: keychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobStaticKey, keychain: keychain)
+        try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
+
+        let establishedSession = try #require(
+            aliceManager.getSession(for: alicePeerID) as? SecureNoiseSession
+        )
+        establishedSession.setMessageCountForTesting(
+            UInt64(Double(NoiseSecurityConstants.maxMessagesPerSession) * 0.9)
+        )
+
+        let sessionsNeedingRekey = aliceManager.getSessionsNeedingRekey()
+        #expect(sessionsNeedingRekey.contains { $0.peerID == alicePeerID && $0.needsRekey })
+
+        #expect(throws: NoiseSessionError.alreadyEstablished) {
+            try aliceManager.initiateHandshake(with: alicePeerID)
+        }
+
+        try aliceManager.initiateRekey(for: alicePeerID)
+        let rekeyedSession = try #require(aliceManager.getSession(for: alicePeerID))
+
+        #expect(rekeyedSession !== establishedSession)
+        #expect(rekeyedSession.getState() == .handshaking)
+    }
+
+    @Test("Secure noise sessions enforce limits and renegotiation thresholds")
+    func secureNoiseSessionsEnforceLimitsAndThresholds() throws {
+        let initiator = SecureNoiseSession(
+            peerID: alicePeerID,
+            role: .initiator,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey
+        )
+        let responder = SecureNoiseSession(
+            peerID: bobPeerID,
+            role: .responder,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        try establishSessions(initiator: initiator, responder: responder)
+
+        responder.setMessageCountForTesting(0)
+        responder.setLastActivityTimeForTesting(Date())
+        #expect(!responder.needsRenegotiation())
+
+        responder.setMessageCountForTesting(
+            UInt64(Double(NoiseSecurityConstants.maxMessagesPerSession) * 0.9)
+        )
+        #expect(responder.needsRenegotiation())
+
+        responder.setMessageCountForTesting(0)
+        responder.setLastActivityTimeForTesting(
+            Date().addingTimeInterval(-(NoiseSecurityConstants.sessionTimeout + 1))
+        )
+        #expect(responder.needsRenegotiation())
+
+        initiator.setMessageCountForTesting(NoiseSecurityConstants.maxMessagesPerSession)
+        #expect(throws: (any Error).self) {
+            try initiator.encrypt(Data("exhausted".utf8))
+        }
+
+        initiator.setMessageCountForTesting(0)
+        #expect(throws: (any Error).self) {
+            try initiator.encrypt(Data(repeating: 0xAB, count: NoiseSecurityConstants.maxMessageSize + 1))
+        }
+
+        responder.setLastActivityTimeForTesting(Date())
+        #expect(throws: (any Error).self) {
+            try responder.decrypt(
+                Data(repeating: 0xCD, count: NoiseSecurityConstants.maxMessageSize + 1)
+            )
+        }
+
+        let transportCiphertext = try initiator.encrypt(Data("secure-session".utf8))
+        #expect(try responder.decrypt(transportCiphertext) == Data("secure-session".utf8))
+    }
+
+    @Test("Secure noise sessions expire based on session start time")
+    func secureNoiseSessionsExpireBasedOnSessionStartTime() throws {
+        let initiator = SecureNoiseSession(
+            peerID: alicePeerID,
+            role: .initiator,
+            keychain: keychain,
+            localStaticKey: aliceStaticKey
+        )
+        let responder = SecureNoiseSession(
+            peerID: bobPeerID,
+            role: .responder,
+            keychain: keychain,
+            localStaticKey: bobStaticKey
+        )
+
+        try establishSessions(initiator: initiator, responder: responder)
+
+        initiator.setSessionStartTimeForTesting(
+            Date().addingTimeInterval(-(NoiseSecurityConstants.sessionTimeout + 1))
+        )
+        #expect(throws: (any Error).self) {
+            try initiator.encrypt(Data("expired".utf8))
+        }
+
+        responder.setSessionStartTimeForTesting(
+            Date().addingTimeInterval(-(NoiseSecurityConstants.sessionTimeout + 1))
+        )
+        #expect(throws: (any Error).self) {
+            try responder.decrypt(Data())
+        }
+    }
+
+    @Test("Rate limiter handles global message caps and per-peer resets")
+    func rateLimiterGlobalMessageCapAndReset() async throws {
+        let globalLimiter = NoiseRateLimiter()
+        for index in 0..<NoiseSecurityConstants.maxGlobalMessagesPerSecond {
+            #expect(globalLimiter.allowMessage(from: PeerID(str: "peer-\(index)")))
+        }
+        #expect(!globalLimiter.allowMessage(from: charliePeerID))
+
+        let peerLimiter = NoiseRateLimiter()
+        for _ in 0..<NoiseSecurityConstants.maxMessagesPerSecond {
+            #expect(peerLimiter.allowMessage(from: alicePeerID))
+        }
+        #expect(!peerLimiter.allowMessage(from: alicePeerID))
+
+        peerLimiter.reset(for: alicePeerID)
+        try await sleep(0.05)
+        #expect(peerLimiter.allowMessage(from: alicePeerID))
+    }
+
+    @Test("Cipher state decrypts high extracted nonces and rejects truncated extracted payloads")
+    func cipherStateDecryptsHighExtractedNoncesAndRejectsTruncatedPayloads() throws {
+        let key = SymmetricKey(size: .bits256)
+        let receiver = NoiseCipherState(key: key, useExtractedNonce: true)
+        let highNoncePayload = try makeExtractedNoncePayload(
+            key: key,
+            nonce: 1_000_000_001,
+            plaintext: Data("high-nonce".utf8)
+        )
+
+        #expect(try receiver.decrypt(ciphertext: highNoncePayload) == Data("high-nonce".utf8))
+        #expect(throws: NoiseError.invalidCiphertext) {
+            try receiver.decrypt(ciphertext: extractedNoncePrefix(7))
+        }
+    }
+
+    private func establishSessions(initiator: NoiseSession, responder: NoiseSession) throws {
+        let message1 = try initiator.startHandshake()
+        let response2 = try responder.processHandshakeMessage(message1)
+        let message2 = try #require(response2)
+        let response3 = try initiator.processHandshakeMessage(message2)
+        let message3 = try #require(response3)
+        let final = try responder.processHandshakeMessage(message3)
+        #expect(final == nil)
+    }
+
+    private func establishManagerSessions(
+        aliceManager: NoiseSessionManager,
+        bobManager: NoiseSessionManager
+    ) throws {
+        let message1 = try aliceManager.initiateHandshake(with: alicePeerID)
+        let response2 = try bobManager.handleIncomingHandshake(from: bobPeerID, message: message1)
+        let message2 = try #require(response2)
+        let response3 = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: message2)
+        let message3 = try #require(response3)
+        let final = try bobManager.handleIncomingHandshake(from: bobPeerID, message: message3)
+        #expect(final == nil)
+    }
+
+    private func makeExtractedNoncePayload(
+        key: SymmetricKey,
+        nonce: UInt64,
+        plaintext: Data,
+        associatedData: Data = Data()
+    ) throws -> Data {
+        var fullNonce = Data(count: 12)
+        withUnsafeBytes(of: nonce.littleEndian) { bytes in
+            fullNonce.replaceSubrange(4..<12, with: bytes)
+        }
+
+        let sealedBox = try ChaChaPoly.seal(
+            plaintext,
+            using: key,
+            nonce: ChaChaPoly.Nonce(data: fullNonce),
+            authenticating: associatedData
+        )
+
+        return extractedNoncePrefix(nonce) + sealedBox.ciphertext + sealedBox.tag
+    }
+
+    private func extractedNoncePrefix(_ nonce: UInt64) -> Data {
+        withUnsafeBytes(of: nonce.bigEndian) { bytes in
+            Data(bytes.suffix(4))
+        }
+    }
+}
+
+private final class SessionCallbackRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var establishedEntries: [(PeerID, Data)] = []
+    private var failureEntries: [(PeerID, String)] = []
+
+    var establishedCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return establishedEntries.count
+    }
+
+    var failureCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return failureEntries.count
+    }
+
+    var establishedPeerIDs: [PeerID] {
+        lock.lock()
+        defer { lock.unlock() }
+        return establishedEntries.map(\.0)
+    }
+
+    func recordEstablished(peerID: PeerID, remoteKey: Curve25519.KeyAgreement.PublicKey) {
+        lock.lock()
+        establishedEntries.append((peerID, remoteKey.rawRepresentation))
+        lock.unlock()
+    }
+
+    func recordFailure(peerID: PeerID, error: Error) {
+        lock.lock()
+        failureEntries.append((peerID, String(describing: error)))
+        lock.unlock()
+    }
+}
+
+private final class FailingNoiseSession: NoiseSession {
+    enum Error: Swift.Error {
+        case synthetic
+    }
+
+    override func startHandshake() throws -> Data {
+        throw Error.synthetic
+    }
+}