Merge branch 'main' into update-tor-0.4.8.19

* Add localizable strings in show commands view n refactor code to remove duplicate string declarations.

* Modify struct to enum in separate file to Models/CommandsInfo.

* Add corrections code in refactory and enum.

* Correct code in command enum and ContentView.

* Dedicated CommandSuggestionsView to extract code

* Simplify CommandInfo + minor optimization

* Fix preview

---------

Co-authored-by: islam <2553451+qalandarov@users.noreply.github.com>

.cache/clang/ModuleCache/Swift-207X6UTF85MUY.swiftmodule

@@ -1,12 +0,0 @@
----
-path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/Swift.swiftmodule/arm64e-apple-macos.swiftmodule'
-dependencies:
-  - mtime:           1757258659000000000
-    path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/Swift.swiftmodule/arm64e-apple-macos.swiftmodule'
-    size:            14166264
-  - mtime:           1754189697000000000
-    path:            'usr/lib/swift/Swift.swiftmodule/arm64e-apple-macos.swiftinterface'
-    size:            2261306
-    sdk_relative:    true
-version:         1
-...

.cache/clang/ModuleCache/SwiftOnoneSupport-3W234PQLRG1JJ.swiftmodule

@@ -1,16 +0,0 @@
----
-path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/SwiftOnoneSupport.swiftmodule/arm64e-apple-macos.swiftmodule'
-dependencies:
-  - mtime:           1757258662000000000
-    path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/SwiftOnoneSupport.swiftmodule/arm64e-apple-macos.swiftmodule'
-    size:            18068
-  - mtime:           1754189697000000000
-    path:            'usr/lib/swift/Swift.swiftmodule/arm64e-apple-macos.swiftinterface'
-    size:            2261306
-    sdk_relative:    true
-  - mtime:           1754191141000000000
-    path:            'usr/lib/swift/SwiftOnoneSupport.swiftmodule/arm64e-apple-macos.swiftinterface'
-    size:            1224
-    sdk_relative:    true
-version:         1
-...

.cache/clang/ModuleCache/_Concurrency-IW47C06QYY26.swiftmodule

@@ -1,16 +0,0 @@
----
-path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/_Concurrency.swiftmodule/arm64e-apple-macos.swiftmodule'
-dependencies:
-  - mtime:           1757258669000000000
-    path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/_Concurrency.swiftmodule/arm64e-apple-macos.swiftmodule'
-    size:            699544
-  - mtime:           1754189697000000000
-    path:            'usr/lib/swift/Swift.swiftmodule/arm64e-apple-macos.swiftinterface'
-    size:            2261306
-    sdk_relative:    true
-  - mtime:           1754192470000000000
-    path:            'usr/lib/swift/_Concurrency.swiftmodule/arm64e-apple-macos.swiftinterface'
-    size:            364219
-    sdk_relative:    true
-version:         1
-...

.cache/clang/ModuleCache/_StringProcessing-1C2ZFCSIKDXY1.swiftmodule

@@ -1,16 +0,0 @@
----
-path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/_StringProcessing.swiftmodule/arm64e-apple-macos.swiftmodule'
-dependencies:
-  - mtime:           1757258664000000000
-    path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/_StringProcessing.swiftmodule/arm64e-apple-macos.swiftmodule'
-    size:            83568
-  - mtime:           1754189697000000000
-    path:            'usr/lib/swift/Swift.swiftmodule/arm64e-apple-macos.swiftinterface'
-    size:            2261306
-    sdk_relative:    true
-  - mtime:           1754192532000000000
-    path:            'usr/lib/swift/_StringProcessing.swiftmodule/arm64e-apple-macos.swiftinterface'
-    size:            24507
-    sdk_relative:    true
-version:         1
-...

.github/workflows/fetch_georelays.yml

@@ -7,6 +7,7 @@ on:
 
 permissions:
   contents: write
+  pull-requests: write
 
 jobs:
   update-relay-data:
@@ -17,24 +18,54 @@ jobs:
         uses: actions/checkout@v4
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-      
+          fetch-depth: 0
+
       - name: Fetch GeoRelays
         run: |
-          wget https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv
+          wget -q https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv
           mv nostr_relays.csv ./relays/online_relays_gps.csv
 
-      - name: Check for changes
+      - name: Configure git
-        id: git-check
         run: |
-          git diff --exit-code || echo "changes=true" >> $GITHUB_OUTPUT
+          git config user.email "action@github.com"
-    
+          git config user.name "GitHub Action"
-      - name: Commit and push changes
+
-        if: steps.git-check.outputs.changes == 'true'
+      - name: Create update branch if changes
+        id: create_branch
         run: |
-          git config --local user.email "action@github.com"
+          # exit early if no changes
-          git config --local user.name "GitHub Action"
+          if git diff --quiet --relays/online_relays_gps.csv; then
+            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)"
+          git commit -m "Automated update of relay data - $(date -u --rfc-3339=seconds)"
-          git push
+          echo "changed=true" >> $GITHUB_OUTPUT
-        env:
+          echo "branch=$BRANCH" >> $GITHUB_OUTPUT
-          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"

.gitignore

@@ -66,6 +66,9 @@ __pycache__/
 *.tmp
 *.temp
 
+## Cache
+.cache/
+
 # Local build results
 .Result*/
 .Result*.xcresult/

Configs/Release.xcconfig

@@ -1,4 +1,4 @@
-MARKETING_VERSION = 1.4.4
+MARKETING_VERSION = 1.5.0
 CURRENT_PROJECT_VERSION = 1
 
 IPHONEOS_DEPLOYMENT_TARGET = 16.0

Justfile

@@ -14,8 +14,11 @@ default:
 # Check prerequisites
 check:
     @echo "Checking prerequisites..."
-    @command -v xcodebuild >/dev/null 2>&1 || (echo "❌ Xcode not found. Install Xcode from App Store" && exit 1)
+    @command -v xcodebuild >/dev/null 2>&1 || (echo "❌ xcodebuild not found. Install Xcode from App Store" && exit 1)
-    @security find-identity -v -p codesigning | grep -q "Developer ID" || (echo "⚠️  No Developer ID found - code signing may fail" && exit 0)
+    @xcode-select -p | grep -q "Xcode.app" || (echo "❌ Full Xcode required, not just command line tools. Install from App Store and run:\n   sudo xcode-select -s /Applications/Xcode.app/Contents/Developer" && exit 1)
+    @test -d "/Applications/Xcode.app" || (echo "❌ Xcode.app not found in Applications folder. Install from App Store" && exit 1)
+    @xcodebuild -version >/dev/null 2>&1 || (echo "❌ Xcode not properly configured. Try:\n   sudo xcode-select -s /Applications/Xcode.app/Contents/Developer" && exit 1)
+    @security find-identity -v -p codesigning | grep -q "Apple Development\|Developer ID" || (echo "⚠️  No Developer ID found - code signing may fail" && exit 0)
     @echo "✅ All prerequisites met"
 
 # Backup original files

Package.swift

@@ -6,7 +6,7 @@ let package = Package(
     name: "bitchat",
     defaultLocalization: "en",
     platforms: [
-        .iOS(.v17),
+        .iOS(.v16),
         .macOS(.v13)
     ],
     products: [

bitchat.xcodeproj/project.pbxproj

@@ -312,6 +312,7 @@
 				ne,
 				"pt-BR",
 				ru,
+				tr,
 				uk,
 				"zh-Hans",
 			);

bitchat.xcodeproj/xcshareddata/xcschemes/bitchat (iOS).xcscheme

@@ -98,8 +98,8 @@
       </BuildableProductRunnable>
       <EnvironmentVariables>
          <EnvironmentVariable
-            key = "-DBITCHAT_DEV_ALLOW_CLEARNET"
+            key = "BITCHAT_LOG_LEVEL"
-            value = ""
+            value = "debug"
             isEnabled = "YES">
          </EnvironmentVariable>
       </EnvironmentVariables>

bitchat/Assets.xcassets/AppIconDebug.appiconset/Contents.json

@@ -13,7 +13,6 @@
           "value" : "dark"
         }
       ],
-      "filename" : "image-1024 1.png",
       "idiom" : "universal",
       "platform" : "ios",
       "size" : "1024x1024"
@@ -25,7 +24,6 @@
           "value" : "tinted"
         }
       ],
-      "filename" : "image-1024 2.png",
       "idiom" : "universal",
       "platform" : "ios",
       "size" : "1024x1024"

bitchat/BitchatApp.swift

@@ -26,11 +26,15 @@ struct BitchatApp: App {
     @NSApplicationDelegateAdaptor(MacAppDelegate.self) var appDelegate
     #endif
     
+    private let idBridge = NostrIdentityBridge()
+    
     init() {
         let keychain = KeychainManager()
+        let idBridge = self.idBridge
         _chatViewModel = StateObject(
             wrappedValue: ChatViewModel(
                 keychain: keychain,
+                idBridge: idBridge,
                 identityManager: SecureIdentityStateManager(keychain)
             )
         )
@@ -50,14 +54,12 @@ struct BitchatApp: App {
                     VerificationService.shared.configure(with: chatViewModel.meshService.getNoiseService())
                     // Prewarm Nostr identity and QR to make first VERIFY sheet fast
                     DispatchQueue.global(qos: .utility).async {
-                        let npub = try? NostrIdentityBridge.getCurrentNostrIdentity()?.npub
+                        let npub = try? idBridge.getCurrentNostrIdentity()?.npub
                         _ = VerificationService.shared.buildMyQRString(nickname: chatViewModel.nickname, npub: npub)
                     }
-                    #if os(iOS)
+
                     appDelegate.chatViewModel = chatViewModel
-                    #elseif os(macOS)
+
-                    appDelegate.chatViewModel = chatViewModel
-                    #endif
                     // Initialize network activation policy; will start Tor/Nostr only when allowed
                     NetworkActivationService.shared.start()
                     // Check for shared content
@@ -185,6 +187,10 @@ final class AppDelegate: NSObject, UIApplicationDelegate {
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
         return true
     }
+    
+    func applicationWillTerminate(_ application: UIApplication) {
+        chatViewModel?.applicationWillTerminate()
+    }
 }
 #endif
 
@@ -217,7 +223,7 @@ final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
             // Get peer ID from userInfo
             if let peerID = userInfo["peerID"] as? String {
                 DispatchQueue.main.async {
-                    self.chatViewModel?.startPrivateChat(with: peerID)
+                    self.chatViewModel?.startPrivateChat(with: PeerID(str: peerID))
                 }
             }
         }
@@ -242,7 +248,7 @@ final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
             // Get peer ID from userInfo
             if let peerID = userInfo["peerID"] as? String {
                 // Don't show notification if the private chat is already open
-                if chatViewModel?.selectedPrivateChatPeer == peerID {
+                if chatViewModel?.selectedPrivateChatPeer == PeerID(str: peerID) {
                     completionHandler([])
                     return
                 }

bitchat/Features/media/ImageUtils.swift

@@ -0,0 +1,203 @@
+import Foundation
+import ImageIO
+import UniformTypeIdentifiers
+#if os(iOS)
+import UIKit
+#else
+import AppKit
+#endif
+
+enum ImageUtilsError: Error {
+    case invalidImage
+    case encodingFailed
+}
+
+enum ImageUtils {
+    private static let compressionQuality: CGFloat = 0.82
+    private static let targetImageBytes: Int = 45_000
+
+    static func processImage(at url: URL, maxDimension: CGFloat = 448) throws -> URL {
+        // Security H1: Check file size BEFORE reading into memory
+        let attrs = try FileManager.default.attributesOfItem(atPath: url.path)
+        guard let fileSize = attrs[.size] as? Int else {
+            throw ImageUtilsError.invalidImage
+        }
+        // Allow up to 10MB source images (will be scaled down)
+        guard fileSize <= 10 * 1024 * 1024 else {
+            throw ImageUtilsError.invalidImage
+        }
+
+        let data = try Data(contentsOf: url)
+        #if os(iOS)
+        guard let image = UIImage(data: data) else { throw ImageUtilsError.invalidImage }
+        return try processImage(image, maxDimension: maxDimension)
+        #else
+        guard let image = NSImage(data: data) else { throw ImageUtilsError.invalidImage }
+        return try processImage(image, maxDimension: maxDimension)
+        #endif
+    }
+
+    #if os(iOS)
+    static func processImage(_ image: UIImage, maxDimension: CGFloat = 448) throws -> URL {
+        return try autoreleasepool {
+            // Scale the image first
+            let scaled = scaledImage(image, maxDimension: maxDimension)
+
+            // Get CGImage from UIImage - this is the key to stripping metadata
+            guard let cgImage = scaled.cgImage else {
+                throw ImageUtilsError.encodingFailed
+            }
+
+            // Use CGImageDestination to encode without metadata (same as macOS)
+            var quality = compressionQuality
+            guard var jpegData = encodeJPEG(from: cgImage, quality: quality) else {
+                throw ImageUtilsError.encodingFailed
+            }
+
+            // Compress to target size
+            while jpegData.count > targetImageBytes && quality > 0.3 {
+                quality -= 0.1
+                autoreleasepool {
+                    if let next = encodeJPEG(from: cgImage, quality: quality) {
+                        jpegData = next
+                    }
+                }
+            }
+
+            let outputURL = try makeOutputURL()
+            try jpegData.write(to: outputURL, options: .atomic)
+            return outputURL
+        }
+    }
+
+    private static func scaledImage(_ image: UIImage, maxDimension: CGFloat) -> UIImage {
+        let size = image.size
+        let maxSide = max(size.width, size.height)
+        guard maxSide > maxDimension else { return image }
+        let scale = maxDimension / maxSide
+        let newSize = CGSize(width: size.width * scale, height: size.height * scale)
+
+        // Draw into a new context to get a clean CGImage without metadata
+        UIGraphicsBeginImageContextWithOptions(newSize, true, 1.0)
+        image.draw(in: CGRect(origin: .zero, size: newSize))
+        let rendered = UIGraphicsGetImageFromCurrentImageContext()
+        UIGraphicsEndImageContext()
+        return rendered ?? image
+    }
+
+    // Shared EXIF-stripping JPEG encoder for both iOS and macOS
+    private static func encodeJPEG(from cgImage: CGImage, quality: CGFloat) -> Data? {
+        guard let data = CFDataCreateMutable(nil, 0) else {
+            return nil
+        }
+        guard let destination = CGImageDestinationCreateWithData(data, UTType.jpeg.identifier as CFString, 1, nil) else {
+            return nil
+        }
+        // Security: Strip ALL metadata (EXIF, GPS, TIFF, IPTC, XMP)
+        // By only specifying compression quality and no metadata keys,
+        // we ensure a clean JPEG with no privacy-leaking information
+        let options: [CFString: Any] = [
+            kCGImageDestinationLossyCompressionQuality: quality
+        ]
+        CGImageDestinationAddImage(destination, cgImage, options as CFDictionary)
+        guard CGImageDestinationFinalize(destination) else {
+            return nil
+        }
+        return data as Data
+    }
+    #else
+    static func processImage(_ image: NSImage, maxDimension: CGFloat = 448) throws -> URL {
+        return try autoreleasepool {
+            let scaled = scaledImage(image, maxDimension: maxDimension)
+            guard let inputCG = scaled.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
+                throw ImageUtilsError.encodingFailed
+            }
+            let width = inputCG.width
+            let height = inputCG.height
+            let colorSpace = CGColorSpace(name: CGColorSpace.sRGB) ?? CGColorSpaceCreateDeviceRGB()
+            guard let context = CGContext(
+                data: nil,
+                width: width,
+                height: height,
+                bitsPerComponent: 8,
+                bytesPerRow: 0,
+                space: colorSpace,
+                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+            ) else {
+                throw ImageUtilsError.encodingFailed
+            }
+            context.draw(inputCG, in: CGRect(x: 0, y: 0, width: width, height: height))
+            guard let cgImage = context.makeImage() else {
+                throw ImageUtilsError.encodingFailed
+            }
+            var quality = compressionQuality
+            guard var jpegData = encodeJPEG(from: cgImage, quality: quality) else {
+                throw ImageUtilsError.encodingFailed
+            }
+            while jpegData.count > targetImageBytes && quality > 0.3 {
+                quality -= 0.1
+                autoreleasepool {
+                    if let next = encodeJPEG(from: cgImage, quality: quality) {
+                        jpegData = next
+                    }
+                }
+            }
+            let outputURL = try makeOutputURL()
+            try jpegData.write(to: outputURL, options: .atomic)
+            return outputURL
+        }
+    }
+
+    private static func scaledImage(_ image: NSImage, maxDimension: CGFloat) -> NSImage {
+        let size = image.size
+        let maxSide = max(size.width, size.height)
+        guard maxSide > maxDimension else { return image }
+        let scale = maxDimension / maxSide
+        let newSize = NSSize(width: size.width * scale, height: size.height * scale)
+        let scaledImage = NSImage(size: newSize)
+        scaledImage.lockFocus()
+        image.draw(in: NSRect(origin: .zero, size: newSize),
+                   from: NSRect(origin: .zero, size: size),
+                   operation: .copy,
+                   fraction: 1.0)
+        scaledImage.unlockFocus()
+        return scaledImage
+    }
+
+    // Shared EXIF-stripping JPEG encoder for both iOS and macOS
+    private static func encodeJPEG(from cgImage: CGImage, quality: CGFloat) -> Data? {
+        guard let data = CFDataCreateMutable(nil, 0) else {
+            return nil
+        }
+        guard let destination = CGImageDestinationCreateWithData(data, UTType.jpeg.identifier as CFString, 1, nil) else {
+            return nil
+        }
+        // Security: Strip ALL metadata (EXIF, GPS, TIFF, IPTC, XMP)
+        // By only specifying compression quality and no metadata keys,
+        // we ensure a clean JPEG with no privacy-leaking information
+        let options: [CFString: Any] = [
+            kCGImageDestinationLossyCompressionQuality: quality
+        ]
+        CGImageDestinationAddImage(destination, cgImage, options as CFDictionary)
+        guard CGImageDestinationFinalize(destination) else {
+            return nil
+        }
+        return data as Data
+    }
+    #endif
+
+    private static func makeOutputURL() throws -> URL {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyyMMdd_HHmmss"
+        let fileName = "img_\(formatter.string(from: Date())).jpg"
+
+        let directory = try applicationFilesDirectory().appendingPathComponent("images/outgoing", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true, attributes: nil)
+        return directory.appendingPathComponent(fileName)
+    }
+
+    private static func applicationFilesDirectory() throws -> URL {
+        let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+        return base.appendingPathComponent("files", isDirectory: true)
+    }
+}

bitchat/Features/voice/VoiceNotePlaybackController.swift

@@ -0,0 +1,193 @@
+import Foundation
+import AVFoundation
+import BitLogger
+
+/// Controls playback for a single voice note and coordinates exclusive playback across the app.
+final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlayerDelegate {
+    @Published private(set) var isPlaying: Bool = false
+    @Published private(set) var currentTime: TimeInterval = 0
+    @Published private(set) var duration: TimeInterval = 0
+    @Published private(set) var progress: Double = 0
+
+    private var player: AVAudioPlayer?
+    private var timer: Timer?
+    private var url: URL
+
+    init(url: URL) {
+        self.url = url
+        super.init()
+        // Don't load anything eagerly - wait until user interaction or view is fully displayed
+    }
+
+    func loadDuration() {
+        guard duration == 0 else { return }
+
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            guard let self = self else { return }
+            do {
+                let player = try AVAudioPlayer(contentsOf: self.url)
+                let loadedDuration = player.duration
+                DispatchQueue.main.async { [weak self] in
+                    guard let self = self, self.duration == 0 else { return }
+                    self.duration = loadedDuration
+                }
+            } catch {
+                SecureLogger.error("Failed to load audio duration: \(error)", category: .session)
+            }
+        }
+    }
+
+    deinit {
+        timer?.invalidate()
+    }
+
+    func replaceURL(_ url: URL) {
+        guard url != self.url else { return }
+        stop()
+        self.url = url
+        player = nil
+        duration = 0
+        // Duration will be loaded on demand when needed
+    }
+
+    func togglePlayback() {
+        isPlaying ? pause() : play()
+    }
+
+    func play() {
+        guard ensurePlayerReady() else { return }
+        VoiceNotePlaybackCoordinator.shared.activate(self)
+        player?.play()
+        startTimer()
+        updateProgress()
+        isPlaying = true
+    }
+
+    func pause() {
+        player?.pause()
+        stopTimer()
+        updateProgress()
+        isPlaying = false
+    }
+
+    func stop() {
+        player?.stop()
+        player?.currentTime = 0
+        stopTimer()
+        updateProgress()
+        isPlaying = false
+        VoiceNotePlaybackCoordinator.shared.deactivate(self)
+    }
+
+    func seek(to fraction: Double) {
+        guard ensurePlayerReady() else { return }
+        let clamped = max(0, min(1, fraction))
+        if let player = player {
+            player.currentTime = clamped * player.duration
+            if isPlaying {
+                player.play()
+            }
+            updateProgress()
+        }
+    }
+
+    // MARK: - AVAudioPlayerDelegate
+
+    func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
+        // Delegate callback may be on background thread - ensure main thread for UI updates
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.stopTimer()
+            self.updateProgress()
+            self.isPlaying = false
+            VoiceNotePlaybackCoordinator.shared.deactivate(self)
+        }
+    }
+
+    // MARK: - Private Helpers
+
+    private func preparePlayer(for url: URL) {
+        // Prepare player synchronously (only called when playback is requested)
+        do {
+            let player = try AVAudioPlayer(contentsOf: url)
+            player.delegate = self
+            player.prepareToPlay()
+            self.player = player
+            duration = player.duration
+            currentTime = player.currentTime
+            progress = duration > 0 ? currentTime / duration : 0
+        } catch {
+            SecureLogger.error("Voice note playback failed for \(url.lastPathComponent): \(error)", category: .session)
+            player = nil
+            duration = 0
+            currentTime = 0
+            progress = 0
+        }
+    }
+
+    private func ensurePlayerReady() -> Bool {
+        if player == nil {
+            preparePlayer(for: url)
+        }
+        #if os(iOS)
+        let session = AVAudioSession.sharedInstance()
+        do {
+            try session.setCategory(.playback, mode: .spokenAudio, options: [.mixWithOthers])
+            try session.setActive(true, options: [])
+        } catch {
+            SecureLogger.error("Failed to activate audio session: \(error)", category: .session)
+        }
+        #endif
+        return player != nil
+    }
+
+    private func startTimer() {
+        if timer != nil { return }
+        timer = Timer.scheduledTimer(withTimeInterval: 0.05, repeats: true) { [weak self] _ in
+            self?.updateProgress()
+        }
+        if let timer = timer {
+            RunLoop.main.add(timer, forMode: .common)
+        }
+    }
+
+    private func stopTimer() {
+        timer?.invalidate()
+        timer = nil
+    }
+
+    private func updateProgress() {
+        guard let player = player else {
+            currentTime = 0
+            duration = 0
+            progress = 0
+            return
+        }
+        currentTime = player.currentTime
+        duration = player.duration
+        progress = duration > 0 ? currentTime / duration : 0
+    }
+}
+
+/// Ensures only one voice note plays at a time.
+final class VoiceNotePlaybackCoordinator {
+    static let shared = VoiceNotePlaybackCoordinator()
+
+    private weak var activeController: VoiceNotePlaybackController?
+
+    private init() {}
+
+    func activate(_ controller: VoiceNotePlaybackController) {
+        if activeController === controller {
+            return
+        }
+        activeController?.pause()
+        activeController = controller
+    }
+
+    func deactivate(_ controller: VoiceNotePlaybackController) {
+        if activeController === controller {
+            activeController = nil
+        }
+    }
+}

bitchat/Features/voice/VoiceRecorder.swift

@@ -0,0 +1,170 @@
+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.
+final class VoiceRecorder: NSObject, AVAudioRecorderDelegate {
+    enum RecorderError: Error {
+        case microphoneAccessDenied
+        case recorderInitializationFailed
+        case recordingInProgress
+    }
+
+    static let shared = VoiceRecorder()
+
+    private let queue = DispatchQueue(label: "com.bitchat.voice-recorder")
+    private let paddingInterval: TimeInterval = 0.5
+    private let maxRecordingDuration: TimeInterval = 120
+
+    private var recorder: AVAudioRecorder?
+    private var currentURL: URL?
+    private var stopWorkItem: DispatchWorkItem?
+
+    private override init() {
+        super.init()
+    }
+
+    // MARK: - Permissions
+
+    @discardableResult
+    func requestPermission() async -> Bool {
+        #if os(iOS)
+        return await withCheckedContinuation { continuation in
+            AVAudioSession.sharedInstance().requestRecordPermission { granted in
+                continuation.resume(returning: granted)
+            }
+        }
+        #elseif os(macOS)
+        return await withCheckedContinuation { continuation in
+            AVCaptureDevice.requestAccess(for: .audio) { granted in
+                continuation.resume(returning: granted)
+            }
+        }
+        #else
+        return true
+        #endif
+    }
+
+    // MARK: - Recording Lifecycle
+
+    func startRecording() throws -> URL {
+        try queue.sync {
+            if recorder?.isRecording == true {
+                throw RecorderError.recordingInProgress
+            }
+
+            #if os(iOS)
+            let session = AVAudioSession.sharedInstance()
+            guard session.recordPermission == .granted else {
+                throw RecorderError.microphoneAccessDenied
+            }
+            try session.setCategory(
+                .playAndRecord,
+                mode: .default,
+                options: [.defaultToSpeaker, .allowBluetoothA2DP, .allowBluetoothHFP]
+            )
+            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
+        }
+    }
+
+    func stopRecording(completion: @escaping (URL?) -> Void) {
+        queue.async { [weak self] in
+            guard let self = self, let recorder = self.recorder, recorder.isRecording else {
+                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)
+        }
+    }
+
+    func cancelRecording() {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            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
+        }
+    }
+
+    // MARK: - Metering
+
+    func currentAveragePower() -> Float {
+        queue.sync {
+            recorder?.updateMeters()
+            return recorder?.averagePower(forChannel: 0) ?? -160
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func makeOutputURL() throws -> URL {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyyMMdd_HHmmss"
+        let fileName = "voice_\(formatter.string(from: Date())).m4a"
+
+        let baseDirectory = try applicationFilesDirectory().appendingPathComponent("voicenotes/outgoing", isDirectory: true)
+        try FileManager.default.createDirectory(at: baseDirectory, withIntermediateDirectories: true, attributes: nil)
+        return baseDirectory.appendingPathComponent(fileName)
+    }
+
+    private func applicationFilesDirectory() throws -> URL {
+        #if os(iOS)
+        return try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+            .appendingPathComponent("files", isDirectory: true)
+        #else
+        let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+        return base.appendingPathComponent("files", isDirectory: true)
+        #endif
+    }
+
+    private func cleanupSession() {
+        #if os(iOS)
+        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+        #endif
+    }
+}

bitchat/Features/voice/Waveform.swift

@@ -0,0 +1,113 @@
+import AVFoundation
+import Foundation
+import BitLogger
+
+/// Generates and caches downsampled waveforms for audio files so UI rendering is cheap.
+final class WaveformCache {
+    static let shared = WaveformCache()
+
+    private let queue = DispatchQueue(label: "com.bitchat.waveform-cache", attributes: .concurrent)
+    private var cache: [URL: (waveform: [Float], lastAccess: Date)] = [:]
+    private let maxCacheSize = 20  // Limit cache to prevent unbounded memory growth
+
+    private init() {}
+
+    func cachedWaveform(for url: URL) -> [Float]? {
+        queue.sync {
+            guard let entry = cache[url] else { return nil }
+            return entry.waveform
+        }
+    }
+
+    func waveform(for url: URL, bins: Int = 120, completion: @escaping ([Float]) -> Void) {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+
+            // Check cache (read-only, no update needed on cache hit for performance)
+            if let entry = self.cache[url] {
+                DispatchQueue.main.async { completion(entry.waveform) }
+                return
+            }
+
+            guard let computed = self.computeWaveform(url: url, bins: bins) else {
+                DispatchQueue.main.async { completion([]) }
+                return
+            }
+
+            self.queue.async(flags: .barrier) { [weak self] in
+                guard let self = self else { return }
+
+                // Evict oldest entry if cache is full
+                if self.cache.count >= self.maxCacheSize {
+                    if let oldest = self.cache.min(by: { $0.value.lastAccess < $1.value.lastAccess }) {
+                        self.cache.removeValue(forKey: oldest.key)
+                    }
+                }
+
+                self.cache[url] = (computed, Date())
+            }
+            DispatchQueue.main.async { completion(computed) }
+        }
+    }
+
+    func purge(url: URL) {
+        queue.async(flags: .barrier) { [weak self] in
+            self?.cache.removeValue(forKey: url)
+        }
+    }
+
+    func purgeAll() {
+        queue.async(flags: .barrier) { [weak self] in
+            self?.cache.removeAll()
+        }
+    }
+
+    private func computeWaveform(url: URL, bins: Int) -> [Float]? {
+        guard bins > 0 else { return nil }
+        // Use autoreleasepool to manage memory from audio buffer allocations
+        return autoreleasepool {
+            do {
+                let audioFile = try AVAudioFile(forReading: url)
+                let length = Int(audioFile.length)
+                guard length > 0 else { return nil }
+
+                guard let buffer = AVAudioPCMBuffer(pcmFormat: audioFile.processingFormat, frameCapacity: AVAudioFrameCount(length)) else {
+                    return nil
+                }
+                try audioFile.read(into: buffer, frameCount: AVAudioFrameCount(length))
+                guard let channelData = buffer.floatChannelData else { return nil }
+
+                let channelCount = Int(audioFile.processingFormat.channelCount)
+                let frameLength = Int(buffer.frameLength)
+                let samplesPerBin = max(1, frameLength / bins)
+
+                var magnitudes: [Float] = Array(repeating: 0, count: bins)
+                for bin in 0..<bins {
+                    let start = bin * samplesPerBin
+                    let end = min(frameLength, start + samplesPerBin)
+                    if start >= end { break }
+
+                    var sum: Float = 0
+                    var sampleCount = 0
+                    for frame in start..<end {
+                        var sampleValue: Float = 0
+                        for channel in 0..<channelCount {
+                            sampleValue += fabsf(channelData[channel][frame])
+                        }
+                        sum += sampleValue / Float(channelCount)
+                        sampleCount += 1
+                    }
+                    magnitudes[bin] = sampleCount > 0 ? sum / Float(sampleCount) : 0
+                }
+
+                if let maxMagnitude = magnitudes.max(), maxMagnitude > 0 {
+                    magnitudes = magnitudes.map { min($0 / maxMagnitude, 1.0) }
+                }
+                return magnitudes
+            } catch {
+                SecureLogger.error("Waveform extraction failed for \(url.lastPathComponent): \(error)", category: .session)
+                return nil
+            }
+        }
+    }
+}

bitchat/Info.plist

@@ -37,6 +37,10 @@
 	<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>UIBackgroundModes</key>

bitchat/Models/BitchatMessage.swift

@@ -335,20 +335,6 @@ extension BitchatMessage {
     }
 }
 
-// MARK: - System Message Factory
-
-extension BitchatMessage {
-    /// Creates a system message with default values
-    static func system(_ content: String, timestamp: Date = Date()) -> BitchatMessage {
-        return BitchatMessage(
-            sender: "system",
-            content: content,
-            timestamp: timestamp,
-            isRelay: false
-        )
-    }
-}
-
 extension Array where Element == BitchatMessage {
     /// Filters out empty ones and deduplicate by ID while preserving order (from oldest to newest)
     func cleanedAndDeduped() -> [Element] {

bitchat/Models/BitchatPacket.swift

@@ -21,9 +21,10 @@ struct BitchatPacket: Codable {
     let payload: Data
     var signature: Data?
     var ttl: UInt8
+    var route: [Data]?
     
-    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8) {
+    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8, version: UInt8 = 1, route: [Data]? = nil) {
-        self.version = 1
+        self.version = version
         self.type = type
         self.senderID = senderID
         self.recipientID = recipientID
@@ -31,6 +32,7 @@ struct BitchatPacket: Codable {
         self.payload = payload
         self.signature = signature
         self.ttl = ttl
+        self.route = route
     }
     
     // Convenience initializer for new binary format
@@ -53,6 +55,7 @@ struct BitchatPacket: Codable {
         self.payload = payload
         self.signature = nil
         self.ttl = ttl
+        self.route = nil
     }
     
     var data: Data? {
@@ -80,7 +83,9 @@ struct BitchatPacket: Codable {
             timestamp: timestamp,
             payload: payload,
             signature: nil, // Remove signature for signing
-            ttl: 0 // Use fixed TTL=0 for signing to ensure relay compatibility
+            ttl: 0, // Use fixed TTL=0 for signing to ensure relay compatibility
+            version: version,
+            route: route
         )
         return BinaryProtocol.encode(unsignedPacket)
     }

bitchat/Models/CommandInfo.swift

@@ -0,0 +1,58 @@
+//
+// CommandsInfo.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+// MARK: - CommandInfo Enum
+
+enum CommandInfo: String, Identifiable {
+    case block
+    case clear
+    case hug
+    case message = "dm"
+    case slap
+    case unblock
+    case who
+    case favorite
+    case unfavorite
+    
+    var id: String { rawValue }
+    
+    var alias: String { "/" + rawValue }
+    
+    var placeholder: String? {
+        switch self {
+        case .block, .hug, .message, .slap, .unblock, .favorite, .unfavorite:
+            return "<" + String(localized: "content.input.nickname_placeholder") + ">"
+        case .clear, .who:
+            return nil
+        }
+    }
+    
+    var description: String {
+        switch self {
+        case .block:        String(localized: "content.commands.block")
+        case .clear:        String(localized: "content.commands.clear")
+        case .hug:          String(localized: "content.commands.hug")
+        case .message:      String(localized: "content.commands.message")
+        case .slap:         String(localized: "content.commands.slap")
+        case .unblock:      String(localized: "content.commands.unblock")
+        case .who:          String(localized: "content.commands.who")
+        case .favorite:     String(localized: "content.commands.favorite")
+        case .unfavorite:   String(localized: "content.commands.unfavorite")
+        }
+    }
+    
+    static func all(isGeoPublic: Bool, isGeoDM: Bool) -> [CommandInfo] {
+        let baseCommands: [CommandInfo] = [.block, .unblock, .clear, .hug, .message, .slap, .who]
+        if isGeoPublic || isGeoDM {
+            return baseCommands + [.favorite, .unfavorite]
+        }
+        return baseCommands
+    }
+}

bitchat/Models/GeoPerson.swift

@@ -1,16 +0,0 @@
-//
-// GeoPerson.swift
-// bitchat
-//
-// Model representing a participant in a geohash channel
-// This is free and unencumbered software released into the public domain.
-//
-
-import Foundation
-
-/// Represents a person participating in a geohash-based location channel
-struct GeoPerson: Identifiable, Equatable {
-    let id: String        // pubkey hex (lowercased)
-    let displayName: String
-    let lastSeen: Date
-}

bitchat/Models/PeerID.swift

@@ -35,7 +35,7 @@ struct PeerID: Equatable, Hashable {
     // Private so the callers have to go through a convenience init
     private init(prefix: Prefix, bare: any StringProtocol) {
         self.prefix = prefix
-        self.bare = String(bare)
+        self.bare = String(bare).lowercased()
     }
 }
 
@@ -76,6 +76,12 @@ extension PeerID {
     init(hexData: Data) {
         self.init(str: hexData.hexEncodedString())
     }
+    
+    /// Convenience init to "hide" hex-encoding implementation detail
+    init?(hexData: Data?) {
+        guard let hexData else { return nil }
+        self.init(hexData: hexData)
+    }
 }
 
 // MARK: - Noise Public Key Helpers
@@ -130,6 +136,20 @@ extension PeerID {
     }
 }
 
+extension PeerID {
+    var routingData: Data? {
+        if let direct = Data(hexString: id), direct.count == 8 { return direct }
+        if let bareData = Data(hexString: bare), bareData.count == 8 { return bareData }
+        let short = toShort()
+        return Data(hexString: short.id)
+    }
+
+    init?(routingData: Data) {
+        guard routingData.count == 8 else { return nil }
+        self.init(hexData: routingData)
+    }
+}
+
 // MARK: - Validation
 
 extension PeerID {
@@ -161,9 +181,14 @@ extension PeerID {
                 id.rangeOfCharacter(from: validCharset.inverted) == nil
     }
     
+    /// Returns true if the `bare` id is all hex
+    var isHex: Bool {
+        bare.allSatisfy { $0.isHexDigit }
+    }
+    
     /// Short routing IDs (exact 16-hex)
     var isShort: Bool {
-        bare.count == Constants.hexIDLength && Data(hexString: bare) != nil
+        bare.count == Constants.hexIDLength && isHex
     }
     
     /// Full Noise key hex (exact 64-hex)
@@ -186,9 +211,7 @@ extension PeerID: Comparable {
     }
 }
 
-// MARK: - String Interop Helpers
+// MARK: - CustomStringConvertible
-
-// MARK: CustomStringConvertible
 
 extension PeerID: CustomStringConvertible {
     /// So it returns the actual `id` like before even inside another String
@@ -196,17 +219,3 @@ extension PeerID: CustomStringConvertible {
         id
     }
 }
-
-// MARK: Custom Equatable w/ String & Optionality
-
-// PeerID <> String
-extension Optional where Wrapped == PeerID {
-    static func ==(lhs: Optional<Wrapped>, rhs: Optional<String>) -> Bool   { lhs?.id == rhs }
-    static func !=(lhs: Optional<Wrapped>, rhs: Optional<String>) -> Bool   { lhs?.id != rhs }
-}
-
-// String <> PeerID
-extension Optional where Wrapped == String {
-    static func ==(lhs: Optional<Wrapped>, rhs: Optional<PeerID>) -> Bool   { lhs == rhs?.id }
-    static func !=(lhs: Optional<Wrapped>, rhs: Optional<PeerID>) -> Bool   { lhs != rhs?.id }
-}

bitchat/Models/ReadReceipt.swift

@@ -11,11 +11,11 @@ import Foundation
 struct ReadReceipt: Codable {
     let originalMessageID: String
     let receiptID: String
-    var readerID: String  // Who read it
+    var readerID: PeerID  // Who read it
     let readerNickname: String
     let timestamp: Date
     
-    init(originalMessageID: String, readerID: String, readerNickname: String) {
+    init(originalMessageID: String, readerID: PeerID, readerNickname: String) {
         self.originalMessageID = originalMessageID
         self.receiptID = UUID().uuidString
         self.readerID = readerID
@@ -24,7 +24,7 @@ struct ReadReceipt: Codable {
     }
     
     // For binary decoding
-    private init(originalMessageID: String, receiptID: String, readerID: String, readerNickname: String, timestamp: Date) {
+    private init(originalMessageID: String, receiptID: String, readerID: PeerID, readerNickname: String, timestamp: Date) {
         self.originalMessageID = originalMessageID
         self.receiptID = receiptID
         self.readerID = readerID
@@ -48,7 +48,7 @@ struct ReadReceipt: Codable {
         data.appendUUID(receiptID)
         // ReaderID as 8-byte hex string
         var readerData = Data()
-        var tempID = readerID
+        var tempID = readerID.id
         while tempID.count >= 2 && readerData.count < 8 {
             let hexByte = String(tempID.prefix(2))
             if let byte = UInt8(hexByte, radix: 16) {
@@ -78,8 +78,8 @@ struct ReadReceipt: Codable {
               let receiptID = dataCopy.readUUID(at: &offset) else { return nil }
         
         guard let readerIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
-        let readerID = readerIDData.hexEncodedString()
+        let readerID = PeerID(hexData: readerIDData)
-        guard PeerID(str: readerID).isValid else { return nil }
+        guard readerID.isValid else { return nil }
         
         guard let timestamp = dataCopy.readDate(at: &offset),
               InputValidator.validateTimestamp(timestamp),

bitchat/Models/RequestSyncPacket.swift

@@ -8,6 +8,14 @@ struct RequestSyncPacket {
     let p: Int
     let m: UInt32
     let data: Data
+    let types: SyncTypeFlags?
+
+    init(p: Int, m: UInt32, data: Data, types: SyncTypeFlags? = nil) {
+        self.p = p
+        self.m = m
+        self.data = data
+        self.types = types
+    }
 
     func encode() -> Data {
         var out = Data()
@@ -25,6 +33,9 @@ struct RequestSyncPacket {
         putTLV(0x02, withUnsafeBytes(of: &mBE) { Data($0) })
         // data
         putTLV(0x03, data)
+        if let typesData = types?.toData() {
+            putTLV(0x04, typesData)
+        }
         return out
     }
 
@@ -33,6 +44,7 @@ struct RequestSyncPacket {
         var p: Int? = nil
         var m: UInt32? = nil
         var payload: Data? = nil
+        var types: SyncTypeFlags? = nil
 
         while off + 3 <= data.count {
             let t = Int(data[off]); off += 1
@@ -52,12 +64,16 @@ struct RequestSyncPacket {
             case 0x03:
                 if v.count > maxAcceptBytes { return nil }
                 payload = v
+            case 0x04:
+                if let decoded = SyncTypeFlags.decode(v) {
+                    types = decoded
+                }
             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)
+        return RequestSyncPacket(p: pp, m: mm, data: dd, types: types)
     }
 }

bitchat/Noise/NoiseProtocol.swift

@@ -767,7 +767,7 @@ final class NoiseHandshakeState {
             let shared = try localStatic.sharedSecretFromKeyAgreement(with: remoteStatic)
             symmetricState.mixKey(shared.withUnsafeBytes { Data($0) })
             
-        default:
+        case .e, .s:
             break
         }
     }

bitchat/Noise/NoiseRateLimiter.swift

@@ -0,0 +1,95 @@
+//
+// NoiseRateLimiter.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import BitLogger
+import Foundation
+
+final class NoiseRateLimiter {
+    private var handshakeTimestamps: [PeerID: [Date]] = [:]
+    private var messageTimestamps: [PeerID: [Date]] = [:]
+    
+    // Global rate limiting
+    private var globalHandshakeTimestamps: [Date] = []
+    private var globalMessageTimestamps: [Date] = []
+    
+    private let queue = DispatchQueue(label: "chat.bitchat.noise.ratelimit", attributes: .concurrent)
+    
+    func allowHandshake(from peerID: PeerID) -> Bool {
+        return queue.sync(flags: .barrier) {
+            let now = Date()
+            let oneMinuteAgo = now.addingTimeInterval(-60)
+            
+            // Check global rate limit first
+            globalHandshakeTimestamps = globalHandshakeTimestamps.filter { $0 > oneMinuteAgo }
+            if globalHandshakeTimestamps.count >= NoiseSecurityConstants.maxGlobalHandshakesPerMinute {
+                SecureLogger.warning("Global handshake rate limit exceeded: \(globalHandshakeTimestamps.count)/\(NoiseSecurityConstants.maxGlobalHandshakesPerMinute) per minute", category: .security)
+                return false
+            }
+            
+            // Check per-peer rate limit
+            var timestamps = handshakeTimestamps[peerID] ?? []
+            timestamps = timestamps.filter { $0 > oneMinuteAgo }
+            
+            if timestamps.count >= NoiseSecurityConstants.maxHandshakesPerMinute {
+                SecureLogger.warning("Per-peer handshake rate limit exceeded for \(peerID): \(timestamps.count)/\(NoiseSecurityConstants.maxHandshakesPerMinute) per minute", category: .security)
+                return false
+            }
+            
+            // Record new handshake
+            timestamps.append(now)
+            handshakeTimestamps[peerID] = timestamps
+            globalHandshakeTimestamps.append(now)
+            return true
+        }
+    }
+    
+    func allowMessage(from peerID: PeerID) -> Bool {
+        return queue.sync(flags: .barrier) {
+            let now = Date()
+            let oneSecondAgo = now.addingTimeInterval(-1)
+            
+            // Check global rate limit first
+            globalMessageTimestamps = globalMessageTimestamps.filter { $0 > oneSecondAgo }
+            if globalMessageTimestamps.count >= NoiseSecurityConstants.maxGlobalMessagesPerSecond {
+                SecureLogger.warning("Global message rate limit exceeded: \(globalMessageTimestamps.count)/\(NoiseSecurityConstants.maxGlobalMessagesPerSecond) per second", category: .security)
+                return false
+            }
+            
+            // Check per-peer rate limit
+            var timestamps = messageTimestamps[peerID] ?? []
+            timestamps = timestamps.filter { $0 > oneSecondAgo }
+            
+            if timestamps.count >= NoiseSecurityConstants.maxMessagesPerSecond {
+                SecureLogger.warning("Per-peer message rate limit exceeded for \(peerID): \(timestamps.count)/\(NoiseSecurityConstants.maxMessagesPerSecond) per second", category: .security)
+                return false
+            }
+            
+            // Record new message
+            timestamps.append(now)
+            messageTimestamps[peerID] = timestamps
+            globalMessageTimestamps.append(now)
+            return true
+        }
+    }
+    
+    func reset(for peerID: PeerID) {
+        queue.async(flags: .barrier) {
+            self.handshakeTimestamps.removeValue(forKey: peerID)
+            self.messageTimestamps.removeValue(forKey: peerID)
+        }
+    }
+
+    func resetAll() {
+        queue.async(flags: .barrier) {
+            self.handshakeTimestamps.removeAll()
+            self.messageTimestamps.removeAll()
+            self.globalHandshakeTimestamps.removeAll()
+            self.globalMessageTimestamps.removeAll()
+        }
+    }
+}

bitchat/Noise/NoiseSecurityConsiderations.swift

@@ -1,227 +0,0 @@
-//
-// NoiseSecurityConsiderations.swift
-// bitchat
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import BitLogger
-import Foundation
-
-// MARK: - Security Constants
-
-enum NoiseSecurityConstants {
-    // Maximum message size to prevent memory exhaustion
-    static let maxMessageSize = 65535 // 64KB as per Noise spec
-    
-    // Maximum handshake message size
-    static let maxHandshakeMessageSize = 2048 // 2KB to accommodate XX pattern
-    
-    // Session timeout - sessions older than this should be renegotiated
-    static let sessionTimeout: TimeInterval = 86400 // 24 hours
-    
-    // Maximum number of messages before rekey (2^64 - 1 is the nonce limit)
-    static let maxMessagesPerSession: UInt64 = 1_000_000_000 // 1 billion messages
-    
-    // Handshake timeout - abandon incomplete handshakes
-    static let handshakeTimeout: TimeInterval = 60 // 1 minute
-    
-    // Maximum concurrent sessions per peer
-    static let maxSessionsPerPeer = 3
-    
-    // Rate limiting
-    static let maxHandshakesPerMinute = 10
-    static let maxMessagesPerSecond = 100
-    
-    // Global rate limiting (across all peers)
-    static let maxGlobalHandshakesPerMinute = 30
-    static let maxGlobalMessagesPerSecond = 500
-}
-
-// MARK: - Security Validations
-
-struct NoiseSecurityValidator {
-    
-    /// Validate message size
-    static func validateMessageSize(_ data: Data) -> Bool {
-        return data.count <= NoiseSecurityConstants.maxMessageSize
-    }
-    
-    /// Validate handshake message size
-    static func validateHandshakeMessageSize(_ data: Data) -> Bool {
-        return data.count <= NoiseSecurityConstants.maxHandshakeMessageSize
-    }
-}
-
-// MARK: - Enhanced Noise Session with Security
-
-final class SecureNoiseSession: NoiseSession {
-    private(set) var messageCount: UInt64 = 0
-    private let sessionStartTime = Date()
-    private(set) var lastActivityTime = Date()
-    
-    override func encrypt(_ plaintext: Data) throws -> Data {
-        // Check session age
-        if Date().timeIntervalSince(sessionStartTime) > NoiseSecurityConstants.sessionTimeout {
-            throw NoiseSecurityError.sessionExpired
-        }
-        
-        // Check message count
-        if messageCount >= NoiseSecurityConstants.maxMessagesPerSession {
-            throw NoiseSecurityError.sessionExhausted
-        }
-        
-        // Validate message size
-        guard NoiseSecurityValidator.validateMessageSize(plaintext) else {
-            throw NoiseSecurityError.messageTooLarge
-        }
-        
-        let encrypted = try super.encrypt(plaintext)
-        messageCount += 1
-        lastActivityTime = Date()
-        
-        return encrypted
-    }
-    
-    override func decrypt(_ ciphertext: Data) throws -> Data {
-        // Check session age
-        if Date().timeIntervalSince(sessionStartTime) > NoiseSecurityConstants.sessionTimeout {
-            throw NoiseSecurityError.sessionExpired
-        }
-        
-        // Validate message size
-        guard NoiseSecurityValidator.validateMessageSize(ciphertext) else {
-            throw NoiseSecurityError.messageTooLarge
-        }
-        
-        let decrypted = try super.decrypt(ciphertext)
-        lastActivityTime = Date()
-        
-        return decrypted
-    }
-    
-    func needsRenegotiation() -> Bool {
-        // Check if we've used more than 90% of message limit
-        let messageThreshold = UInt64(Double(NoiseSecurityConstants.maxMessagesPerSession) * 0.9)
-        if messageCount >= messageThreshold {
-            return true
-        }
-        
-        // Check if last activity was more than 30 minutes ago
-        if Date().timeIntervalSince(lastActivityTime) > NoiseSecurityConstants.sessionTimeout {
-            return true
-        }
-        
-        return false
-    }
-    
-    // MARK: - Testing Support
-    #if DEBUG
-    func setLastActivityTimeForTesting(_ date: Date) {
-        lastActivityTime = date
-    }
-    
-    func setMessageCountForTesting(_ count: UInt64) {
-        messageCount = count
-    }
-    #endif
-}
-
-// MARK: - Rate Limiter
-
-final class NoiseRateLimiter {
-    private var handshakeTimestamps: [PeerID: [Date]] = [:]
-    private var messageTimestamps: [PeerID: [Date]] = [:]
-    
-    // Global rate limiting
-    private var globalHandshakeTimestamps: [Date] = []
-    private var globalMessageTimestamps: [Date] = []
-    
-    private let queue = DispatchQueue(label: "chat.bitchat.noise.ratelimit", attributes: .concurrent)
-    
-    func allowHandshake(from peerID: PeerID) -> Bool {
-        return queue.sync(flags: .barrier) {
-            let now = Date()
-            let oneMinuteAgo = now.addingTimeInterval(-60)
-            
-            // Check global rate limit first
-            globalHandshakeTimestamps = globalHandshakeTimestamps.filter { $0 > oneMinuteAgo }
-            if globalHandshakeTimestamps.count >= NoiseSecurityConstants.maxGlobalHandshakesPerMinute {
-                SecureLogger.warning("Global handshake rate limit exceeded: \(globalHandshakeTimestamps.count)/\(NoiseSecurityConstants.maxGlobalHandshakesPerMinute) per minute", category: .security)
-                return false
-            }
-            
-            // Check per-peer rate limit
-            var timestamps = handshakeTimestamps[peerID] ?? []
-            timestamps = timestamps.filter { $0 > oneMinuteAgo }
-            
-            if timestamps.count >= NoiseSecurityConstants.maxHandshakesPerMinute {
-                SecureLogger.warning("Per-peer handshake rate limit exceeded for \(peerID): \(timestamps.count)/\(NoiseSecurityConstants.maxHandshakesPerMinute) per minute", category: .security)
-                return false
-            }
-            
-            // Record new handshake
-            timestamps.append(now)
-            handshakeTimestamps[peerID] = timestamps
-            globalHandshakeTimestamps.append(now)
-            return true
-        }
-    }
-    
-    func allowMessage(from peerID: PeerID) -> Bool {
-        return queue.sync(flags: .barrier) {
-            let now = Date()
-            let oneSecondAgo = now.addingTimeInterval(-1)
-            
-            // Check global rate limit first
-            globalMessageTimestamps = globalMessageTimestamps.filter { $0 > oneSecondAgo }
-            if globalMessageTimestamps.count >= NoiseSecurityConstants.maxGlobalMessagesPerSecond {
-                SecureLogger.warning("Global message rate limit exceeded: \(globalMessageTimestamps.count)/\(NoiseSecurityConstants.maxGlobalMessagesPerSecond) per second", category: .security)
-                return false
-            }
-            
-            // Check per-peer rate limit
-            var timestamps = messageTimestamps[peerID] ?? []
-            timestamps = timestamps.filter { $0 > oneSecondAgo }
-            
-            if timestamps.count >= NoiseSecurityConstants.maxMessagesPerSecond {
-                SecureLogger.warning("Per-peer message rate limit exceeded for \(peerID): \(timestamps.count)/\(NoiseSecurityConstants.maxMessagesPerSecond) per second", category: .security)
-                return false
-            }
-            
-            // Record new message
-            timestamps.append(now)
-            messageTimestamps[peerID] = timestamps
-            globalMessageTimestamps.append(now)
-            return true
-        }
-    }
-    
-    func reset(for peerID: PeerID) {
-        queue.async(flags: .barrier) {
-            self.handshakeTimestamps.removeValue(forKey: peerID)
-            self.messageTimestamps.removeValue(forKey: peerID)
-        }
-    }
-
-    func resetAll() {
-        queue.async(flags: .barrier) {
-            self.handshakeTimestamps.removeAll()
-            self.messageTimestamps.removeAll()
-            self.globalHandshakeTimestamps.removeAll()
-            self.globalMessageTimestamps.removeAll()
-        }
-    }
-}
-
-// MARK: - Security Errors
-
-enum NoiseSecurityError: Error {
-    case sessionExpired
-    case sessionExhausted
-    case messageTooLarge
-    case invalidPeerID
-    case rateLimitExceeded
-    case handshakeTimeout
-}

bitchat/Noise/NoiseSecurityConstants.swift

@@ -0,0 +1,37 @@
+//
+// NoiseSecurityConstants.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+enum NoiseSecurityConstants {
+    // Maximum message size to prevent memory exhaustion
+    static let maxMessageSize = 65535 // 64KB as per Noise spec
+    
+    // Maximum handshake message size
+    static let maxHandshakeMessageSize = 2048 // 2KB to accommodate XX pattern
+    
+    // Session timeout - sessions older than this should be renegotiated
+    static let sessionTimeout: TimeInterval = 86400 // 24 hours
+    
+    // Maximum number of messages before rekey (2^64 - 1 is the nonce limit)
+    static let maxMessagesPerSession: UInt64 = 1_000_000_000 // 1 billion messages
+    
+    // Handshake timeout - abandon incomplete handshakes
+    static let handshakeTimeout: TimeInterval = 60 // 1 minute
+    
+    // Maximum concurrent sessions per peer
+    static let maxSessionsPerPeer = 3
+    
+    // Rate limiting
+    static let maxHandshakesPerMinute = 10
+    static let maxMessagesPerSecond = 100
+    
+    // Global rate limiting (across all peers)
+    static let maxGlobalHandshakesPerMinute = 30
+    static let maxGlobalMessagesPerSecond = 500
+}

bitchat/Noise/NoiseSecurityError.swift

@@ -0,0 +1,18 @@
+//
+// NoiseSecurityError.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+enum NoiseSecurityError: Error {
+    case sessionExpired
+    case sessionExhausted
+    case messageTooLarge
+    case invalidPeerID
+    case rateLimitExceeded
+    case handshakeTimeout
+}

bitchat/Noise/NoiseSecurityValidator.swift

@@ -0,0 +1,22 @@
+//
+// NoiseSecurityValidator.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+struct NoiseSecurityValidator {
+    
+    /// Validate message size
+    static func validateMessageSize(_ data: Data) -> Bool {
+        return data.count <= NoiseSecurityConstants.maxMessageSize
+    }
+    
+    /// Validate handshake message size
+    static func validateHandshakeMessageSize(_ data: Data) -> Bool {
+        return data.count <= NoiseSecurityConstants.maxHandshakeMessageSize
+    }
+}

bitchat/Noise/NoiseSession.swift

@@ -196,12 +196,6 @@ class NoiseSession {
         }
     }
     
-    func getHandshakeHash() -> Data? {
-        return sessionQueue.sync {
-            return handshakeHash
-        }
-    }
-    
     func reset() {
         sessionQueue.sync(flags: .barrier) {
             let wasEstablished = state == .established

bitchat/Noise/NoiseSessionError.swift

@@ -6,10 +6,9 @@
 // For more information, see <https://unlicense.org>
 //
 
-enum NoiseSessionError: Error {
+enum NoiseSessionError: Error, Equatable {
     case invalidState
     case notEstablished
     case sessionNotFound
-    case handshakeFailed(Error)
     case alreadyEstablished
 }

bitchat/Noise/NoiseSessionManager.swift

@@ -27,19 +27,6 @@ final class NoiseSessionManager {
     
     // MARK: - Session Management
     
-    func createSession(for peerID: PeerID, role: NoiseRole) -> NoiseSession {
-        return managerQueue.sync(flags: .barrier) {
-            let session = SecureNoiseSession(
-                peerID: peerID,
-                role: role,
-                keychain: keychain,
-                localStaticKey: localStaticKey
-            )
-            sessions[peerID] = session
-            return session
-        }
-    }
-    
     func getSession(for peerID: PeerID) -> NoiseSession? {
         return managerQueue.sync {
             return sessions[peerID]
@@ -48,14 +35,9 @@ final class NoiseSessionManager {
     
     func removeSession(for peerID: PeerID) {
         managerQueue.sync(flags: .barrier) {
-            if let session = sessions[peerID] {
+            if let session = sessions.removeValue(forKey: peerID) {
-                if session.isEstablished() {
+                session.reset() // Clear sensitive data before removing
-                    SecureLogger.info(.sessionExpired(peerID: peerID.id))
-                }
-                // Clear sensitive data before removing
-                session.reset()
             }
-            _ = sessions.removeValue(forKey: peerID)
         }
     }
 
@@ -68,12 +50,6 @@ final class NoiseSessionManager {
         }
     }
     
-    func getEstablishedSessions() -> [PeerID: NoiseSession] {
-        return managerQueue.sync {
-            return sessions.filter { $0.value.isEstablished() }
-        }
-    }
-    
     // MARK: - Handshake Helpers
     
     func initiateHandshake(with peerID: PeerID) throws -> Data {
@@ -207,10 +183,6 @@ final class NoiseSessionManager {
         return getSession(for: peerID)?.getRemoteStaticPublicKey()
     }
     
-    func getHandshakeHash(for peerID: PeerID) -> Data? {
-        return getSession(for: peerID)?.getHandshakeHash()
-    }
-    
     // MARK: - Session Rekeying
     
     func getSessionsNeedingRekey() -> [(peerID: PeerID, needsRekey: Bool)] {

bitchat/Noise/SecureNoiseSession.swift

@@ -0,0 +1,81 @@
+//
+// SecureNoiseSession.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+final class SecureNoiseSession: NoiseSession {
+    private(set) var messageCount: UInt64 = 0
+    private let sessionStartTime = Date()
+    private(set) var lastActivityTime = Date()
+    
+    override func encrypt(_ plaintext: Data) throws -> Data {
+        // Check session age
+        if Date().timeIntervalSince(sessionStartTime) > NoiseSecurityConstants.sessionTimeout {
+            throw NoiseSecurityError.sessionExpired
+        }
+        
+        // Check message count
+        if messageCount >= NoiseSecurityConstants.maxMessagesPerSession {
+            throw NoiseSecurityError.sessionExhausted
+        }
+        
+        // Validate message size
+        guard NoiseSecurityValidator.validateMessageSize(plaintext) else {
+            throw NoiseSecurityError.messageTooLarge
+        }
+        
+        let encrypted = try super.encrypt(plaintext)
+        messageCount += 1
+        lastActivityTime = Date()
+        
+        return encrypted
+    }
+    
+    override func decrypt(_ ciphertext: Data) throws -> Data {
+        // Check session age
+        if Date().timeIntervalSince(sessionStartTime) > NoiseSecurityConstants.sessionTimeout {
+            throw NoiseSecurityError.sessionExpired
+        }
+        
+        // Validate message size
+        guard NoiseSecurityValidator.validateMessageSize(ciphertext) else {
+            throw NoiseSecurityError.messageTooLarge
+        }
+        
+        let decrypted = try super.decrypt(ciphertext)
+        lastActivityTime = Date()
+        
+        return decrypted
+    }
+    
+    func needsRenegotiation() -> Bool {
+        // Check if we've used more than 90% of message limit
+        let messageThreshold = UInt64(Double(NoiseSecurityConstants.maxMessagesPerSession) * 0.9)
+        if messageCount >= messageThreshold {
+            return true
+        }
+        
+        // Check if last activity was more than 30 minutes ago
+        if Date().timeIntervalSince(lastActivityTime) > NoiseSecurityConstants.sessionTimeout {
+            return true
+        }
+        
+        return false
+    }
+    
+    // MARK: - Testing Support
+    #if DEBUG
+    func setLastActivityTimeForTesting(_ date: Date) {
+        lastActivityTime = date
+    }
+    
+    func setMessageCountForTesting(_ count: UInt64) {
+        messageCount = count
+    }
+    #endif
+}

bitchat/Nostr/Bech32.swift

@@ -0,0 +1,135 @@
+import Foundation
+
+/// Bech32 encoding for Nostr (minimal implementation)
+enum Bech32 {
+    private static let charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+    private static let generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+    
+    static func encode(hrp: String, data: Data) throws -> String {
+        let values = convertBits(from: 8, to: 5, pad: true, data: Array(data))
+        let checksum = createChecksum(hrp: hrp, values: values)
+        let combined = values + checksum
+        
+        return hrp + "1" + combined.map { 
+            let index = charset.index(charset.startIndex, offsetBy: Int($0))
+            return String(charset[index])
+        }.joined()
+    }
+    
+    static func decode(_ bech32String: String) throws -> (hrp: String, data: Data) {
+        // Find the last occurrence of '1'
+        guard let separatorIndex = bech32String.lastIndex(of: "1") else {
+            throw Bech32Error.invalidFormat
+        }
+        
+        let hrp = String(bech32String[..<separatorIndex])
+        
+        // Validate HRP contains only ASCII characters
+        for char in hrp {
+            guard char.asciiValue != nil else {
+                throw Bech32Error.invalidCharacter
+            }
+        }
+        
+        let dataString = String(bech32String[bech32String.index(after: separatorIndex)...])
+        
+        // Convert characters to values
+        var values = [UInt8]()
+        for char in dataString {
+            guard let index = charset.firstIndex(of: char) else {
+                throw Bech32Error.invalidCharacter
+            }
+            values.append(UInt8(charset.distance(from: charset.startIndex, to: index)))
+        }
+        
+        // Verify checksum
+        guard values.count >= 6 else {
+            throw Bech32Error.invalidChecksum
+        }
+        
+        let payloadValues = Array(values.dropLast(6))
+        let checksum = Array(values.suffix(6))
+        let expectedChecksum = createChecksum(hrp: hrp, values: payloadValues)
+        
+        guard checksum == expectedChecksum else {
+            throw Bech32Error.invalidChecksum
+        }
+        
+        // Convert back to bytes
+        let bytes = convertBits(from: 5, to: 8, pad: false, data: payloadValues)
+        return (hrp: hrp, data: Data(bytes))
+    }
+    
+    enum Bech32Error: Error {
+        case invalidFormat
+        case invalidCharacter
+        case invalidChecksum
+    }
+    
+    private static func convertBits(from: Int, to: Int, pad: Bool, data: [UInt8]) -> [UInt8] {
+        var acc = 0
+        var bits = 0
+        var result = [UInt8]()
+        let maxv = (1 << to) - 1
+        
+        for value in data {
+            acc = (acc << from) | Int(value)
+            bits += from
+            
+            while bits >= to {
+                bits -= to
+                result.append(UInt8((acc >> bits) & maxv))
+            }
+        }
+        
+        if pad && bits > 0 {
+            result.append(UInt8((acc << (to - bits)) & maxv))
+        }
+        
+        return result
+    }
+    
+    private static func createChecksum(hrp: String, values: [UInt8]) -> [UInt8] {
+        let checksumValues = hrpExpand(hrp) + values + [0, 0, 0, 0, 0, 0]
+        let polymod = polymod(checksumValues) ^ 1
+        var checksum = [UInt8]()
+        
+        for i in 0..<6 {
+            checksum.append(UInt8((polymod >> (5 * (5 - i))) & 31))
+        }
+        
+        return checksum
+    }
+    
+    private static func hrpExpand(_ hrp: String) -> [UInt8] {
+        var result = [UInt8]()
+        for c in hrp {
+            guard let asciiValue = c.asciiValue else {
+                return [] // Return empty array for invalid input
+            }
+            result.append(UInt8(asciiValue >> 5))
+        }
+        result.append(0)
+        for c in hrp {
+            guard let asciiValue = c.asciiValue else {
+                return [] // Return empty array for invalid input
+            }
+            result.append(UInt8(asciiValue & 31))
+        }
+        return result
+    }
+    
+    private static func polymod(_ values: [UInt8]) -> Int {
+        var chk = 1
+        for value in values {
+            let b = chk >> 25
+            chk = (chk & 0x1ffffff) << 5 ^ Int(value)
+            for i in 0..<5 {
+                if (b >> i) & 1 == 1 {
+                    chk ^= generator[i]
+                }
+            }
+        }
+        return chk
+    }
+}

bitchat/Nostr/GeoRelayDirectory.swift

@@ -1,6 +1,11 @@
 import BitLogger
 import Foundation
 import Tor
+#if os(iOS)
+import UIKit
+#elseif os(macOS)
+import AppKit
+#endif
 
 /// Directory of online Nostr relays with approximate GPS locations, used for geohash routing.
 @MainActor
@@ -12,19 +17,32 @@ final class GeoRelayDirectory {
     }
 
     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 fetchInterval: TimeInterval = TransportConfig.geoRelayFetchIntervalSeconds // 24h
+    private let fetchInterval: TimeInterval = TransportConfig.geoRelayFetchIntervalSeconds
+
+    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() {
-        // Load cached or bundled data synchronously
+        entries = loadLocalEntries()
-        self.entries = self.loadLocalEntries()
+        registerObservers()
-        // Fire-and-forget remote refresh if stale
+        startRefreshTimer()
         prefetchIfNeeded()
     }
 
+    deinit {
+        observers.forEach { NotificationCenter.default.removeObserver($0) }
+        refreshTimer?.invalidate()
+        retryTask?.cancel()
+    }
+
     /// Returns up to `count` relay URLs (wss://) closest to the geohash center.
     func closestRelays(toGeohash geohash: String, count: Int = 5) -> [String] {
         let center = Geohash.decodeCenter(geohash)
@@ -33,52 +51,148 @@ final class GeoRelayDirectory {
 
     /// Returns up to `count` relay URLs (wss://) closest to the given coordinate.
     func closestRelays(toLat lat: Double, lon: Double, count: Int = 5) -> [String] {
-        guard !entries.isEmpty else { return [] }
+        guard !entries.isEmpty, count > 0 else { return [] }
-        let sorted = entries
+
-            .sorted { a, b in
+        if entries.count <= count {
-                haversineKm(lat, lon, a.lat, a.lon) < haversineKm(lat, lon, b.lat, b.lon)
+            return entries
+                .sorted { a, b in
+                    haversineKm(lat, lon, a.lat, a.lon) < haversineKm(lat, lon, b.lat, b.lon)
+                }
+                .map { "wss://\($0.host)" }
+        }
+
+        var best: [(entry: Entry, distance: Double)] = []
+        best.reserveCapacity(count)
+
+        for entry in entries {
+            let distance = haversineKm(lat, lon, entry.lat, entry.lon)
+            if best.count < count {
+                let idx = best.firstIndex { $0.distance > distance } ?? best.count
+                best.insert((entry, distance), at: idx)
+            } else if let worstDistance = best.last?.distance, distance < worstDistance {
+                let idx = best.firstIndex { $0.distance > distance } ?? best.count
+                best.insert((entry, distance), at: idx)
+                best.removeLast()
             }
-            .prefix(count)
+        }
-        return sorted.map { "wss://\($0.host)" }
+
+        return best.map { "wss://\($0.entry.host)" }
     }
 
     // MARK: - Remote Fetch
-    func prefetchIfNeeded() {
+    func prefetchIfNeeded(force: Bool = false) {
+        guard !isFetching else { return }
+
         let now = Date()
         let last = UserDefaults.standard.object(forKey: lastFetchKey) as? Date ?? .distantPast
-        guard now.timeIntervalSince(last) >= fetchInterval else { return }
+
+        if !force {
+            guard now.timeIntervalSince(last) >= fetchInterval else { return }
+        } else if last != .distantPast,
+                  now.timeIntervalSince(last) < TransportConfig.geoRelayRetryInitialSeconds {
+            // Skip forced fetches if we just refreshed moments ago.
+            return
+        }
+
+        cancelRetry()
         fetchRemote()
     }
 
     private func fetchRemote() {
-        let req = URLRequest(url: remoteURL, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 15)
+        guard !isFetching else { return }
-        // Ensure Tor readiness before fetching (fail-closed by default)
+        isFetching = true
-        Task.detached {
+
+        let request = URLRequest(
+            url: remoteURL,
+            cachePolicy: .reloadIgnoringLocalCacheData,
+            timeoutInterval: 15
+        )
+
+        Task.detached { [weak self] in
+            guard let self else { return }
+
             let ready = await TorManager.shared.awaitReady()
             if !ready {
-                SecureLogger.warning("GeoRelayDirectory: Tor not ready; skipping remote fetch (fail-closed)", category: .session)
+                await self.handleFetchFailure(.torNotReady)
                 return
             }
-            let task = TorURLSession.shared.session.dataTask(with: req) { [weak self] data, _, error in
+
-                guard let self = self else { return }
+            do {
-                if let data = data, error == nil, let text = String(data: data, encoding: .utf8) {
+                let (data, _) = try await TorURLSession.shared.session.data(for: request)
-                    let parsed = GeoRelayDirectory.parseCSV(text)
+                guard let text = String(data: data, encoding: .utf8) else {
-                    if !parsed.isEmpty {
+                    await self.handleFetchFailure(.invalidData)
-                        Task { @MainActor in
+                    return
-                            self.entries = parsed
-                            self.persistCache(text)
-                            UserDefaults.standard.set(Date(), forKey: self.lastFetchKey)
-                            SecureLogger.info("GeoRelayDirectory: refreshed \(parsed.count) relays from remote", category: .session)
-                        }
-                        return
-                    }
                 }
-                SecureLogger.warning("GeoRelayDirectory: remote fetch failed; keeping local entries", category: .session)
+
+                let parsed = GeoRelayDirectory.parseCSV(text)
+                guard !parsed.isEmpty else {
+                    await self.handleFetchFailure(.invalidData)
+                    return
+                }
+
+                await self.handleFetchSuccess(entries: parsed, csv: text)
+            } catch {
+                await self.handleFetchFailure(.network(error))
             }
-            task.resume()
         }
     }
 
+    private enum FetchFailure {
+        case torNotReady
+        case invalidData
+        case network(Error)
+    }
+
+    @MainActor
+    private func handleFetchSuccess(entries parsed: [Entry], csv: String) {
+        entries = parsed
+        persistCache(csv)
+        UserDefaults.standard.set(Date(), forKey: lastFetchKey)
+        SecureLogger.info("GeoRelayDirectory: refreshed \(parsed.count) relays from remote", category: .session)
+        isFetching = false
+        retryAttempt = 0
+        cancelRetry()
+    }
+
+    @MainActor
+    private func handleFetchFailure(_ reason: FetchFailure) {
+        switch reason {
+        case .torNotReady:
+            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):
+            SecureLogger.warning("GeoRelayDirectory: remote fetch failed with error: \(error.localizedDescription)", category: .session)
+        }
+        isFetching = false
+        scheduleRetry()
+    }
+
+    @MainActor
+    private func scheduleRetry() {
+        retryAttempt = min(retryAttempt + 1, 10)
+        let base = TransportConfig.geoRelayRetryInitialSeconds
+        let maxDelay = TransportConfig.geoRelayRetryMaxSeconds
+        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
+            let nanoseconds = UInt64(delay * 1_000_000_000)
+            try? await Task.sleep(nanoseconds: nanoseconds)
+            await MainActor.run {
+                self?.prefetchIfNeeded(force: true)
+            }
+        }
+    }
+
+    @MainActor
+    private func cancelRetry() {
+        retryTask?.cancel()
+        retryTask = nil
+    }
+
     private func persistCache(_ text: String) {
         guard let url = cacheURL() else { return }
         do {
@@ -91,30 +205,35 @@ final class GeoRelayDirectory {
     // MARK: - Loading
     private func loadLocalEntries() -> [Entry] {
         // Prefer cached file if present
-        if let cache = self.cacheURL(),
+        if let cache = cacheURL(),
            let data = try? Data(contentsOf: cache),
            let text = String(data: data, encoding: .utf8) {
             let arr = Self.parseCSV(text)
             if !arr.isEmpty { return arr }
         }
+
         // Try bundled resource(s)
         let bundleCandidates = [
             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), let text = String(data: data, encoding: .utf8) {
+            if let data = try? Data(contentsOf: url),
+               let text = String(data: data, encoding: .utf8) {
                 let arr = Self.parseCSV(text)
                 if !arr.isEmpty { return arr }
             }
         }
+
         // Try filesystem path (development/test)
         if let cwd = FileManager.default.currentDirectoryPath as String?,
            let data = try? Data(contentsOf: URL(fileURLWithPath: cwd).appendingPathComponent("relays/online_relays_gps.csv")),
            let text = String(data: data, encoding: .utf8) {
             return Self.parseCSV(text)
         }
+
         SecureLogger.warning("GeoRelayDirectory: no local CSV found; entries empty", category: .session)
         return []
     }
@@ -122,7 +241,6 @@ final class GeoRelayDirectory {
     nonisolated static func parseCSV(_ text: String) -> [Entry] {
         var result: Set<Entry> = []
         let lines = text.split(whereSeparator: { $0.isNewline })
-        // Skip header if present
         for (idx, raw) in lines.enumerated() {
             let line = raw.trimmingCharacters(in: .whitespacesAndNewlines)
             if line.isEmpty { continue }
@@ -143,11 +261,76 @@ final class GeoRelayDirectory {
 
     private func cacheURL() -> URL? {
         do {
-            let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+            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 }
+        } catch {
+            return nil
+        }
+    }
+
+    // MARK: - Observers & Timers
+    private func registerObservers() {
+        let center = NotificationCenter.default
+
+        let torReady = center.addObserver(
+            forName: .TorDidBecomeReady,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            guard let self else { return }
+            Task { @MainActor in
+                self.prefetchIfNeeded(force: true)
+            }
+        }
+        observers.append(torReady)
+
+#if os(iOS)
+        let didBecomeActive = center.addObserver(
+            forName: UIApplication.didBecomeActiveNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            guard let self else { return }
+            Task { @MainActor in
+                self.prefetchIfNeeded()
+            }
+        }
+        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()
+        let interval = TransportConfig.geoRelayRefreshCheckIntervalSeconds
+        guard interval > 0 else { return }
+
+        let timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
+            guard let self else { return }
+            Task { @MainActor in
+                self.prefetchIfNeeded()
+            }
+        }
+        refreshTimer = timer
+        RunLoop.main.add(timer, forMode: .common)
     }
 }
 

bitchat/Nostr/KeychainHelper.swift

@@ -0,0 +1,50 @@
+import Foundation
+
+protocol KeychainHelperProtocol {
+    func save(key: String, data: Data, service: String, accessible: CFString?)
+    func load(key: String, service: String) -> Data?
+    func delete(key: String, service: String)
+}
+
+/// Keychain helper for secure storage
+struct KeychainHelper: KeychainHelperProtocol {
+    func save(key: String, data: Data, service: String, accessible: CFString? = nil) {
+        var query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key,
+            kSecValueData as String: data
+        ]
+        if let accessible = accessible {
+            query[kSecAttrAccessible as String] = accessible
+        }
+        
+        SecItemDelete(query as CFDictionary)
+        SecItemAdd(query as CFDictionary, nil)
+    }
+    
+    func load(key: String, service: String) -> Data? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key,
+            kSecReturnData as String: true
+        ]
+        
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        
+        guard status == errSecSuccess else { return nil }
+        return result as? Data
+    }
+    
+    func delete(key: String, service: String) {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key
+        ]
+        
+        SecItemDelete(query as CFDictionary)
+    }
+}

bitchat/Nostr/NostrEmbeddedBitChat.swift

@@ -4,7 +4,7 @@ import Foundation
 
 struct NostrEmbeddedBitChat {
     /// Build a `bitchat1:` base64url-encoded BitChat packet carrying a private message for Nostr DMs.
-    static func encodePMForNostr(content: String, messageID: String, recipientPeerID: String, senderPeerID: String) -> String? {
+    static func encodePMForNostr(content: String, messageID: String, recipientPeerID: PeerID, senderPeerID: PeerID) -> String? {
         // TLV-encode the private message
         let pm = PrivateMessagePacket(messageID: messageID, content: content)
         guard let tlv = pm.encode() else { return nil }
@@ -14,12 +14,12 @@ struct NostrEmbeddedBitChat {
         payload.append(tlv)
 
         // Determine 8-byte recipient ID to embed
-        let recipientIDHex: String = normalizeRecipientPeerID(recipientPeerID)
+        let recipientID = normalizeRecipientPeerID(recipientPeerID)
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
-            recipientID: Data(hexString: recipientIDHex),
+            recipientID: Data(hexString: recipientID.id),
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
             signature: nil,
@@ -31,18 +31,18 @@ struct NostrEmbeddedBitChat {
     }
 
     /// Build a `bitchat1:` base64url-encoded BitChat packet carrying a delivery/read ack for Nostr DMs.
-    static func encodeAckForNostr(type: NoisePayloadType, messageID: String, recipientPeerID: String, senderPeerID: String) -> String? {
+    static func encodeAckForNostr(type: NoisePayloadType, messageID: String, recipientPeerID: PeerID, senderPeerID: PeerID) -> String? {
         guard type == .delivered || type == .readReceipt else { return nil }
 
         var payload = Data([type.rawValue])
         payload.append(Data(messageID.utf8))
 
-        let recipientIDHex: String = normalizeRecipientPeerID(recipientPeerID)
+        let recipientID = normalizeRecipientPeerID(recipientPeerID)
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
-            recipientID: Data(hexString: recipientIDHex),
+            recipientID: Data(hexString: recipientID.id),
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
             signature: nil,
@@ -54,7 +54,7 @@ struct NostrEmbeddedBitChat {
     }
 
     /// Build a `bitchat1:` ACK (delivered/read) without an embedded recipient peer ID (geohash DMs).
-    static func encodeAckForNostrNoRecipient(type: NoisePayloadType, messageID: String, senderPeerID: String) -> String? {
+    static func encodeAckForNostrNoRecipient(type: NoisePayloadType, messageID: String, senderPeerID: PeerID) -> String? {
         guard type == .delivered || type == .readReceipt else { return nil }
 
         var payload = Data([type.rawValue])
@@ -62,7 +62,7 @@ struct NostrEmbeddedBitChat {
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -75,7 +75,7 @@ struct NostrEmbeddedBitChat {
     }
 
     /// Build a `bitchat1:` payload without an embedded recipient peer ID (used for geohash DMs).
-    static func encodePMForNostrNoRecipient(content: String, messageID: String, senderPeerID: String) -> String? {
+    static func encodePMForNostrNoRecipient(content: String, messageID: String, senderPeerID: PeerID) -> String? {
         let pm = PrivateMessagePacket(messageID: messageID, content: content)
         guard let tlv = pm.encode() else { return nil }
 
@@ -84,7 +84,7 @@ struct NostrEmbeddedBitChat {
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -96,11 +96,11 @@ struct NostrEmbeddedBitChat {
         return "bitchat1:" + base64URLEncode(data)
     }
 
-    private static func normalizeRecipientPeerID(_ recipientPeerID: String) -> String {
+    private static func normalizeRecipientPeerID(_ recipientPeerID: PeerID) -> PeerID {
-        if let maybeData = Data(hexString: recipientPeerID) {
+        if let maybeData = Data(hexString: recipientPeerID.id) {
             if maybeData.count == 32 {
                 // Treat as Noise static public key; derive peerID from fingerprint
-                return PeerID(publicKey: maybeData).id
+                return PeerID(publicKey: maybeData)
             } else if maybeData.count == 8 {
                 // Already an 8-byte peer ID
                 return recipientPeerID

bitchat/Nostr/NostrIdentity.swift

@@ -1,50 +1,5 @@
 import Foundation
-import CryptoKit
 import P256K
-import Security
-
-// Keychain helper for secure storage
-struct KeychainHelper {
-    static func save(key: String, data: Data, service: String, accessible: CFString? = nil) {
-        var query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: service,
-            kSecAttrAccount as String: key,
-            kSecValueData as String: data
-        ]
-        if let accessible = accessible {
-            query[kSecAttrAccessible as String] = accessible
-        }
-        
-        SecItemDelete(query as CFDictionary)
-        SecItemAdd(query as CFDictionary, nil)
-    }
-    
-    static func load(key: String, service: String) -> Data? {
-        let query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: service,
-            kSecAttrAccount as String: key,
-            kSecReturnData as String: true
-        ]
-        
-        var result: AnyObject?
-        let status = SecItemCopyMatching(query as CFDictionary, &result)
-        
-        guard status == errSecSuccess else { return nil }
-        return result as? Data
-    }
-    
-    static func delete(key: String, service: String) {
-        let query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: service,
-            kSecAttrAccount as String: key
-        ]
-        
-        SecItemDelete(query as CFDictionary)
-    }
-}
 
 /// Manages Nostr identity (secp256k1 keypair) for NIP-17 private messaging
 struct NostrIdentity: Codable {
@@ -103,266 +58,3 @@ struct NostrIdentity: Codable {
         return publicKey.hexEncodedString()
     }
 }
-
-/// Bridge between Noise and Nostr identities
-struct NostrIdentityBridge {
-    private static let keychainService = "chat.bitchat.nostr"
-    private static let currentIdentityKey = "nostr-current-identity"
-    private static let deviceSeedKey = "nostr-device-seed"
-    // In-memory cache to avoid transient keychain access issues
-    private static var deviceSeedCache: Data?
-    
-    /// Get or create the current Nostr identity
-    static func getCurrentNostrIdentity() throws -> NostrIdentity? {
-        // Check if we already have a Nostr identity
-        if let existingData = KeychainHelper.load(key: currentIdentityKey, service: keychainService),
-           let identity = try? JSONDecoder().decode(NostrIdentity.self, from: existingData) {
-            return identity
-        }
-        
-        // Generate new Nostr identity
-        let nostrIdentity = try NostrIdentity.generate()
-        
-        // Store it
-        let data = try JSONEncoder().encode(nostrIdentity)
-        KeychainHelper.save(key: currentIdentityKey, data: data, service: keychainService)
-        
-        return nostrIdentity
-    }
-    
-    /// Associate a Nostr identity with a Noise public key (for favorites)
-    static func associateNostrIdentity(_ nostrPubkey: String, with noisePublicKey: Data) {
-        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
-        if let data = nostrPubkey.data(using: .utf8) {
-            KeychainHelper.save(key: key, data: data, service: keychainService)
-        }
-    }
-    
-    /// Get Nostr public key associated with a Noise public key
-    static func getNostrPublicKey(for noisePublicKey: Data) -> String? {
-        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
-        guard let data = KeychainHelper.load(key: key, service: keychainService),
-              let pubkey = String(data: data, encoding: .utf8) else {
-            return nil
-        }
-        return pubkey
-    }
-    
-    /// Clear all Nostr identity associations and current identity
-    static func clearAllAssociations() {
-        let query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: keychainService,
-            kSecMatchLimit as String: kSecMatchLimitAll,
-            kSecReturnAttributes as String: true
-        ]
-
-        var result: AnyObject?
-        let status = SecItemCopyMatching(query as CFDictionary, &result)
-        if status == errSecSuccess, let items = result as? [[String: Any]] {
-            for item in items {
-                var deleteQuery: [String: Any] = [
-                    kSecClass as String: kSecClassGenericPassword,
-                    kSecAttrService as String: keychainService
-                ]
-                if let account = item[kSecAttrAccount as String] as? String {
-                    deleteQuery[kSecAttrAccount as String] = account
-                }
-                SecItemDelete(deleteQuery as CFDictionary)
-            }
-        } else if status == errSecItemNotFound {
-            // nothing persisted; no action needed
-        }
-
-        deviceSeedCache = nil
-    }
-
-    // MARK: - Per-Geohash Identities (Location Channels)
-
-    /// Returns a stable device seed used to derive unlinkable per-geohash identities.
-    /// Stored only on device keychain.
-    private static func getOrCreateDeviceSeed() -> Data {
-        if let cached = deviceSeedCache { return cached }
-        if let existing = KeychainHelper.load(key: deviceSeedKey, service: keychainService) {
-            // Migrate to AfterFirstUnlockThisDeviceOnly for stability during lock
-            KeychainHelper.save(key: deviceSeedKey, data: existing, service: keychainService, accessible: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly)
-            deviceSeedCache = existing
-            return existing
-        }
-        var seed = Data(count: 32)
-        _ = seed.withUnsafeMutableBytes { ptr in
-            SecRandomCopyBytes(kSecRandomDefault, 32, ptr.baseAddress!)
-        }
-        // Ensure availability after first unlock to prevent unintended rotation when locked
-        KeychainHelper.save(key: deviceSeedKey, data: seed, service: keychainService, accessible: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly)
-        deviceSeedCache = seed
-        return seed
-    }
-
-    /// Derive a deterministic, unlinkable Nostr identity for a given geohash.
-    /// Uses HMAC-SHA256(deviceSeed, geohash) as private key material, with fallback rehashing
-    /// if the candidate is not a valid secp256k1 private key.
-    static func deriveIdentity(forGeohash geohash: String) throws -> NostrIdentity {
-        let seed = getOrCreateDeviceSeed()
-        guard let msg = geohash.data(using: .utf8) else {
-            throw NSError(domain: "NostrIdentity", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid geohash string"])
-        }
-
-        func candidateKey(iteration: UInt32) -> Data {
-            var input = Data(msg)
-            var iterBE = iteration.bigEndian
-            withUnsafeBytes(of: &iterBE) { bytes in
-                input.append(contentsOf: bytes)
-            }
-            let code = CryptoKit.HMAC<CryptoKit.SHA256>.authenticationCode(for: input, using: SymmetricKey(data: seed))
-            return Data(code)
-        }
-
-        // Try a few iterations to ensure a valid key can be formed
-        for i in 0..<10 {
-            let keyData = candidateKey(iteration: UInt32(i))
-            if let identity = try? NostrIdentity(privateKeyData: keyData) {
-                return identity
-            }
-        }
-        // As a final fallback, hash the seed+msg and try again
-        let fallback = (seed + msg).sha256Hash()
-        return try NostrIdentity(privateKeyData: fallback)
-    }
-}
-
-// Bech32 encoding for Nostr (minimal implementation)
-enum Bech32 {
-    private static let charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
-    private static let generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
-    
-    static func encode(hrp: String, data: Data) throws -> String {
-        let values = convertBits(from: 8, to: 5, pad: true, data: Array(data))
-        let checksum = createChecksum(hrp: hrp, values: values)
-        let combined = values + checksum
-        
-        return hrp + "1" + combined.map { 
-            let index = charset.index(charset.startIndex, offsetBy: Int($0))
-            return String(charset[index])
-        }.joined()
-    }
-    
-    static func decode(_ bech32String: String) throws -> (hrp: String, data: Data) {
-        // Find the last occurrence of '1'
-        guard let separatorIndex = bech32String.lastIndex(of: "1") else {
-            throw Bech32Error.invalidFormat
-        }
-        
-        let hrp = String(bech32String[..<separatorIndex])
-        
-        // Validate HRP contains only ASCII characters
-        for char in hrp {
-            guard char.asciiValue != nil else {
-                throw Bech32Error.invalidCharacter
-            }
-        }
-        
-        let dataString = String(bech32String[bech32String.index(after: separatorIndex)...])
-        
-        // Convert characters to values
-        var values = [UInt8]()
-        for char in dataString {
-            guard let index = charset.firstIndex(of: char) else {
-                throw Bech32Error.invalidCharacter
-            }
-            values.append(UInt8(charset.distance(from: charset.startIndex, to: index)))
-        }
-        
-        // Verify checksum
-        guard values.count >= 6 else {
-            throw Bech32Error.invalidChecksum
-        }
-        
-        let payloadValues = Array(values.dropLast(6))
-        let checksum = Array(values.suffix(6))
-        let expectedChecksum = createChecksum(hrp: hrp, values: payloadValues)
-        
-        guard checksum == expectedChecksum else {
-            throw Bech32Error.invalidChecksum
-        }
-        
-        // Convert back to bytes
-        let bytes = convertBits(from: 5, to: 8, pad: false, data: payloadValues)
-        return (hrp: hrp, data: Data(bytes))
-    }
-    
-    enum Bech32Error: Error {
-        case invalidFormat
-        case invalidCharacter
-        case invalidChecksum
-    }
-    
-    private static func convertBits(from: Int, to: Int, pad: Bool, data: [UInt8]) -> [UInt8] {
-        var acc = 0
-        var bits = 0
-        var result = [UInt8]()
-        let maxv = (1 << to) - 1
-        
-        for value in data {
-            acc = (acc << from) | Int(value)
-            bits += from
-            
-            while bits >= to {
-                bits -= to
-                result.append(UInt8((acc >> bits) & maxv))
-            }
-        }
-        
-        if pad && bits > 0 {
-            result.append(UInt8((acc << (to - bits)) & maxv))
-        }
-        
-        return result
-    }
-    
-    private static func createChecksum(hrp: String, values: [UInt8]) -> [UInt8] {
-        let checksumValues = hrpExpand(hrp) + values + [0, 0, 0, 0, 0, 0]
-        let polymod = polymod(checksumValues) ^ 1
-        var checksum = [UInt8]()
-        
-        for i in 0..<6 {
-            checksum.append(UInt8((polymod >> (5 * (5 - i))) & 31))
-        }
-        
-        return checksum
-    }
-    
-    private static func hrpExpand(_ hrp: String) -> [UInt8] {
-        var result = [UInt8]()
-        for c in hrp {
-            guard let asciiValue = c.asciiValue else {
-                return [] // Return empty array for invalid input
-            }
-            result.append(UInt8(asciiValue >> 5))
-        }
-        result.append(0)
-        for c in hrp {
-            guard let asciiValue = c.asciiValue else {
-                return [] // Return empty array for invalid input
-            }
-            result.append(UInt8(asciiValue & 31))
-        }
-        return result
-    }
-    
-    private static func polymod(_ values: [UInt8]) -> Int {
-        var chk = 1
-        for value in values {
-            let b = chk >> 25
-            chk = (chk & 0x1ffffff) << 5 ^ Int(value)
-            for i in 0..<5 {
-                if (b >> i) & 1 == 1 {
-                    chk ^= generator[i]
-                }
-            }
-        }
-        return chk
-    }
-}
-
-// Data hex encoding extension moved to BinaryEncodingUtils.swift to avoid duplication

bitchat/Nostr/NostrIdentityBridge.swift

@@ -0,0 +1,157 @@
+import Foundation
+import CryptoKit
+
+/// Bridge between Noise and Nostr identities
+final class NostrIdentityBridge {
+    private let keychainService = "chat.bitchat.nostr"
+    private let currentIdentityKey = "nostr-current-identity"
+    private let deviceSeedKey = "nostr-device-seed"
+    // In-memory cache to avoid transient keychain access issues
+    private var deviceSeedCache: Data?
+    // Cache derived identities to avoid repeated crypto during view rendering
+    private var derivedIdentityCache: [String: NostrIdentity] = [:]
+    private let cacheLock = NSLock()
+
+    private let keychain: KeychainHelperProtocol
+
+    init(keychain: KeychainHelperProtocol = KeychainHelper()) {
+        self.keychain = keychain
+    }
+    
+    /// Get or create the current Nostr identity
+    func getCurrentNostrIdentity() throws -> NostrIdentity? {
+        // Check if we already have a Nostr identity
+        if let existingData = keychain.load(key: currentIdentityKey, service: keychainService),
+           let identity = try? JSONDecoder().decode(NostrIdentity.self, from: existingData) {
+            return identity
+        }
+        
+        // Generate new Nostr identity
+        let nostrIdentity = try NostrIdentity.generate()
+        
+        // Store it
+        let data = try JSONEncoder().encode(nostrIdentity)
+        keychain.save(key: currentIdentityKey, data: data, service: keychainService, accessible: nil)
+        
+        return nostrIdentity
+    }
+    
+    /// Associate a Nostr identity with a Noise public key (for favorites)
+    func associateNostrIdentity(_ nostrPubkey: String, with noisePublicKey: Data) {
+        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
+        if let data = nostrPubkey.data(using: .utf8) {
+            keychain.save(key: key, data: data, service: keychainService, accessible: nil)
+        }
+    }
+    
+    /// Get Nostr public key associated with a Noise public key
+    func getNostrPublicKey(for noisePublicKey: Data) -> String? {
+        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
+        guard let data = keychain.load(key: key, service: keychainService),
+              let pubkey = String(data: data, encoding: .utf8) else {
+            return nil
+        }
+        return pubkey
+    }
+    
+    /// Clear all Nostr identity associations and current identity
+    func clearAllAssociations() {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: keychainService,
+            kSecMatchLimit as String: kSecMatchLimitAll,
+            kSecReturnAttributes as String: true
+        ]
+
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        if status == errSecSuccess, let items = result as? [[String: Any]] {
+            for item in items {
+                var deleteQuery: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: keychainService
+                ]
+                if let account = item[kSecAttrAccount as String] as? String {
+                    deleteQuery[kSecAttrAccount as String] = account
+                }
+                SecItemDelete(deleteQuery as CFDictionary)
+            }
+        } else if status == errSecItemNotFound {
+            // nothing persisted; no action needed
+        }
+
+        deviceSeedCache = nil
+    }
+
+    // MARK: - Per-Geohash Identities (Location Channels)
+
+    /// Returns a stable device seed used to derive unlinkable per-geohash identities.
+    /// Stored only on device keychain.
+    private func getOrCreateDeviceSeed() -> Data {
+        if let cached = deviceSeedCache { return cached }
+        if let existing = keychain.load(key: deviceSeedKey, service: keychainService) {
+            // Migrate to AfterFirstUnlockThisDeviceOnly for stability during lock
+            keychain.save(key: deviceSeedKey, data: existing, service: keychainService, accessible: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly)
+            deviceSeedCache = existing
+            return existing
+        }
+        var seed = Data(count: 32)
+        _ = seed.withUnsafeMutableBytes { ptr in
+            SecRandomCopyBytes(kSecRandomDefault, 32, ptr.baseAddress!)
+        }
+        // Ensure availability after first unlock to prevent unintended rotation when locked
+        keychain.save(key: deviceSeedKey, data: seed, service: keychainService, accessible: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly)
+        deviceSeedCache = seed
+        return seed
+    }
+
+    /// Derive a deterministic, unlinkable Nostr identity for a given geohash.
+    /// Uses HMAC-SHA256(deviceSeed, geohash) as private key material, with fallback rehashing
+    /// if the candidate is not a valid secp256k1 private key.
+    func deriveIdentity(forGeohash geohash: String) throws -> NostrIdentity {
+        // Check cache first to avoid repeated crypto + keychain I/O during view rendering
+        cacheLock.lock()
+        if let cached = derivedIdentityCache[geohash] {
+            cacheLock.unlock()
+            return cached
+        }
+        cacheLock.unlock()
+
+        let seed = getOrCreateDeviceSeed()
+        guard let msg = geohash.data(using: .utf8) else {
+            throw NSError(domain: "NostrIdentity", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid geohash string"])
+        }
+
+        func candidateKey(iteration: UInt32) -> Data {
+            var input = Data(msg)
+            var iterBE = iteration.bigEndian
+            withUnsafeBytes(of: &iterBE) { bytes in
+                input.append(contentsOf: bytes)
+            }
+            let code = HMAC<SHA256>.authenticationCode(for: input, using: SymmetricKey(data: seed))
+            return Data(code)
+        }
+
+        // Try a few iterations to ensure a valid key can be formed
+        for i in 0..<10 {
+            let keyData = candidateKey(iteration: UInt32(i))
+            if let identity = try? NostrIdentity(privateKeyData: keyData) {
+                // Cache the result
+                cacheLock.lock()
+                derivedIdentityCache[geohash] = identity
+                cacheLock.unlock()
+                return identity
+            }
+        }
+        // As a final fallback, hash the seed+msg and try again
+        let fallback = (seed + msg).sha256Hash()
+        let identity = try NostrIdentity(privateKeyData: fallback)
+
+        // Cache the result
+        cacheLock.lock()
+        derivedIdentityCache[geohash] = identity
+        cacheLock.unlock()
+
+        return identity
+    }
+}

bitchat/Nostr/NostrRelayManager.swift

@@ -109,20 +109,7 @@ final class NostrRelayManager: ObservableObject {
             }
             .store(in: &cancellables)
     }
-
+    
-    deinit {
-        // Clean up timers and active connections
-        reconnectionTimer?.invalidate()
-        for (_, tracker) in eoseTrackers {
-            tracker.timer?.invalidate()
-        }
-        for (_, task) in connections {
-            task.cancel(with: .goingAway, reason: nil)
-        }
-        cancellables.removeAll()
-        SecureLogger.debug("NostrRelayManager deinitialized", category: .session)
-    }
-
     /// Connect to all configured relays
     func connect() {
         // Global network policy gate
@@ -919,6 +906,16 @@ struct NostrFilter: Encodable {
         filter.limit = limit
         return filter
     }
+
+    // For location notes with neighbors: subscribe to multiple geohashes (center + neighbors)
+    static func geohashNotes(_ geohashes: [String], since: Date? = nil, limit: Int = 200) -> NostrFilter {
+        var filter = NostrFilter()
+        filter.kinds = [1]
+        filter.since = since?.timeIntervalSince1970.toInt()
+        filter.tagFilters = ["g": geohashes]
+        filter.limit = limit
+        return filter
+    }
 }
 
 // Dynamic coding key for tag filters

bitchat/Protocols/BinaryEncodingUtils.swift

@@ -6,6 +6,7 @@
 //
 
 import Foundation
+import CryptoKit
 
 // MARK: - Hex Encoding/Decoding
 
@@ -16,6 +17,11 @@ extension Data {
         }
         return self.map { String(format: "%02x", $0) }.joined()
     }
+
+    func sha256Hex() -> String {
+        let digest = SHA256.hash(data: self)
+        return digest.map { String(format: "%02x", $0) }.joined()
+    }
     
     init?(hexString: String) {
         let len = hexString.count / 2

bitchat/Protocols/BinaryProtocol.swift

@@ -22,11 +22,11 @@
 ///
 /// ## Wire Format
 /// ```
-/// Header (Fixed 13 bytes):
+/// Header (Fixed 14 bytes for v1, 16 bytes for v2):
-/// +--------+------+-----+-----------+-------+----------------+
+/// +--------+------+-----+-----------+-------+------------------+
-/// |Version | Type | TTL | Timestamp | Flags | PayloadLength  |
+/// |Version | Type | TTL | Timestamp | Flags | PayloadLength    |
-/// |1 byte  |1 byte|1byte| 8 bytes   | 1 byte| 2 bytes        |
+/// |1 byte  |1 byte|1byte| 8 bytes   | 1 byte| 2 or 4 bytes     |
-/// +--------+------+-----+-----------+-------+----------------+
+/// +--------+------+-----+-----------+-------+------------------+
 ///
 /// Variable sections:
 /// +----------+-------------+---------+------------+
@@ -52,7 +52,7 @@
 /// ## Flag Bits
 /// - Bit 0: Has recipient ID (directed message)
 /// - Bit 1: Has signature (authenticated message)
-/// - Bit 2: Is compressed (LZ4 compression applied)
+/// - Bit 2: Is compressed (zlib compression applied)
 /// - Bits 3-7: Reserved for future use
 ///
 /// ## Size Constraints
@@ -89,6 +89,7 @@
 ///
 
 import Foundation
+import BitLogger
 
 extension Data {
     func trimmingNullBytes() -> Data {
@@ -105,83 +106,119 @@ extension Data {
 /// their binary wire format representation.
 /// - Note: All multi-byte values use network byte order (big-endian)
 struct BinaryProtocol {
-    static let headerSize = 13
+    static let v1HeaderSize = 14
+    static let v2HeaderSize = 16
     static let senderIDSize = 8
     static let recipientIDSize = 8
     static let signatureSize = 64
+
+    // Field offsets within packet header
+    struct Offsets {
+        static let version = 0
+        static let type = 1
+        static let ttl = 2
+        static let timestamp = 3
+        static let flags = 11  // After version(1) + type(1) + ttl(1) + timestamp(8)
+    }
+
+    static func headerSize(for version: UInt8) -> Int? {
+        switch version {
+        case 1: return v1HeaderSize
+        case 2: return v2HeaderSize
+        default: return nil
+        }
+    }
+
+    private static func lengthFieldSize(for version: UInt8) -> Int {
+        return version == 2 ? 4 : 2
+    }
     
     struct Flags {
         static let hasRecipient: UInt8 = 0x01
         static let hasSignature: UInt8 = 0x02
         static let isCompressed: UInt8 = 0x04
+        static let hasRoute: UInt8 = 0x08
     }
     
     // Encode BitchatPacket to binary format
     static func encode(_ packet: BitchatPacket, padding: Bool = true) -> Data? {
-        var data = Data()
+        let version = packet.version
-        
+        guard version == 1 || version == 2 else { return nil }
-        
+
-        // Try to compress payload if beneficial
+        // Try to compress payload when beneficial, keeping original size for later decoding
         var payload = packet.payload
-        var originalPayloadSize: UInt16? = nil
         var isCompressed = false
-        
+        var originalPayloadSize: Int?
         if CompressionUtil.shouldCompress(payload) {
-            if let compressedPayload = CompressionUtil.compress(payload) {
+            // Only compress when we can represent the original length in the outbound frame
-                // Store original size for decompression (2 bytes after payload)
+            let maxRepresentable = version == 2 ? Int(UInt32.max) : Int(UInt16.max)
-                originalPayloadSize = UInt16(payload.count)
+            if payload.count <= maxRepresentable,
+               let compressedPayload = CompressionUtil.compress(payload) {
+                originalPayloadSize = payload.count
                 payload = compressedPayload
                 isCompressed = true
-                
-            } else {
             }
-        } else {
         }
-        
+
-        // Header
+        let lengthFieldBytes = lengthFieldSize(for: version)
-        // Reserve capacity to reduce reallocations. Estimate base size conservatively.
+        let originalRoute = packet.route ?? []
-        // header(13) + sender(8) + opt recipient(8) + opt originalSize(2) + payload + opt signature(64) + up to 255 pad
+        if originalRoute.contains(where: { $0.isEmpty }) { return nil }
-        let estimatedPayload = payload.count + (isCompressed ? 2 : 0)
+        let sanitizedRoute: [Data] = originalRoute.map { hop in
-        let estimated = headerSize + senderIDSize + (packet.recipientID == nil ? 0 : recipientIDSize) + estimatedPayload + (packet.signature == nil ? 0 : signatureSize) + 255
+            if hop.count == senderIDSize { return hop }
-        data.reserveCapacity(estimated)
+            if hop.count > senderIDSize { return Data(hop.prefix(senderIDSize)) }
-        data.append(packet.version)
+            var padded = hop
+            padded.append(Data(repeating: 0, count: senderIDSize - hop.count))
+            return padded
+        }
+        guard sanitizedRoute.count <= 255 else { return nil }
+
+        let hasRoute = !sanitizedRoute.isEmpty
+        let routeLength = hasRoute ? 1 + sanitizedRoute.count * senderIDSize : 0
+        let originalSizeFieldBytes = isCompressed ? lengthFieldBytes : 0
+        let payloadDataSize = routeLength + 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 estimatedPayload = payloadDataSize
+        let estimatedSignature = (packet.signature == nil ? 0 : signatureSize)
+        var data = Data()
+        data.reserveCapacity(estimatedHeader + estimatedPayload + estimatedSignature + 255)
+
+        data.append(version)
         data.append(packet.type)
         data.append(packet.ttl)
-        
+
-        // Timestamp (8 bytes, big-endian)
+        for shift in stride(from: 56, through: 0, by: -8) {
-        for i in (0..<8).reversed() {
+            data.append(UInt8((packet.timestamp >> UInt64(shift)) & 0xFF))
-            data.append(UInt8((packet.timestamp >> (i * 8)) & 0xFF))
         }
-        
+
-        // Flags
         var flags: UInt8 = 0
-        if packet.recipientID != nil {
+        if packet.recipientID != nil { flags |= Flags.hasRecipient }
-            flags |= Flags.hasRecipient
+        if packet.signature != nil { flags |= Flags.hasSignature }
-        }
+        if isCompressed { flags |= Flags.isCompressed }
-        if packet.signature != nil {
+        if hasRoute { flags |= Flags.hasRoute }
-            flags |= Flags.hasSignature
-        }
-        if isCompressed {
-            flags |= Flags.isCompressed
-        }
         data.append(flags)
-        
+
-        // Payload length (2 bytes, big-endian) - includes original size if compressed
+        if version == 2 {
-        let payloadDataSize = payload.count + (isCompressed ? 2 : 0)
+            let length = UInt32(payloadDataSize)
-        let payloadLength = UInt16(payloadDataSize)
+            for shift in stride(from: 24, through: 0, by: -8) {
-        
+                data.append(UInt8((length >> UInt32(shift)) & 0xFF))
-        
+            }
-        data.append(UInt8((payloadLength >> 8) & 0xFF))
+        } else {
-        data.append(UInt8(payloadLength & 0xFF))
+            let length = UInt16(payloadDataSize)
-        
+            data.append(UInt8((length >> 8) & 0xFF))
-        // SenderID (exactly 8 bytes)
+            data.append(UInt8(length & 0xFF))
+        }
+
         let senderBytes = packet.senderID.prefix(senderIDSize)
         data.append(senderBytes)
         if senderBytes.count < senderIDSize {
             data.append(Data(repeating: 0, count: senderIDSize - senderBytes.count))
         }
-        
+
-        // RecipientID (if present)
         if let recipientID = packet.recipientID {
             let recipientBytes = recipientID.prefix(recipientIDSize)
             data.append(recipientBytes)
@@ -189,30 +226,37 @@ struct BinaryProtocol {
                 data.append(Data(repeating: 0, count: recipientIDSize - recipientBytes.count))
             }
         }
-        
+
-        // Payload (with original size prepended if compressed)
+        if hasRoute {
+            data.append(UInt8(sanitizedRoute.count))
+            for hop in sanitizedRoute {
+                data.append(hop)
+            }
+        }
+
         if isCompressed, let originalSize = originalPayloadSize {
-            // Prepend original size (2 bytes, big-endian)
+            if version == 2 {
-            data.append(UInt8((originalSize >> 8) & 0xFF))
+                let value = UInt32(originalSize)
-            data.append(UInt8(originalSize & 0xFF))
+                for shift in stride(from: 24, through: 0, by: -8) {
+                    data.append(UInt8((value >> UInt32(shift)) & 0xFF))
+                }
+            } else {
+                let value = UInt16(originalSize)
+                data.append(UInt8((value >> 8) & 0xFF))
+                data.append(UInt8(value & 0xFF))
+            }
         }
         data.append(payload)
-        
+
-        // Signature (if present)
         if let signature = packet.signature {
             data.append(signature.prefix(signatureSize))
         }
-        
+
-        
-        // Apply padding to standard block sizes for traffic analysis resistance
         if padding {
             let optimalSize = MessagePadding.optimalBlockSize(for: data.count)
-            let paddedData = MessagePadding.pad(data, toSize: optimalSize)
+            return MessagePadding.pad(data, toSize: optimalSize)
-            return paddedData
-        } else {
-            // Caller explicitly requested no padding (e.g., BLE write path)
-            return data
         }
+        return data
     }
     
     // Decode binary data to BitchatPacket
@@ -227,87 +271,129 @@ struct BinaryProtocol {
 
     // Core decoding implementation used by decode(_:) with and without padding removal
     private static func decodeCore(_ raw: Data) -> BitchatPacket? {
-        // Minimum size: header + senderID
+        guard raw.count >= v1HeaderSize + senderIDSize else { return nil }
-        guard raw.count >= headerSize + senderIDSize else { return nil }
 
         return raw.withUnsafeBytes { (buf: UnsafeRawBufferPointer) -> BitchatPacket? in
             guard let base = buf.baseAddress else { return nil }
             var offset = 0
             func require(_ n: Int) -> Bool { offset + n <= buf.count }
-            // Read single byte
             func read8() -> UInt8? {
                 guard require(1) else { return nil }
-                let v = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self).pointee
+                let value = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self).pointee
                 offset += 1
-                return v
+                return value
             }
-            // Read big-endian 16-bit
             func read16() -> UInt16? {
                 guard require(2) else { return nil }
-                let p = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self)
+                let ptr = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self)
-                let v = (UInt16(p[0]) << 8) | UInt16(p[1])
+                let value = (UInt16(ptr[0]) << 8) | UInt16(ptr[1])
                 offset += 2
-                return v
+                return value
+            }
+            func read32() -> UInt32? {
+                guard require(4) else { return nil }
+                let ptr = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self)
+                let value = (UInt32(ptr[0]) << 24) | (UInt32(ptr[1]) << 16) | (UInt32(ptr[2]) << 8) | UInt32(ptr[3])
+                offset += 4
+                return value
             }
-            // Copy N bytes into Data
             func readData(_ n: Int) -> Data? {
                 guard require(n) else { return nil }
                 let ptr = base.advanced(by: offset)
-                let d = Data(bytes: ptr, count: n)
+                let data = Data(bytes: ptr, count: n)
                 offset += n
-                return d
+                return data
             }
 
-            // Version
+            guard let version = read8(), version == 1 || version == 2 else { return nil }
-            guard let version = read8(), version == 1 else { return nil }
+            let lengthFieldBytes = lengthFieldSize(for: version)
-            guard let type = read8() else { return nil }
+            guard let headerSize = headerSize(for: version) else { return nil }
-            guard let ttl = read8() else { return nil }
+            let minimumRequired = headerSize + senderIDSize
+            guard raw.count >= minimumRequired else { return nil }
 
-            // Timestamp 8 bytes BE
+            guard let type = read8(), let ttl = read8() else { return nil }
-            guard require(8) else { return nil }
+
-            var ts: UInt64 = 0
+            var timestamp: UInt64 = 0
             for _ in 0..<8 {
-                guard let b = read8() else { return nil }
+                guard let byte = read8() else { return nil }
-                ts = (ts << 8) | UInt64(b)
+                timestamp = (timestamp << 8) | UInt64(byte)
             }
 
-            // Flags
             guard let flags = read8() else { return nil }
             let hasRecipient = (flags & Flags.hasRecipient) != 0
             let hasSignature = (flags & Flags.hasSignature) != 0
             let isCompressed = (flags & Flags.isCompressed) != 0
 
-            // Payload length
+            let payloadLength: Int
-            guard let payloadLen = read16(), payloadLen <= 65535 else { return nil }
+            if version == 2 {
+                guard let len = read32() else { return nil }
+                payloadLength = Int(len)
+            } else {
+                guard let len = read16() else { return nil }
+                payloadLength = Int(len)
+            }
+
+            guard payloadLength >= 0 else { return nil }
 
-            // SenderID
             guard let senderID = readData(senderIDSize) else { return nil }
 
-            // Recipient
             var recipientID: Data? = nil
             if hasRecipient {
                 recipientID = readData(recipientIDSize)
                 if recipientID == nil { return nil }
             }
 
-            // Payload
+            var route: [Data]? = nil
+            var remainingPayloadBytes = payloadLength
+
+            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,
+                              let hop = readData(senderIDSize) else { return nil }
+                        remainingPayloadBytes -= senderIDSize
+                        hops.append(hop)
+                    }
+                    route = hops
+                }
+            }
+
             let payload: Data
             if isCompressed {
-                // Need original size (2 bytes)
+                guard remainingPayloadBytes >= lengthFieldBytes else { return nil }
-                guard let origSize16 = read16() else { return nil }
+                let originalSize: Int
-                let originalSize = Int(origSize16)
+                if version == 2 {
-                guard originalSize >= 0 && originalSize <= 1_048_576 else { return nil }
+                    guard let rawSize = read32() else { return nil }
-                let compSize = Int(payloadLen) - 2
+                    originalSize = Int(rawSize)
-                guard compSize >= 0, let compressed = readData(compSize) else { return nil }
+                } else {
+                    guard let rawSize = read16() else { return nil }
+                    originalSize = Int(rawSize)
+                }
+                remainingPayloadBytes -= lengthFieldBytes
+                guard originalSize >= 0 && originalSize <= FileTransferLimits.maxFramedFileBytes else { return nil }
+                let compressedSize = remainingPayloadBytes
+                guard compressedSize > 0, let compressed = readData(compressedSize) else { return nil }
+                remainingPayloadBytes = 0
+
+                let compressionRatio = Double(originalSize) / Double(compressedSize)
+                guard compressionRatio <= 50_000.0 else {
+                    SecureLogger.warning("🚫 Suspicious compression ratio: \(String(format: "%.0f", compressionRatio)):1", category: .security)
+                    return nil
+                }
+
                 guard let decompressed = CompressionUtil.decompress(compressed, originalSize: originalSize),
                       decompressed.count == originalSize else { return nil }
                 payload = decompressed
             } else {
-                guard let p = readData(Int(payloadLen)) else { return nil }
+                guard remainingPayloadBytes >= 0,
-                payload = p
+                      let rawPayload = readData(remainingPayloadBytes) else { return nil }
+                remainingPayloadBytes = 0
+                payload = rawPayload
             }
 
-            // Signature
             var signature: Data? = nil
             if hasSignature {
                 signature = readData(signatureSize)
@@ -320,10 +406,12 @@ struct BinaryProtocol {
                 type: type,
                 senderID: senderID,
                 recipientID: recipientID,
-                timestamp: ts,
+                timestamp: timestamp,
                 payload: payload,
                 signature: signature,
-                ttl: ttl
+                ttl: ttl,
+                version: version,
+                route: route
             )
         }
     }

bitchat/Protocols/BitchatFilePacket.swift

@@ -0,0 +1,155 @@
+//
+// BitchatFilePacket.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+import BitLogger
+
+/// TLV payload for Bluetooth mesh file transfers (voice notes, images, generic files).
+/// Mirrors the Android client specification to ensure cross-platform interoperability.
+struct BitchatFilePacket {
+    var fileName: String?
+    var fileSize: UInt64?
+    var mimeType: String?
+    var content: Data
+
+    /// Canonical TLV tags defined by the Android implementation.
+    private enum TLVType: UInt8 {
+        case fileName = 0x01
+        case fileSize = 0x02
+        case mimeType = 0x03
+        case content = 0x04
+    }
+
+    /// Encodes the packet using v2 canonical TLVs (4-byte FILE_SIZE, 4-byte CONTENT length).
+    /// Returns `nil` when fields exceed protocol limits (e.g., content > UInt32.max).
+    func encode() -> Data? {
+        let resolvedSize = fileSize ?? UInt64(content.count)
+        guard resolvedSize <= UInt64(UInt32.max) else { return nil }
+        guard resolvedSize <= UInt64(FileTransferLimits.maxPayloadBytes) else { return nil }
+        guard content.count <= Int(UInt32.max) else { return nil }
+        guard FileTransferLimits.isValidPayload(content.count) else { return nil }
+
+        func appendBE<T: FixedWidthInteger>(_ value: T, into data: inout Data) {
+            var big = value.bigEndian
+            withUnsafeBytes(of: &big) { data.append(contentsOf: $0) }
+        }
+
+        var encoded = Data()
+
+        if let name = fileName, let nameData = name.data(using: .utf8), nameData.count <= Int(UInt16.max) {
+            encoded.append(TLVType.fileName.rawValue)
+            appendBE(UInt16(nameData.count), into: &encoded)
+            encoded.append(nameData)
+        }
+
+        encoded.append(TLVType.fileSize.rawValue)
+        appendBE(UInt16(4), into: &encoded)
+        appendBE(UInt32(resolvedSize), into: &encoded)
+
+        if let mime = mimeType, let mimeData = mime.data(using: .utf8), mimeData.count <= Int(UInt16.max) {
+            encoded.append(TLVType.mimeType.rawValue)
+            appendBE(UInt16(mimeData.count), into: &encoded)
+            encoded.append(mimeData)
+        }
+
+        encoded.append(TLVType.content.rawValue)
+        appendBE(UInt32(content.count), into: &encoded)
+        encoded.append(content)
+
+        return encoded
+    }
+
+    /// Decodes TLV payloads, tolerating legacy encodings (FILE_SIZE len=8, CONTENT len=2) when possible.
+    static func decode(_ data: Data) -> BitchatFilePacket? {
+        var cursor = data.startIndex
+        let end = data.endIndex
+
+        var fileName: String?
+        var fileSize: UInt64?
+        var mimeType: String?
+        var content = Data()
+
+        while cursor < end {
+            let typeRaw = data[cursor]
+            cursor = data.index(after: cursor)
+
+            guard cursor <= end else { return nil }
+            let tlvType = TLVType(rawValue: typeRaw)
+
+            func readBigEndianLength(bytes: Int) -> Int? {
+                guard data.distance(from: cursor, to: end) >= bytes else { return nil }
+                // Use UInt64 to prevent integer overflow during shift operations
+                var result: UInt64 = 0
+                for _ in 0..<bytes {
+                    result = (result << 8) | UInt64(data[cursor])
+                    cursor = data.index(after: cursor)
+                }
+                // Safely convert to Int with overflow check
+                guard result <= Int.max else { return nil }
+                return Int(result)
+            }
+
+            let length: Int?
+            if tlvType == .content {
+                let snapshot = cursor
+                let canonical = readBigEndianLength(bytes: 4)
+                if let canonical = canonical,
+                   canonical <= data.distance(from: cursor, to: end) {
+                    length = canonical
+                } else {
+                    cursor = snapshot
+                    length = readBigEndianLength(bytes: 2)
+                }
+            } else {
+                length = readBigEndianLength(bytes: 2)
+            }
+
+            guard let tlvLength = length, tlvLength >= 0 else { return nil }
+            guard data.distance(from: cursor, to: end) >= tlvLength else { return nil }
+
+            let valueStart = cursor
+            cursor = data.index(cursor, offsetBy: tlvLength)
+            let value = data[valueStart..<cursor]
+
+            switch tlvType {
+            case .fileName:
+                fileName = String(data: Data(value), encoding: .utf8)
+            case .fileSize:
+                if tlvLength == 4 || tlvLength == 8 {
+                    var size: UInt64 = 0
+                    for byte in value {
+                        size = (size << 8) | UInt64(byte)
+                    }
+                    if size > UInt64(FileTransferLimits.maxPayloadBytes) {
+                        return nil
+                    }
+                    fileSize = size
+                }
+            case .mimeType:
+                mimeType = String(data: Data(value), encoding: .utf8)
+            case .content:
+                let proposedSize = content.count + value.count
+                if proposedSize > FileTransferLimits.maxPayloadBytes {
+                    return nil
+                }
+                content.append(contentsOf: value)
+            case nil:
+                continue
+            }
+        }
+
+        guard !content.isEmpty else { return nil }
+        guard FileTransferLimits.isValidPayload(content.count) else { return nil }
+        return BitchatFilePacket(
+            fileName: fileName,
+            fileSize: fileSize ?? UInt64(content.count),
+            mimeType: mimeType,
+            content: content
+        )
+    }
+}

bitchat/Protocols/BitchatProtocol.swift

@@ -79,6 +79,7 @@ enum MessageType: UInt8 {
     
     // Fragmentation (simplified)
     case fragment = 0x20        // Single fragment type for large messages
+    case fileTransfer = 0x22    // Binary file/audio/image payloads
     
     var description: String {
         switch self {
@@ -89,6 +90,7 @@ enum MessageType: UInt8 {
         case .noiseHandshake: return "noiseHandshake"
         case .noiseEncrypted: return "noiseEncrypted"
         case .fragment: return "fragment"
+        case .fileTransfer: return "fileTransfer"
         }
     }
 }
@@ -176,7 +178,7 @@ protocol BitchatDelegate: AnyObject {
 
     // Bluetooth state updates for user notifications
     func didUpdateBluetoothState(_ state: CBManagerState)
-    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date)
+    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?)
 }
 
 // Provide default implementation to make it effectively optional
@@ -193,7 +195,7 @@ extension BitchatDelegate {
         // Default empty implementation
     }
 
-    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date) {
+    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {
         // Default empty implementation
     }
 }

bitchat/Protocols/Geohash.swift

@@ -119,4 +119,57 @@ enum Geohash {
         }
         return (latInterval.0, latInterval.1, lonInterval.0, lonInterval.1)
     }
+
+    /// Returns all 8 neighboring geohash cells at the same precision.
+    /// - Parameter geohash: Base32 geohash string.
+    /// - Returns: Array of 8 neighboring geohashes (N, NE, E, SE, S, SW, W, NW order).
+    static func neighbors(of geohash: String) -> [String] {
+        guard !geohash.isEmpty else { return [] }
+
+        let precision = geohash.count
+        let bounds = decodeBounds(geohash)
+        let center = decodeCenter(geohash)
+
+        // Calculate cell dimensions
+        let latHeight = bounds.latMax - bounds.latMin
+        let lonWidth = bounds.lonMax - bounds.lonMin
+
+        // Helper to wrap longitude around ±180
+        func wrapLongitude(_ lon: Double) -> Double {
+            var wrapped = lon
+            while wrapped > 180.0 { wrapped -= 360.0 }
+            while wrapped < -180.0 { wrapped += 360.0 }
+            return wrapped
+        }
+
+        // Helper to clamp latitude to ±90
+        func clampLatitude(_ lat: Double) -> Double {
+            return max(-90.0, min(90.0, lat))
+        }
+
+        // Calculate 8 neighbor centers
+        let neighbors: [(lat: Double, lon: Double)] = [
+            (center.lat + latHeight, center.lon),                    // N
+            (center.lat + latHeight, center.lon + lonWidth),         // NE
+            (center.lat, center.lon + lonWidth),                     // E
+            (center.lat - latHeight, center.lon + lonWidth),         // SE
+            (center.lat - latHeight, center.lon),                    // S
+            (center.lat - latHeight, center.lon - lonWidth),         // SW
+            (center.lat, center.lon - lonWidth),                     // W
+            (center.lat + latHeight, center.lon - lonWidth)          // NW
+        ]
+
+        // Encode each neighbor, handling boundary conditions
+        return neighbors.compactMap { neighbor in
+            let lat = clampLatitude(neighbor.lat)
+            let lon = wrapLongitude(neighbor.lon)
+
+            // Skip if we've crossed a pole (latitude clamped to boundary)
+            if (neighbor.lat > 90.0 || neighbor.lat < -90.0) {
+                return nil
+            }
+
+            return encode(latitude: lat, longitude: lon, precision: precision)
+        }
+    }
 }

bitchat/Protocols/LocationChannel.swift

@@ -116,4 +116,18 @@ enum ChannelID: Equatable, Codable {
         case .location(let ch): return ch.geohash
         }
     }
+    
+    var isMesh: Bool {
+        switch self {
+        case .mesh:     true
+        case .location: false
+        }
+    }
+    
+    var isLocation: Bool {
+        switch self {
+        case .mesh:     false
+        case .location: true
+        }
+    }
 }

bitchat/Protocols/Packets.swift

@@ -6,11 +6,13 @@ struct AnnouncementPacket {
     let nickname: String
     let noisePublicKey: Data            // Noise static public key (Curve25519.KeyAgreement)
     let signingPublicKey: Data          // Ed25519 public key for signing
+    let directNeighbors: [Data]?        // 8-byte peer IDs
 
     private enum TLVType: UInt8 {
         case nickname = 0x01
         case noisePublicKey = 0x02
         case signingPublicKey = 0x03
+        case directNeighbors = 0x04
     }
 
     func encode() -> Data? {
@@ -35,6 +37,16 @@ struct AnnouncementPacket {
         data.append(TLVType.signingPublicKey.rawValue)
         data.append(UInt8(signingPublicKey.count))
         data.append(signingPublicKey)
+        
+        // TLV for direct neighbors (optional)
+        if let neighbors = directNeighbors, !neighbors.isEmpty {
+            let neighborsData = neighbors.prefix(10).reduce(Data()) { $0 + $1 }
+            if !neighborsData.isEmpty && neighborsData.count % 8 == 0 {
+                data.append(TLVType.directNeighbors.rawValue)
+                data.append(UInt8(neighborsData.count))
+                data.append(neighborsData)
+            }
+        }
 
         return data
     }
@@ -44,6 +56,7 @@ struct AnnouncementPacket {
         var nickname: String?
         var noisePublicKey: Data?
         var signingPublicKey: Data?
+        var directNeighbors: [Data]?
 
         while offset + 2 <= data.count {
             let typeRaw = data[offset]
@@ -63,6 +76,17 @@ struct AnnouncementPacket {
                     noisePublicKey = Data(value)
                 case .signingPublicKey:
                     signingPublicKey = Data(value)
+                case .directNeighbors:
+                    if length > 0 && length % 8 == 0 {
+                        var neighbors = [Data]()
+                        let count = length / 8
+                        for i in 0..<count {
+                            let start = value.startIndex + i * 8
+                            let end = start + 8
+                            neighbors.append(Data(value[start..<end]))
+                        }
+                        directNeighbors = neighbors
+                    }
                 }
             } else {
                 // Unknown TLV; skip (tolerant decoder for forward compatibility)
@@ -74,7 +98,8 @@ struct AnnouncementPacket {
         return AnnouncementPacket(
             nickname: nickname,
             noisePublicKey: noisePublicKey,
-            signingPublicKey: signingPublicKey
+            signingPublicKey: signingPublicKey,
+            directNeighbors: directNeighbors
         )
     }
 }

bitchat/Services/BLE/MimeType.swift

@@ -0,0 +1,195 @@
+//
+// MimeType.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import UniformTypeIdentifiers
+
+// MARK: - Extensions for missing UTTypes
+
+extension UTType {
+    static let webP = UTType(importedAs: "image/webp")
+    static let aac  = UTType(importedAs: "audio/aac")
+    static let m4a  = UTType(importedAs: "audio/m4a")
+    static let ogg  = UTType(importedAs: "audio/ogg")
+}
+
+// MARK: - MimeType Enum
+
+enum MimeType: CaseIterable, Hashable {
+    case jpeg
+    case jpg
+    case png
+    case gif
+    case webp
+    case mp4Audio
+    case m4a
+    case aac
+    case mpeg
+    case mp3
+    case wav
+    case xWav
+    case ogg
+    case pdf
+    case octetStream
+
+    var utType: UTType {
+        switch self {
+        case .jpeg, .jpg:   .jpeg
+        case .png:          .png
+        case .gif:          .gif
+        case .webp:         .webP
+        case .aac:          .aac
+        case .m4a:          .m4a
+        case .mp4Audio:     .mpeg4Audio
+        case .mp3, .mpeg:   .mp3
+        case .wav, .xWav:   .wav
+        case .ogg:          .ogg
+        case .pdf:          .pdf
+        case .octetStream:  .data
+        }
+    }
+    
+    var category: Category {
+        switch self {
+        case .jpeg, .jpg, .png, .gif, .webp:
+            return .image
+        case .aac, .m4a, .mp4Audio, .mpeg, .mp3, .wav, .xWav, .ogg:
+            return .audio
+        case .pdf, .octetStream:
+            return .file
+        }
+    }
+
+
+    var mimeString: String {
+        switch self {
+        case .jpeg, .jpg:   "image/jpeg"
+        case .png:          "image/png"
+        case .gif:          "image/gif"
+        case .webp:         "image/webp"
+        case .mp4Audio:     "audio/mp4"
+        case .m4a:          "audio/m4a"
+        case .aac:          "audio/aac"
+        case .mpeg:         "audio/mpeg"
+        case .mp3:          "audio/mp3"
+        case .wav:          "audio/wav"
+        case .xWav:         "audio/x-wav"
+        case .ogg:          "audio/ogg"
+        case .pdf:          "application/pdf"
+        case .octetStream:  "application/octet-stream"
+        }
+    }
+    
+    var defaultExtension: String {
+        switch self {
+        case .jpeg, .jpg:           "jpg"
+        case .png:                  "png"
+        case .webp:                 "webp"
+        case .gif:                  "gif"
+        case .mp4Audio, .m4a, .aac: "m4a"
+        case .mpeg, .mp3:           "mp3"
+        case .wav, .xWav:           "wav"
+        case .ogg:                  "ogg"
+        case .pdf:                  "pdf"
+        case .octetStream:          "bin"
+        }
+    }
+
+    static var allowed: Set<MimeType> = [
+        .jpeg, .jpg, .png, .gif, .webp,
+        .mp4Audio, .m4a, .aac, .mpeg, .mp3,
+        .wav, .xWav, .ogg,
+        .pdf, .octetStream
+    ]
+
+    var isAllowed: Bool {
+        Self.allowed.contains(self)
+    }
+
+    // MARK: - Byte signature validation
+    func matches(data: Data) -> Bool {
+        guard !data.isEmpty else { return false }
+
+        // Generic type → skip validation
+        if self == .octetStream { return true }
+
+        switch self {
+        case .jpeg, .jpg:
+            return data.count >= 3 && data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF
+
+        case .png:
+            return data.count >= 8 &&
+                   data[0] == 0x89 && data[1] == 0x50 && data[2] == 0x4E && data[3] == 0x47 &&
+                   data[4] == 0x0D && data[5] == 0x0A && data[6] == 0x1A && data[7] == 0x0A
+
+        case .gif:
+            return data.count >= 6 && data[0] == 0x47 && data[1] == 0x49 && data[2] == 0x46 &&
+                   data[3] == 0x38 && (data[4] == 0x37 || data[4] == 0x39) && data[5] == 0x61
+
+        case .webp:
+            return data.count >= 12 &&
+                   data[0] == 0x52 && data[1] == 0x49 && data[2] == 0x46 && data[3] == 0x46 &&
+                   data[8] == 0x57 && data[9] == 0x45 && data[10] == 0x42 && data[11] == 0x50
+
+        case .m4a, .mp4Audio, .aac:
+            // AVAudioRecorder output varies by platform - be lenient
+            // Security: size already capped + sandboxed execution
+            return data.count > 100
+
+        case .mpeg, .mp3:
+            if data.count >= 3 && data[0] == 0x49 && data[1] == 0x44 && data[2] == 0x33 {
+                return true // ID3 header
+            }
+            return data.count >= 2 && data[0] == 0xFF && (data[1] & 0xE0) == 0xE0
+
+        case .wav, .xWav:
+            return data.count >= 12 &&
+                   data[0] == 0x52 && data[1] == 0x49 && data[2] == 0x46 && data[3] == 0x46 &&
+                   data[8] == 0x57 && data[9] == 0x41 && data[10] == 0x56 && data[11] == 0x45
+
+        case .ogg:
+            return data.count >= 4 &&
+                   data[0] == 0x4F && data[1] == 0x67 && data[2] == 0x67 && data[3] == 0x53
+
+        case .pdf:
+            return data.count >= 4 &&
+                   data[0] == 0x25 && data[1] == 0x50 && data[2] == 0x44 && data[3] == 0x46
+
+        default:
+            return false
+        }
+    }
+
+    // MARK: - Convenience Initializers
+
+    init?(_ mimeString: String?) {
+        guard let mimeString else { return nil }
+        
+        let normalized = mimeString.lowercased()
+
+        // Direct match with our canonical list
+        if let match = MimeType.allCases.first(where: { $0.mimeString == normalized }) {
+            self = match
+            return
+        }
+
+        // Let UTType normalize aliases like "image/jpg", "audio/x-wav", etc.
+        if let type = UTType(mimeType: normalized),
+           let match = MimeType.allCases.first(where: { type.conforms(to: $0.utType) }) {
+            self = match
+            return
+        }
+
+        return nil
+    }
+}
+
+extension MimeType {
+    enum Category: String {
+        case audio, image, file
+    }
+}

bitchat/Services/ColorPaletteService.swift

@@ -1,328 +0,0 @@
-//
-// ColorPaletteService.swift
-// bitchat
-//
-// Manages consistent color assignment for peers using minimal-distance algorithm
-// This is free and unencumbered software released into the public domain.
-//
-
-import Foundation
-import SwiftUI
-
-/// Service that assigns consistent, visually distinct colors to peers
-/// Uses a minimal-distance hue assignment algorithm to maximize color separation
-final class ColorPaletteService {
-
-    // MARK: - Palette State
-
-    private var peerPaletteLight: [String: (slot: Int, ring: Int, hue: Double)] = [:]
-    private var peerPaletteDark: [String: (slot: Int, ring: Int, hue: Double)] = [:]
-    private var peerPaletteSeeds: [String: String] = [:] // peerID -> seed used
-
-    private var nostrPaletteLight: [String: (slot: Int, ring: Int, hue: Double)] = [:]
-    private var nostrPaletteDark: [String: (slot: Int, ring: Int, hue: Double)] = [:]
-    private var nostrPaletteSeeds: [String: String] = [:] // pubkey -> seed used
-
-    // MARK: - Configuration
-
-    private let slotCount: Int
-    private let avoidCenter: Double // Hue to avoid (typically orange for self)
-    private let avoidDelta: Double
-    private let saturationDark: Double
-    private let saturationLight: Double
-    private let baseBrightnessDark: Double
-    private let baseBrightnessLight: Double
-    private let ringDeltaDark: Double
-    private let ringDeltaLight: Double
-
-    // MARK: - Initialization
-
-    init(
-        slotCount: Int = max(8, TransportConfig.uiPeerPaletteSlots),
-        avoidCenter: Double = 30.0 / 360.0, // Orange hue
-        avoidDelta: Double = TransportConfig.uiColorHueAvoidanceDelta,
-        saturationDark: Double = 0.80,
-        saturationLight: Double = 0.70,
-        baseBrightnessDark: Double = 0.75,
-        baseBrightnessLight: Double = 0.45,
-        ringDeltaDark: Double = TransportConfig.uiPeerPaletteRingBrightnessDeltaDark,
-        ringDeltaLight: Double = TransportConfig.uiPeerPaletteRingBrightnessDeltaLight
-    ) {
-        self.slotCount = slotCount
-        self.avoidCenter = avoidCenter
-        self.avoidDelta = avoidDelta
-        self.saturationDark = saturationDark
-        self.saturationLight = saturationLight
-        self.baseBrightnessDark = baseBrightnessDark
-        self.baseBrightnessLight = baseBrightnessLight
-        self.ringDeltaDark = ringDeltaDark
-        self.ringDeltaLight = ringDeltaLight
-    }
-
-    // MARK: - Public API
-
-    /// Get color for a mesh peer
-    func colorForMeshPeer(
-        peerID: String,
-        isDark: Bool,
-        myPeerID: String,
-        allPeers: [BitchatPeer],
-        getNoiseKeyForShortID: (String) -> String?
-    ) -> Color {
-        // Ensure palette is up to date
-        rebuildPeerPaletteIfNeeded(
-            myPeerID: myPeerID,
-            allPeers: allPeers,
-            getNoiseKeyForShortID: getNoiseKeyForShortID
-        )
-
-        let entry = (isDark ? peerPaletteDark[peerID] : peerPaletteLight[peerID])
-        let orange = Color.orange
-        if peerID == myPeerID { return orange }
-
-        let saturation: Double = isDark ? saturationDark : saturationLight
-        let baseBrightness: Double = isDark ? baseBrightnessDark : baseBrightnessLight
-        let ringDelta = isDark ? ringDeltaDark : ringDeltaLight
-
-        if let e = entry {
-            let brightness = min(1.0, max(0.0, baseBrightness + ringDelta * Double(e.ring)))
-            return Color(hue: e.hue, saturation: saturation, brightness: brightness)
-        }
-
-        // Fallback to seed color if not in palette
-        let seed = meshSeed(for: peerID, getNoiseKeyForShortID: getNoiseKeyForShortID)
-        return Color(peerSeed: seed, isDark: isDark)
-    }
-
-    /// Get color for a Nostr participant
-    func colorForNostrPubkey(
-        pubkeyHexLowercased: String,
-        isDark: Bool,
-        myNostrPubkey: String?,
-        geohashPeople: [(id: String, seed: String)]
-    ) -> Color {
-        rebuildNostrPaletteIfNeeded(
-            myNostrPubkey: myNostrPubkey,
-            geohashPeople: geohashPeople
-        )
-
-        let entry = (isDark ? nostrPaletteDark[pubkeyHexLowercased] : nostrPaletteLight[pubkeyHexLowercased])
-        if let me = myNostrPubkey, pubkeyHexLowercased == me { return .orange }
-
-        let saturation: Double = isDark ? saturationDark : saturationLight
-        let baseBrightness: Double = isDark ? baseBrightnessDark : baseBrightnessLight
-        let ringDelta = isDark ? ringDeltaDark : ringDeltaLight
-
-        if let e = entry {
-            let brightness = min(1.0, max(0.0, baseBrightness + ringDelta * Double(e.ring)))
-            return Color(hue: e.hue, saturation: saturation, brightness: brightness)
-        }
-
-        // Fallback to seed color
-        return Color(peerSeed: "nostr:" + pubkeyHexLowercased, isDark: isDark)
-    }
-
-    /// Get color for a message sender (auto-detects type)
-    func peerColor(
-        for message: BitchatMessage,
-        isDark: Bool,
-        myPeerID: String,
-        myNostrPubkey: String?,
-        nostrKeyMapping: [String: String],
-        allPeers: [BitchatPeer],
-        geohashPeople: [(id: String, seed: String)],
-        getNoiseKeyForShortID: (String) -> String?
-    ) -> Color {
-        if let spid = message.senderPeerID?.id {
-            if spid.hasPrefix("nostr:") || spid.hasPrefix("nostr_") {
-                let bare: String = {
-                    if spid.hasPrefix("nostr:") { return String(spid.dropFirst(6)) }
-                    if spid.hasPrefix("nostr_") { return String(spid.dropFirst(6)) }
-                    return spid
-                }()
-                let full = nostrKeyMapping[spid]?.lowercased() ?? bare.lowercased()
-                return colorForNostrPubkey(
-                    pubkeyHexLowercased: full,
-                    isDark: isDark,
-                    myNostrPubkey: myNostrPubkey,
-                    geohashPeople: geohashPeople
-                )
-            } else if spid.count == 16 {
-                return colorForMeshPeer(
-                    peerID: spid,
-                    isDark: isDark,
-                    myPeerID: myPeerID,
-                    allPeers: allPeers,
-                    getNoiseKeyForShortID: getNoiseKeyForShortID
-                )
-            } else {
-                return colorForMeshPeer(
-                    peerID: spid.lowercased(),
-                    isDark: isDark,
-                    myPeerID: myPeerID,
-                    allPeers: allPeers,
-                    getNoiseKeyForShortID: getNoiseKeyForShortID
-                )
-            }
-        }
-        // Fallback when we only have a display name
-        return Color(peerSeed: message.sender.lowercased(), isDark: isDark)
-    }
-
-    /// Reset all palette state (useful for testing)
-    func reset() {
-        peerPaletteLight.removeAll()
-        peerPaletteDark.removeAll()
-        peerPaletteSeeds.removeAll()
-        nostrPaletteLight.removeAll()
-        nostrPaletteDark.removeAll()
-        nostrPaletteSeeds.removeAll()
-    }
-
-    // MARK: - Private Helpers
-
-    private func meshSeed(for peerID: String, getNoiseKeyForShortID: (String) -> String?) -> String {
-        if let full = getNoiseKeyForShortID(peerID)?.lowercased() {
-            return "noise:" + full
-        }
-        return peerID.lowercased()
-    }
-
-    private func rebuildPeerPaletteIfNeeded(
-        myPeerID: String,
-        allPeers: [BitchatPeer],
-        getNoiseKeyForShortID: (String) -> String?
-    ) {
-        // Build current peer->seed map (excluding self)
-        var currentSeeds: [String: String] = [:]
-        for p in allPeers where p.peerID.id != myPeerID {
-            currentSeeds[p.peerID.id] = meshSeed(for: p.peerID.id, getNoiseKeyForShortID: getNoiseKeyForShortID)
-        }
-
-        // If seeds unchanged and palette exists for both themes, skip
-        if currentSeeds == peerPaletteSeeds,
-           peerPaletteLight.keys.count == currentSeeds.count,
-           peerPaletteDark.keys.count == currentSeeds.count {
-            return
-        }
-        peerPaletteSeeds = currentSeeds
-
-        // Generate palette
-        let mapping = assignColorsMinimalDistance(seeds: currentSeeds, previousMapping: peerPaletteLight)
-        peerPaletteLight = mapping
-        peerPaletteDark = mapping
-    }
-
-    private func rebuildNostrPaletteIfNeeded(
-        myNostrPubkey: String?,
-        geohashPeople: [(id: String, seed: String)]
-    ) {
-        // Build seeds map from currently visible geohash people (excluding self)
-        var currentSeeds: [String: String] = [:]
-        for p in geohashPeople where p.id != myNostrPubkey {
-            currentSeeds[p.id] = p.seed
-        }
-
-        if currentSeeds == nostrPaletteSeeds,
-           nostrPaletteLight.keys.count == currentSeeds.count,
-           nostrPaletteDark.keys.count == currentSeeds.count {
-            return
-        }
-        nostrPaletteSeeds = currentSeeds
-
-        let mapping = assignColorsMinimalDistance(seeds: currentSeeds, previousMapping: nostrPaletteLight)
-        nostrPaletteLight = mapping
-        nostrPaletteDark = mapping
-    }
-
-    // MARK: - Minimal-Distance Color Assignment Algorithm
-
-    private func assignColorsMinimalDistance(
-        seeds: [String: String],
-        previousMapping: [String: (slot: Int, ring: Int, hue: Double)]
-    ) -> [String: (slot: Int, ring: Int, hue: Double)] {
-        // Generate evenly spaced hue slots avoiding self-orange range
-        var slots: [Double] = []
-        for i in 0..<slotCount {
-            let hue = Double(i) / Double(slotCount)
-            if abs(hue - avoidCenter) < avoidDelta { continue }
-            slots.append(hue)
-        }
-        if slots.isEmpty {
-            // Safety: if avoidance consumed all (shouldn't happen), fall back to full slots
-            for i in 0..<slotCount { slots.append(Double(i) / Double(slotCount)) }
-        }
-
-        // Helper to compute circular distance
-        func circDist(_ a: Double, _ b: Double) -> Double {
-            let d = abs(a - b)
-            return d > 0.5 ? 1.0 - d : d
-        }
-
-        // Assign slots to peers to maximize minimal distance, deterministically
-        let peers = seeds.keys.sorted() // stable order
-
-        // Preferred slot index by seed (wrapping to available slots)
-        let prefIndex: [String: Int] = Dictionary(uniqueKeysWithValues: peers.map { id in
-            let h = (seeds[id] ?? id).djb2()
-            let idx = Int(h % UInt64(slots.count))
-            return (id, idx)
-        })
-
-        var mapping: [String: (slot: Int, ring: Int, hue: Double)] = [:]
-        var usedSlots = Set<Int>()
-        var usedHues: [Double] = []
-
-        // Keep previous assignments if still valid to minimize churn
-        for (id, entry) in previousMapping {
-            if seeds.keys.contains(id), entry.slot < slots.count { // slot index still valid
-                mapping[id] = (entry.slot, entry.ring, slots[entry.slot])
-                usedSlots.insert(entry.slot)
-                usedHues.append(slots[entry.slot])
-            }
-        }
-
-        // First ring assignment using free slots
-        let unassigned = peers.filter { mapping[$0] == nil }
-        for id in unassigned {
-            // If a preferred slot free, take it
-            let preferred = prefIndex[id] ?? 0
-            if !usedSlots.contains(preferred) && preferred < slots.count {
-                mapping[id] = (preferred, 0, slots[preferred])
-                usedSlots.insert(preferred)
-                usedHues.append(slots[preferred])
-                continue
-            }
-            // Choose free slot maximizing minimal distance to used hues
-            var bestSlot: Int? = nil
-            var bestScore: Double = -1
-            for sIdx in 0..<slots.count where !usedSlots.contains(sIdx) {
-                let hue = slots[sIdx]
-                let minDist = usedHues.isEmpty ? 1.0 : usedHues.map { circDist(hue, $0) }.min() ?? 1.0
-                // Bias toward preferred index for stability
-                let bias = 1.0 - (Double((abs(sIdx - (prefIndex[id] ?? 0)) % slots.count)) / Double(slots.count))
-                let score = minDist + 0.05 * bias
-                if score > bestScore { bestScore = score; bestSlot = sIdx }
-            }
-            if let s = bestSlot {
-                mapping[id] = (s, 0, slots[s])
-                usedSlots.insert(s)
-                usedHues.append(slots[s])
-            }
-        }
-
-        // Overflow peers: assign additional rings by reusing slots with stable preference
-        let stillUnassigned = peers.filter { mapping[$0] == nil }
-        if !stillUnassigned.isEmpty {
-            for (idx, id) in stillUnassigned.enumerated() {
-                let preferred = prefIndex[id] ?? 0
-                // Spread over slots by rotating from preferred with a golden-step
-                let goldenStep = 7 // small prime step for dispersion
-                let s = (preferred + idx * goldenStep) % slots.count
-                mapping[id] = (s, 1, slots[s])
-            }
-        }
-
-        return mapping
-    }
-}

bitchat/Services/CommandProcessor.swift

@@ -42,7 +42,7 @@ final class CommandProcessor {
             case .location: return true
             }
         }()
-        let inGeoDM = (chatViewModel?.selectedPrivateChatPeer?.hasPrefix("nostr_") == true)
+        let inGeoDM = chatViewModel?.selectedPrivateChatPeer?.isGeoDM == true
 
         switch cmd {
         case "/m", "/msg":
@@ -65,14 +65,11 @@ final class CommandProcessor {
         case "/unfav":
             if inGeoPublic || inGeoDM { return .error(message: "favorites are only for mesh peers in #mesh") }
             return handleFavorite(args, add: false)
-        //
-        case "/help", "/h":
-            return .error(message: "unknown command: \(cmd)")
         default:
             return .error(message: "unknown command: \(cmd)")
         }
     }
-    
+
     // MARK: - Command Handlers
     
     private func handleMessage(_ args: String) -> CommandResult {
@@ -104,7 +101,7 @@ final class CommandProcessor {
         case .location(let ch):
             // Geohash context: show visible geohash participants (exclude self)
             guard let vm = chatViewModel else { return .success(message: "nobody around") }
-            let myHex = (try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash))?.publicKeyHex.lowercased()
+            let myHex = (try? chatViewModel?.idBridge.deriveIdentity(forGeohash: ch.geohash))?.publicKeyHex.lowercased()
             let people = vm.visibleGeohashPeople().filter { person in
                 if let me = myHex { return person.id.lowercased() != me }
                 return true
@@ -148,9 +145,9 @@ final class CommandProcessor {
         
         if chatViewModel?.selectedPrivateChatPeer != nil {
             // In private chat
-            if let peerNickname = meshService?.peerNickname(peerID: PeerID(str: targetPeerID)) {
+            if let peerNickname = meshService?.peerNickname(peerID: targetPeerID) {
                 let personalMessage = "* \(emoji) \(myNickname) \(action) you\(suffix) *"
-                meshService?.sendPrivateMessage(personalMessage, to: PeerID(str: targetPeerID),
+                meshService?.sendPrivateMessage(personalMessage, to: targetPeerID,
                                                recipientNickname: peerNickname,
                                                messageID: UUID().uuidString)
                 // Also add a local system message so the sender sees a natural-language confirmation
@@ -214,7 +211,7 @@ final class CommandProcessor {
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
         if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-           let fingerprint = meshService?.getFingerprint(for: PeerID(str: peerID)) {
+           let fingerprint = meshService?.getFingerprint(for: peerID) {
             if identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is already blocked")
             }
@@ -258,7 +255,7 @@ final class CommandProcessor {
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
         if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-           let fingerprint = meshService?.getFingerprint(for: PeerID(str: peerID)) {
+           let fingerprint = meshService?.getFingerprint(for: peerID) {
             if !identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is not blocked")
             }
@@ -285,7 +282,7 @@ final class CommandProcessor {
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
         guard let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-              let noisePublicKey = Data(hexString: peerID) else {
+              let noisePublicKey = Data(hexString: peerID.id) else {
             return .error(message: "can't find peer: \(nickname)")
         }
         
@@ -311,19 +308,4 @@ final class CommandProcessor {
         }
     }
     
-    private func handleHelp() -> CommandResult {
-        let helpText = """
-        commands:
-        /msg @name - start private chat
-        /who - list who's online
-        /clear - clear messages
-        /hug @name - send a hug
-        /slap @name - slap with a trout
-        /fav @name - add to favorites
-        /unfav @name - remove from favorites
-        /block @name - block
-        /unblock @name - unblock
-        """
-        return .success(message: helpText)
-    }
 }

bitchat/Services/DeliveryTrackingService.swift

@@ -1,73 +0,0 @@
-//
-// DeliveryTrackingService.swift
-// bitchat
-//
-// Service for tracking message delivery and read status
-// This is free and unencumbered software released into the public domain.
-//
-
-import BitLogger
-import Foundation
-
-/// Service that manages delivery status updates for messages
-/// Prevents status downgrades (e.g., read → delivered) and maintains consistency
-final class DeliveryTrackingService {
-
-    // MARK: - Public API
-
-    /// Update delivery status for a message, preventing downgrades
-    /// - Parameters:
-    ///   - messageID: The message ID to update
-    ///   - status: The new delivery status
-    ///   - messages: Array of public messages (inout for mutation)
-    ///   - privateChats: Dictionary of private chats (inout for mutation)
-    ///   - notifyChange: Closure to trigger UI update
-    func updateStatus(
-        messageID: String,
-        status: DeliveryStatus,
-        messages: inout [BitchatMessage],
-        privateChats: inout [String: [BitchatMessage]],
-        notifyChange: @escaping () -> Void
-    ) {
-        // Update in main messages
-        if let index = messages.firstIndex(where: { $0.id == messageID }) {
-            let currentStatus = messages[index].deliveryStatus
-            if !shouldSkipUpdate(currentStatus: currentStatus, newStatus: status) {
-                messages[index].deliveryStatus = status
-            }
-        }
-
-        // Update in private chats
-        for (peerID, chatMessages) in privateChats {
-            guard let index = chatMessages.firstIndex(where: { $0.id == messageID }) else { continue }
-
-            let currentStatus = chatMessages[index].deliveryStatus
-            guard !shouldSkipUpdate(currentStatus: currentStatus, newStatus: status) else { continue }
-
-            // Update delivery status
-            privateChats[peerID]?[index].deliveryStatus = status
-        }
-
-        // Trigger UI update
-        DispatchQueue.main.async {
-            notifyChange()
-        }
-    }
-
-    // MARK: - Private Helpers
-
-    /// Check if we should skip a status update to prevent downgrades
-    private func shouldSkipUpdate(currentStatus: DeliveryStatus?, newStatus: DeliveryStatus) -> Bool {
-        guard let current = currentStatus else { return false }
-
-        // Don't downgrade from read to delivered or sent
-        switch (current, newStatus) {
-        case (.read, .delivered):
-            return true
-        case (.read, .sent):
-            return true
-        default:
-            return false
-        }
-    }
-}

bitchat/Services/FavoritesPersistenceService.swift

@@ -26,6 +26,7 @@ final class FavoritesPersistenceService: ObservableObject {
 
     private static let storageKey = "chat.bitchat.favorites"
     private static let keychainService = "chat.bitchat.favorites"
+    private let keychain: KeychainHelperProtocol
     
     @Published private(set) var favorites: [Data: FavoriteRelationship] = [:] // Noise pubkey -> relationship
     @Published private(set) var mutualFavorites: Set<Data> = []
@@ -35,7 +36,8 @@ final class FavoritesPersistenceService: ObservableObject {
     
     static let shared = FavoritesPersistenceService()
     
-    private init() {
+    init(keychain: KeychainHelperProtocol = KeychainHelper()) {
+        self.keychain = keychain
         loadFavorites()
         
         // Update mutual favorites when favorites change
@@ -45,13 +47,7 @@ final class FavoritesPersistenceService: ObservableObject {
             }
             .assign(to: &$mutualFavorites)
     }
-
+    
-    deinit {
-        // Clean up Combine subscriptions
-        cancellables.removeAll()
-        SecureLogger.debug("FavoritesPersistenceService deinitialized", category: .session)
-    }
-
     /// Add or update a favorite
     func addFavorite(
         peerNoisePublicKey: Data,
@@ -202,7 +198,7 @@ final class FavoritesPersistenceService: ObservableObject {
         saveFavorites()
         
         // Delete from keychain directly
-        KeychainHelper.delete(
+        keychain.delete(
             key: Self.storageKey,
             service: Self.keychainService
         )
@@ -222,10 +218,11 @@ final class FavoritesPersistenceService: ObservableObject {
             let data = try encoder.encode(relationships)
             
             // Store in keychain for security
-            KeychainHelper.save(
+            keychain.save(
                 key: Self.storageKey,
                 data: data,
-                service: Self.keychainService
+                service: Self.keychainService,
+                accessible: nil
             )
             
             // Successfully saved favorites
@@ -237,7 +234,7 @@ final class FavoritesPersistenceService: ObservableObject {
     private func loadFavorites() {
         // Loading favorites from keychain
         
-        guard let data = KeychainHelper.load(
+        guard let data = keychain.load(
             key: Self.storageKey,
             service: Self.keychainService
         ) else { 

bitchat/Services/GeohashBookmarksStore.swift

@@ -1,7 +1,8 @@
-import BitLogger
 import Foundation
 import Combine
+#if os(iOS) || os(macOS)
 import CoreLocation
+#endif
 
 /// Stores a user-maintained list of bookmarked geohash channels.
 /// - Persistence: UserDefaults (JSON string array)
@@ -15,8 +16,10 @@ final class GeohashBookmarksStore: ObservableObject {
     private let storeKey = "locationChannel.bookmarks"
     private let namesStoreKey = "locationChannel.bookmarkNames"
     private var membership: Set<String> = []
+    #if os(iOS) || os(macOS)
     private let geocoder = CLGeocoder()
     private var resolving: Set<String> = []
+    #endif
     
     private let storage: UserDefaults
 
@@ -25,12 +28,6 @@ final class GeohashBookmarksStore: ObservableObject {
         load()
     }
 
-    deinit {
-        // Cancel any pending geocoding operations
-        geocoder.cancelGeocode()
-        SecureLogger.debug("GeohashBookmarksStore deinitialized", category: .session)
-    }
-
     // MARK: - Public API
     func isBookmarked(_ geohash: String) -> Bool {
         return membership.contains(Self.normalize(geohash))
@@ -121,6 +118,7 @@ final class GeohashBookmarksStore: ObservableObject {
         let gh = Self.normalize(geohash)
         guard !gh.isEmpty else { return }
         if bookmarkNames[gh] != nil { return }
+        #if os(iOS) || os(macOS)
         if resolving.contains(gh) { return }
         resolving.insert(gh)
         // For very coarse geohashes, sample multiple points to capture multiple admin areas
@@ -151,8 +149,10 @@ final class GeohashBookmarksStore: ObservableObject {
                 }
             }
         }
+        #endif
     }
 
+    #if os(iOS) || os(macOS)
     private func resolveCompositeAdminName(geohash gh: String, points: [CLLocation]) {
         var uniqueAdmins = OrderedSet<String>()
         var idx = 0
@@ -215,15 +215,5 @@ final class GeohashBookmarksStore: ObservableObject {
             return pm.subLocality ?? pm.locality ?? pm.administrativeArea ?? pm.country
         }
     }
-
-    #if DEBUG
-    /// Testing-only reset helper
-    func _resetForTesting() {
-        bookmarks.removeAll()
-        membership.removeAll()
-        bookmarkNames.removeAll()
-        persist()
-        persistNames()
-    }
     #endif
 }

bitchat/Services/GeohashParticipantsService.swift

@@ -1,180 +0,0 @@
-//
-// GeohashParticipantsService.swift
-// bitchat
-//
-// Manages tracking of participants in geohash-based location channels
-// This is free and unencumbered software released into the public domain.
-//
-
-import BitLogger
-import Foundation
-import Combine
-
-/// Service for tracking and managing participants in geohash channels
-/// Handles automatic expiration, refresh timers, and participant list management
-final class GeohashParticipantsService: ObservableObject {
-
-    // MARK: - Published Properties
-
-    @Published private(set) var geohashPeople: [GeoPerson] = []
-
-    // MARK: - Private State
-
-    private var geoParticipants: [String: [String: Date]] = [:] // geohash -> [pubkeyHex -> lastSeen]
-    private var geoParticipantsTimer: Timer? = nil
-    private var currentGeohash: String? = nil
-
-    // MARK: - Dependencies
-
-    private let identityManager: SecureIdentityStateManagerProtocol
-    private let displayNameProvider: (String) -> String
-
-    // MARK: - Configuration
-
-    private let activityWindowSeconds: TimeInterval
-    private let refreshIntervalSeconds: TimeInterval
-
-    // MARK: - Initialization
-
-    init(
-        identityManager: SecureIdentityStateManagerProtocol,
-        displayNameProvider: @escaping (String) -> String,
-        activityWindowSeconds: TimeInterval = TransportConfig.uiRecentCutoffFiveMinutesSeconds,
-        refreshIntervalSeconds: TimeInterval = 30.0
-    ) {
-        self.identityManager = identityManager
-        self.displayNameProvider = displayNameProvider
-        self.activityWindowSeconds = activityWindowSeconds
-        self.refreshIntervalSeconds = refreshIntervalSeconds
-    }
-
-    deinit {
-        // Note: deinit cannot call @MainActor methods
-        // Timer cleanup will happen automatically when service is deallocated
-        SecureLogger.debug("GeohashParticipantsService deinitialized", category: .session)
-    }
-
-    // MARK: - Public API
-
-    /// Set the current geohash being tracked (starts/stops timer accordingly)
-    func setCurrentGeohash(_ geohash: String?) {
-        if currentGeohash != geohash {
-            currentGeohash = geohash
-            refreshPeopleList()
-
-            if geohash != nil {
-                startTimer()
-            } else {
-                stopTimer()
-            }
-        }
-    }
-
-    /// Record a participant activity in the current geohash
-    func recordParticipant(pubkeyHex: String) {
-        guard let gh = currentGeohash else { return }
-        recordParticipant(pubkeyHex: pubkeyHex, geohash: gh)
-    }
-
-    /// Record a participant activity in a specific geohash
-    func recordParticipant(pubkeyHex: String, geohash: String) {
-        let key = pubkeyHex.lowercased()
-        var map = geoParticipants[geohash] ?? [:]
-        map[key] = Date()
-        geoParticipants[geohash] = map
-
-        // Only refresh list if this geohash is currently selected
-        if currentGeohash == geohash {
-            refreshPeopleList()
-        }
-    }
-
-    /// Get visible people for the current geohash (without mutating state)
-    func visiblePeople() -> [GeoPerson] {
-        guard let gh = currentGeohash else { return [] }
-        return visiblePeople(for: gh)
-    }
-
-    /// Get visible people for a specific geohash
-    func visiblePeople(for geohash: String) -> [GeoPerson] {
-        let cutoff = Date().addingTimeInterval(-activityWindowSeconds)
-        let map = (geoParticipants[geohash] ?? [:])
-            .filter { $0.value >= cutoff }
-            .filter { !identityManager.isNostrBlocked(pubkeyHexLowercased: $0.key) }
-        let people = map
-            .map { (pub, seen) in
-                GeoPerson(id: pub, displayName: displayNameProvider(pub), lastSeen: seen)
-            }
-            .sorted { $0.lastSeen > $1.lastSeen }
-        return people
-    }
-
-    /// Get participant count for a specific geohash (using activity window)
-    func participantCount(for geohash: String) -> Int {
-        let cutoff = Date().addingTimeInterval(-activityWindowSeconds)
-        let map = geoParticipants[geohash] ?? [:]
-        return map.values.filter { $0 >= cutoff }.count
-    }
-
-    /// Remove a participant from all geohashes (e.g., when blocked)
-    func removeParticipant(pubkeyHexLowercased: String) {
-        let hex = pubkeyHexLowercased.lowercased()
-        for (gh, var map) in geoParticipants {
-            map.removeValue(forKey: hex)
-            geoParticipants[gh] = map
-        }
-        refreshPeopleList()
-    }
-
-    /// Clear all participant data (for testing or reset)
-    func reset() {
-        stopTimer()
-        geoParticipants.removeAll()
-        geohashPeople.removeAll()
-        currentGeohash = nil
-    }
-
-    // MARK: - Private Helpers
-
-    private func refreshPeopleList() {
-        guard let gh = currentGeohash else {
-            geohashPeople = []
-            return
-        }
-
-        let cutoff = Date().addingTimeInterval(-activityWindowSeconds)
-        var map = geoParticipants[gh] ?? [:]
-
-        // Prune expired entries
-        map = map.filter { $0.value >= cutoff }
-
-        // Remove blocked Nostr pubkeys
-        map = map.filter { !identityManager.isNostrBlocked(pubkeyHexLowercased: $0.key) }
-
-        // Update cleaned map
-        geoParticipants[gh] = map
-
-        // Build display list
-        let people = map
-            .map { (pub, seen) in
-                GeoPerson(id: pub, displayName: displayNameProvider(pub), lastSeen: seen)
-            }
-            .sorted { $0.lastSeen > $1.lastSeen }
-
-        geohashPeople = people
-    }
-
-    private func startTimer() {
-        stopTimer()
-        geoParticipantsTimer = Timer.scheduledTimer(withTimeInterval: refreshIntervalSeconds, repeats: true) { [weak self] _ in
-            Task { @MainActor in
-                self?.refreshPeopleList()
-            }
-        }
-    }
-
-    private func stopTimer() {
-        geoParticipantsTimer?.invalidate()
-        geoParticipantsTimer = nil
-    }
-}

bitchat/Services/KeychainManager.swift

@@ -27,34 +27,6 @@ final class KeychainManager: KeychainManagerProtocol {
     private let service = BitchatApp.bundleID
     private let appGroup = "group.\(BitchatApp.bundleID)"
     
-    private func isSandboxed() -> Bool {
-        #if os(macOS)
-        // More robust sandbox detection using multiple methods
-        
-        // Method 1: Check environment variable (can be spoofed)
-        let environment = ProcessInfo.processInfo.environment
-        let hasEnvVar = environment["APP_SANDBOX_CONTAINER_ID"] != nil
-        
-        // Method 2: Check if we can access a path outside sandbox
-        let homeDir = FileManager.default.homeDirectoryForCurrentUser
-        let testPath = homeDir.appendingPathComponent("../../../tmp/bitchat_sandbox_test_\(UUID().uuidString)")
-        let canWriteOutsideSandbox = FileManager.default.createFile(atPath: testPath.path, contents: nil, attributes: nil)
-        if canWriteOutsideSandbox {
-            try? FileManager.default.removeItem(at: testPath)
-        }
-        
-        // Method 3: Check container path
-        let containerPath = FileManager.default.urls(for: .libraryDirectory, in: .userDomainMask).first?.path ?? ""
-        let hasContainerPath = containerPath.contains("/Containers/")
-        
-        // If any method indicates sandbox, we consider it sandboxed
-        return hasEnvVar || !canWriteOutsideSandbox || hasContainerPath
-        #else
-        // iOS is always sandboxed
-        return true
-        #endif
-    }
-    
     // MARK: - Identity Keys
     
     func saveIdentityKey(_ keyData: Data, forKey key: String) -> Bool {

bitchat/Services/LocationChannelManager.swift

@@ -64,7 +64,9 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         switch status {
         case .authorizedAlways, .authorizedWhenInUse, .authorized:
             break // will compute from location
-        default:
+        case .notDetermined, .restricted, .denied:
+            fallthrough
+        @unknown default:
             if case .location(let ch) = selectedChannel {
                 teleported = teleportedSet.contains(ch.geohash)
             }

bitchat/Services/LocationNotesCounter.swift

@@ -1,110 +0,0 @@
-import BitLogger
-import Foundation
-
-struct LocationNotesCounterDependencies {
-    typealias RelayLookup = @MainActor (_ geohash: String, _ count: Int) -> [String]
-    typealias Subscribe = @MainActor (_ filter: NostrFilter, _ id: String, _ relays: [String], _ handler: @escaping (NostrEvent) -> Void, _ onEOSE: (() -> Void)?) -> Void
-    typealias Unsubscribe = @MainActor (_ id: String) -> Void
-
-    var relayLookup: RelayLookup
-    var subscribe: Subscribe
-    var unsubscribe: Unsubscribe
-
-    static let live = LocationNotesCounterDependencies(
-        relayLookup: { geohash, count in
-            GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: count)
-        },
-        subscribe: { filter, id, relays, handler, onEOSE in
-            NostrRelayManager.shared.subscribe(
-                filter: filter,
-                id: id,
-                relayUrls: relays,
-                handler: handler,
-                onEOSE: onEOSE
-            )
-        },
-        unsubscribe: { id in
-            NostrRelayManager.shared.unsubscribe(id: id)
-        }
-    )
-}
-
-/// Lightweight background counter for location notes (kind 1) at building-level geohash (8 chars).
-@MainActor
-final class LocationNotesCounter: ObservableObject {
-    static let shared = LocationNotesCounter()
-
-    @Published private(set) var geohash: String? = nil
-    @Published private(set) var count: Int? = 0
-    @Published private(set) var initialLoadComplete: Bool = false
-    @Published private(set) var relayAvailable: Bool = true
-
-    private var subscriptionID: String? = nil
-    private var noteIDs = Set<String>()
-    private let dependencies: LocationNotesCounterDependencies
-
-    private init(dependencies: LocationNotesCounterDependencies = .live) {
-        self.dependencies = dependencies
-    }
-
-    init(testDependencies: LocationNotesCounterDependencies) {
-        self.dependencies = testDependencies
-    }
-
-    deinit {
-        // Note: deinit cannot call @MainActor functions
-        // Subscription cleanup will happen automatically when counter is deallocated
-        SecureLogger.debug("LocationNotesCounter deinitialized", category: .session)
-    }
-
-    func subscribe(geohash gh: String) {
-        let norm = gh.lowercased()
-        if geohash == norm, subscriptionID != nil { return }
-        // Validate geohash (building-level precision: 8 chars)
-        guard Geohash.isValidBuildingGeohash(norm) else {
-            SecureLogger.warning("LocationNotesCounter: rejecting invalid geohash '\(norm)' (expected 8 valid base32 chars)", category: .session)
-            return
-        }
-        // Unsubscribe previous without clearing count to avoid flicker
-        if let sub = subscriptionID { dependencies.unsubscribe(sub) }
-        subscriptionID = nil
-        geohash = norm
-        noteIDs.removeAll()
-        initialLoadComplete = false
-        relayAvailable = true
-
-        // Subscribe only to the building geohash (precision 8)
-        let subID = "locnotes-count-\(norm)-\(UUID().uuidString.prefix(6))"
-        let relays = dependencies.relayLookup(norm, TransportConfig.nostrGeoRelayCount)
-        guard !relays.isEmpty else {
-            relayAvailable = false
-            initialLoadComplete = true
-            count = 0
-            SecureLogger.warning("LocationNotesCounter: no geo relays for geohash=\(norm)", category: .session)
-            return
-        }
-
-        subscriptionID = subID
-        let filter = NostrFilter.geohashNotes(norm, since: nil, limit: 200)
-        dependencies.subscribe(filter, subID, relays, { [weak self] event in
-            guard let self = self else { return }
-            guard event.kind == NostrProtocol.EventKind.textNote.rawValue else { return }
-            guard event.tags.contains(where: { $0.count >= 2 && $0[0].lowercased() == "g" && $0[1].lowercased() == norm }) else { return }
-            if !self.noteIDs.contains(event.id) {
-                self.noteIDs.insert(event.id)
-                self.count = self.noteIDs.count
-            }
-        }, { [weak self] in
-            self?.initialLoadComplete = true
-        })
-    }
-
-    func cancel() {
-        if let sub = subscriptionID { dependencies.unsubscribe(sub) }
-        subscriptionID = nil
-        geohash = nil
-        count = 0
-        noteIDs.removeAll()
-        relayAvailable = true
-    }
-}

bitchat/Services/LocationNotesManager.swift

@@ -14,6 +14,8 @@ struct LocationNotesDependencies {
     var sendEvent: SendEvent
     var deriveIdentity: (_ geohash: String) throws -> NostrIdentity
     var now: () -> Date
+    
+    private static let idBridge = NostrIdentityBridge()
 
     static let live = LocationNotesDependencies(
         relayLookup: { geohash, count in
@@ -35,7 +37,7 @@ struct LocationNotesDependencies {
             NostrRelayManager.shared.sendEvent(event, to: relays)
         },
         deriveIdentity: { geohash in
-            try NostrIdentityBridge.deriveIdentity(forGeohash: geohash)
+            try idBridge.deriveIdentity(forGeohash: geohash)
         },
         now: { Date() }
     )
@@ -101,12 +103,6 @@ final class LocationNotesManager: ObservableObject {
         subscribe()
     }
 
-    deinit {
-        // Note: deinit cannot call @MainActor functions
-        // Subscription cleanup will happen automatically when manager is deallocated
-        SecureLogger.debug("LocationNotesManager deinitialized", category: .session)
-    }
-
     func setGeohash(_ newGeohash: String) {
         let norm = newGeohash.lowercased()
         guard norm != geohash else { return }
@@ -167,14 +163,22 @@ final class LocationNotesManager: ObservableObject {
 
         subscriptionID = subID
         initialLoadComplete = false
-        // For persistent notes, allow relays to return recent history without an aggressive time cutoff
+
-        let filter = NostrFilter.geohashNotes(geohash, since: nil, limit: 200)
+        // Subscribe to center + 8 neighbors (± 1 grid)
+        let neighbors = Geohash.neighbors(of: geohash)
+        let allGeohashes = [geohash] + neighbors
+        let filter = NostrFilter.geohashNotes(allGeohashes, since: nil, limit: 200)
+
+        // Build a set of valid geohashes for tag matching (includes all 9 cells)
+        let validGeohashes = Set(allGeohashes.map { $0.lowercased() })
 
         dependencies.subscribe(filter, subID, relays, { [weak self] event in
             guard let self = self else { return }
             guard event.kind == NostrProtocol.EventKind.textNote.rawValue else { return }
-            // Ensure matching tag
+            // Ensure matching tag - accept any of our 9 geohashes
-            guard event.tags.contains(where: { $0.count >= 2 && $0[0].lowercased() == "g" && $0[1].lowercased() == self.geohash }) else { return }
+            guard event.tags.contains(where: { tag in
+                tag.count >= 2 && tag[0].lowercased() == "g" && validGeohashes.contains(tag[1].lowercased())
+            }) else { return }
             guard !self.noteIDs.contains(event.id) else { return }
             self.noteIDs.insert(event.id)
             let nick = event.tags.first(where: { $0.first?.lowercased() == "n" && $0.count >= 2 })?.dropFirst().first

bitchat/Services/MeshTopologyTracker.swift

@@ -0,0 +1,120 @@
+import Foundation
+
+/// Tracks observed mesh topology and computes hop-by-hop routes.
+final class MeshTopologyTracker {
+    private typealias RoutingID = Data
+
+    private let queue = DispatchQueue(label: "mesh.topology", attributes: .concurrent)
+    private let hopSize = 8
+    private var adjacency: [RoutingID: Set<RoutingID>] = [:]
+
+    func reset() {
+        queue.sync(flags: .barrier) {
+            self.adjacency.removeAll()
+        }
+    }
+
+    func recordDirectLink(between a: Data?, and b: Data?) {
+        guard let left = sanitize(a), let right = sanitize(b), left != right else { return }
+        queue.sync(flags: .barrier) {
+            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 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 }
+            for neighbor in neighbors {
+                if var set = self.adjacency[neighbor] {
+                    set.remove(peer)
+                    self.adjacency[neighbor] = set.isEmpty ? nil : set
+                }
+            }
+        }
+    }
+
+    func recordRoute(_ hops: [Data]) {
+        let sanitized = hops.compactMap { sanitize($0) }
+        guard sanitized.count >= 2 else { return }
+        queue.sync(flags: .barrier) {
+            for idx in 0..<(sanitized.count - 1) {
+                let left = sanitized[idx]
+                let right = sanitized[idx + 1]
+                guard left != right else { continue }
+
+                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]? {
+        guard let source = sanitize(start), let target = sanitize(goal) else { return nil }
+        if source == target { return [source] }
+
+        let graph = queue.sync { adjacency }
+        guard graph[source] != nil, graph[target] != nil else { return nil }
+
+        var visited: Set<RoutingID> = [source]
+        var queuePaths: [[RoutingID]] = [[source]]
+        var index = 0
+
+        while index < queuePaths.count {
+            let path = queuePaths[index]
+            index += 1
+            guard path.count <= maxHops else { continue }
+            guard let last = path.last, let neighbors = graph[last] else { continue }
+
+            for neighbor in neighbors {
+                if visited.contains(neighbor) { continue }
+                var nextPath = path
+                nextPath.append(neighbor)
+                if neighbor == target { return nextPath }
+                if nextPath.count <= maxHops {
+                    queuePaths.append(nextPath)
+                }
+                visited.insert(neighbor)
+            }
+        }
+
+        return nil
+    }
+
+    // MARK: - Helpers
+
+    private func sanitize(_ data: Data?) -> Data? {
+        guard var value = data, !value.isEmpty else { return nil }
+        if value.count > hopSize {
+            value = Data(value.prefix(hopSize))
+        } else if value.count < hopSize {
+            value.append(Data(repeating: 0, count: hopSize - value.count))
+        }
+        return value
+    }
+}

bitchat/Services/MessageFormattingService.swift

@@ -1,618 +0,0 @@
-//
-// MessageFormattingService.swift
-// bitchat
-//
-// Service for formatting chat messages with syntax highlighting
-// This is free and unencumbered software released into the public domain.
-//
-
-import Foundation
-import SwiftUI
-
-/// Service that formats BitchatMessages into styled AttributedStrings
-/// Handles hashtags, mentions, links, payment tokens, and more
-final class MessageFormattingService {
-
-    // MARK: - Precompiled Regexes
-
-    private enum Regexes {
-        static let hashtag: NSRegularExpression = {
-            try! NSRegularExpression(pattern: "#([a-zA-Z0-9_]+)", options: [])
-        }()
-        static let mention: NSRegularExpression = {
-            try! NSRegularExpression(pattern: "@([\\p{L}0-9_]+(?:#[a-fA-F0-9]{4})?)", options: [])
-        }()
-        static let cashu: NSRegularExpression = {
-            try! NSRegularExpression(pattern: "\\bcashu[AB][A-Za-z0-9._-]{40,}\\b", 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: [])
-        }()
-        static let lightningScheme: NSRegularExpression = {
-            try! NSRegularExpression(pattern: "(?i)\\blightning:[^\\s]+", options: [])
-        }()
-        static let linkDetector: NSDataDetector? = {
-            try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue)
-        }()
-        static let quickCashuPresence: NSRegularExpression = {
-            try! NSRegularExpression(pattern: "\\bcashu[AB][A-Za-z0-9._-]{40,}\\b", options: [])
-        }()
-    }
-
-    // MARK: - Dependencies
-
-    private let colorPalette: ColorPaletteService
-
-    // MARK: - Initialization
-
-    init(colorPalette: ColorPaletteService) {
-        self.colorPalette = colorPalette
-    }
-
-    // MARK: - Public API
-
-    /// Format a message with full syntax highlighting (hashtags, mentions, links, payments)
-    /// This is the primary formatter used in the main chat view
-    func formatMessageAsText(
-        _ message: BitchatMessage,
-        colorScheme: ColorScheme,
-        nickname: String,
-        myPeerID: String,
-        myNostrPubkey: String?,
-        activeChannel: ChannelID,
-        nostrKeyMapping: [String: String],
-        allPeers: [BitchatPeer],
-        geohashPeople: [GeoPerson],
-        getNoiseKeyForShortID: @escaping (String) -> String?
-    ) -> AttributedString {
-        // Determine if this message was sent by self
-        let isSelf = isSelfMessage(
-            message,
-            nickname: nickname,
-            myPeerID: myPeerID,
-            myNostrPubkey: myNostrPubkey,
-            activeChannel: activeChannel
-        )
-
-        // Check cache first
-        let isDark = colorScheme == .dark
-        if let cachedText = message.getCachedFormattedText(isDark: isDark, isSelf: isSelf) {
-            return cachedText
-        }
-
-        // Not cached, format the message
-        var result = AttributedString()
-
-        let baseColor: Color = isSelf ? .orange : colorPalette.peerColor(
-            for: message,
-            isDark: isDark,
-            myPeerID: myPeerID,
-            myNostrPubkey: myNostrPubkey,
-            nostrKeyMapping: nostrKeyMapping,
-            allPeers: allPeers,
-            geohashPeople: geohashPeople.map { (id: $0.id, seed: "nostr:" + $0.id) },
-            getNoiseKeyForShortID: getNoiseKeyForShortID
-        )
-
-        if message.sender != "system" {
-            // Sender (at the beginning) with light-gray suffix styling if present
-            let (baseName, suffix) = message.sender.splitSuffix()
-            var senderStyle = AttributeContainer()
-            senderStyle.foregroundColor = baseColor
-            let fontWeight: Font.Weight = isSelf ? .bold : .medium
-            senderStyle.font = .bitchatSystem(size: 14, weight: fontWeight, design: .monospaced)
-
-            // Make sender clickable: encode senderPeerID into a custom URL
-            if let spid = message.senderPeerID?.id,
-               let url = URL(string: "bitchat://user/\(spid.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? spid)") {
-                senderStyle.link = url
-            }
-
-            // Format: <@name#suffix>
-            result.append(AttributedString("<@").mergingAttributes(senderStyle))
-            result.append(AttributedString(baseName).mergingAttributes(senderStyle))
-            if !suffix.isEmpty {
-                var suffixStyle = senderStyle
-                suffixStyle.foregroundColor = baseColor.opacity(0.6)
-                result.append(AttributedString(suffix).mergingAttributes(suffixStyle))
-            }
-            result.append(AttributedString("> ").mergingAttributes(senderStyle))
-
-            // Process content with syntax highlighting
-            let content = message.content
-            let nsContent = content as NSString
-            let nsLen = nsContent.length
-
-            // Check for Cashu presence early to decide rendering strategy
-            let containsCashuEarly = Regexes.quickCashuPresence.numberOfMatches(
-                in: content,
-                options: [],
-                range: NSRange(location: 0, length: nsLen)
-            ) > 0
-
-            // For extremely long content, render as plain text (unless has Cashu)
-            if (content.count > 4000 || content.hasVeryLongToken(threshold: 1024)) && !containsCashuEarly {
-                var plainStyle = AttributeContainer()
-                plainStyle.foregroundColor = baseColor
-                plainStyle.font = isSelf
-                    ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
-                    : .bitchatSystem(size: 14, design: .monospaced)
-                result.append(AttributedString(content).mergingAttributes(plainStyle))
-            } else {
-                // Full syntax highlighting
-                result.append(formatContent(
-                    content,
-                    nsContent: nsContent,
-                    nsLen: nsLen,
-                    message: message,
-                    baseColor: baseColor,
-                    isSelf: isSelf,
-                    isDark: isDark,
-                    nickname: nickname,
-                    myPeerID: myPeerID,
-                    myNostrPubkey: myNostrPubkey,
-                    activeChannel: activeChannel
-                ))
-            }
-
-            // Add timestamp
-            let timestamp = AttributedString(" [\(message.formattedTimestamp)]")
-            var timestampStyle = AttributeContainer()
-            timestampStyle.foregroundColor = Color.gray.opacity(0.7)
-            timestampStyle.font = .bitchatSystem(size: 10, design: .monospaced)
-            result.append(timestamp.mergingAttributes(timestampStyle))
-        } else {
-            // System message
-            var contentStyle = AttributeContainer()
-            contentStyle.foregroundColor = Color.gray
-            let content = AttributedString("* \(message.content) *")
-            contentStyle.font = .bitchatSystem(size: 12, design: .monospaced).italic()
-            result.append(content.mergingAttributes(contentStyle))
-
-            // Add timestamp
-            let timestamp = AttributedString(" [\(message.formattedTimestamp)]")
-            var timestampStyle = AttributeContainer()
-            timestampStyle.foregroundColor = Color.gray.opacity(0.5)
-            timestampStyle.font = .bitchatSystem(size: 10, design: .monospaced)
-            result.append(timestamp.mergingAttributes(timestampStyle))
-        }
-
-        // Cache the formatted text
-        message.setCachedFormattedText(result, isDark: isDark, isSelf: isSelf)
-
-        return result
-    }
-
-    /// Simpler message formatter (used in legacy contexts)
-    func formatMessage(
-        _ message: BitchatMessage,
-        colorScheme: ColorScheme,
-        nickname: String
-    ) -> AttributedString {
-        var result = AttributedString()
-
-        let isDark = colorScheme == .dark
-        let primaryColor = isDark ? Color.green : Color(red: 0, green: 0.5, blue: 0)
-
-        if message.sender == "system" {
-            let content = AttributedString("* \(message.content) *")
-            var contentStyle = AttributeContainer()
-            contentStyle.foregroundColor = Color.gray
-            contentStyle.font = .bitchatSystem(size: 12, design: .monospaced).italic()
-            result.append(content.mergingAttributes(contentStyle))
-
-            // Add timestamp
-            let timestamp = AttributedString(" [\(message.formattedTimestamp)]")
-            var timestampStyle = AttributeContainer()
-            timestampStyle.foregroundColor = Color.gray.opacity(0.5)
-            timestampStyle.font = .bitchatSystem(size: 10, design: .monospaced)
-            result.append(timestamp.mergingAttributes(timestampStyle))
-        } else {
-            let sender = AttributedString("<@\(message.sender)> ")
-            var senderStyle = AttributeContainer()
-            senderStyle.foregroundColor = primaryColor
-            let fontWeight: Font.Weight = message.sender == nickname ? .bold : .medium
-            senderStyle.font = .bitchatSystem(size: 12, weight: fontWeight, design: .monospaced)
-            result.append(sender.mergingAttributes(senderStyle))
-
-            // Process content to highlight mentions
-            let contentText = message.content
-            let pattern = "@([\\p{L}0-9_]+)"
-            let regex = try? NSRegularExpression(pattern: pattern, options: [])
-            let nsContent = contentText as NSString
-            let nsLen = nsContent.length
-            let matches = regex?.matches(in: contentText, options: [], range: NSRange(location: 0, length: nsLen)) ?? []
-
-            var processedContent = AttributedString()
-            var lastEndIndex = contentText.startIndex
-
-            for match in matches {
-                if let range = Range(match.range(at: 0), in: contentText) {
-                    // Add text before mention
-                    if lastEndIndex < range.lowerBound {
-                        let beforeText = String(contentText[lastEndIndex..<range.lowerBound])
-                        if !beforeText.isEmpty {
-                            var normalStyle = AttributeContainer()
-                            normalStyle.font = .bitchatSystem(size: 14, design: .monospaced)
-                            normalStyle.foregroundColor = isDark ? Color.white : Color.black
-                            processedContent.append(AttributedString(beforeText).mergingAttributes(normalStyle))
-                        }
-                    }
-
-                    // Add the mention with highlight
-                    let mentionText = String(contentText[range])
-                    var mentionStyle = AttributeContainer()
-                    mentionStyle.font = .bitchatSystem(size: 14, weight: .semibold, design: .monospaced)
-                    mentionStyle.foregroundColor = Color.orange
-                    processedContent.append(AttributedString(mentionText).mergingAttributes(mentionStyle))
-
-                    if lastEndIndex < range.upperBound { lastEndIndex = range.upperBound }
-                }
-            }
-
-            // Add remaining text
-            if lastEndIndex < contentText.endIndex {
-                let remainingText = String(contentText[lastEndIndex...])
-                var normalStyle = AttributeContainer()
-                normalStyle.font = .bitchatSystem(size: 14, design: .monospaced)
-                normalStyle.foregroundColor = isDark ? Color.white : Color.black
-                processedContent.append(AttributedString(remainingText).mergingAttributes(normalStyle))
-            }
-
-            result.append(processedContent)
-
-            if message.isRelay, let originalSender = message.originalSender {
-                let relay = AttributedString(" (via \(originalSender))")
-                var relayStyle = AttributeContainer()
-                relayStyle.foregroundColor = primaryColor.opacity(0.7)
-                relayStyle.font = .bitchatSystem(size: 11, design: .monospaced)
-                result.append(relay.mergingAttributes(relayStyle))
-            }
-
-            // Add timestamp
-            let timestamp = AttributedString(" [\(message.formattedTimestamp)]")
-            var timestampStyle = AttributeContainer()
-            timestampStyle.foregroundColor = Color.gray.opacity(0.7)
-            timestampStyle.font = .bitchatSystem(size: 10, design: .monospaced)
-            result.append(timestamp.mergingAttributes(timestampStyle))
-        }
-
-        return result
-    }
-
-    // MARK: - Private Helpers
-
-    private func isSelfMessage(
-        _ message: BitchatMessage,
-        nickname: String,
-        myPeerID: String,
-        myNostrPubkey: String?,
-        activeChannel: ChannelID
-    ) -> Bool {
-        if let spid = message.senderPeerID?.id {
-            // In geohash channels, compare against our per-geohash nostr short ID
-            if case .location = activeChannel, spid.hasPrefix("nostr:"),
-               let myGeo = myNostrPubkey {
-                return spid == "nostr:\(myGeo.prefix(TransportConfig.nostrShortKeyDisplayLength))"
-            }
-            return spid == myPeerID
-        }
-        // Fallback by nickname
-        if message.sender == nickname { return true }
-        if message.sender.hasPrefix(nickname + "#") { return true }
-        return false
-    }
-
-    private func formatContent(
-        _ content: String,
-        nsContent: NSString,
-        nsLen: Int,
-        message: BitchatMessage,
-        baseColor: Color,
-        isSelf: Bool,
-        isDark: Bool,
-        nickname: String,
-        myPeerID: String,
-        myNostrPubkey: String?,
-        activeChannel: ChannelID
-    ) -> AttributedString {
-        // Extract all matches
-        let hasMentionsHint = content.contains("@")
-        let hasHashtagsHint = content.contains("#")
-        let hasURLHint = content.contains("://") || content.contains("www.") || content.contains("http")
-        let hasLightningHint = content.lowercased().contains("ln") || content.lowercased().contains("lightning:")
-        let hasCashuHint = content.lowercased().contains("cashu")
-
-        let hashtagMatches = hasHashtagsHint ? Regexes.hashtag.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
-        let mentionMatches = hasMentionsHint ? Regexes.mention.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
-        let urlMatches = hasURLHint ? (Regexes.linkDetector?.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) ?? []) : []
-        let cashuMatches = hasCashuHint ? Regexes.cashu.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
-        let lightningMatches = hasLightningHint ? Regexes.lightningScheme.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
-        let bolt11Matches = hasLightningHint ? Regexes.bolt11.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
-        let lnurlMatches = hasLightningHint ? Regexes.lnurl.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
-
-        // Combine and sort matches, excluding hashtags/URLs overlapping mentions
-        let mentionRanges = mentionMatches.map { $0.range(at: 0) }
-
-        func overlapsMention(_ r: NSRange) -> Bool {
-            for mr in mentionRanges {
-                if NSIntersectionRange(r, mr).length > 0 { return true }
-            }
-            return false
-        }
-
-        func attachedToMention(_ r: NSRange) -> Bool {
-            if let nsRange = Range(r, in: content), nsRange.lowerBound > content.startIndex {
-                var i = content.index(before: nsRange.lowerBound)
-                while true {
-                    let ch = content[i]
-                    if ch.isWhitespace || ch.isNewline { break }
-                    if ch == "@" { return true }
-                    if i == content.startIndex { break }
-                    i = content.index(before: i)
-                }
-            }
-            return false
-        }
-
-        func isStandaloneHashtag(_ r: NSRange) -> Bool {
-            guard let nsRange = Range(r, in: content) else { return false }
-            if nsRange.lowerBound == content.startIndex { return true }
-            let prev = content.index(before: nsRange.lowerBound)
-            return content[prev].isWhitespace || content[prev].isNewline
-        }
-
-        var allMatches: [(range: NSRange, type: String)] = []
-        for match in hashtagMatches where !overlapsMention(match.range(at: 0)) && !attachedToMention(match.range(at: 0)) && isStandaloneHashtag(match.range(at: 0)) {
-            allMatches.append((match.range(at: 0), "hashtag"))
-        }
-        for match in mentionMatches {
-            allMatches.append((match.range(at: 0), "mention"))
-        }
-        for match in urlMatches where !overlapsMention(match.range) {
-            allMatches.append((match.range, "url"))
-        }
-        for match in cashuMatches where !overlapsMention(match.range(at: 0)) {
-            allMatches.append((match.range(at: 0), "cashu"))
-        }
-        for match in lightningMatches where !overlapsMention(match.range(at: 0)) {
-            allMatches.append((match.range(at: 0), "lightning"))
-        }
-
-        // Exclude overlaps with lightning/url for bolt11/lnurl
-        let occupied: [NSRange] = urlMatches.map { $0.range } + lightningMatches.map { $0.range(at: 0) }
-        func overlapsOccupied(_ r: NSRange) -> Bool {
-            for or in occupied {
-                if NSIntersectionRange(r, or).length > 0 { return true }
-            }
-            return false
-        }
-        for match in bolt11Matches where !overlapsMention(match.range(at: 0)) && !overlapsOccupied(match.range(at: 0)) {
-            allMatches.append((match.range(at: 0), "bolt11"))
-        }
-        for match in lnurlMatches where !overlapsMention(match.range(at: 0)) && !overlapsOccupied(match.range(at: 0)) {
-            allMatches.append((match.range(at: 0), "lnurl"))
-        }
-        allMatches.sort { $0.range.location < $1.range.location }
-
-        // Build content with styling
-        var processedContent = AttributedString()
-        var lastEnd = content.startIndex
-        let isMentioned = message.mentions?.contains(nickname) ?? false
-
-        for (range, type) in allMatches {
-            if let nsRange = Range(range, in: content) {
-                // Add text before match
-                if lastEnd < nsRange.lowerBound {
-                    let beforeText = String(content[lastEnd..<nsRange.lowerBound])
-                    if !beforeText.isEmpty {
-                        var beforeStyle = AttributeContainer()
-                        beforeStyle.foregroundColor = baseColor
-                        beforeStyle.font = isSelf
-                            ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
-                            : .bitchatSystem(size: 14, design: .monospaced)
-                        if isMentioned {
-                            beforeStyle.font = beforeStyle.font?.bold()
-                        }
-                        processedContent.append(AttributedString(beforeText).mergingAttributes(beforeStyle))
-                    }
-                }
-
-                // Add styled match
-                let matchText = String(content[nsRange])
-                processedContent.append(formatMatch(
-                    matchText,
-                    type: type,
-                    baseColor: baseColor,
-                    isSelf: isSelf,
-                    isDark: isDark,
-                    nickname: nickname,
-                    myPeerID: myPeerID,
-                    myNostrPubkey: myNostrPubkey,
-                    activeChannel: activeChannel
-                ))
-
-                lastEnd = nsRange.upperBound
-            }
-        }
-
-        // Add remaining text after last match
-        if lastEnd < content.endIndex {
-            let remainingText = String(content[lastEnd...])
-            var remainingStyle = AttributeContainer()
-            remainingStyle.foregroundColor = baseColor
-            remainingStyle.font = isSelf
-                ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
-                : .bitchatSystem(size: 14, design: .monospaced)
-            if isMentioned {
-                remainingStyle.font = remainingStyle.font?.bold()
-            }
-            processedContent.append(AttributedString(remainingText).mergingAttributes(remainingStyle))
-        }
-
-        return processedContent
-    }
-
-    private func formatMatch(
-        _ matchText: String,
-        type: String,
-        baseColor: Color,
-        isSelf: Bool,
-        isDark: Bool,
-        nickname: String,
-        myPeerID: String,
-        myNostrPubkey: String?,
-        activeChannel: ChannelID
-    ) -> AttributedString {
-        switch type {
-        case "mention":
-            return formatMention(
-                matchText,
-                baseColor: baseColor,
-                isSelf: isSelf,
-                nickname: nickname,
-                myPeerID: myPeerID,
-                myNostrPubkey: myNostrPubkey,
-                activeChannel: activeChannel
-            )
-        case "hashtag":
-            return formatHashtag(matchText, isDark: isDark, baseColor: baseColor, activeChannel: activeChannel)
-        case "url":
-            return formatURL(matchText, baseColor: baseColor, isSelf: isSelf)
-        case "cashu", "bolt11", "lnurl", "lightning":
-            return formatPayment(matchText, type: type, baseColor: baseColor, isSelf: isSelf)
-        default:
-            return AttributedString(matchText)
-        }
-    }
-
-    private func formatMention(
-        _ matchText: String,
-        baseColor: Color,
-        isSelf: Bool,
-        nickname: String,
-        myPeerID: String,
-        myNostrPubkey: String?,
-        activeChannel: ChannelID
-    ) -> AttributedString {
-        // Split optional '#abcd' suffix and color suffix light grey
-        let (mBase, mSuffix) = matchText.splitSuffix()
-
-        // Determine if this mention targets me
-        let mySuffix: String? = {
-            if case .location = activeChannel, let myGeo = myNostrPubkey {
-                return String(myGeo.suffix(4))
-            }
-            return String(myPeerID.prefix(4))
-        }()
-
-        let isMentionToMe: Bool = {
-            if mBase == nickname {
-                if let suf = mySuffix, !mSuffix.isEmpty {
-                    return mSuffix == "#\(suf)"
-                }
-                return mSuffix.isEmpty
-            }
-            return false
-        }()
-
-        var mentionStyle = AttributeContainer()
-        mentionStyle.font = .bitchatSystem(size: 14, weight: .semibold, design: .monospaced)
-        mentionStyle.foregroundColor = isMentionToMe ? .orange : baseColor
-
-        var result = AttributedString()
-        result.append(AttributedString(mBase).mergingAttributes(mentionStyle))
-
-        if !mSuffix.isEmpty {
-            var suffixStyle = mentionStyle
-            suffixStyle.foregroundColor = (isMentionToMe ? Color.orange : baseColor).opacity(0.5)
-            result.append(AttributedString(mSuffix).mergingAttributes(suffixStyle))
-        }
-
-        return result
-    }
-
-    private func formatHashtag(
-        _ matchText: String,
-        isDark: Bool,
-        baseColor: Color,
-        activeChannel: ChannelID
-    ) -> AttributedString {
-        var hashtagStyle = AttributeContainer()
-        hashtagStyle.font = .bitchatSystem(size: 14, weight: .medium, design: .monospaced)
-
-        // Determine if this hashtag represents the active channel
-        let isActiveChannel: Bool = {
-            if matchText.count > 1 {
-                let tag = String(matchText.dropFirst()) // Remove '#'
-                switch activeChannel {
-                case .mesh:
-                    return tag.lowercased() == "mesh"
-                case .location(let ch):
-                    return tag.lowercased() == ch.geohash.lowercased()
-                }
-            }
-            return false
-        }()
-
-        if isActiveChannel {
-            // Highlight active channel hashtag in green
-            hashtagStyle.foregroundColor = isDark ? Color.green : Color(red: 0, green: 0.5, blue: 0)
-            hashtagStyle.font = .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
-        } else {
-            // Link to geohash if valid
-            if matchText.count > 1 {
-                let tag = String(matchText.dropFirst())
-                if tag.count >= 2, tag.count <= 12,
-                   tag.allSatisfy({ "0123456789bcdefghjkmnpqrstuvwxyz".contains($0) }) {
-                    if let url = URL(string: "bitchat://geohash/\(tag)") {
-                        hashtagStyle.link = url
-                    }
-                }
-            }
-            hashtagStyle.foregroundColor = baseColor.opacity(0.8)
-        }
-
-        return AttributedString(matchText).mergingAttributes(hashtagStyle)
-    }
-
-    private func formatURL(_ matchText: String, baseColor: Color, isSelf: Bool) -> AttributedString {
-        var urlStyle = AttributeContainer()
-        if let url = URL(string: matchText) {
-            urlStyle.link = url
-        }
-        urlStyle.foregroundColor = baseColor
-        urlStyle.font = isSelf
-            ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
-            : .bitchatSystem(size: 14, design: .monospaced)
-        urlStyle.underlineStyle = .single
-        return AttributedString(matchText).mergingAttributes(urlStyle)
-    }
-
-    private func formatPayment(
-        _ matchText: String,
-        type: String,
-        baseColor: Color,
-        isSelf: Bool
-    ) -> AttributedString {
-        var paymentStyle = AttributeContainer()
-        paymentStyle.foregroundColor = baseColor
-        paymentStyle.font = isSelf
-            ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
-            : .bitchatSystem(size: 14, design: .monospaced)
-
-        // Make payment tokens tappable
-        if type == "cashu", let url = URL(string: "cashu:\(matchText)") {
-            paymentStyle.link = url
-        } else if type == "lightning" || type == "bolt11" || type == "lnurl" {
-            if let url = URL(string: matchText.lowercased().hasPrefix("lightning:") ? matchText : "lightning:\(matchText)") {
-                paymentStyle.link = url
-            }
-        }
-
-        return AttributedString(matchText).mergingAttributes(paymentStyle)
-    }
-}

bitchat/Services/NetworkActivationService.swift

@@ -20,12 +20,6 @@ final class NetworkActivationService: ObservableObject {
 
     private init() {}
 
-    deinit {
-        // Clean up Combine subscriptions
-        cancellables.removeAll()
-        SecureLogger.debug("NetworkActivationService deinitialized", category: .session)
-    }
-
     func start() {
         guard !started else { return }
         started = true

bitchat/Services/NoiseEncryptionService.swift

@@ -177,18 +177,18 @@ final class NoiseEncryptionService {
     private let rekeyCheckInterval: TimeInterval = 60.0 // Check every minute
     
     // Callbacks
-    private var onPeerAuthenticatedHandlers: [((String, String) -> Void)] = [] // Array of handlers for peer authentication
+    private var onPeerAuthenticatedHandlers: [((PeerID, String) -> Void)] = [] // Array of handlers for peer authentication
     var onHandshakeRequired: ((PeerID) -> Void)? // peerID needs handshake
     
     // Add a handler for peer authentication
-    func addOnPeerAuthenticatedHandler(_ handler: @escaping (String, String) -> Void) {
+    func addOnPeerAuthenticatedHandler(_ handler: @escaping (PeerID, String) -> Void) {
         serviceQueue.async(flags: .barrier) { [weak self] in
             self?.onPeerAuthenticatedHandlers.append(handler)
         }
     }
     
     // Legacy support - setting this will add to the handlers array
-    var onPeerAuthenticated: ((String, String) -> Void)? {
+    var onPeerAuthenticated: ((PeerID, String) -> Void)? {
         get { nil } // Always return nil for backward compatibility
         set {
             if let handler = newValue {
@@ -546,7 +546,7 @@ final class NoiseEncryptionService {
         // Notify all handlers about authentication
         serviceQueue.async { [weak self] in
             self?.onPeerAuthenticatedHandlers.forEach { handler in
-                handler(peerID.id, fingerprint)
+                handler(peerID, fingerprint)
             }
         }
     }

bitchat/Services/NostrTransport.swift

@@ -16,9 +16,11 @@ final class NostrTransport: Transport {
     private var isSendingReadAcks = false
     private let readAckInterval: TimeInterval = TransportConfig.nostrReadAckInterval
     private let keychain: KeychainManagerProtocol
+    private let idBridge: NostrIdentityBridge
 
-    init(keychain: KeychainManagerProtocol) {
+    init(keychain: KeychainManagerProtocol, idBridge: NostrIdentityBridge) {
         self.keychain = keychain
+        self.idBridge = idBridge
     }
 
     // MARK: - Transport Protocol Conformance
@@ -65,7 +67,7 @@ final class NostrTransport: Transport {
     func sendPrivateMessage(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String) {
         Task { @MainActor in
             guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
+            guard let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
             SecureLogger.debug("NostrTransport: preparing PM to \(recipientNpub.prefix(16))… for peerID \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
             // Convert recipient npub -> hex (x-only)
             let recipientHex: String
@@ -80,7 +82,7 @@ final class NostrTransport: Transport {
                 SecureLogger.error("NostrTransport: failed to decode npub -> hex: \(error)", category: .session)
                 return
             }
-            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: messageID, recipientPeerID: peerID.id, senderPeerID: senderPeerID.id) else {
+            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
             }
@@ -102,7 +104,7 @@ final class NostrTransport: Transport {
     func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool) {
         Task { @MainActor in
             guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
+            guard let senderIdentity = try? idBridge.getCurrentNostrIdentity() 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
@@ -112,7 +114,7 @@ final class NostrTransport: Transport {
                 guard hrp == "npub" else { return }
                 recipientHex = data.hexEncodedString()
             } catch { return }
-            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: UUID().uuidString, recipientPeerID: peerID.id, senderPeerID: senderPeerID.id) else {
+            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
             }
@@ -129,7 +131,7 @@ final class NostrTransport: Transport {
     func sendDeliveryAck(for messageID: String, to peerID: PeerID) {
         Task { @MainActor in
             guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
+            guard let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
             SecureLogger.debug("NostrTransport: preparing DELIVERED ack for id=\(messageID.prefix(8))… to \(recipientNpub.prefix(16))…", category: .session)
             let recipientHex: String
             do {
@@ -137,7 +139,7 @@ final class NostrTransport: Transport {
                 guard hrp == "npub" else { return }
                 recipientHex = data.hexEncodedString()
             } catch { return }
-            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .delivered, messageID: messageID, recipientPeerID: peerID.id, senderPeerID: senderPeerID.id) else {
+            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
             }
@@ -159,7 +161,7 @@ extension NostrTransport {
     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)
-            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID.id) else { return }
+            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 }
             NostrRelayManager.registerPendingGiftWrap(id: event.id)
             NostrRelayManager.shared.sendEvent(event)
@@ -169,7 +171,7 @@ extension NostrTransport {
     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)
-            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID.id) else { return }
+            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 }
             NostrRelayManager.registerPendingGiftWrap(id: event.id)
             NostrRelayManager.shared.sendEvent(event)
@@ -182,7 +184,7 @@ extension NostrTransport {
             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)
             // Build embedded BitChat packet without recipient peer ID
-            guard let embedded = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(content: content, messageID: messageID, senderPeerID: senderPeerID.id) else {
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(content: content, messageID: messageID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed geohash PM packet", category: .session)
                 return
             }
@@ -212,7 +214,7 @@ extension NostrTransport {
         let item = readQueue.removeFirst()
         Task { @MainActor in
             guard let recipientNpub = resolveRecipientNpub(for: item.peerID) else { scheduleNextReadAck(); return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { scheduleNextReadAck(); return }
+            guard let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { scheduleNextReadAck(); return }
             SecureLogger.debug("NostrTransport: preparing READ ack for id=\(item.receipt.originalMessageID.prefix(8))… to \(recipientNpub.prefix(16))…", category: .session)
             // Convert recipient npub -> hex
             let recipientHex: String
@@ -221,7 +223,7 @@ extension NostrTransport {
                 guard hrp == "npub" else { scheduleNextReadAck(); return }
                 recipientHex = data.hexEncodedString()
             } catch { scheduleNextReadAck(); return }
-            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .readReceipt, messageID: item.receipt.originalMessageID, recipientPeerID: item.peerID.id, senderPeerID: senderPeerID.id) else {
+            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
             }

bitchat/Services/NotificationService.swift

@@ -29,28 +29,30 @@ final class NotificationService {
         }
     }
     
-    func sendLocalNotification(title: String, body: String, identifier: String, userInfo: [String: Any]? = nil) {
+    func sendLocalNotification(
-        // For now, skip app state check entirely to avoid thread issues
+        title: String,
-        // The NotificationDelegate will handle foreground presentation
+        body: String,
-        DispatchQueue.main.async {
+        identifier: String,
-            let content = UNMutableNotificationContent()
+        userInfo: [String: Any]? = nil,
-            content.title = title
+        interruptionLevel: UNNotificationInterruptionLevel = .active
-            content.body = body
+    ) {
-            content.sound = .default
+        let content = UNMutableNotificationContent()
-            if let userInfo = userInfo {
+        content.title = title
-                content.userInfo = userInfo
+        content.body = body
-            }
+        content.sound = .default
-            
+        content.interruptionLevel = interruptionLevel
-            let request = UNNotificationRequest(
+
-                identifier: identifier,
+        if let userInfo = userInfo {
-                content: content,
+            content.userInfo = userInfo
-                trigger: nil // Deliver immediately
-            )
-            
-            UNUserNotificationCenter.current().add(request) { _ in
-                // Notification added
-            }
         }
+
+        let request = UNNotificationRequest(
+            identifier: identifier,
+            content: content,
+            trigger: nil // Deliver immediately
+        )
+
+        UNUserNotificationCenter.current().add(request)
     }
     
     func sendMentionNotification(from sender: String, message: String) {
@@ -61,11 +63,11 @@ final class NotificationService {
         sendLocalNotification(title: title, body: body, identifier: identifier)
     }
     
-    func sendPrivateMessageNotification(from sender: String, message: String, peerID: String) {
+    func sendPrivateMessageNotification(from sender: String, message: String, peerID: PeerID) {
         let title = "🔒 DM from \(sender)"
         let body = message
         let identifier = "private-\(UUID().uuidString)"
-        let userInfo = ["peerID": peerID, "senderName": sender]
+        let userInfo = ["peerID": peerID.id, "senderName": sender]
         
         sendLocalNotification(title: title, body: body, identifier: identifier, userInfo: userInfo)
     }
@@ -83,25 +85,12 @@ final class NotificationService {
         let title = "👥 bitchatters nearby!"
         let body = peerCount == 1 ? "1 person around" : "\(peerCount) people around"
         let identifier = "network-available-\(Date().timeIntervalSince1970)"
-        
+
-        // For network notifications, we want to show them even in foreground
+        sendLocalNotification(
-        // No app state check - let the notification delegate handle presentation
+            title: title,
-        DispatchQueue.main.async {
+            body: body,
-            let content = UNMutableNotificationContent()
+            identifier: identifier,
-            content.title = title
+            interruptionLevel: .timeSensitive
-            content.body = body
+        )
-            content.sound = .default
-            content.interruptionLevel = .timeSensitive  // Make it more prominent
-            
-            let request = UNNotificationRequest(
-                identifier: identifier,
-                content: content,
-                trigger: nil // Deliver immediately
-            )
-            
-            UNUserNotificationCenter.current().add(request) { _ in
-                // Notification added
-            }
-        }
     }
 }

bitchat/Services/NotificationStreamAssembler.swift

@@ -6,10 +6,19 @@
 // For more information, see <https://unlicense.org>
 //
 
+import BitLogger
 import Foundation
 
 struct NotificationStreamAssembler {
     private var buffer = Data()
+    private var pendingFrameStartedAt: DispatchTime?
+    private var pendingFrameExpectedLength: Int = 0
+
+    private mutating func resetState() {
+        buffer.removeAll(keepingCapacity: false)
+        pendingFrameStartedAt = nil
+        pendingFrameExpectedLength = 0
+    }
 
     mutating func append(_ chunk: Data) -> (frames: [Data], droppedPrefixes: [UInt8], reset: Bool) {
         guard !chunk.isEmpty else { return ([], [], false) }
@@ -18,64 +27,107 @@ struct NotificationStreamAssembler {
 
         var frames: [Data] = []
         var dropped: [UInt8] = []
-        var reset = false
+        var didReset = false
-        let maxFrameLength = TransportConfig.blePendingWriteBufferCapBytes
+        let now = DispatchTime.now()
+        let maxFrameLength = TransportConfig.bleNotificationAssemblerHardCapBytes
+        let minimumFramePrefix = BinaryProtocol.v1HeaderSize + BinaryProtocol.senderIDSize
 
-        let minHeaderBytes = 14 // version + type + ttl + timestamp(8) + flags + length(2)
+        if buffer.count > TransportConfig.bleNotificationAssemblerHardCapBytes {
-        let minFramePrefix = minHeaderBytes + BinaryProtocol.senderIDSize
+            SecureLogger.error("❌ Notification assembler overflow (\(buffer.count) bytes); dropping partial frame", category: .session)
+            resetState()
+            return ([], [], true)
+        }
 
-        while buffer.count >= minFramePrefix {
+        while buffer.count >= minimumFramePrefix {
-            guard let first = buffer.first else { break }
+            guard let version = buffer.first else { break }
-            if first != 1 {
+            guard version == 1 || version == 2 else {
                 dropped.append(buffer.removeFirst())
+                pendingFrameStartedAt = nil
+                pendingFrameExpectedLength = 0
                 continue
             }
 
-            guard buffer.count >= minHeaderBytes else { break }
+            guard let headerSize = BinaryProtocol.headerSize(for: version) else {
+                dropped.append(buffer.removeFirst())
+                pendingFrameStartedAt = nil
+                pendingFrameExpectedLength = 0
+                continue
+            }
+            let framePrefix = headerSize + BinaryProtocol.senderIDSize
+            guard buffer.count >= framePrefix else { break }
 
-            let headerBytes = Array(buffer.prefix(minFramePrefix))
+            let flagsIndex = buffer.startIndex + BinaryProtocol.Offsets.flags
-            guard headerBytes.count == minFramePrefix else { break }
+            guard flagsIndex < buffer.endIndex else { break }
-
+            let flags = buffer[flagsIndex]
-            let flags = headerBytes[11]
             let hasRecipient = (flags & BinaryProtocol.Flags.hasRecipient) != 0
             let hasSignature = (flags & BinaryProtocol.Flags.hasSignature) != 0
-            let payloadLen = (Int(headerBytes[12]) << 8) | Int(headerBytes[13])
+            let isCompressed = (flags & BinaryProtocol.Flags.isCompressed) != 0
 
-            var frameLength = minFramePrefix + payloadLen
+            let lengthOffset = 12
+            let payloadLength: Int
+            if version == 2 {
+                let lengthIndex = buffer.startIndex + lengthOffset
+                payloadLength =
+                    (Int(buffer[lengthIndex]) << 24) |
+                    (Int(buffer[lengthIndex + 1]) << 16) |
+                    (Int(buffer[lengthIndex + 2]) << 8) |
+                    Int(buffer[lengthIndex + 3])
+            } else {
+                let lengthIndex = buffer.startIndex + lengthOffset
+                payloadLength = (Int(buffer[lengthIndex]) << 8) | Int(buffer[lengthIndex + 1])
+            }
+
+            var frameLength = framePrefix + payloadLength
             if hasRecipient { frameLength += BinaryProtocol.recipientIDSize }
             if hasSignature { frameLength += BinaryProtocol.signatureSize }
+            if isCompressed {
+                let rawLengthFieldBytes = (version == 2) ? 4 : 2
+                if payloadLength < rawLengthFieldBytes {
+                    SecureLogger.error("❌ Invalid compressed payload length (\(payloadLength))", category: .session)
+                    resetState()
+                    didReset = true
+                    break
+                }
+            }
 
             guard frameLength > 0, frameLength <= maxFrameLength else {
-                buffer.removeAll()
+                SecureLogger.error("❌ Notification frame length \(frameLength) invalid (cap=\(maxFrameLength)); resetting stream", category: .session)
-                reset = true
+                resetState()
+                didReset = true
                 break
             }
 
             if buffer.count < frameLength {
-                // Check if a new frame start exists within the incomplete buffer; if so, drop leading partial bytes.
+                let remaining = frameLength - buffer.count
-                if let nextStart = buffer.dropFirst().firstIndex(of: 1) {
+                if pendingFrameStartedAt == nil || frameLength != pendingFrameExpectedLength {
-                    let dropCount = buffer.distance(from: buffer.startIndex, to: nextStart)
+                    pendingFrameStartedAt = now
-                    if dropCount > 0 {
+                    pendingFrameExpectedLength = frameLength
-                        buffer.removeFirst(dropCount)
+                } else if let started = pendingFrameStartedAt {
-                        dropped.append(1) // treat as dropped partial start
+                    let elapsed = now.uptimeNanoseconds - started.uptimeNanoseconds
+                    let threshold = UInt64(TransportConfig.bleAssemblerStallResetMs) * 1_000_000
+                    if elapsed >= threshold {
+                        SecureLogger.debug("📉 Resetting notification assembler after waiting \(remaining)B for \(TransportConfig.bleAssemblerStallResetMs)ms", category: .session)
+                        resetState()
+                        didReset = true
+                    } else {
+                        SecureLogger.debug("⌛ Waiting for remaining \(remaining)B to complete BLE frame", category: .session)
                     }
                 }
                 break
             }
 
+            pendingFrameStartedAt = nil
+            pendingFrameExpectedLength = 0
+
             let frame = Data(buffer.prefix(frameLength))
             frames.append(frame)
             buffer.removeFirst(frameLength)
         }
 
         if !buffer.isEmpty, buffer.allSatisfy({ $0 == 0 }) {
-            buffer.removeAll(keepingCapacity: false)
+            resetState()
         }
 
-        return (frames, dropped, reset)
+        return (frames, dropped, didReset)
-    }
-
-    mutating func reset() {
-        buffer.removeAll(keepingCapacity: false)
     }
 }

bitchat/Services/PrivateChatManager.swift

@@ -12,9 +12,9 @@ import SwiftUI
 
 /// Manages all private chat functionality
 final class PrivateChatManager: ObservableObject {
-    @Published var privateChats: [String: [BitchatMessage]] = [:]
+    @Published var privateChats: [PeerID: [BitchatMessage]] = [:]
-    @Published var selectedPeer: String? = nil
+    @Published var selectedPeer: PeerID? = nil
-    @Published var unreadMessages: Set<String> = []
+    @Published var unreadMessages: Set<PeerID> = []
     
     private var selectedPeerFingerprint: String? = nil
     var sentReadReceipts: Set<String> = []  // Made accessible for ChatViewModel
@@ -27,19 +27,15 @@ final class PrivateChatManager: ObservableObject {
         self.meshService = meshService
     }
 
-    deinit {
-        SecureLogger.debug("PrivateChatManager deinitialized", category: .session)
-    }
-
     // Cap for messages stored per private chat
     private let privateChatCap = TransportConfig.privateChatCap
     
     /// Start a private chat with a peer
-    func startChat(with peerID: String) {
+    func startChat(with peerID: PeerID) {
         selectedPeer = peerID
         
         // Store fingerprint for persistence across reconnections
-        if let fingerprint = meshService?.getFingerprint(for: PeerID(str: peerID)) {
+        if let fingerprint = meshService?.getFingerprint(for: peerID) {
             selectedPeerFingerprint = fingerprint
         }
         
@@ -59,7 +55,7 @@ final class PrivateChatManager: ObservableObject {
     }
 
     /// Remove duplicate messages by ID and keep chronological order
-    func sanitizeChat(for peerID: String) {
+    func sanitizeChat(for peerID: PeerID) {
         guard let arr = privateChats[peerID] else { return }
         if arr.count <= 1 {
             return
@@ -83,7 +79,7 @@ final class PrivateChatManager: ObservableObject {
     }
     
     /// Mark messages from a peer as read
-    func markAsRead(from peerID: String) {
+    func markAsRead(from peerID: PeerID) {
         unreadMessages.remove(peerID)
         
         // Send read receipts for unread messages that haven't been sent yet
@@ -109,7 +105,7 @@ final class PrivateChatManager: ObservableObject {
         // Create read receipt using the simplified method
         let receipt = ReadReceipt(
             originalMessageID: message.id,
-            readerID: meshService?.myPeerID.id ?? "",
+            readerID: meshService?.myPeerID ?? PeerID(str: ""),
             readerNickname: meshService?.myNickname ?? ""
         )
         

bitchat/Services/RelayController.swift

@@ -13,6 +13,7 @@ struct RelayController {
                        senderIsSelf: Bool,
                        isEncrypted: Bool,
                        isDirectedEncrypted: Bool,
+                       isFragment: Bool,
                        isDirectedFragment: Bool,
                        isHandshake: Bool,
                        isAnnounce: Bool,
@@ -36,6 +37,16 @@ struct RelayController {
             return RelayDecision(shouldRelay: true, newTTL: newTTL, delayMs: delayMs)
         }
 
+        if isFragment {
+            let ttlLimit = min(ttlCap, TransportConfig.bleFragmentRelayTtlCap)
+            guard ttlLimit > 1 else {
+                return RelayDecision(shouldRelay: false, newTTL: ttlLimit, delayMs: 0)
+            }
+            let newTTL = ttlLimit &- 1
+            let delayMs = Int.random(in: TransportConfig.bleFragmentRelayMinDelayMs...TransportConfig.bleFragmentRelayMaxDelayMs)
+            return RelayDecision(shouldRelay: true, newTTL: newTTL, delayMs: delayMs)
+        }
+
         // TTL clamping for broadcast
         // - Dense graphs: keep lower but still allow multi-hop bridging
         // - Announces get a bit more headroom

bitchat/Services/TransferProgressManager.swift

@@ -0,0 +1,65 @@
+import Foundation
+import Combine
+
+/// Centralized progress bus for Bluetooth file transfers.
+/// Emits Combine events consumed by ChatViewModel to update UI progress indicators.
+final class TransferProgressManager {
+    static let shared = TransferProgressManager()
+
+    enum Event {
+        case started(id: String, totalFragments: Int)
+        case updated(id: String, sentFragments: Int, totalFragments: Int)
+        case completed(id: String, totalFragments: Int)
+        case cancelled(id: String, sentFragments: Int, totalFragments: Int)
+    }
+
+    private let subject = PassthroughSubject<Event, Never>()
+    private let queue = DispatchQueue(label: "com.bitchat.transfer-progress", attributes: .concurrent)
+    private var states: [String: (sent: Int, total: Int)] = [:]
+
+    var publisher: AnyPublisher<Event, Never> {
+        subject.eraseToAnyPublisher()
+    }
+
+    func start(id: String, totalFragments: Int) {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            self.states[id] = (sent: 0, total: totalFragments)
+            self.subject.send(.started(id: id, totalFragments: totalFragments))
+        }
+    }
+
+    func recordFragmentSent(id: String) {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self, var state = self.states[id] else { return }
+            state.sent = min(state.sent + 1, state.total)
+            self.states[id] = state
+            self.subject.send(.updated(id: id, sentFragments: state.sent, totalFragments: state.total))
+            if state.sent >= state.total {
+                self.states.removeValue(forKey: id)
+                self.subject.send(.completed(id: id, totalFragments: state.total))
+            }
+        }
+    }
+
+    func cancel(id: String) {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self, let state = self.states.removeValue(forKey: id) else { return }
+            self.subject.send(.cancelled(id: id, sentFragments: state.sent, totalFragments: state.total))
+        }
+    }
+
+    func reset(id: String) {
+        queue.async(flags: .barrier) { [weak self] in
+            self?.states.removeValue(forKey: id)
+        }
+    }
+
+    func snapshot(id: String) -> (sent: Int, total: Int)? {
+        var result: (sent: Int, total: Int)?
+        queue.sync {
+            result = states[id]
+        }
+        return result
+    }
+}

bitchat/Services/Transport.swift

@@ -45,11 +45,15 @@ protocol Transport: AnyObject {
 
     // Messaging
     func sendMessage(_ content: String, mentions: [String])
+    func sendMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date)
     func sendPrivateMessage(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String)
     func sendReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID)
     func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool)
     func sendBroadcastAnnounce()
     func sendDeliveryAck(for messageID: String, to peerID: PeerID)
+    func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String)
+    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String)
+    func cancelTransfer(_ transferId: String)
 
     // QR verification (optional for transports)
     func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
@@ -59,6 +63,13 @@ protocol Transport: AnyObject {
 extension Transport {
     func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {}
     func sendVerifyResponse(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {}
+    func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String) {}
+    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {}
+    func cancelTransfer(_ transferId: String) {}
+
+    func sendMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date) {
+        sendMessage(content, mentions: mentions)
+    }
 }
 
 protocol TransportPeerEventsDelegate: AnyObject {

bitchat/Services/TransportConfig.swift

@@ -8,6 +8,10 @@ enum TransportConfig {
     static let messageTTLDefault: UInt8 = 7                 // Default TTL for mesh flooding
     static let bleMaxInFlightAssemblies: Int = 128          // Cap concurrent fragment assemblies
     static let bleHighDegreeThreshold: Int = 6              // For adaptive TTL/probabilistic relays
+    static let bleMaxConcurrentTransfers: Int = 2           // Limit simultaneous large media sends
+    static let bleFragmentRelayMinDelayMs: Int = 8          // Faster forwarding for media fragments
+    static let bleFragmentRelayMaxDelayMs: Int = 25         // Upper jitter bound for fragment relays
+    static let bleFragmentRelayTtlCap: UInt8 = 5            // Clamp fragment TTL to contain floods
 
     // UI / Storage Caps
     static let privateChatCap: Int = 1337
@@ -30,7 +34,11 @@ enum TransportConfig {
     static let bleDynamicRSSIThresholdDefault: Int = -90
     static let bleConnectionCandidatesMax: Int = 100
     static let blePendingWriteBufferCapBytes: Int = 1_000_000
-    static let blePendingNotificationsCapCount: Int = 20
+    static let bleNotificationAssemblerHardCapBytes: Int = 8 * 1024 * 1024
+    static let bleAssemblerStallResetMs: Int = 250
+    static let blePendingNotificationsCapCount: Int = 128
+    static let bleNotificationRetryDelayMs: Int = 25
+    static let bleNotificationRetryMaxAttempts: Int = 80
 
     // Nostr
     static let nostrReadAckInterval: TimeInterval = 0.35 // ~3 per second
@@ -41,6 +49,12 @@ enum TransportConfig {
     static let uiLateInsertThresholdGeo: TimeInterval = 0.0
     static let uiProcessedNostrEventsCap: Int = 2000
     static let uiChannelInactivityThresholdSeconds: TimeInterval = 9 * 60
+    
+    // UI rate limiters (token buckets)
+    static let uiSenderRateBucketCapacity: Double = 5
+    static let uiSenderRateBucketRefillPerSec: Double = 1.0
+    static let uiContentRateBucketCapacity: Double = 3
+    static let uiContentRateBucketRefillPerSec: Double = 0.5
 
     // UI sleeps/delays
     static let uiStartupInitialDelaySeconds: TimeInterval = 1.0
@@ -56,6 +70,7 @@ enum TransportConfig {
     static let uiAnimationMediumSeconds: TimeInterval = 0.2
     static let uiAnimationSidebarSeconds: TimeInterval = 0.25
     static let uiRecentCutoffFiveMinutesSeconds: TimeInterval = 5 * 60
+    static let uiMeshEmptyConfirmationSeconds: TimeInterval = 30.0
 
     // BLE maintenance & thresholds
     static let bleMaintenanceInterval: TimeInterval = 5.0
@@ -135,6 +150,9 @@ enum TransportConfig {
 
     // Geo relay directory
     static let geoRelayFetchIntervalSeconds: TimeInterval = 60 * 60 * 24
+    static let geoRelayRefreshCheckIntervalSeconds: TimeInterval = 60 * 60
+    static let geoRelayRetryInitialSeconds: TimeInterval = 60
+    static let geoRelayRetryMaxSeconds: TimeInterval = 60 * 60
 
     // BLE operational delays
     static let bleInitialAnnounceDelaySeconds: TimeInterval = 0.6

bitchat/Services/UnifiedPeerService.swift

@@ -27,6 +27,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     private var peerIndex: [PeerID: BitchatPeer] = [:]
     private var fingerprintCache: [PeerID: String] = [:]
     private let meshService: Transport
+    private let idBridge: NostrIdentityBridge
     private let identityManager: SecureIdentityStateManagerProtocol
     weak var messageRouter: MessageRouter?
     private let favoritesService = FavoritesPersistenceService.shared
@@ -34,8 +35,13 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     
     // MARK: - Initialization
     
-    init(meshService: Transport, identityManager: SecureIdentityStateManagerProtocol) {
+    init(
+        meshService: Transport,
+        idBridge: NostrIdentityBridge,
+        identityManager: SecureIdentityStateManagerProtocol
+    ) {
         self.meshService = meshService
+        self.idBridge = idBridge
         self.identityManager = identityManager
         
         // Subscribe to changes from both services
@@ -46,17 +52,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
             updatePeers()
         }
     }
-
+    
-    deinit {
-        // Clean up NotificationCenter observers
-        NotificationCenter.default.removeObserver(self)
-
-        // Clean up Combine subscriptions
-        cancellables.removeAll()
-
-        SecureLogger.debug("UnifiedPeerService deinitialized", category: .session)
-    }
-
     // MARK: - Setup
     
     private func setupSubscriptions() {
@@ -239,10 +235,10 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     }
     
     /// Get peer ID for nickname
-    func getPeerID(for nickname: String) -> String? {
+    func getPeerID(for nickname: String) -> PeerID? {
         for peer in peers {
             if peer.displayName == nickname || peer.nickname == nickname {
-                return peer.peerID.id
+                return peer.peerID
             }
         }
         return nil
@@ -295,7 +291,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
             var peerNostrKey = peer.nostrPublicKey
             if peerNostrKey == nil {
                 // Try to get from NostrIdentityBridge association
-                peerNostrKey = NostrIdentityBridge.getNostrPublicKey(for: peer.noisePublicKey)
+                peerNostrKey = idBridge.getNostrPublicKey(for: peer.noisePublicKey)
             }
             
             // Add favorite
@@ -351,7 +347,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     // MARK: - Compatibility Methods (for easy migration)
     
     var allPeers: [BitchatPeer] { peers }
-    var connectedPeers: [PeerID] { Array(connectedPeerIDs) }
+    var connectedPeers: Set<PeerID> { connectedPeerIDs }
     var favoritePeers: Set<String> {
         Set(favorites.compactMap { getFingerprint(for: $0.peerID) })
     }

bitchat/Sync/GossipSyncManager.swift

@@ -8,38 +8,109 @@ final class GossipSyncManager {
         func signPacketForBroadcast(_ packet: BitchatPacket) -> BitchatPacket
     }
 
+    private struct PacketStore {
+        private(set) var packets: [String: BitchatPacket] = [:]
+        private(set) var order: [String] = []
+
+        mutating func insert(idHex: String, packet: BitchatPacket, capacity: Int) {
+            guard capacity > 0 else { return }
+            if packets[idHex] != nil {
+                packets[idHex] = packet
+                return
+            }
+            packets[idHex] = packet
+            order.append(idHex)
+            while order.count > capacity {
+                let victim = order.removeFirst()
+                packets.removeValue(forKey: victim)
+            }
+        }
+
+        func allPackets(isFresh: (BitchatPacket) -> Bool) -> [BitchatPacket] {
+            order.compactMap { key in
+                guard let packet = packets[key], isFresh(packet) else { return nil }
+                return packet
+            }
+        }
+
+        mutating func remove(where shouldRemove: (BitchatPacket) -> Bool) {
+            var nextOrder: [String] = []
+            for key in order {
+                guard let packet = packets[key] else { continue }
+                if shouldRemove(packet) {
+                    packets.removeValue(forKey: key)
+                } else {
+                    nextOrder.append(key)
+                }
+            }
+            order = nextOrder
+        }
+
+        mutating func removeExpired(isFresh: (BitchatPacket) -> Bool) {
+            remove { !isFresh($0) }
+        }
+    }
+
+    private struct SyncSchedule {
+        let types: SyncTypeFlags
+        let interval: TimeInterval
+        var lastSent: Date
+    }
+
     struct Config {
         var seenCapacity: Int = 1000          // max packets per sync (cap across types)
         var gcsMaxBytes: Int = 400           // filter size budget (128..1024)
         var gcsTargetFpr: Double = 0.01      // 1%
         var maxMessageAgeSeconds: TimeInterval = 900  // 15 min - discard older messages
+        var maintenanceIntervalSeconds: TimeInterval = 30.0
+        var stalePeerCleanupIntervalSeconds: TimeInterval = 60.0
+        var stalePeerTimeoutSeconds: TimeInterval = 60.0
+        var fragmentCapacity: Int = 600
+        var fileTransferCapacity: Int = 200
+        var fragmentSyncIntervalSeconds: TimeInterval = 30.0
+        var fileTransferSyncIntervalSeconds: TimeInterval = 60.0
+        var messageSyncIntervalSeconds: TimeInterval = 15.0
     }
 
     private let myPeerID: PeerID
     private let config: Config
     weak var delegate: Delegate?
 
-    // Storage: broadcast messages (ordered by insert), and latest announce per sender
+    // Storage: broadcast packets by type, and latest announce per sender
-    private var messages: [String: BitchatPacket] = [:] // idHex -> packet
+    private var messages = PacketStore()
-    private var messageOrder: [String] = []
+    private var fragments = PacketStore()
-    private var latestAnnouncementByPeer: [String: (id: String, packet: BitchatPacket)] = [:]
+    private var fileTransfers = PacketStore()
+    private var latestAnnouncementByPeer: [PeerID: (id: String, packet: BitchatPacket)] = [:]
 
     // Timer
     private var periodicTimer: DispatchSourceTimer?
     private let queue = DispatchQueue(label: "mesh.sync", qos: .utility)
+    private var lastStalePeerCleanup: Date = .distantPast
+    private var syncSchedules: [SyncSchedule] = []
 
     init(myPeerID: PeerID, config: Config = Config()) {
         self.myPeerID = myPeerID
         self.config = config
+        var schedules: [SyncSchedule] = []
+        if config.seenCapacity > 0 && config.messageSyncIntervalSeconds > 0 {
+            schedules.append(SyncSchedule(types: .publicMessages, interval: config.messageSyncIntervalSeconds, lastSent: .distantPast))
+        }
+        if config.fragmentCapacity > 0 && config.fragmentSyncIntervalSeconds > 0 {
+            schedules.append(SyncSchedule(types: .fragment, interval: config.fragmentSyncIntervalSeconds, lastSent: .distantPast))
+        }
+        if config.fileTransferCapacity > 0 && config.fileTransferSyncIntervalSeconds > 0 {
+            schedules.append(SyncSchedule(types: .fileTransfer, interval: config.fileTransferSyncIntervalSeconds, lastSent: .distantPast))
+        }
+        syncSchedules = schedules
     }
 
     func start() {
         stop()
         let timer = DispatchSource.makeTimerSource(queue: queue)
-        timer.schedule(deadline: .now() + 30.0, repeating: 30.0, leeway: .seconds(1))
+        let interval = max(0.1, config.maintenanceIntervalSeconds)
+        timer.schedule(deadline: .now() + interval, repeating: interval, leeway: .seconds(1))
         timer.setEventHandler { [weak self] in
-            self?.cleanupExpiredMessages()
+            self?.performPeriodicMaintenance()
-            self?.sendRequestSync()
         }
         timer.resume()
         periodicTimer = timer
@@ -51,7 +122,18 @@ final class GossipSyncManager {
 
     func scheduleInitialSyncToPeer(_ peerID: PeerID, delaySeconds: TimeInterval = 5.0) {
         queue.asyncAfter(deadline: .now() + delaySeconds) { [weak self] in
-            self?.sendRequestSync(to: peerID)
+            guard let self = self else { return }
+            self.sendRequestSync(to: peerID, types: .publicMessages)
+            if self.config.fragmentCapacity > 0 && self.config.fragmentSyncIntervalSeconds > 0 {
+                self.queue.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+                    self?.sendRequestSync(to: peerID, types: .fragment)
+                }
+            }
+            if self.config.fileTransferCapacity > 0 && self.config.fileTransferSyncIntervalSeconds > 0 {
+                self.queue.asyncAfter(deadline: .now() + 1.0) { [weak self] in
+                    self?.sendRequestSync(to: peerID, types: .fileTransfer)
+                }
+            }
         }
     }
 
@@ -73,40 +155,55 @@ final class GossipSyncManager {
         return packet.timestamp >= cutoffMs
     }
 
+    private func isAnnouncementFresh(_ packet: BitchatPacket) -> Bool {
+        guard config.stalePeerTimeoutSeconds > 0 else { return true }
+        let nowMs = UInt64(Date().timeIntervalSince1970 * 1000)
+        let timeoutMs = UInt64(config.stalePeerTimeoutSeconds * 1000)
+        guard nowMs >= timeoutMs else { return true }
+        let cutoffMs = nowMs - timeoutMs
+        return packet.timestamp >= cutoffMs
+    }
+
     private func _onPublicPacketSeen(_ packet: BitchatPacket) {
-        let mt = MessageType(rawValue: packet.type)
+        guard let messageType = MessageType(rawValue: packet.type) else { return }
         let isBroadcastRecipient: Bool = {
             guard let r = packet.recipientID else { return true }
             return r.count == 8 && r.allSatisfy { $0 == 0xFF }
         }()
-        let isBroadcastMessage = (mt == .message && isBroadcastRecipient)
-        let isAnnounce = (mt == .announce)
-        guard isBroadcastMessage || isAnnounce else { return }
 
-        // Reject expired packets to prevent ghost peers and old messages
+        switch messageType {
-        guard isPacketFresh(packet) else { return }
+        case .announce:
-
+            guard isPacketFresh(packet) else { return }
-        let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+            guard isAnnouncementFresh(packet) else {
-
+                let sender = PeerID(hexData: packet.senderID)
-        if isBroadcastMessage {
+                removeState(for: sender)
-            if messages[idHex] == nil {
+                return
-                messages[idHex] = packet
-                messageOrder.append(idHex)
-                // Enforce capacity
-                let cap = max(1, config.seenCapacity)
-                while messageOrder.count > cap {
-                    let victim = messageOrder.removeFirst()
-                    messages.removeValue(forKey: victim)
-                }
             }
-        } else if isAnnounce {
+            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
-            let sender = packet.senderID.hexEncodedString()
+            let sender = PeerID(hexData: packet.senderID)
             latestAnnouncementByPeer[sender] = (id: idHex, packet: packet)
+        case .message:
+            guard isBroadcastRecipient else { return }
+            guard isPacketFresh(packet) else { return }
+            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+            messages.insert(idHex: idHex, packet: packet, capacity: max(1, config.seenCapacity))
+        case .fragment:
+            guard isBroadcastRecipient else { return }
+            guard isPacketFresh(packet) else { return }
+            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+            fragments.insert(idHex: idHex, packet: packet, capacity: max(1, config.fragmentCapacity))
+        case .fileTransfer:
+            guard isBroadcastRecipient else { return }
+            guard isPacketFresh(packet) else { return }
+            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+            fileTransfers.insert(idHex: idHex, packet: packet, capacity: max(1, config.fileTransferCapacity))
+        default:
+            break
         }
     }
 
-    private func sendRequestSync() {
+    private func sendRequestSync(for types: SyncTypeFlags) {
-        let payload = buildGcsPayload()
+        let payload = buildGcsPayload(for: types)
         let pkt = BitchatPacket(
             type: MessageType.requestSync.rawValue,
             senderID: Data(hexString: myPeerID.id) ?? Data(),
@@ -120,8 +217,8 @@ final class GossipSyncManager {
         delegate?.sendPacket(signed)
     }
 
-    private func sendRequestSync(to peerID: PeerID) {
+    private func sendRequestSync(to peerID: PeerID, types: SyncTypeFlags) {
-        let payload = buildGcsPayload()
+        let payload = buildGcsPayload(for: types)
         var recipient = Data()
         var temp = peerID.id
         while temp.count >= 2 && recipient.count < 8 {
@@ -149,6 +246,7 @@ final class GossipSyncManager {
     }
 
     private func _handleRequestSync(from peerID: PeerID, request: RequestSyncPacket) {
+        let requestedTypes = (request.types ?? .publicMessages)
         // Decode GCS into sorted set and prepare membership checker
         let sorted = GCSFilter.decodeToSortedSet(p: request.p, m: request.m, data: request.data)
         func mightContain(_ id: Data) -> Bool {
@@ -156,60 +254,100 @@ final class GossipSyncManager {
             return GCSFilter.contains(sortedValues: sorted, candidate: bucket)
         }
 
-        // 1) Announcements: send latest per peer if requester lacks them (and not expired)
+        if requestedTypes.contains(.announce) {
-        for (_, pair) in latestAnnouncementByPeer {
+            for (_, pair) in latestAnnouncementByPeer {
-            let (idHex, pkt) = pair
+                let (idHex, pkt) = pair
-            guard isPacketFresh(pkt) else { continue }
+                guard isPacketFresh(pkt) else { continue }
-            let idBytes = Data(hexString: idHex) ?? Data()
+                let idBytes = Data(hexString: idHex) ?? Data()
-            if !mightContain(idBytes) {
+                if !mightContain(idBytes) {
-                var toSend = pkt
+                    var toSend = pkt
-                toSend.ttl = 0
+                    toSend.ttl = 0
-                delegate?.sendPacket(to: peerID, packet: toSend)
+                    delegate?.sendPacket(to: peerID, packet: toSend)
+                }
             }
         }
 
-        // 2) Broadcast messages: send all missing (and not expired)
+        if requestedTypes.contains(.message) {
-        let toSendMsgs = messageOrder.compactMap { messages[$0] }
+            let toSendMsgs = messages.allPackets(isFresh: isPacketFresh)
-        for pkt in toSendMsgs {
+            for pkt in toSendMsgs {
-            guard isPacketFresh(pkt) else { continue }
+                let idBytes = PacketIdUtil.computeId(pkt)
-            let idBytes = PacketIdUtil.computeId(pkt)
+                if !mightContain(idBytes) {
-            if !mightContain(idBytes) {
+                    var toSend = pkt
-                var toSend = pkt
+                    toSend.ttl = 0
-                toSend.ttl = 0
+                    delegate?.sendPacket(to: peerID, packet: toSend)
-                delegate?.sendPacket(to: peerID, packet: toSend)
+                }
+            }
+        }
+
+        if requestedTypes.contains(.fragment) {
+            let frags = fragments.allPackets(isFresh: isPacketFresh)
+            for pkt in frags {
+                let idBytes = PacketIdUtil.computeId(pkt)
+                if !mightContain(idBytes) {
+                    var toSend = pkt
+                    toSend.ttl = 0
+                    delegate?.sendPacket(to: peerID, packet: toSend)
+                }
+            }
+        }
+
+        if requestedTypes.contains(.fileTransfer) {
+            let files = fileTransfers.allPackets(isFresh: isPacketFresh)
+            for pkt in files {
+                let idBytes = PacketIdUtil.computeId(pkt)
+                if !mightContain(idBytes) {
+                    var toSend = pkt
+                    toSend.ttl = 0
+                    delegate?.sendPacket(to: peerID, packet: toSend)
+                }
             }
         }
     }
 
     // Build REQUEST_SYNC payload using current candidates and GCS params
-    private func buildGcsPayload() -> Data {
+    private func buildGcsPayload(for types: SyncTypeFlags) -> Data {
-        // Collect candidates: latest announce per peer + broadcast messages (only fresh)
         var candidates: [BitchatPacket] = []
-        candidates.reserveCapacity(latestAnnouncementByPeer.count + messageOrder.count)
+        if types.contains(.announce) {
-        for (_, pair) in latestAnnouncementByPeer {
+            for (_, pair) in latestAnnouncementByPeer where isPacketFresh(pair.packet) {
-            if isPacketFresh(pair.packet) {
                 candidates.append(pair.packet)
             }
         }
-        for id in messageOrder {
+        if types.contains(.message) {
-            if let p = messages[id], isPacketFresh(p) {
+            candidates.append(contentsOf: messages.allPackets(isFresh: isPacketFresh))
-                candidates.append(p)
-            }
         }
+        if types.contains(.fragment) {
+            candidates.append(contentsOf: fragments.allPackets(isFresh: isPacketFresh))
+        }
+        if types.contains(.fileTransfer) {
+            candidates.append(contentsOf: fileTransfers.allPackets(isFresh: isPacketFresh))
+        }
+        if candidates.isEmpty {
+            let p = GCSFilter.deriveP(targetFpr: config.gcsTargetFpr)
+            let req = RequestSyncPacket(p: p, m: 1, data: Data(), types: types)
+            return req.encode()
+        }
+
         // Sort by timestamp desc
         candidates.sort { $0.timestamp > $1.timestamp }
 
         let p = GCSFilter.deriveP(targetFpr: config.gcsTargetFpr)
         let nMax = GCSFilter.estimateMaxElements(sizeBytes: config.gcsMaxBytes, p: p)
-        let cap = max(1, config.seenCapacity)
+        let cap: Int
+        if types == .fragment {
+            cap = max(1, config.fragmentCapacity)
+        } else if types == .fileTransfer {
+            cap = max(1, config.fileTransferCapacity)
+        } else {
+            cap = max(1, config.seenCapacity)
+        }
         let takeN = min(candidates.count, min(nMax, cap))
         if takeN <= 0 {
-            let req = RequestSyncPacket(p: p, m: 1, data: Data())
+            let req = RequestSyncPacket(p: p, m: 1, data: Data(), types: types)
             return req.encode()
         }
         let ids: [Data] = candidates.prefix(takeN).map { PacketIdUtil.computeId($0) }
         let params = GCSFilter.buildFilter(ids: ids, maxBytes: config.gcsMaxBytes, targetFpr: config.gcsTargetFpr)
-        let req = RequestSyncPacket(p: params.p, m: params.m, data: params.data)
+        let req = RequestSyncPacket(p: params.p, m: params.m, data: params.data, types: types)
         return req.encode()
     }
 
@@ -220,37 +358,78 @@ final class GossipSyncManager {
             isPacketFresh(pair.packet)
         }
 
-        // Remove expired messages
+        messages.removeExpired(isFresh: isPacketFresh)
-        let expiredMessageIds = messages.compactMap { id, pkt in
+        fragments.removeExpired(isFresh: isPacketFresh)
-            isPacketFresh(pkt) ? nil : id
+        fileTransfers.removeExpired(isFresh: isPacketFresh)
+    }
+
+    private func performPeriodicMaintenance(now: Date = Date()) {
+        cleanupExpiredMessages()
+        cleanupStaleAnnouncementsIfNeeded(now: now)
+        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)
+            }
         }
-        for id in expiredMessageIds {
+    }
-            messages.removeValue(forKey: id)
+
-            messageOrder.removeAll { $0 == id }
+    private func cleanupStaleAnnouncementsIfNeeded(now: Date) {
+        guard now.timeIntervalSince(lastStalePeerCleanup) >= config.stalePeerCleanupIntervalSeconds else {
+            return
+        }
+        lastStalePeerCleanup = now
+        cleanupStaleAnnouncements(now: now)
+    }
+
+    private func cleanupStaleAnnouncements(now: Date) {
+        let timeoutMs = UInt64(config.stalePeerTimeoutSeconds * 1000)
+        let nowMs = UInt64(now.timeIntervalSince1970 * 1000)
+        guard nowMs >= timeoutMs else { return }
+        let cutoff = nowMs - timeoutMs
+        let stalePeerIDs = latestAnnouncementByPeer.compactMap { peerID, pair in
+            pair.packet.timestamp < cutoff ? peerID : nil
+        }
+        guard !stalePeerIDs.isEmpty else { return }
+        for peerKey in stalePeerIDs {
+            removeState(for: peerKey)
         }
     }
 
     // Explicit removal hook for LEAVE/stale peer
     func removeAnnouncementForPeer(_ peerID: PeerID) {
         queue.async { [weak self] in
-            self?._removeAnnouncementForPeer(peerID)
+            self?.removeState(for: peerID)
         }
     }
 
-    private func _removeAnnouncementForPeer(_ peerID: PeerID) {
+    private func removeState(for peerID: PeerID) {
-        let normalizedPeerID = peerID.id.lowercased()
+        _ = latestAnnouncementByPeer.removeValue(forKey: peerID)
-        _ = latestAnnouncementByPeer.removeValue(forKey: normalizedPeerID)
+        messages.remove { PeerID(hexData: $0.senderID) == peerID }
+        fragments.remove { PeerID(hexData: $0.senderID) == peerID }
+        fileTransfers.remove { PeerID(hexData: $0.senderID) == peerID }
+    }
+}
 
-        // Remove messages from this peer
+#if DEBUG
-        // Collect IDs to remove first to avoid concurrent modification
+extension GossipSyncManager {
-        let messageIdsToRemove = messages.compactMap { (id, message) -> String? in
+    func _performMaintenanceSynchronously(now: Date = Date()) {
-            message.senderID.hexEncodedString().lowercased() == normalizedPeerID ? id : nil
+        queue.sync {
+            performPeriodicMaintenance(now: now)
         }
-        
+    }
-        // Remove messages and update messageOrder
+
-        for id in messageIdsToRemove {
+    func _hasAnnouncement(for peerID: PeerID) -> Bool {
-            messages.removeValue(forKey: id)
+        queue.sync {
-            messageOrder.removeAll { $0 == id }
+            latestAnnouncementByPeer[peerID] != nil
+        }
+    }
+
+    func _messageCount(for peerID: PeerID) -> Int {
+        queue.sync {
+            messages.allPackets { _ in true }.filter { PeerID(hexData: $0.senderID) == peerID }.count
         }
     }
 }
+#endif

bitchat/Sync/SyncTypeFlags.swift

@@ -0,0 +1,104 @@
+import Foundation
+
+/// Bitfield describing which message types are covered by a REQUEST_SYNC round.
+/// Matches the Android mapping (bit index -> message type).
+struct SyncTypeFlags: OptionSet {
+    let rawValue: UInt64
+
+    init(rawValue: UInt64) {
+        self.rawValue = rawValue & 0x00FF_FFFF_FFFF_FFFF // Trim to max 8 bytes
+    }
+
+    private static func bitIndex(for type: MessageType) -> Int? {
+        switch type {
+        case .announce: return 0
+        case .message: return 1
+        case .leave: return 2
+        case .noiseHandshake: return 3
+        case .noiseEncrypted: return 4
+        case .fragment: return 5
+        case .requestSync: return 6
+        case .fileTransfer: return 7
+        }
+    }
+
+    private static func type(forBit index: Int) -> MessageType? {
+        switch index {
+        case 0: return .announce
+        case 1: return .message
+        case 2: return .leave
+        case 3: return .noiseHandshake
+        case 4: return .noiseEncrypted
+        case 5: return .fragment
+        case 6: return .requestSync
+        case 7: return .fileTransfer
+        default:
+            return nil
+        }
+    }
+
+    static let announce = SyncTypeFlags(messageTypes: [.announce])
+    static let message = SyncTypeFlags(messageTypes: [.message])
+    static let fragment = SyncTypeFlags(messageTypes: [.fragment])
+    static let fileTransfer = SyncTypeFlags(messageTypes: [.fileTransfer])
+
+    static let publicMessages = SyncTypeFlags(messageTypes: [.announce, .message])
+
+    init(messageTypes: [MessageType]) {
+        var raw: UInt64 = 0
+        for type in messageTypes {
+            guard let bit = SyncTypeFlags.bitIndex(for: type) else { continue }
+            raw |= (1 << UInt64(bit))
+        }
+        self.init(rawValue: raw)
+    }
+
+    func contains(_ type: MessageType) -> Bool {
+        guard let bit = SyncTypeFlags.bitIndex(for: type) else { return false }
+        return contains(SyncTypeFlags(rawValue: 1 << UInt64(bit)))
+    }
+
+    func union(_ other: SyncTypeFlags) -> SyncTypeFlags {
+        SyncTypeFlags(rawValue: rawValue | other.rawValue)
+    }
+
+    func intersection(_ other: SyncTypeFlags) -> SyncTypeFlags {
+        SyncTypeFlags(rawValue: rawValue & other.rawValue)
+    }
+
+    func toMessageTypes() -> [MessageType] {
+        guard rawValue != 0 else { return [] }
+        var types: [MessageType] = []
+        for bit in 0..<64 {
+            guard (rawValue & (1 << UInt64(bit))) != 0 else { continue }
+            if let type = SyncTypeFlags.type(forBit: bit) {
+                types.append(type)
+            }
+        }
+        return types
+    }
+
+    func toData() -> Data? {
+        guard rawValue != 0 else { return nil }
+        var value = rawValue
+        var bytes: [UInt8] = []
+        while value > 0 && bytes.count < 8 {
+            bytes.append(UInt8(value & 0xFF))
+            value >>= 8
+        }
+        while let last = bytes.last, last == 0 {
+            bytes.removeLast()
+        }
+        guard !bytes.isEmpty, bytes.count <= 8 else { return nil }
+        return Data(bytes)
+    }
+
+    static func decode(_ data: Data) -> SyncTypeFlags? {
+        guard (1...8).contains(data.count) else { return nil }
+        var raw: UInt64 = 0
+        for (index, byte) in data.enumerated() {
+            raw |= UInt64(byte) << UInt64(index * 8)
+        }
+        return SyncTypeFlags(rawValue: raw)
+    }
+}

bitchat/Utils/CompressionUtil.swift

@@ -61,15 +61,13 @@ struct CompressionUtil {
         // 1. Data is too small
         // 2. Data appears to be already compressed (high entropy)
         guard data.count >= compressionThreshold else { return false }
-        
+
-        // Simple entropy check - count unique bytes
+        // Quick uniqueness check — a high diversity of bytes usually means the
-        var byteFrequency = [UInt8: Int]()
+        // payload is already compressed. We only need to know how many unique
-        for byte in data {
+        // values exist rather than keeping full frequency counts.
-            byteFrequency[byte, default: 0] += 1
+        let uniqueByteCount = Set(data).count
-        }
+        let sampleSize = min(data.count, 256)
-        
+        let uniqueByteRatio = Double(uniqueByteCount) / Double(sampleSize)
-        // If we have very high byte diversity, data is likely already compressed
-        let uniqueByteRatio = Double(byteFrequency.count) / Double(min(data.count, 256))
         return uniqueByteRatio < 0.9 // Compress if less than 90% unique bytes
     }
 }

bitchat/Utils/FileTransferLimits.swift

@@ -0,0 +1,25 @@
+import Foundation
+
+/// Centralized thresholds for Bluetooth file transfers to keep payload sizes sane on constrained radios.
+enum FileTransferLimits {
+    /// Absolute ceiling enforced for any file payload (voice, image, other).
+    static let maxPayloadBytes: Int = 1 * 1024 * 1024 // 1 MiB
+    /// Voice notes stay small for low-latency relays.
+    static let maxVoiceNoteBytes: Int = 512 * 1024 // 512 KiB
+    /// Compressed images after downscaling should comfortably fit under this budget.
+    static let maxImageBytes: Int = 512 * 1024 // 512 KiB
+    /// Worst-case size once TLV metadata and binary packet framing are included for the largest payloads.
+    static let maxFramedFileBytes: Int = {
+        let maxMetadataBytes = Int(UInt16.max) * 2 // fileName + mimeType TLVs
+        let tlvEnvelopeOverhead = 18 + maxMetadataBytes // TLV tags + lengths + metadata bytes
+        let binaryEnvelopeOverhead = BinaryProtocol.v2HeaderSize
+            + BinaryProtocol.senderIDSize
+            + BinaryProtocol.recipientIDSize
+            + BinaryProtocol.signatureSize
+        return maxPayloadBytes + tlvEnvelopeOverhead + binaryEnvelopeOverhead
+    }()
+
+    static func isValidPayload(_ size: Int) -> Bool {
+        size <= maxPayloadBytes
+    }
+}

bitchat/Utils/InputValidator.swift

@@ -1,4 +1,5 @@
 import Foundation
+import BitLogger
 
 /// Comprehensive input validation for BitChat protocol
 /// Prevents injection attacks, buffer overflows, and malformed data
@@ -16,29 +17,28 @@ struct InputValidator {
     // MARK: - String Content Validation
     
     /// Validates and sanitizes user-provided strings used in UI
+    ///
+    /// 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? {
-        // Check empty
-        guard !string.isEmpty else { return nil }
-
-        // Trim whitespace
         let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !trimmed.isEmpty else { return nil }
-
-        // Check length
         guard trimmed.count <= maxLength else { return nil }
 
-        // Remove control characters
+        // Reject control characters outright instead of rewriting the string.
+        // This prevents injection attacks and ensures consistent UI rendering.
         let controlChars = CharacterSet.controlCharacters
-        let cleaned = trimmed.components(separatedBy: controlChars).joined()
+        if !trimmed.unicodeScalars.allSatisfy({ !controlChars.contains($0) }) {
-        
+            // Log rejection for monitoring, without exposing actual content for privacy
-        // Ensure valid UTF-8 (should already be, but double-check)
+            let controlCharCount = trimmed.unicodeScalars.filter { controlChars.contains($0) }.count
-        guard cleaned.data(using: .utf8) != nil else { return nil }
+            SecureLogger.debug(
-        
+                "Input validation rejected string (length: \(trimmed.count), control chars: \(controlCharCount))",
-        // Prevent zero-width characters and other invisible unicode
+                category: .security
-        let invisibleChars = CharacterSet(charactersIn: "\u{200B}\u{200C}\u{200D}\u{FEFF}")
+            )
-        let visible = cleaned.components(separatedBy: invisibleChars).joined()
+            return nil
-        
+        }
-        return visible.isEmpty ? nil : visible
+
+        return trimmed
     }
     
     /// Validates nickname

bitchat/ViewModels/GeoChannelCoordinator.swift

@@ -0,0 +1,118 @@
+//
+// GeoChannelCoordinator.swift
+// bitchat
+//
+// Centralizes Combine wiring for location channel selection and sampling.
+//
+
+import Combine
+import Foundation
+import Tor
+
+@MainActor
+final class GeoChannelCoordinator {
+    private let locationManager: LocationChannelManager
+    private let bookmarksStore: GeohashBookmarksStore
+    private let torManager: TorManager
+
+    private let onChannelSwitch: (ChannelID) -> Void
+    private let beginSampling: ([String]) -> Void
+    private let endSampling: () -> Void
+
+    private var cancellables = Set<AnyCancellable>()
+    private var regionalGeohashes: [String] = []
+    private var bookmarkedGeohashes: [String] = []
+
+    init(
+        locationManager: LocationChannelManager? = nil,
+        bookmarksStore: GeohashBookmarksStore? = nil,
+        torManager: TorManager? = nil,
+        onChannelSwitch: @escaping (ChannelID) -> Void,
+        beginSampling: @escaping ([String]) -> Void,
+        endSampling: @escaping () -> Void
+    ) {
+        self.locationManager = locationManager ?? Self.defaultLocationManager()
+        self.bookmarksStore = bookmarksStore ?? GeohashBookmarksStore.shared
+        self.torManager = torManager ?? Self.defaultTorManager()
+        self.onChannelSwitch = onChannelSwitch
+        self.beginSampling = beginSampling
+        self.endSampling = endSampling
+
+        start()
+    }
+
+    func start() {
+        regionalGeohashes = locationManager.availableChannels.map { $0.geohash }
+        bookmarkedGeohashes = bookmarksStore.bookmarks
+
+        locationManager.$selectedChannel
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] channel in
+                guard let self else { return }
+                Task { @MainActor in
+                    self.onChannelSwitch(channel)
+                }
+            }
+            .store(in: &cancellables)
+
+        locationManager.$availableChannels
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] channels in
+                guard let self else { return }
+                self.regionalGeohashes = channels.map { $0.geohash }
+                self.updateSampling()
+            }
+            .store(in: &cancellables)
+
+        bookmarksStore.$bookmarks
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] bookmarks in
+                guard let self else { return }
+                self.bookmarkedGeohashes = bookmarks
+                self.updateSampling()
+            }
+            .store(in: &cancellables)
+
+        locationManager.$permissionState
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] state in
+                guard let self, state == .authorized else { return }
+                Task { @MainActor [weak self] in
+                    self?.locationManager.refreshChannels()
+                }
+            }
+            .store(in: &cancellables)
+
+        Task { @MainActor in
+            self.onChannelSwitch(self.locationManager.selectedChannel)
+        }
+        updateSampling()
+    }
+
+    private func updateSampling() {
+        let union = Array(Set(regionalGeohashes).union(bookmarkedGeohashes))
+        Task { @MainActor in
+            guard !union.isEmpty else {
+                endSampling()
+                return
+            }
+            if torManager.isForeground() {
+                beginSampling(union)
+            } else {
+                endSampling()
+            }
+        }
+    }
+
+    func refreshSampling() {
+        updateSampling()
+    }
+    private static func defaultLocationManager() -> LocationChannelManager {
+        LocationChannelManager.shared
+    }
+
+    @MainActor
+    private static func defaultTorManager() -> TorManager {
+        TorManager.shared
+    }
+}

bitchat/ViewModels/MessageRateLimiter.swift

@@ -0,0 +1,77 @@
+//
+// MessageRateLimiter.swift
+// bitchat
+//
+// Handles per-sender and per-content token buckets for public message intake.
+//
+
+import Foundation
+
+struct MessageRateLimiter {
+    private struct TokenBucket {
+        var capacity: Double
+        var tokens: Double
+        var refillPerSec: Double
+        var lastRefill: Date
+
+        mutating func allow(cost: Double = 1.0, now: Date = Date()) -> Bool {
+            let dt = now.timeIntervalSince(lastRefill)
+            if dt > 0 {
+                tokens = min(capacity, tokens + dt * refillPerSec)
+                lastRefill = now
+            }
+            if tokens >= cost {
+                tokens -= cost
+                return true
+            }
+            return false
+        }
+    }
+
+    private var senderBuckets: [String: TokenBucket] = [:]
+    private var contentBuckets: [String: TokenBucket] = [:]
+
+    private let senderCapacity: Double
+    private let senderRefill: Double
+    private let contentCapacity: Double
+    private let contentRefill: Double
+
+    init(
+        senderCapacity: Double,
+        senderRefillPerSec: Double,
+        contentCapacity: Double,
+        contentRefillPerSec: Double
+    ) {
+        self.senderCapacity = senderCapacity
+        self.senderRefill = senderRefillPerSec
+        self.contentCapacity = contentCapacity
+        self.contentRefill = contentRefillPerSec
+    }
+
+    mutating func allow(senderKey: String, contentKey: String, now: Date = Date()) -> Bool {
+        var senderBucket = senderBuckets[senderKey] ?? TokenBucket(
+            capacity: senderCapacity,
+            tokens: senderCapacity,
+            refillPerSec: senderRefill,
+            lastRefill: now
+        )
+        let senderAllowed = senderBucket.allow(now: now)
+        senderBuckets[senderKey] = senderBucket
+
+        var contentBucket = contentBuckets[contentKey] ?? TokenBucket(
+            capacity: contentCapacity,
+            tokens: contentCapacity,
+            refillPerSec: contentRefill,
+            lastRefill: now
+        )
+        let contentAllowed = contentBucket.allow(now: now)
+        contentBuckets[contentKey] = contentBucket
+
+        return senderAllowed && contentAllowed
+    }
+
+    mutating func reset() {
+        senderBuckets.removeAll()
+        contentBuckets.removeAll()
+    }
+}

bitchat/ViewModels/MinimalDistancePalette.swift

@@ -0,0 +1,210 @@
+//
+// MinimalDistancePalette.swift
+// bitchat
+//
+// Lightweight palette generator that keeps peer colors evenly spaced.
+//
+
+import Foundation
+import SwiftUI
+
+final class MinimalDistancePalette {
+    struct Config {
+        let slotCount: Int
+        let avoidCenterHue: Double
+        let avoidHueDelta: Double
+        let saturationLight: Double
+        let saturationDark: Double
+        let baseBrightnessLight: Double
+        let baseBrightnessDark: Double
+        let ringBrightnessDeltaLight: Double
+        let ringBrightnessDeltaDark: Double
+        let preferredBiasWeight: Double
+        let goldenStep: Int
+
+        init(
+            slotCount: Int,
+            avoidCenterHue: Double,
+            avoidHueDelta: Double,
+            saturationLight: Double,
+            saturationDark: Double,
+            baseBrightnessLight: Double,
+            baseBrightnessDark: Double,
+            ringBrightnessDeltaLight: Double,
+            ringBrightnessDeltaDark: Double,
+            preferredBiasWeight: Double = 0.05,
+            goldenStep: Int = 7
+        ) {
+            self.slotCount = slotCount
+            self.avoidCenterHue = avoidCenterHue
+            self.avoidHueDelta = avoidHueDelta
+            self.saturationLight = saturationLight
+            self.saturationDark = saturationDark
+            self.baseBrightnessLight = baseBrightnessLight
+            self.baseBrightnessDark = baseBrightnessDark
+            self.ringBrightnessDeltaLight = ringBrightnessDeltaLight
+            self.ringBrightnessDeltaDark = ringBrightnessDeltaDark
+            self.preferredBiasWeight = preferredBiasWeight
+            self.goldenStep = goldenStep
+        }
+    }
+
+    private struct Entry {
+        let slot: Int
+        let ring: Int
+        let hue: Double
+    }
+
+    private let config: Config
+    private var currentSeeds: [String: String] = [:]
+    private var entries: [String: Entry] = [:]
+    private var previousEntries: [String: Entry] = [:]
+
+    init(config: Config) {
+        self.config = config
+    }
+
+    @MainActor
+    func ensurePalette(for seeds: [String: String]) {
+        guard seeds != currentSeeds || entries.count != seeds.count else { return }
+        previousEntries = entries
+        currentSeeds = seeds
+        rebuildEntries()
+    }
+
+    @MainActor
+    func color(for identifier: String, isDark: Bool) -> Color? {
+        guard let entry = entries[identifier] else { return nil }
+        let saturation = isDark ? config.saturationDark : config.saturationLight
+        let baseBrightness = isDark ? config.baseBrightnessDark : config.baseBrightnessLight
+        let ringDelta = isDark ? config.ringBrightnessDeltaDark : config.ringBrightnessDeltaLight
+        let brightness = min(1.0, max(0.0, baseBrightness + ringDelta * Double(entry.ring)))
+        return Color(hue: entry.hue, saturation: saturation, brightness: brightness)
+    }
+
+    @MainActor
+    func reset() {
+        currentSeeds.removeAll()
+        entries.removeAll()
+        previousEntries.removeAll()
+    }
+
+    @MainActor
+    private func rebuildEntries() {
+        guard !currentSeeds.isEmpty else {
+            entries.removeAll()
+            return
+        }
+
+        let slotCount = max(8, config.slotCount)
+        var slots: [Double] = []
+        for idx in 0..<slotCount {
+            let hue = Double(idx) / Double(slotCount)
+            if abs(hue - config.avoidCenterHue) < config.avoidHueDelta {
+                continue
+            }
+            slots.append(hue)
+        }
+        if slots.isEmpty {
+            for idx in 0..<slotCount {
+                slots.append(Double(idx) / Double(slotCount))
+            }
+        }
+
+        func circularDistance(_ a: Double, _ b: Double) -> Double {
+            let diff = abs(a - b)
+            return diff > 0.5 ? 1.0 - diff : diff
+        }
+
+        let peerIDs = currentSeeds.keys.sorted()
+        let preferredIndex: [String: Int] = Dictionary(uniqueKeysWithValues: peerIDs.map { id in
+            let seed = currentSeeds[id] ?? id
+            let hash = seed.djb2()
+            let index = Int(hash % UInt64(slots.count))
+            return (id, index)
+        })
+
+        var mapping: [String: Entry] = [:]
+        var usedSlots = Set<Int>()
+        var usedHues: [Double] = []
+
+        let prior = entries.isEmpty ? previousEntries : entries
+        for (id, entry) in prior {
+            guard currentSeeds.keys.contains(id), entry.slot < slots.count else { continue }
+            let hue = slots[entry.slot]
+            mapping[id] = Entry(slot: entry.slot, ring: entry.ring, hue: hue)
+            usedSlots.insert(entry.slot)
+            usedHues.append(hue)
+        }
+
+        let unassigned = peerIDs.filter { mapping[$0] == nil }
+        for id in unassigned {
+            let preferred = preferredIndex[id] ?? 0
+            if !usedSlots.contains(preferred), preferred < slots.count {
+                let hue = slots[preferred]
+                mapping[id] = Entry(slot: preferred, ring: 0, hue: hue)
+                usedSlots.insert(preferred)
+                usedHues.append(hue)
+                continue
+            }
+
+            var bestSlot: Int?
+            var bestScore = -Double.infinity
+            for slot in 0..<slots.count where !usedSlots.contains(slot) {
+                let hue = slots[slot]
+                let minDistance = usedHues.isEmpty ? 1.0 : usedHues.map { circularDistance(hue, $0) }.min() ?? 1.0
+                let bias = 1.0 - (Double((abs(slot - (preferredIndex[id] ?? 0)) % slots.count)) / Double(slots.count))
+                let score = minDistance + config.preferredBiasWeight * bias
+                if score > bestScore {
+                    bestScore = score
+                    bestSlot = slot
+                }
+            }
+
+            if let slot = bestSlot {
+                let hue = slots[slot]
+                mapping[id] = Entry(slot: slot, ring: 0, hue: hue)
+                usedSlots.insert(slot)
+                usedHues.append(hue)
+            }
+        }
+
+        let remaining = peerIDs.filter { mapping[$0] == nil }
+        if !remaining.isEmpty {
+            for (index, id) in remaining.enumerated() {
+                let preferred = preferredIndex[id] ?? 0
+                let slot = (preferred + index * config.goldenStep) % slots.count
+                let hue = slots[slot]
+                mapping[id] = Entry(slot: slot, ring: 1, hue: hue)
+            }
+        }
+
+        entries = mapping
+    }
+}
+
+extension MinimalDistancePalette.Config {
+    static let mesh = MinimalDistancePalette.Config(
+        slotCount: TransportConfig.uiPeerPaletteSlots,
+        avoidCenterHue: 30.0 / 360.0,
+        avoidHueDelta: TransportConfig.uiColorHueAvoidanceDelta,
+        saturationLight: 0.70,
+        saturationDark: 0.80,
+        baseBrightnessLight: 0.45,
+        baseBrightnessDark: 0.75,
+        ringBrightnessDeltaLight: TransportConfig.uiPeerPaletteRingBrightnessDeltaLight,
+        ringBrightnessDeltaDark: TransportConfig.uiPeerPaletteRingBrightnessDeltaDark
+    )
+
+    static let nostr = MinimalDistancePalette.Config(
+        slotCount: TransportConfig.uiPeerPaletteSlots,
+        avoidCenterHue: 30.0 / 360.0,
+        avoidHueDelta: TransportConfig.uiColorHueAvoidanceDelta,
+        saturationLight: 0.70,
+        saturationDark: 0.80,
+        baseBrightnessLight: 0.45,
+        baseBrightnessDark: 0.75,
+        ringBrightnessDeltaLight: TransportConfig.uiPeerPaletteRingBrightnessDeltaLight,
+        ringBrightnessDeltaDark: TransportConfig.uiPeerPaletteRingBrightnessDeltaDark
+    )
+}

bitchat/ViewModels/PublicMessagePipeline.swift

@@ -0,0 +1,190 @@
+//
+// PublicMessagePipeline.swift
+// bitchat
+//
+// Handles batching and deduplication of public chat messages before surfacing them to the UI.
+//
+
+import Foundation
+
+@MainActor
+protocol PublicMessagePipelineDelegate: AnyObject {
+    func pipelineCurrentMessages(_ pipeline: PublicMessagePipeline) -> [BitchatMessage]
+    func pipeline(_ pipeline: PublicMessagePipeline, setMessages messages: [BitchatMessage])
+    func pipeline(_ pipeline: PublicMessagePipeline, normalizeContent content: String) -> String
+    func pipeline(_ pipeline: PublicMessagePipeline, contentTimestampForKey key: String) -> Date?
+    func pipeline(_ pipeline: PublicMessagePipeline, recordContentKey key: String, timestamp: Date)
+    func pipelineTrimMessages(_ pipeline: PublicMessagePipeline)
+    func pipelinePrewarmMessage(_ pipeline: PublicMessagePipeline, message: BitchatMessage)
+    func pipelineSetBatchingState(_ pipeline: PublicMessagePipeline, isBatching: Bool)
+}
+
+@MainActor
+final class PublicMessagePipeline {
+    weak var delegate: PublicMessagePipelineDelegate?
+
+    private var buffer: [BitchatMessage] = []
+    private var timer: Timer?
+    private let baseFlushInterval: TimeInterval
+    private var dynamicFlushInterval: TimeInterval
+    private var recentBatchSizes: [Int] = []
+    private let maxRecentBatchSamples: Int
+    private let dedupWindow: TimeInterval
+    private var activeChannel: ChannelID = .mesh
+
+    init(
+        baseFlushInterval: TimeInterval = TransportConfig.basePublicFlushInterval,
+        maxRecentBatchSamples: Int = 10,
+        dedupWindow: TimeInterval = 1.0
+    ) {
+        self.baseFlushInterval = baseFlushInterval
+        self.dynamicFlushInterval = baseFlushInterval
+        self.maxRecentBatchSamples = maxRecentBatchSamples
+        self.dedupWindow = dedupWindow
+    }
+
+    deinit {
+        timer?.invalidate()
+    }
+
+    func updateActiveChannel(_ channel: ChannelID) {
+        activeChannel = channel
+    }
+
+    func enqueue(_ message: BitchatMessage) {
+        buffer.append(message)
+        scheduleFlush()
+    }
+
+    func flushIfNeeded() {
+        flushBuffer()
+    }
+
+    func reset() {
+        timer?.invalidate()
+        timer = nil
+        buffer.removeAll(keepingCapacity: false)
+    }
+
+}
+
+private extension PublicMessagePipeline {
+    func scheduleFlush() {
+        guard timer == nil else { return }
+        timer = Timer.scheduledTimer(withTimeInterval: dynamicFlushInterval, repeats: false) { [weak self] _ in
+            guard let self else { return }
+            Task { @MainActor in
+                self.flushBuffer()
+            }
+        }
+    }
+
+    func flushBuffer() {
+        timer?.invalidate()
+        timer = nil
+        guard !buffer.isEmpty else { return }
+        guard let delegate = delegate else {
+            buffer.removeAll(keepingCapacity: false)
+            return
+        }
+
+        delegate.pipelineSetBatchingState(self, isBatching: true)
+
+        var existingIDs = Set(delegate.pipelineCurrentMessages(self).map { $0.id })
+        var pending: [(message: BitchatMessage, contentKey: String)] = []
+        var batchContentLatest: [String: Date] = [:]
+
+        for message in buffer {
+            if existingIDs.contains(message.id) { continue }
+            let contentKey = delegate.pipeline(self, normalizeContent: message.content)
+            if let ts = delegate.pipeline(self, contentTimestampForKey: contentKey),
+               abs(ts.timeIntervalSince(message.timestamp)) < dedupWindow {
+                continue
+            }
+            if let ts = batchContentLatest[contentKey],
+               abs(ts.timeIntervalSince(message.timestamp)) < dedupWindow {
+                continue
+            }
+            existingIDs.insert(message.id)
+            pending.append((message, contentKey))
+            batchContentLatest[contentKey] = message.timestamp
+        }
+
+        buffer.removeAll(keepingCapacity: true)
+        guard !pending.isEmpty else {
+            delegate.pipelineSetBatchingState(self, isBatching: false)
+            if !buffer.isEmpty { scheduleFlush() }
+            return
+        }
+
+        pending.sort { $0.message.timestamp < $1.message.timestamp }
+
+        var messages = delegate.pipelineCurrentMessages(self)
+        let threshold = lateInsertThreshold(for: activeChannel)
+        let lastTimestamp = messages.last?.timestamp ?? .distantPast
+
+        for item in pending {
+            let message = item.message
+            if threshold == 0 || message.timestamp < lastTimestamp.addingTimeInterval(-threshold) {
+                let index = insertionIndex(for: message.timestamp, in: messages)
+                if index >= messages.count {
+                    messages.append(message)
+                } else {
+                    messages.insert(message, at: index)
+                }
+            } else {
+                messages.append(message)
+            }
+            delegate.pipeline(self, recordContentKey: item.contentKey, timestamp: message.timestamp)
+        }
+
+        delegate.pipeline(self, setMessages: messages)
+        delegate.pipelineTrimMessages(self)
+
+        updateFlushInterval(withBatchSize: pending.count)
+
+        for item in pending {
+            delegate.pipelinePrewarmMessage(self, message: item.message)
+        }
+
+        delegate.pipelineSetBatchingState(self, isBatching: false)
+
+        if !buffer.isEmpty {
+            scheduleFlush()
+        }
+    }
+
+    func updateFlushInterval(withBatchSize size: Int) {
+        recentBatchSizes.append(size)
+        if recentBatchSizes.count > maxRecentBatchSamples {
+            recentBatchSizes.removeFirst(recentBatchSizes.count - maxRecentBatchSamples)
+        }
+        let avg = recentBatchSizes.isEmpty
+            ? 0.0
+            : Double(recentBatchSizes.reduce(0, +)) / Double(recentBatchSizes.count)
+        dynamicFlushInterval = avg > 100.0 ? 0.12 : baseFlushInterval
+    }
+
+    func lateInsertThreshold(for channel: ChannelID) -> TimeInterval {
+        switch channel {
+        case .mesh:
+            return TransportConfig.uiLateInsertThreshold
+        case .location:
+            return TransportConfig.uiLateInsertThresholdGeo
+        }
+    }
+
+    func insertionIndex(for timestamp: Date, in messages: [BitchatMessage]) -> Int {
+        var low = 0
+        var high = messages.count
+        while low < high {
+            let mid = (low + high) / 2
+            if messages[mid].timestamp < timestamp {
+                low = mid + 1
+            } else {
+                high = mid
+            }
+        }
+        return low
+    }
+}

bitchat/ViewModels/PublicTimelineStore.swift

@@ -0,0 +1,124 @@
+//
+// PublicTimelineStore.swift
+// bitchat
+//
+// Maintains mesh and geohash public timelines with simple caps and helpers.
+//
+
+import Foundation
+
+struct PublicTimelineStore {
+    private var meshTimeline: [BitchatMessage] = []
+    private var geohashTimelines: [String: [BitchatMessage]] = [:]
+    private var pendingGeohashSystemMessages: [String] = []
+
+    private let meshCap: Int
+    private let geohashCap: Int
+
+    init(meshCap: Int, geohashCap: Int) {
+        self.meshCap = meshCap
+        self.geohashCap = geohashCap
+    }
+
+    mutating func append(_ message: BitchatMessage, to channel: ChannelID) {
+        switch channel {
+        case .mesh:
+            guard !meshTimeline.contains(where: { $0.id == message.id }) else { return }
+            meshTimeline.append(message)
+            trimMeshTimelineIfNeeded()
+        case .location(let channel):
+            append(message, toGeohash: channel.geohash)
+        }
+    }
+
+    mutating func append(_ message: BitchatMessage, toGeohash geohash: String) {
+        var timeline = geohashTimelines[geohash] ?? []
+        guard !timeline.contains(where: { $0.id == message.id }) else { return }
+        timeline.append(message)
+        trimGeohashTimelineIfNeeded(&timeline)
+        geohashTimelines[geohash] = timeline
+    }
+
+    /// Append message if absent, returning true when stored.
+    mutating func appendIfAbsent(_ message: BitchatMessage, toGeohash geohash: String) -> Bool {
+        var timeline = geohashTimelines[geohash] ?? []
+        guard !timeline.contains(where: { $0.id == message.id }) else { return false }
+        timeline.append(message)
+        trimGeohashTimelineIfNeeded(&timeline)
+        geohashTimelines[geohash] = timeline
+        return true
+    }
+
+    mutating func messages(for channel: ChannelID) -> [BitchatMessage] {
+        switch channel {
+        case .mesh:
+            return meshTimeline
+        case .location(let channel):
+            let cleaned = geohashTimelines[channel.geohash]?.cleanedAndDeduped() ?? []
+            geohashTimelines[channel.geohash] = cleaned
+            return cleaned
+        }
+    }
+
+    mutating func clear(channel: ChannelID) {
+        switch channel {
+        case .mesh:
+            meshTimeline.removeAll()
+        case .location(let channel):
+            geohashTimelines[channel.geohash] = []
+        }
+    }
+
+    @discardableResult
+    mutating func removeMessage(withID id: String) -> BitchatMessage? {
+        if let index = meshTimeline.firstIndex(where: { $0.id == id }) {
+            return meshTimeline.remove(at: index)
+        }
+
+        for key in Array(geohashTimelines.keys) {
+            var timeline = geohashTimelines[key] ?? []
+            if let index = timeline.firstIndex(where: { $0.id == id }) {
+                let removed = timeline.remove(at: index)
+                geohashTimelines[key] = timeline.isEmpty ? nil : timeline
+                return removed
+            }
+        }
+
+        return nil
+    }
+
+    mutating func removeMessages(in geohash: String, where predicate: (BitchatMessage) -> Bool) {
+        var timeline = geohashTimelines[geohash] ?? []
+        timeline.removeAll(where: predicate)
+        geohashTimelines[geohash] = timeline.isEmpty ? nil : timeline
+    }
+
+    mutating func mutateGeohash(_ geohash: String, _ transform: (inout [BitchatMessage]) -> Void) {
+        var timeline = geohashTimelines[geohash] ?? []
+        transform(&timeline)
+        geohashTimelines[geohash] = timeline.isEmpty ? nil : timeline
+    }
+
+    mutating func queueGeohashSystemMessage(_ content: String) {
+        pendingGeohashSystemMessages.append(content)
+    }
+
+    mutating func drainPendingGeohashSystemMessages() -> [String] {
+        defer { pendingGeohashSystemMessages.removeAll(keepingCapacity: false) }
+        return pendingGeohashSystemMessages
+    }
+
+    func geohashKeys() -> [String] {
+        Array(geohashTimelines.keys)
+    }
+
+    private mutating func trimMeshTimelineIfNeeded() {
+        guard meshTimeline.count > meshCap else { return }
+        meshTimeline = Array(meshTimeline.suffix(meshCap))
+    }
+
+    private func trimGeohashTimelineIfNeeded(_ timeline: inout [BitchatMessage]) {
+        guard timeline.count > geohashCap else { return }
+        timeline = Array(timeline.suffix(geohashCap))
+    }
+}

bitchat/Views/Components/CommandSuggestionsView.swift

@@ -0,0 +1,90 @@
+//
+//  CommandSuggestionsView.swift
+//  bitchat
+//
+//  Created by Islam on 29/10/2025.
+//
+
+import SwiftUI
+
+struct CommandSuggestionsView: View {
+    @EnvironmentObject private var viewModel: ChatViewModel
+    @ObservedObject private var locationManager = LocationChannelManager.shared
+    
+    @Binding var messageText: String
+    
+    let textColor: Color
+    let backgroundColor: Color
+    let secondaryTextColor: Color
+    
+    private var filteredCommands: [CommandInfo] {
+        guard messageText.hasPrefix("/") && !messageText.contains(" ") else { return [] }
+        let isGeoPublic = locationManager.selectedChannel.isLocation
+        let isGeoDM = viewModel.selectedPrivateChatPeer?.isGeoDM == true
+        return CommandInfo.all(isGeoPublic: isGeoPublic, isGeoDM: isGeoDM).filter { command in
+            command.alias.starts(with: messageText.lowercased())
+        }
+    }
+    
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            ForEach(filteredCommands) { command in
+                Button {
+                    messageText = command.alias + " "
+                } label: {
+                    buttonRow(for: command)
+                }
+                .buttonStyle(.plain)
+                .background(Color.gray.opacity(0.1))
+            }
+        }
+        .background(backgroundColor)
+        .overlay(
+            RoundedRectangle(cornerRadius: 4)
+                .stroke(secondaryTextColor.opacity(0.3), lineWidth: 1)
+        )
+    }
+    
+    private func buttonRow(for command: CommandInfo) -> some View {
+        HStack {
+            Text(command.alias)
+                .font(.bitchatSystem(size: 11, design: .monospaced))
+                .foregroundColor(textColor)
+                .fontWeight(.medium)
+            
+            if let placeholder = command.placeholder {
+                Text(placeholder)
+                    .font(.bitchatSystem(size: 10, design: .monospaced))
+                    .foregroundColor(secondaryTextColor.opacity(0.8))
+            }
+
+            Spacer()
+            
+            Text(command.description)
+                .font(.bitchatSystem(size: 10, design: .monospaced))
+                .foregroundColor(secondaryTextColor)
+        }
+        .padding(.horizontal, 12)
+        .padding(.vertical, 3)
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+}
+
+@available(iOS 17, macOS 14, *)
+#Preview {
+    @Previewable @State var messageText: String = "/"
+    let keychain = KeychainManager()
+    let viewModel = ChatViewModel(
+        keychain: keychain,
+        idBridge: NostrIdentityBridge(),
+        identityManager: SecureIdentityStateManager(keychain)
+    )
+    
+    CommandSuggestionsView(
+        messageText: $messageText,
+        textColor: .green,
+        backgroundColor: .primary,
+        secondaryTextColor: .secondary
+    )
+    .environmentObject(viewModel)
+}

bitchat/Views/Components/TextMessageView.swift

@@ -91,6 +91,7 @@ struct TextMessageView: View {
     .environmentObject(
         ChatViewModel(
             keychain: keychain,
+            idBridge: NostrIdentityBridge(),
             identityManager: SecureIdentityStateManager(keychain)
         )
     )

bitchat/Views/FingerprintView.swift

@@ -10,7 +10,7 @@ import SwiftUI
 
 struct FingerprintView: View {
     @ObservedObject var viewModel: ChatViewModel
-    let peerID: String
+    let peerID: PeerID
     @Environment(\.dismiss) var dismiss
     @Environment(\.colorScheme) var colorScheme
     
@@ -65,15 +65,12 @@ struct FingerprintView: View {
             
             VStack(alignment: .leading, spacing: 16) {
                 // Prefer short mesh ID for session/encryption status
-                let statusPeerID: String = {
+                let statusPeerID = viewModel.getShortIDForNoiseKey(peerID)
-                    if peerID.count == 64, let short = viewModel.getShortIDForNoiseKey(peerID) { return short }
-                    return peerID
-                }()
                 // Resolve a friendly name
                 let peerNickname: String = {
                     if let p = viewModel.getPeer(byID: statusPeerID) { return p.displayName }
-                    if let name = viewModel.meshService.peerNickname(peerID: PeerID(str: statusPeerID)) { return name }
+                    if let name = viewModel.meshService.peerNickname(peerID: statusPeerID) { return name }
-                    if peerID.count == 64, let data = Data(hexString: peerID) {
+                    if let data = peerID.noiseKey {
                         if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: data), !fav.peerNickname.isEmpty { return fav.peerNickname }
                         let fp = data.sha256Fingerprint()
                         if let social = viewModel.identityManager.getSocialIdentity(for: fp) {
@@ -239,8 +236,6 @@ struct FingerprintView: View {
         .padding()
         .frame(maxWidth: .infinity, maxHeight: .infinity)
         .background(backgroundColor)
-        .presentationDetents([.large])
-        .presentationDragIndicator(.visible)
     }
     
     private func formatFingerprint(_ fingerprint: String) -> String {

bitchat/Views/GeohashPeopleList.swift

@@ -28,7 +28,7 @@ struct GeohashPeopleList: View {
         } else {
             let myHex: String? = {
                 if case .location(let ch) = LocationChannelManager.shared.selectedChannel,
-                   let id = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) {
+                   let id = try? viewModel.idBridge.deriveIdentity(forGeohash: ch.geohash) {
                     return id.publicKeyHex.lowercased()
                 }
                 return nil

bitchat/Views/LocationChannelsSheet.swift

@@ -125,9 +125,6 @@ struct LocationChannelsSheet: View {
             .navigationTitle("")
             #endif
         }
-        #if os(iOS)
-        .presentationDetents([.large])
-        #endif
         #if os(macOS)
         .frame(minWidth: 420, minHeight: 520)
         #endif
@@ -599,7 +596,7 @@ extension LocationChannelsSheet {
         switch level {
         case .region:
             return ""
-        default:
+        case .building, .block, .neighborhood, .city, .province:
             return "~"
         }
     }