Fix geohash UX: rising-edge notify, correct teleport, sort timeline

- Remove "new chats!" background nudge; notify only when a regional geohash goes from 0 participants to activity, with content preview and cooldown.\n- Do not mark teleported when selected geohash is in regional channel list; clear persisted teleport when in-region; avoid self teleported state from historical tags; deep links don’t mark teleported for regional geohashes or during cold start.\n- Sort per-geohash timelines chronologically on re-entry and trim whitespace-only content to prevent blank lines.\n- Trim inbound public content and ignore whitespace-only sends.

bitchat.xcodeproj/project.pbxproj

@@ -32,10 +32,6 @@
 		048A4BE72E5CCCC300162C4A /* TransportConfig.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4BE62E5CCCC300162C4A /* TransportConfig.swift */; };
 		048A4BE82E5CCCC300162C4A /* TransportConfig.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4BE62E5CCCC300162C4A /* TransportConfig.swift */; };
 		048A4BE92E5CCCC300162C4B /* TransportConfig.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4BE62E5CCCC300162C4A /* TransportConfig.swift */; };
-		048A4C282E5FCD6600162C4A /* GeohashBookmarksStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4C272E5FCD6600162C4A /* GeohashBookmarksStore.swift */; };
-		048A4C292E5FCD6600162C4A /* GeohashBookmarksStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4C272E5FCD6600162C4A /* GeohashBookmarksStore.swift */; };
-		048A4C2B2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4C2A2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift */; };
-		048A4C2C2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4C2A2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift */; };
 		049BD3902E4EC4F0001A566B /* PrivateChatManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = 049BD38F2E4EC4F0001A566B /* PrivateChatManager.swift */; };
 		049BD3912E4EC4F0001A566B /* AutocompleteService.swift in Sources */ = {isa = PBXBuildFile; fileRef = 049BD38C2E4EC4F0001A566B /* AutocompleteService.swift */; };
 		049BD3922E4EC4F0001A566B /* CommandProcessor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 049BD38D2E4EC4F0001A566B /* CommandProcessor.swift */; };
@@ -209,8 +205,6 @@
 		047502B32E55FED60083520F /* MeshPeerList.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeshPeerList.swift; sourceTree = "<group>"; };
 		047502B82E560F690083520F /* RelayController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RelayController.swift; sourceTree = "<group>"; };
 		048A4BE62E5CCCC300162C4A /* TransportConfig.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TransportConfig.swift; sourceTree = "<group>"; };
-		048A4C272E5FCD6600162C4A /* GeohashBookmarksStore.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GeohashBookmarksStore.swift; sourceTree = "<group>"; };
-		048A4C2A2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GeohashBookmarksStoreTests.swift; sourceTree = "<group>"; };
 		049BD38C2E4EC4F0001A566B /* AutocompleteService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AutocompleteService.swift; sourceTree = "<group>"; };
 		049BD38D2E4EC4F0001A566B /* CommandProcessor.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CommandProcessor.swift; sourceTree = "<group>"; };
 		049BD38F2E4EC4F0001A566B /* PrivateChatManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PrivateChatManager.swift; sourceTree = "<group>"; };
@@ -489,7 +483,6 @@
 		C3D98EB3E1B455E321F519F4 /* bitchatTests */ = {
 			isa = PBXGroup;
 			children = (
-				048A4C2A2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift */,
 				D69A18D27F9A565FD6041E12 /* Info.plist */,
 				047502912E547ACC0083520F /* LocationChannelsTests.swift */,
 				C272F137CE00FC5A96E0CC06 /* NostrProtocolTests.swift */,
@@ -526,7 +519,6 @@
 		D98A3186D7E4C72E35BDF7FE /* Services */ = {
 			isa = PBXGroup;
 			children = (
-				048A4C272E5FCD6600162C4A /* GeohashBookmarksStore.swift */,
 				048A4BE62E5CCCC300162C4A /* TransportConfig.swift */,
 				AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */,
 				047502B82E560F690083520F /* RelayController.swift */,
@@ -779,7 +771,6 @@
 				0475028C2E54171C0083520F /* LocationChannelManager.swift in Sources */,
 				AFF33EF44626EF0579D17EB1 /* NoiseHandshakeCoordinator.swift in Sources */,
 				8C1AB0F2D48207E0755DA91A /* NoiseProtocol.swift in Sources */,
-				048A4C282E5FCD6600162C4A /* GeohashBookmarksStore.swift in Sources */,
 				049BD3AC2E51E38E001A566B /* PeerIDResolver.swift in Sources */,
 				D691938B4029A04CC905FDC8 /* NoiseSecurityConsiderations.swift in Sources */,
 				8A14ADADF5CD7A79919CB655 /* NoiseSession.swift in Sources */,
@@ -839,7 +830,6 @@
 				0475028D2E54171C0083520F /* LocationChannelManager.swift in Sources */,
 				6D0D4A0B1D8B659DCBAE7C9C /* NoiseHandshakeCoordinator.swift in Sources */,
 				A7187D48B07C6857DE01D0ED /* NoiseProtocol.swift in Sources */,
-				048A4C292E5FCD6600162C4A /* GeohashBookmarksStore.swift in Sources */,
 				049BD3AB2E51E38E001A566B /* PeerIDResolver.swift in Sources */,
 				9CCF09F7527EC681A13FC246 /* NoiseSecurityConsiderations.swift in Sources */,
 				92D1CF17DF88EA298F6E5E8E /* NoiseSession.swift in Sources */,
@@ -876,7 +866,6 @@
 				047502B12E55E8450083520F /* InputValidatorTests.swift in Sources */,
 				D727EA273CB214FC32612469 /* MockBluetoothMeshService.swift in Sources */,
 				047502932E547ACC0083520F /* LocationChannelsTests.swift in Sources */,
-				048A4C2B2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */,
 				6C803BF930E7E19BE6E99EAA /* MockBLEService.swift in Sources */,
 				765254F56997F01054699AC0 /* NoiseProtocolTests.swift in Sources */,
 				968181D255CA7A804340B4DA /* NostrProtocolTests.swift in Sources */,
@@ -899,7 +888,6 @@
 				047502B02E55E8450083520F /* InputValidatorTests.swift in Sources */,
 				8851F08D88C5B1DE7B9F55C6 /* MockBluetoothMeshService.swift in Sources */,
 				047502922E547ACC0083520F /* LocationChannelsTests.swift in Sources */,
-				048A4C2C2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */,
 				3849CA6D99B2D536636DF4A6 /* MockBLEService.swift in Sources */,
 				BC4DC75F4FB823FF40569676 /* NoiseProtocolTests.swift in Sources */,
 				EE8C3ECADAB3083A2687D50B /* NostrProtocolTests.swift in Sources */,

bitchat/Nostr/NostrRelayManager.swift

@@ -44,15 +44,8 @@ class NostrRelayManager: ObservableObject {
     private var cancellables = Set<AnyCancellable>()
     
     // Message queue for reliability
-    // Pending sends held only for relays that are not yet connected.
+    private var messageQueue: [(event: NostrEvent, relayUrls: [String])] = []
-    private struct PendingSend {
-        var event: NostrEvent
-        var pendingRelays: Set<String>
-    }
-    private var messageQueue: [PendingSend] = []
     private let messageQueueLock = NSLock()
-    private let encoder = JSONEncoder()
-    private let decoder = JSONDecoder()
     
     // Exponential backoff configuration
     private let initialBackoffInterval: TimeInterval = TransportConfig.nostrRelayInitialBackoffSeconds
@@ -66,8 +59,6 @@ class NostrRelayManager: ObservableObject {
     init() {
         // Initialize with default relays
         self.relays = Self.defaultRelays.map { Relay(url: $0) }
-        // Deterministic JSON shape for outbound requests
-        self.encoder.outputFormatting = .sortedKeys
     }
     
     /// Connect to all configured relays
@@ -105,56 +96,15 @@ class NostrRelayManager: ObservableObject {
         let targetRelays = relayUrls ?? Self.defaultRelays
         ensureConnections(to: targetRelays)
         
-        // Attempt immediate send to relays with active connections; queue the rest
+        // Add to queue for reliability
-        var stillPending = Set<String>()
+        messageQueueLock.lock()
+        messageQueue.append((event, targetRelays))
+        messageQueueLock.unlock()
+        
+        // Attempt immediate send
         for relayUrl in targetRelays {
             if let connection = connections[relayUrl] {
                 sendToRelay(event: event, connection: connection, relayUrl: relayUrl)
-            } else {
-                stillPending.insert(relayUrl)
-            }
-        }
-        if !stillPending.isEmpty {
-            messageQueueLock.lock()
-            messageQueue.append(PendingSend(event: event, pendingRelays: stillPending))
-            messageQueueLock.unlock()
-        }
-    }
-
-    /// Try to flush any queued messages for relays that are now connected.
-    private func flushMessageQueue(for relayUrl: String? = nil) {
-        messageQueueLock.lock()
-        defer { messageQueueLock.unlock() }
-        guard !messageQueue.isEmpty else { return }
-        if let target = relayUrl {
-            // Flush only for a specific relay
-            for i in (0..<messageQueue.count).reversed() {
-                var item = messageQueue[i]
-                if item.pendingRelays.contains(target), let conn = connections[target] {
-                    sendToRelay(event: item.event, connection: conn, relayUrl: target)
-                    item.pendingRelays.remove(target)
-                    if item.pendingRelays.isEmpty {
-                        messageQueue.remove(at: i)
-                    } else {
-                        messageQueue[i] = item
-                    }
-                }
-            }
-        } else {
-            // Flush for any relays that now have connections
-            for i in (0..<messageQueue.count).reversed() {
-                var item = messageQueue[i]
-                for url in item.pendingRelays {
-                    if let conn = connections[url] {
-                        sendToRelay(event: item.event, connection: conn, relayUrl: url)
-                        item.pendingRelays.remove(url)
-                    }
-                }
-                if item.pendingRelays.isEmpty {
-                    messageQueue.remove(at: i)
-                } else {
-                    messageQueue[i] = item
-                }
             }
         }
     }
@@ -174,6 +124,8 @@ class NostrRelayManager: ObservableObject {
         let req = NostrRequest.subscribe(id: id, filters: [filter])
         
         do {
+            let encoder = JSONEncoder()
+            encoder.outputFormatting = .sortedKeys // For consistent output
             let message = try encoder.encode(req)
             guard let messageString = String(data: message, encoding: .utf8) else { 
                 SecureLogger.log("❌ Failed to encode subscription request", category: SecureLogger.session, level: .error)
@@ -223,7 +175,7 @@ class NostrRelayManager: ObservableObject {
         messageHandlers.removeValue(forKey: id)
         
         let req = NostrRequest.close(id: id)
-        let message = try? encoder.encode(req)
+        let message = try? JSONEncoder().encode(req)
         
         guard let messageData = message,
               let messageString = String(data: messageData, encoding: .utf8) else { return }
@@ -290,20 +242,13 @@ class NostrRelayManager: ObservableObject {
             case .success(let message):
                 switch message {
                 case .string(let text):
-                    // Parse off-main to reduce UI jank, then hop back for state updates
+                    Task { @MainActor in
-                    Task.detached(priority: .utility) {
+                        self.handleMessage(text, from: relayUrl)
-                        guard let parsed = parseInboundMessage(text) else { return }
-                        await MainActor.run {
-                            NostrRelayManager.shared.handleParsedMessage(parsed, from: relayUrl)
-                        }
                     }
                 case .data(let data):
                     if let text = String(data: data, encoding: .utf8) {
-                        Task.detached(priority: .utility) {
+                        Task { @MainActor in
-                            guard let parsed = parseInboundMessage(text) else { return }
+                        self.handleMessage(text, from: relayUrl)
-                            await MainActor.run {
-                                NostrRelayManager.shared.handleParsedMessage(parsed, from: relayUrl)
-                            }
                     }
                     }
                 @unknown default:
@@ -323,31 +268,57 @@ class NostrRelayManager: ObservableObject {
         }
     }
     
-    // Parsed inbound message type (off-main)
+    private func handleMessage(_ message: String, from relayUrl: String) {
-    // Note: declared at file scope below to avoid MainActor isolation inside this class
+        guard let data = message.data(using: .utf8) else { return }
-    // and keep parsing off the main actor.
         
-    // Handle parsed message on MainActor (state updates and handlers)
+        do {
-    private func handleParsedMessage(_ parsed: ParsedInbound, from relayUrl: String) {
+            // Try to decode as an array first
-        switch parsed {
+            if let array = try JSONSerialization.jsonObject(with: data) as? [Any],
-        case .event(let subId, let event):
+               array.count >= 2,
+               let type = array[0] as? String {
+                
+                // Received message from relay
+                
+                switch type {
+                case "EVENT":
+                    if array.count >= 3,
+                       let subId = array[1] as? String,
+                       let eventDict = array[2] as? [String: Any] {
+                        
+                        let event = try NostrEvent(from: eventDict)
+                        
+                        // Only log non-gift-wrap events to reduce noise
                         if event.kind != 1059 {
                             SecureLogger.log("📥 Event kind=\(event.kind) id=\(event.id.prefix(16))… relay=\(relayUrl)",
                                             category: SecureLogger.session, level: .debug)
                         }
+                        
+                        DispatchQueue.main.async {
+                            // Update relay stats
                             if let index = self.relays.firstIndex(where: { $0.url == relayUrl }) {
                                 self.relays[index].messagesReceived += 1
                             }
+                            
+                            // Call handler
                             if let handler = self.messageHandlers[subId] {
                                 handler(event)
                             } else {
                                 SecureLogger.log("⚠️ No handler for subscription \(subId)", 
                                                 category: SecureLogger.session, level: .warning)
                             }
-        case .eose:
+                        }
-            // No-op for now
+                    }
-            break
+                    
-        case .ok(let eventId, let success, let reason):
+                case "EOSE":
+                    if array.count >= 2 {
+                        // End of stored events
+                    }
+                    
+                case "OK":
+                    if array.count >= 3,
+                       let eventId = array[1] as? String,
+                       let success = array[2] as? Bool {
+                        let reason = array.count >= 4 ? (array[3] as? String ?? "no reason given") : "no reason given"
                         if success {
                             _ = Self.pendingGiftWrapIDs.remove(eventId)
                             SecureLogger.log("✅ Accepted id=\(eventId.prefix(16))… relay=\(relayUrl)",
@@ -357,8 +328,19 @@ class NostrRelayManager: ObservableObject {
                             SecureLogger.log("📮 Rejected id=\(eventId.prefix(16))… reason=\(reason)", 
                                             category: SecureLogger.session, level: isGiftWrap ? .warning : .error)
                         }
-        case .notice:
+                    }
-            break
+                    
+                case "NOTICE":
+                    if array.count >= 2 {
+                        // Server notice received
+                    }
+                    
+                default:
+                    break // Unknown message type
+                }
+            }
+        } catch {
+            SecureLogger.log("Failed to parse Nostr message: \(error)", category: SecureLogger.session, level: .error)
         }
     }
     
@@ -366,6 +348,8 @@ class NostrRelayManager: ObservableObject {
         let req = NostrRequest.event(event)
         
         do {
+            let encoder = JSONEncoder()
+            encoder.outputFormatting = .sortedKeys
             let data = try encoder.encode(req)
             let message = String(data: data, encoding: .utf8) ?? ""
             
@@ -405,10 +389,6 @@ class NostrRelayManager: ObservableObject {
             }
         }
         updateConnectionStatus()
-        // If we just connected to this relay, flush any queued sends targeting it
-        if isConnected {
-            flushMessageQueue(for: url)
-        }
     }
     
     private func updateConnectionStatus() {
@@ -514,51 +494,6 @@ class NostrRelayManager: ObservableObject {
     }
 }
 
-// MARK: - Off-main inbound parsing helpers (file scope, non-isolated)
-
-private enum ParsedInbound {
-    case event(subId: String, event: NostrEvent)
-    case ok(eventId: String, success: Bool, reason: String)
-    case eose(subscriptionId: String)
-    case notice(String)
-}
-
-// Off-main JSON parse to avoid UI jank; pure function, not actor-isolated
-private func parseInboundMessage(_ message: String) -> ParsedInbound? {
-    guard let data = message.data(using: .utf8) else { return nil }
-    do {
-        if let array = try JSONSerialization.jsonObject(with: data) as? [Any],
-           array.count >= 2,
-           let type = array[0] as? String {
-            switch type {
-            case "EVENT":
-                if array.count >= 3,
-                   let subId = array[1] as? String,
-                   let eventDict = array[2] as? [String: Any] {
-                    let event = try NostrEvent(from: eventDict)
-                    return .event(subId: subId, event: event)
-                }
-            case "EOSE":
-                if let subId = array[1] as? String { return .eose(subscriptionId: subId) }
-            case "OK":
-                if array.count >= 3,
-                   let eventId = array[1] as? String,
-                   let success = array[2] as? Bool {
-                    let reason = array.count >= 4 ? (array[3] as? String ?? "no reason given") : "no reason given"
-                    return .ok(eventId: eventId, success: success, reason: reason)
-                }
-            case "NOTICE":
-                if array.count >= 2, let msg = array[1] as? String { return .notice(msg) }
-            default:
-                return nil
-            }
-        }
-    } catch {
-        // Ignore
-    }
-    return nil
-}
-
 // MARK: - Nostr Protocol Types
 
 enum NostrRequest: Encodable {

bitchat/Protocols/BinaryEncodingUtils.swift

@@ -40,23 +40,23 @@ extension Data {
 extension Data {
     // MARK: Writing
     
-    @inlinable mutating func appendUInt8(_ value: UInt8) {
+    mutating func appendUInt8(_ value: UInt8) {
         self.append(value)
     }
     
-    @inlinable mutating func appendUInt16(_ value: UInt16) {
+    mutating func appendUInt16(_ value: UInt16) {
         self.append(UInt8((value >> 8) & 0xFF))
         self.append(UInt8(value & 0xFF))
     }
     
-    @inlinable mutating func appendUInt32(_ value: UInt32) {
+    mutating func appendUInt32(_ value: UInt32) {
         self.append(UInt8((value >> 24) & 0xFF))
         self.append(UInt8((value >> 16) & 0xFF))
         self.append(UInt8((value >> 8) & 0xFF))
         self.append(UInt8(value & 0xFF))
     }
     
-    @inlinable mutating func appendUInt64(_ value: UInt64) {
+    mutating func appendUInt64(_ value: UInt64) {
         for i in (0..<8).reversed() {
             self.append(UInt8((value >> (i * 8)) & 0xFF))
         }
@@ -113,21 +113,21 @@ extension Data {
     
     // MARK: Reading
     
-    @inlinable func readUInt8(at offset: inout Int) -> UInt8? {
+    func readUInt8(at offset: inout Int) -> UInt8? {
         guard offset >= 0 && offset < self.count else { return nil }
         let value = self[offset]
         offset += 1
         return value
     }
     
-    @inlinable func readUInt16(at offset: inout Int) -> UInt16? {
+    func readUInt16(at offset: inout Int) -> UInt16? {
         guard offset + 2 <= self.count else { return nil }
         let value = UInt16(self[offset]) << 8 | UInt16(self[offset + 1])
         offset += 2
         return value
     }
     
-    @inlinable func readUInt32(at offset: inout Int) -> UInt32? {
+    func readUInt32(at offset: inout Int) -> UInt32? {
         guard offset + 4 <= self.count else { return nil }
         let value = UInt32(self[offset]) << 24 |
                    UInt32(self[offset + 1]) << 16 |
@@ -137,7 +137,7 @@ extension Data {
         return value
     }
     
-    @inlinable func readUInt64(at offset: inout Int) -> UInt64? {
+    func readUInt64(at offset: inout Int) -> UInt64? {
         guard offset + 8 <= self.count else { return nil }
         var value: UInt64 = 0
         for i in 0..<8 {
@@ -220,3 +220,4 @@ extension Data {
         return data
     }
 }
+

bitchat/Protocols/BinaryProtocol.swift

@@ -139,11 +139,6 @@ struct BinaryProtocol {
         }
         
         // Header
-        // Reserve capacity to reduce reallocations. Estimate base size conservatively.
-        // header(13) + sender(8) + opt recipient(8) + opt originalSize(2) + payload + opt signature(64) + up to 255 pad
-        let estimatedPayload = payload.count + (isCompressed ? 2 : 0)
-        let estimated = headerSize + senderIDSize + (packet.recipientID == nil ? 0 : recipientIDSize) + estimatedPayload + (packet.signature == nil ? 0 : signatureSize) + 255
-        data.reserveCapacity(estimated)
         data.append(packet.version)
         data.append(packet.type)
         data.append(packet.ttl)
@@ -227,107 +222,137 @@ struct BinaryProtocol {
 
     // Core decoding implementation used by decode(_:) with and without padding removal
     private static func decodeCore(_ raw: Data) -> BitchatPacket? {
-        // Minimum size: header + senderID
+        // Minimum size check: header + senderID
-        guard raw.count >= headerSize + senderIDSize else { return nil }
+        guard raw.count >= headerSize + senderIDSize else { 
+            return nil 
+        }
         
-        return raw.withUnsafeBytes { (buf: UnsafeRawBufferPointer) -> BitchatPacket? in
+        // Convert to array for safer indexed access
-            guard let base = buf.baseAddress else { return nil }
+        let dataArray = Array(raw)
         var offset = 0
-            func require(_ n: Int) -> Bool { offset + n <= buf.count }
+        
-            // Read single byte
+        // Header parsing with bounds checks
-            func read8() -> UInt8? {
+        guard offset < dataArray.count else { return nil }
-                guard require(1) else { return nil }
+        let version = dataArray[offset]; offset += 1
-                let v = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self).pointee
+        
-                offset += 1
+        // Check if version is 1 (only supported version)
-                return v
+        guard version == 1 else { 
-            }
+            return nil 
-            // 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 v = (UInt16(p[0]) << 8) | UInt16(p[1])
-                offset += 2
-                return v
-            }
-            // 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)
-                offset += n
-                return d
         }
         
-            // Version
+        guard offset < dataArray.count else { return nil }
-            guard let version = read8(), version == 1 else { return nil }
+        let type = dataArray[offset]; offset += 1
-            guard let type = read8() else { return nil }
-            guard let ttl = read8() else { return nil }
         
-            // Timestamp 8 bytes BE
+        guard offset < dataArray.count else { return nil }
-            guard require(8) else { return nil }
+        let ttl = dataArray[offset]; offset += 1
-            var ts: UInt64 = 0
+        
-            for _ in 0..<8 {
+        // Timestamp - need 8 bytes
-                guard let b = read8() else { return nil }
+        guard offset + 8 <= dataArray.count else { return nil }
-                ts = (ts << 8) | UInt64(b)
+        let timestampData = Data(dataArray[offset..<offset+8])
+        let timestamp = timestampData.reduce(0) { result, byte in
+            (result << 8) | UInt64(byte)
         }
+        offset += 8
         
         // Flags
-            guard let flags = read8() else { return nil }
+        guard offset < dataArray.count else { return nil }
+        let flags = dataArray[offset]; offset += 1
         let hasRecipient = (flags & Flags.hasRecipient) != 0
         let hasSignature = (flags & Flags.hasSignature) != 0
         let isCompressed = (flags & Flags.isCompressed) != 0
         
-            // Payload length
+        // Payload length - need 2 bytes
-            guard let payloadLen = read16(), payloadLen <= 65535 else { return nil }
+        guard offset + 2 <= dataArray.count else { return nil }
+        let payloadLengthData = Data(dataArray[offset..<offset+2])
+        let payloadLength = payloadLengthData.reduce(0) { result, byte in
+            (result << 8) | UInt16(byte)
+        }
+        offset += 2
         
-            // SenderID
+        // Validate payloadLength is reasonable (prevent integer overflow)
-            guard let senderID = readData(senderIDSize) else { return nil }
+        guard payloadLength <= 65535 else { return nil }
         
-            // Recipient
+        // SenderID - need 8 bytes
-            var recipientID: Data? = nil
+        guard offset + senderIDSize <= dataArray.count else { return nil }
+        let senderID = Data(dataArray[offset..<offset+senderIDSize])
+        offset += senderIDSize
+        
+        // RecipientID if present
+        var recipientID: Data?
         if hasRecipient {
-                recipientID = readData(recipientIDSize)
+            guard offset + recipientIDSize <= dataArray.count else { return nil }
-                if recipientID == nil { return nil }
+            recipientID = Data(dataArray[offset..<offset+recipientIDSize])
+            offset += recipientIDSize
         }
         
-            // Payload
+        // Payload handling with comprehensive bounds checking
         let payload: Data
         if isCompressed {
-                // Need original size (2 bytes)
+            // Compressed payload needs at least 2 bytes for original size
-                guard let origSize16 = read16() else { return nil }
+            guard Int(payloadLength) >= 2 else { return nil }
-                let originalSize = Int(origSize16)
+            
-                guard originalSize >= 0 && originalSize <= 1_048_576 else { return nil }
+            // Check we have enough data for the original size prefix
-                let compSize = Int(payloadLen) - 2
+            guard offset + 2 <= dataArray.count else { return nil }
-                guard compSize >= 0, let compressed = readData(compSize) else { return nil }
+            let originalSizeData = Data(dataArray[offset..<offset+2])
-                guard let decompressed = CompressionUtil.decompress(compressed, originalSize: originalSize),
+            let originalSize = Int(originalSizeData.reduce(0) { result, byte in
-                      decompressed.count == originalSize else { return nil }
+                (result << 8) | UInt16(byte)
-                payload = decompressed
+            })
+            offset += 2
+            
+            // Validate original size is reasonable
+            guard originalSize >= 0 && originalSize <= 1048576 else { return nil } // Max 1MB
+            
+            // Check we have enough data for the compressed payload
+            let compressedPayloadSize = Int(payloadLength) - 2
+            guard compressedPayloadSize >= 0 && offset + compressedPayloadSize <= dataArray.count else { 
+                return nil 
+            }
+            
+            let compressedPayload = Data(dataArray[offset..<offset+compressedPayloadSize])
+            offset += compressedPayloadSize
+            
+            // Decompress with error handling
+            guard let decompressedPayload = CompressionUtil.decompress(compressedPayload, originalSize: originalSize) else {
+                return nil
+            }
+            
+            // Verify decompressed size matches expected
+            guard decompressedPayload.count == originalSize else {
+                return nil
+            }
+            
+            payload = decompressedPayload
         } else {
-                guard let p = readData(Int(payloadLen)) else { return nil }
+            // Uncompressed payload
-                payload = p
+            guard Int(payloadLength) >= 0 && offset + Int(payloadLength) <= dataArray.count else { 
+                return nil 
+            }
+            payload = Data(dataArray[offset..<offset+Int(payloadLength)])
+            offset += Int(payloadLength)
         }
         
-            // Signature
+        // Signature if present
-            var signature: Data? = nil
+        var signature: Data?
         if hasSignature {
-                signature = readData(signatureSize)
+            guard offset + signatureSize <= dataArray.count else { return nil }
-                if signature == nil { return nil }
+            signature = Data(dataArray[offset..<offset+signatureSize])
+            offset += signatureSize
         }
         
-            guard offset <= buf.count else { return nil }
+        // Final validation: ensure we haven't gone past the end
+        guard offset <= dataArray.count else { return nil }
         
         return BitchatPacket(
             type: type,
             senderID: senderID,
             recipientID: recipientID,
-                timestamp: ts,
+            timestamp: timestamp,
             payload: payload,
             signature: signature,
             ttl: ttl
         )
     }
 }
-}
 
 // Binary encoding for BitchatMessage
 extension BitchatMessage {

bitchat/Protocols/Geohash.swift

@@ -87,28 +87,4 @@ enum Geohash {
         let lon = (lonInterval.0 + lonInterval.1) / 2
         return (lat, lon)
     }
-
-    /// Decodes a geohash into its latitude and longitude bounds.
-    /// - Parameter geohash: Base32 geohash string.
-    /// - Returns: (latMin, latMax, lonMin, lonMax)
-    static func decodeBounds(_ geohash: String) -> (latMin: Double, latMax: Double, lonMin: Double, lonMax: Double) {
-        var latInterval: (Double, Double) = (-90.0, 90.0)
-        var lonInterval: (Double, Double) = (-180.0, 180.0)
-
-        var isEven = true
-        for ch in geohash.lowercased() {
-            guard let cd = base32Map[ch] else { continue }
-            for mask in [16, 8, 4, 2, 1] {
-                if isEven {
-                    let mid = (lonInterval.0 + lonInterval.1) / 2
-                    if (cd & mask) != 0 { lonInterval.0 = mid } else { lonInterval.1 = mid }
-                } else {
-                    let mid = (latInterval.0 + latInterval.1) / 2
-                    if (cd & mask) != 0 { latInterval.0 = mid } else { latInterval.1 = mid }
-                }
-                isEven.toggle()
-            }
-        }
-        return (latInterval.0, latInterval.1, lonInterval.0, lonInterval.1)
-    }
 }

bitchat/Protocols/Packets.swift

@@ -15,8 +15,6 @@ struct AnnouncementPacket {
 
     func encode() -> Data? {
         var data = Data()
-        // Reserve: TLVs for nickname (2 + n), noise key (2 + 32), signing key (2 + 32)
-        data.reserveCapacity(2 + min(nickname.count, 255) + 2 + noisePublicKey.count + 2 + signingPublicKey.count)
 
         // TLV for nickname
         guard let nicknameData = nickname.data(using: .utf8), nicknameData.count <= 255 else { return nil }
@@ -90,7 +88,6 @@ struct PrivateMessagePacket {
 
     func encode() -> Data? {
         var data = Data()
-        data.reserveCapacity(2 + min(messageID.count, 255) + 2 + min(content.count, 255))
 
         // TLV for messageID
         guard let messageIDData = messageID.data(using: .utf8), messageIDData.count <= 255 else { return nil }

bitchat/Services/BLEService.swift

@@ -63,9 +63,8 @@ final class BLEService: NSObject {
     private let messageDeduplicator = MessageDeduplicator()
     
     // 5. Fragment Reassembly (necessary for messages > MTU)
-    private struct FragmentKey: Hashable { let sender: UInt64; let id: UInt64 }
+    private var incomingFragments: [String: [Int: Data]] = [:]
-    private var incomingFragments: [FragmentKey: [Int: Data]] = [:]
+    private var fragmentMetadata: [String: (type: UInt8, total: Int, timestamp: Date)] = [:]
-    private var fragmentMetadata: [FragmentKey: (type: UInt8, total: Int, timestamp: Date)] = [:]
     // Backoff for peripherals that recently timed out connecting
     private var recentConnectTimeouts: [String: Date] = [:] // Peripheral UUID -> last timeout
     
@@ -89,7 +88,6 @@ final class BLEService: NSObject {
     var myPeerID: String = ""
     var myNickname: String = "anon"
     private let noiseService = NoiseEncryptionService()
-    private var myPeerIDData: Data = Data()
 
     // MARK: - Advertising Privacy
     // No Local Name by default for maximum privacy. No rotating alias.
@@ -225,30 +223,7 @@ final class BLEService: NSObject {
                 peripheral.writeValue(data, for: characteristic, type: .withoutResponse)
             } else {
                 self.collectionsQueue.async(flags: .barrier) {
-                    var queue = self.pendingPeripheralWrites[uuid] ?? []
+                    self.pendingPeripheralWrites[uuid, default: []].append(data)
-                    let capBytes = TransportConfig.blePendingWriteBufferCapBytes
-                    let newSize = data.count
-                    // If single chunk exceeds cap, drop it immediately
-                    if newSize > capBytes {
-                        SecureLogger.log("⚠️ Dropping oversized write chunk (\(newSize)B) for peripheral \(uuid)",
-                                         category: SecureLogger.session, level: .warning)
-                    } else {
-                        // Append and trim from the front to respect cap
-                        var total = queue.reduce(0) { $0 + $1.count }
-                        queue.append(data)
-                        total += newSize
-                        if total > capBytes {
-                            var removedBytes = 0
-                            while total > capBytes && !queue.isEmpty {
-                                let removed = queue.removeFirst()
-                                removedBytes += removed.count
-                                total -= removed.count
-                            }
-                            SecureLogger.log("📉 Trimmed pending write buffer for \(uuid) by \(removedBytes)B to \(total)B",
-                                             category: SecureLogger.session, level: .warning)
-                        }
-                        self.pendingPeripheralWrites[uuid] = queue.isEmpty ? nil : queue
-                    }
                 }
             }
         }
@@ -333,7 +308,6 @@ final class BLEService: NSObject {
         // Derive stable peer ID from Noise static public key fingerprint (first 8 bytes → 16 hex chars)
         let fingerprint = noiseService.getIdentityFingerprint() // 64 hex chars
         self.myPeerID = String(fingerprint.prefix(16))
-        self.myPeerIDData = Data(hexString: myPeerID) ?? Data()
         
         // Set queue key for identification
         messageQueue.setSpecific(key: messageQueueKey, value: ())
@@ -400,7 +374,7 @@ final class BLEService: NSObject {
         maintenanceTimer = timer
         
         // Publish initial empty state
-        requestPeerDataPublish()
+        publishFullPeerData()
     }
     
     func setNickname(_ nickname: String) {
@@ -489,7 +463,7 @@ final class BLEService: NSObject {
         // Send leave message synchronously to ensure delivery
         let leavePacket = BitchatPacket(
             type: MessageType.leave.rawValue,
-            senderID: myPeerIDData,
+            senderID: Data(hexString: myPeerID) ?? Data(),
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: Data(),
@@ -617,7 +591,7 @@ final class BLEService: NSObject {
                 let encrypted = try noiseService.encrypt(payload, for: peerID)
                 let packet = BitchatPacket(
                     type: MessageType.noiseEncrypted.rawValue,
-                    senderID: myPeerIDData,
+                    senderID: Data(hexString: myPeerID) ?? Data(),
                     recipientID: Data(hexString: peerID),
                     timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
                     payload: encrypted,
@@ -669,7 +643,7 @@ final class BLEService: NSObject {
             let encrypted = try noiseService.encrypt(typedPayload, for: peerID)
             let packet = BitchatPacket(
                 type: MessageType.noiseEncrypted.rawValue,
-                senderID: myPeerIDData,
+                senderID: Data(hexString: myPeerID) ?? Data(),
                 recipientID: Data(hexString: peerID),
                 timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
                 payload: encrypted,
@@ -826,7 +800,7 @@ final class BLEService: NSObject {
                 
             let packet = BitchatPacket(
                 type: MessageType.noiseEncrypted.rawValue,
-                senderID: myPeerIDData,
+                senderID: Data(hexString: myPeerID) ?? Data(),
                 recipientID: recipientData,
                 timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
                 payload: encrypted,
@@ -880,7 +854,7 @@ final class BLEService: NSObject {
             // Send handshake init
             let packet = BitchatPacket(
                 type: MessageType.noiseHandshake.rawValue,
-                senderID: myPeerIDData,
+                senderID: Data(hexString: myPeerID) ?? Data(),
                 recipientID: Data(hexString: peerID),
                 timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
                 payload: handshakeData,
@@ -930,7 +904,7 @@ final class BLEService: NSObject {
 
                 let packet = BitchatPacket(
                     type: MessageType.noiseEncrypted.rawValue,
-                    senderID: myPeerIDData,
+                    senderID: Data(hexString: myPeerID) ?? Data(),
                     recipientID: Data(hexString: peerID),
                     timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
                     payload: encrypted,
@@ -1273,11 +1247,8 @@ final class BLEService: NSObject {
         // Minimum header: 8 bytes ID + 2 index + 2 total + 1 type
         guard packet.payload.count >= 13 else { return }
 
-        // Compute compact fragment key (sender: 8 bytes, id: 8 bytes), big-endian
+        let senderHex = packet.senderID.hexEncodedString()
-        var senderU64: UInt64 = 0
+        let fragmentID = packet.payload[0..<8].map { String(format: "%02x", $0) }.joined()
-        for b in packet.senderID.prefix(8) { senderU64 = (senderU64 << 8) | UInt64(b) }
-        var fragU64: UInt64 = 0
-        for b in packet.payload.prefix(8) { fragU64 = (fragU64 << 8) | UInt64(b) }
         // Parse big-endian UInt16 safely without alignment assumptions
         let idxHi = UInt16(packet.payload[8])
         let idxLo = UInt16(packet.payload[9])
@@ -1292,7 +1263,7 @@ final class BLEService: NSObject {
         guard total > 0 && index >= 0 && index < total else { return }
 
         // Store fragment
-        let key = FragmentKey(sender: senderU64, id: fragU64)
+        let key = "\(senderHex):\(fragmentID)"
         if incomingFragments[key] == nil {
             // Cap in-flight assemblies to prevent memory/battery blowups
             if incomingFragments.count >= maxInFlightAssemblies {
@@ -1465,20 +1436,6 @@ final class BLEService: NSObject {
         
         // Suppress announce logs to reduce noise
         
-        // Precompute signature verification outside barrier to reduce contention
-        let existingPeerForVerify = collectionsQueue.sync { peers[peerID] }
-        var verifiedAnnounce = false
-        if packet.signature != nil {
-            verifiedAnnounce = noiseService.verifyPacketSignature(packet, publicKey: announcement.signingPublicKey)
-            if !verifiedAnnounce {
-                SecureLogger.log("⚠️ Signature verification for announce failed \(peerID.prefix(8))", category: SecureLogger.security, level: .warning)
-            }
-        }
-        if let existingKey = existingPeerForVerify?.noisePublicKey, existingKey != announcement.noisePublicKey {
-            SecureLogger.log("⚠️ Announce key mismatch for \(peerID.prefix(8))… — keeping unverified", category: SecureLogger.security, level: .warning)
-            verifiedAnnounce = false
-        }
-
         // Track if this is a new or reconnected peer
         var isNewPeer = false
         var isReconnectedPeer = false
@@ -1503,8 +1460,21 @@ final class BLEService: NSObject {
             isNewPeer = (existingPeer == nil)
             isReconnectedPeer = wasDisconnected
             
-            // Use precomputed verification result
+            // Verify packet signature using the announced signing public key
-            let verified = verifiedAnnounce
+            var verified = false
+            if packet.signature != nil {
+                // Verify that the packet was signed by the signing private key corresponding to the announced signing public key
+                verified = noiseService.verifyPacketSignature(packet, publicKey: announcement.signingPublicKey)
+                if !verified {
+                    SecureLogger.log("⚠️ Signature verification for announce failed \(peerID.prefix(8))", category: SecureLogger.security, level: .warning)
+                }
+            }
+
+            // If existing peer has a different noise public key, do not consider this verified
+            if let existing = existingPeer, let existingKey = existing.noisePublicKey, existingKey != announcement.noisePublicKey {
+                SecureLogger.log("⚠️ Announce key mismatch for \(peerID.prefix(8))… — keeping unverified", category: SecureLogger.security, level: .warning)
+                verified = false
+            }
 
             // Require verified announce; ignore otherwise (no backward compatibility)
             if !verified {
@@ -1595,7 +1565,7 @@ final class BLEService: NSObject {
                 self.delegate?.didConnectToPeer(peerID)
             }
             
-            self.requestPeerDataPublish()
+            self.publishFullPeerData()
             self.delegate?.didUpdatePeerList(currentPeerIDs)
         }
         
@@ -1696,7 +1666,7 @@ final class BLEService: NSObject {
                     // Send response
                     let responsePacket = BitchatPacket(
                         type: MessageType.noiseHandshake.rawValue,
-                        senderID: myPeerIDData,
+                        senderID: Data(hexString: myPeerID) ?? Data(),
                         recipientID: Data(hexString: peerID),
                         timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
                         payload: response,
@@ -1852,7 +1822,7 @@ final class BLEService: NSObject {
         // Create packet with signature using the noise private key
         let packet = BitchatPacket(
             type: MessageType.announce.rawValue,
-            senderID: myPeerIDData,
+            senderID: Data(hexString: myPeerID) ?? Data(),
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -1886,7 +1856,7 @@ final class BLEService: NSObject {
                 let encrypted = try noiseService.encrypt(payload, for: peerID)
                 let packet = BitchatPacket(
                     type: MessageType.noiseEncrypted.rawValue,
-                    senderID: myPeerIDData,
+                    senderID: Data(hexString: myPeerID) ?? Data(),
                     recipientID: Data(hexString: peerID),
                     timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
                     payload: encrypted,
@@ -1923,7 +1893,7 @@ final class BLEService: NSObject {
                 let encrypted = try noiseService.encrypt(payload, for: peerID)
                 let packet = BitchatPacket(
                     type: MessageType.noiseEncrypted.rawValue,
-                    senderID: myPeerIDData,
+                    senderID: Data(hexString: myPeerID) ?? Data(),
                     recipientID: Data(hexString: peerID),
                     timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
                     payload: encrypted,
@@ -1990,28 +1960,6 @@ final class BLEService: NSObject {
         }
     }
     
-    // Debounced publish to coalesce rapid changes
-    private var lastPeerPublishAt: Date = .distantPast
-    private var peerPublishPending: Bool = false
-    private let peerPublishMinInterval: TimeInterval = 0.1
-    private func requestPeerDataPublish() {
-        let now = Date()
-        let elapsed = now.timeIntervalSince(lastPeerPublishAt)
-        if elapsed >= peerPublishMinInterval {
-            lastPeerPublishAt = now
-            publishFullPeerData()
-        } else if !peerPublishPending {
-            peerPublishPending = true
-            let delay = peerPublishMinInterval - elapsed
-            messageQueue.asyncAfter(deadline: .now() + delay) { [weak self] in
-                guard let self = self else { return }
-                self.lastPeerPublishAt = Date()
-                self.peerPublishPending = false
-                self.publishFullPeerData()
-            }
-        }
-    }
-    
     // MARK: - Consolidated Maintenance
     
     private func performMaintenance() {
@@ -2124,7 +2072,7 @@ final class BLEService: NSObject {
                     self.delegate?.didDisconnectFromPeer(peerID)
                 }
                 // Publish snapshots so UnifiedPeerService updates connection/reachability icons
-                self.requestPeerDataPublish()
+                self.publishFullPeerData()
                 self.delegate?.didUpdatePeerList(currentPeerIDs)
             }
         }
@@ -2506,7 +2454,7 @@ func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeriph
             if let peerID = peerID {
                 self.notifyPeerDisconnectedDebounced(peerID)
             }
-            self.requestPeerDataPublish()
+            self.publishFullPeerData()
             self.delegate?.didUpdatePeerList(currentPeerIDs)
         }
     }
@@ -2907,7 +2855,7 @@ extension BLEService: CBPeripheralManagerDelegate {
                 
                 self.notifyPeerDisconnectedDebounced(peerID)
                 // Publish snapshots so UnifiedPeerService can refresh icons promptly
-                self.requestPeerDataPublish()
+                self.publishFullPeerData()
                 self.delegate?.didUpdatePeerList(currentPeerIDs)
             }
         }

bitchat/Services/GeohashBookmarksStore.swift

@@ -1,227 +0,0 @@
-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)
-/// - Semantics: geohashes are normalized to lowercase base32 and de-duplicated
-final class GeohashBookmarksStore: ObservableObject {
-    static let shared = GeohashBookmarksStore()
-
-    @Published private(set) var bookmarks: [String] = []
-    @Published private(set) var bookmarkNames: [String: String] = [:] // geohash -> friendly name
-
-    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 init() {
-        load()
-    }
-
-    // MARK: - Public API
-    func isBookmarked(_ geohash: String) -> Bool {
-        return membership.contains(Self.normalize(geohash))
-    }
-
-    func toggle(_ geohash: String) {
-        let gh = Self.normalize(geohash)
-        if membership.contains(gh) {
-            remove(gh)
-        } else {
-            add(gh)
-        }
-    }
-
-    func add(_ geohash: String) {
-        let gh = Self.normalize(geohash)
-        guard !gh.isEmpty else { return }
-        guard !membership.contains(gh) else { return }
-        bookmarks.insert(gh, at: 0)
-        membership.insert(gh)
-        persist()
-        // Resolve and persist a friendly name once when added
-        resolveNameIfNeeded(for: gh)
-    }
-
-    func remove(_ geohash: String) {
-        let gh = Self.normalize(geohash)
-        guard membership.contains(gh) else { return }
-        if let idx = bookmarks.firstIndex(of: gh) { bookmarks.remove(at: idx) }
-        membership.remove(gh)
-        // Clean up stored name to avoid stale cache growth
-        if bookmarkNames.removeValue(forKey: gh) != nil {
-            persistNames()
-        }
-        persist()
-    }
-
-    // MARK: - Persistence
-    private func load() {
-        guard let data = UserDefaults.standard.data(forKey: storeKey) else { return }
-        if let arr = try? JSONDecoder().decode([String].self, from: data) {
-            // Sanitize, normalize, dedupe while preserving order (first occurrence wins)
-            var seen = Set<String>()
-            var list: [String] = []
-            for raw in arr {
-                let gh = Self.normalize(raw)
-                guard !gh.isEmpty else { continue }
-                if !seen.contains(gh) {
-                    seen.insert(gh)
-                    list.append(gh)
-                }
-            }
-            bookmarks = list
-            membership = seen
-        }
-        // Load any saved names
-        if let namesData = UserDefaults.standard.data(forKey: namesStoreKey),
-           let dict = try? JSONDecoder().decode([String: String].self, from: namesData) {
-            bookmarkNames = dict
-        }
-    }
-
-    private func persist() {
-        if let data = try? JSONEncoder().encode(bookmarks) {
-            UserDefaults.standard.set(data, forKey: storeKey)
-        }
-    }
-
-    private func persistNames() {
-        if let data = try? JSONEncoder().encode(bookmarkNames) {
-            UserDefaults.standard.set(data, forKey: namesStoreKey)
-        }
-    }
-
-    // MARK: - Helpers
-    private static func normalize(_ s: String) -> String {
-        let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
-        return s
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-            .lowercased()
-            .replacingOccurrences(of: "#", with: "")
-            .filter { allowed.contains($0) }
-    }
-
-    // MARK: - Name Resolution
-    /// Attempt to resolve and persist a friendly place name for a bookmarked geohash.
-    func resolveNameIfNeeded(for geohash: String) {
-        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
-        if gh.count <= 2 {
-            let b = Geohash.decodeBounds(gh)
-            let pts: [CLLocation] = [
-                CLLocation(latitude: (b.latMin + b.latMax) / 2, longitude: (b.lonMin + b.lonMax) / 2), // center
-                CLLocation(latitude: b.latMin, longitude: b.lonMin),
-                CLLocation(latitude: b.latMin, longitude: b.lonMax),
-                CLLocation(latitude: b.latMax, longitude: b.lonMin),
-                CLLocation(latitude: b.latMax, longitude: b.lonMax)
-            ]
-            resolveCompositeAdminName(geohash: gh, points: pts)
-        } else {
-            let center = Geohash.decodeCenter(gh)
-            let loc = CLLocation(latitude: center.lat, longitude: center.lon)
-            geocoder.reverseGeocodeLocation(loc) { [weak self] placemarks, _ in
-                guard let self = self else { return }
-                defer { self.resolving.remove(gh) }
-                if let pm = placemarks?.first {
-                    let name = Self.nameForGeohashLength(gh.count, from: pm)
-                    if let name = name, !name.isEmpty {
-                        DispatchQueue.main.async {
-                            self.bookmarkNames[gh] = name
-                            self.persistNames()
-                        }
-                    }
-                }
-            }
-        }
-        #endif
-    }
-
-    #if os(iOS) || os(macOS)
-    private func resolveCompositeAdminName(geohash gh: String, points: [CLLocation]) {
-        var uniqueAdmins = OrderedSet<String>()
-        var idx = 0
-        func step() {
-            if idx >= points.count {
-                // Compose up to 2 names joined by ' and '
-                let finalName: String? = {
-                    let names = uniqueAdmins.array
-                    if names.count >= 2 { return names[0] + " and " + names[1] }
-                    return names.first
-                }()
-                if let finalName = finalName, !finalName.isEmpty {
-                    DispatchQueue.main.async {
-                        self.bookmarkNames[gh] = finalName
-                        self.persistNames()
-                    }
-                }
-                self.resolving.remove(gh)
-                return
-            }
-            let loc = points[idx]
-            idx += 1
-            geocoder.reverseGeocodeLocation(loc) { [weak self] placemarks, _ in
-                guard self != nil else { return }
-                if let pm = placemarks?.first {
-                    if let admin = pm.administrativeArea, !admin.isEmpty {
-                        uniqueAdmins.insert(admin)
-                    } else if let country = pm.country, !country.isEmpty {
-                        uniqueAdmins.insert(country)
-                    }
-                }
-                // Proceed to next point
-                step()
-            }
-        }
-        step()
-    }
-
-    // Minimal ordered-set for stable joining
-    private struct OrderedSet<Element: Hashable> {
-        private var set: Set<Element> = []
-        private(set) var array: [Element] = []
-        mutating func insert(_ element: Element) {
-            if set.insert(element).inserted { array.append(element) }
-        }
-    }
-
-    private static func nameForGeohashLength(_ len: Int, from pm: CLPlacemark) -> String? {
-        switch len {
-        case 0...2:
-            // Prefer administrative area if available at this coarse level
-            return pm.administrativeArea ?? pm.country
-        case 3...4:
-            return pm.administrativeArea ?? pm.subAdministrativeArea ?? pm.country
-        case 5:
-            return pm.locality ?? pm.subAdministrativeArea ?? pm.administrativeArea
-        case 6...7:
-            return pm.subLocality ?? pm.locality ?? pm.administrativeArea
-        default:
-            return pm.subLocality ?? pm.locality ?? pm.administrativeArea ?? pm.country
-        }
-    }
-    #endif
-
-    #if DEBUG
-    /// Testing-only reset helper
-    func _resetForTesting() {
-        bookmarks.removeAll()
-        membership.removeAll()
-        bookmarkNames.removeAll()
-        persist()
-        persistNames()
-    }
-    #endif
-}

bitchat/Services/MessageRouter.swift

@@ -89,20 +89,11 @@ final class MessageRouter {
 
     // MARK: - Outbox Management
     private func canSendViaNostr(peerID: String) -> Bool {
-        // Two forms are supported:
+        guard let noiseKey = Data(hexString: peerID) else { return false }
-        // - 64-hex Noise public key (32 bytes)
-        // - 16-hex short peer ID (derived from Noise pubkey)
-        if peerID.count == 64, let noiseKey = Data(hexString: peerID) {
         if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
            fav.peerNostrPublicKey != nil {
             return true
         }
-        } else if peerID.count == 16 {
-            if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID),
-               fav.peerNostrPublicKey != nil {
-                return true
-            }
-        }
         return false
     }
 
@@ -110,7 +101,6 @@ final class MessageRouter {
         guard let queued = outbox[peerID], !queued.isEmpty else { return }
         SecureLogger.log("Flushing outbox for \(peerID.prefix(8))… count=\(queued.count)",
                         category: SecureLogger.session, level: .debug)
-        var remaining: [(content: String, nickname: String, messageID: String)] = []
         // Prefer mesh if connected; else try Nostr if mapping exists
         for (content, nickname, messageID) in queued {
             if mesh.isPeerReachable(peerID) {
@@ -122,19 +112,14 @@ final class MessageRouter {
                                 category: SecureLogger.session, level: .debug)
                 nostr.sendPrivateMessage(content, to: peerID, recipientNickname: nickname, messageID: messageID)
             } else {
-                // Keep unsent items queued
+                continue
-                remaining.append((content, nickname, messageID))
             }
         }
-        // Persist only items we could not send
+        // Remove all flushed items (remaining ones, if any, will be re-queued on next call)
-        if remaining.isEmpty {
+        outbox[peerID]?.removeAll()
-            outbox.removeValue(forKey: peerID)
-        } else {
-            outbox[peerID] = remaining
-        }
     }
 
     func flushAllOutbox() {
-        for key in Array(outbox.keys) { flushOutbox(for: key) }
+        for key in outbox.keys { flushOutbox(for: key) }
     }
 }

bitchat/Services/UnifiedPeerService.swift

@@ -27,7 +27,6 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     private var peerIndex: [String: BitchatPeer] = [:]
     private var fingerprintCache: [String: String] = [:]  // peerID -> fingerprint
     private let meshService: Transport
-    weak var messageRouter: MessageRouter?
     private let favoritesService = FavoritesPersistenceService.shared
     private var cancellables = Set<AnyCancellable>()
     
@@ -331,13 +330,8 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         SecureLogger.log("⭐️ Toggled favorite for '\(finalNickname)' (peerID: \(peerID), was: \(wasFavorite), now: \(!wasFavorite))",
                        category: SecureLogger.session, level: .debug)
         
-        // Send favorite notification to the peer via router (mesh or Nostr)
+        // Send favorite notification to the peer
-        if let router = messageRouter {
-            router.sendFavoriteNotification(to: peerID, isFavorite: !wasFavorite)
-        } else {
-            // Fallback to mesh-only if router not yet wired
         meshService.sendFavoriteNotification(to: peerID, isFavorite: !wasFavorite)
-        }
         
         // Force update of peers to reflect the change
         updatePeers()

bitchat/Utils/MessageDeduplicator.swift

@@ -9,7 +9,6 @@ final class MessageDeduplicator {
     }
 
     private var entries: [Entry] = []
-    private var head: Int = 0
     private var lookup = Set<String>()
     private let lock = NSLock()
     private let maxAge: TimeInterval = TransportConfig.messageDedupMaxAgeSeconds  // 5 minutes
@@ -29,18 +28,10 @@ final class MessageDeduplicator {
         entries.append(Entry(messageID: messageID, timestamp: Date()))
         lookup.insert(messageID)
 
-        // Soft-cap and advance head by a chunk to avoid O(n) shifting
+        if entries.count > maxCount {
-        if (entries.count - head) > maxCount {
+            let toRemove = entries.prefix(100)
-            let removeCount = min(100, entries.count - head)
+            toRemove.forEach { lookup.remove($0.messageID) }
-            for i in head..<(head + removeCount) {
+            entries.removeFirst(100)
-                lookup.remove(entries[i].messageID)
-            }
-            head += removeCount
-            // Periodically compact to reclaim memory
-            if head > entries.count / 2 {
-                entries.removeFirst(head)
-                head = 0
-            }
         }
 
         return false
@@ -70,7 +61,6 @@ final class MessageDeduplicator {
         defer { lock.unlock() }
 
         entries.removeAll()
-        head = 0
         lookup.removeAll()
     }
 
@@ -88,13 +78,9 @@ final class MessageDeduplicator {
 
     private func cleanupOldEntries() {
         let cutoff = Date().addingTimeInterval(-maxAge)
-        while head < entries.count, entries[head].timestamp < cutoff {
+        while let first = entries.first, first.timestamp < cutoff {
-            lookup.remove(entries[head].messageID)
+            lookup.remove(first.messageID)
-            head += 1
+            entries.removeFirst()
-        }
-        if head > 0 && head > entries.count / 2 {
-            entries.removeFirst(head)
-            head = 0
         }
     }
 }

bitchat/Utils/SecureLogger.swift

@@ -140,11 +140,11 @@ class SecureLogger {
     }
     
     /// Log general messages with automatic sensitive data filtering
-    static func log(_ message: @autoclosure () -> String, category: OSLog = noise, level: LogLevel = .debug,
+    static func log(_ message: String, category: OSLog = noise, level: LogLevel = .debug,
                     file: String = #file, line: Int = #line, function: String = #function) {
         guard shouldLog(level) else { return }
         let location = formatLocation(file: file, line: line, function: function)
-        let sanitized = sanitize("\(location) \(message())")
+        let sanitized = sanitize("\(location) \(message)")
         
         #if DEBUG
         os_log("%{public}@", log: category, type: level.osLogType, sanitized)
@@ -157,10 +157,10 @@ class SecureLogger {
     }
     
     /// Log errors with context
-    static func logError(_ error: Error, context: @autoclosure () -> String, category: OSLog = noise,
+    static func logError(_ error: Error, context: String, category: OSLog = noise,
                         file: String = #file, line: Int = #line, function: String = #function) {
         let location = formatLocation(file: file, line: line, function: function)
-        let sanitized = sanitize(context())
+        let sanitized = sanitize(context)
         let errorDesc = sanitize(error.localizedDescription)
         
         #if DEBUG

bitchat/ViewModels/ChatViewModel.swift

@@ -383,11 +383,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     @Published var bluetoothAlertMessage = ""
     @Published var bluetoothState: CBManagerState = .unknown
     
-    // Presentation state for privacy gating
-    @Published var isLocationChannelsSheetPresented: Bool = false
-    @Published var isAppInfoPresented: Bool = false
-    @Published var showScreenshotPrivacyWarning: Bool = false
-    
     // Messages are naturally ephemeral - no persistent storage
     // Persist mesh public timeline across channel switches
     private var meshTimeline: [BitchatMessage] = []
@@ -492,8 +487,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         self.messageRouter = MessageRouter(mesh: meshService, nostr: nostrTransport)
         // Route receipts from PrivateChatManager through MessageRouter
         self.privateChatManager.messageRouter = self.messageRouter
-        // Allow UnifiedPeerService to route favorite notifications via mesh/Nostr
-        self.unifiedPeerService.messageRouter = self.messageRouter
         self.autocompleteService = AutocompleteService()
         
         // Wire up dependencies
@@ -593,11 +586,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                         if connected {
                             Task { @MainActor in
                                 self.resubscribeCurrentGeohash()
-                                // Re-init sampling for regional + bookmarked geohashes after reconnect
-                                let regional = LocationChannelManager.shared.availableChannels.map { $0.geohash }
-                                let bookmarks = GeohashBookmarksStore.shared.bookmarks
-                                let union = Array(Set(regional).union(bookmarks))
-                                self.beginGeohashSampling(for: union)
                             }
                         }
                     }
@@ -623,41 +611,21 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             self.switchLocationChannel(to: LocationChannelManager.shared.selectedChannel)
         }
 
-        // Background: keep sampling nearby geohashes + bookmarks for notifications even when sheet is closed
+        // Background: keep sampling nearby geohashes for notifications even when sheet is closed
         LocationChannelManager.shared.$availableChannels
             .receive(on: DispatchQueue.main)
             .sink { [weak self] channels in
                 guard let self = self else { return }
-                let regional = channels.map { $0.geohash }
+                let ghs = channels.map { $0.geohash }
-                let bookmarks = GeohashBookmarksStore.shared.bookmarks
-                let union = Array(Set(regional).union(bookmarks))
                 Task { @MainActor in
-                    self.beginGeohashSampling(for: union)
+                    self.beginGeohashSampling(for: ghs)
                 }
             }
             .store(in: &cancellables)
-
+        // Kick off initial sampling if we already have channels
-        // Also observe bookmark changes to update sampling
+        if !LocationChannelManager.shared.availableChannels.isEmpty {
-        GeohashBookmarksStore.shared.$bookmarks
+            let ghs = LocationChannelManager.shared.availableChannels.map { $0.geohash }
-            .receive(on: DispatchQueue.main)
+            Task { @MainActor in self.beginGeohashSampling(for: ghs) }
-            .sink { [weak self] bookmarks in
-                guard let self = self else { return }
-                let regional = LocationChannelManager.shared.availableChannels.map { $0.geohash }
-                let union = Array(Set(regional).union(bookmarks))
-                Task { @MainActor in
-                    self.beginGeohashSampling(for: union)
-                }
-            }
-            .store(in: &cancellables)
-
-        // Kick off initial sampling if we have regional channels or bookmarks
-        do {
-            let regional = LocationChannelManager.shared.availableChannels.map { $0.geohash }
-            let bookmarks = GeohashBookmarksStore.shared.bookmarks
-            let union = Array(Set(regional).union(bookmarks))
-            if !union.isEmpty {
-                Task { @MainActor in self.beginGeohashSampling(for: union) }
-            }
         }
         // Refresh channels once when authorized to seed sampling
         LocationChannelManager.shared.$permissionState
@@ -1414,11 +1382,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         switch channel {
         case .mesh:
             messages = meshTimeline
-            // Debug: log if any empty messages are present
-            let emptyMesh = messages.filter { $0.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }.count
-            if emptyMesh > 0 {
-                SecureLogger.log("RenderGuard: mesh timeline contains \(emptyMesh) empty messages", category: SecureLogger.session, level: .debug)
-            }
             stopGeoParticipantsTimer()
             geohashPeople = []
             teleportedGeo.removeAll()
@@ -1426,26 +1389,13 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             // Sanitize existing timeline (filter any prior empty-content entries)
             var arr = geoTimelines[ch.geohash] ?? []
             arr.removeAll { $0.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
-            // Deduplicate by ID while preserving order (from oldest to newest)
+            // Ensure chronological order when returning to a geohash
             if arr.count > 1 {
-                var seen = Set<String>()
+                arr.sort { $0.timestamp < $1.timestamp }
-                var dedup: [BitchatMessage] = []
-                for m in arr.sorted(by: { $0.timestamp < $1.timestamp }) {
-                    if !seen.contains(m.id) {
-                        dedup.append(m)
-                        seen.insert(m.id)
-                    }
-                }
-                arr = dedup
             }
             // Persist the cleaned/sorted timeline for this geohash
             geoTimelines[ch.geohash] = arr
             messages = arr
-            // Debug: log if any empty messages are present post-sanitize
-            let emptyGeo = messages.filter { $0.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }.count
-            if emptyGeo > 0 {
-                SecureLogger.log("RenderGuard: geohash \(ch.geohash) timeline has \(emptyGeo) empty messages after sanitize", category: SecureLogger.session, level: .debug)
-            }
         }
         // Unsubscribe previous
         if let sub = geoSubscriptionID {
@@ -1888,6 +1838,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 let eventTime = Date(timeIntervalSince1970: TimeInterval(event.created_at))
                 if Date().timeIntervalSince(eventTime) > 30 { return }
                 // Foreground policy: allow if it's a different geohash than the one currently open
+                // Suppress only when app is active AND we're already in this same geohash channel
                 #if os(iOS)
                 if UIApplication.shared.applicationState == .active {
                     if case .location(let ch) = self.activeChannel, ch.geohash == gh { return }
@@ -1910,30 +1861,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 }()
                 Task { @MainActor in
                     self.lastGeoNotificationAt[gh] = now
-                    // Pre-populate the target geohash timeline so the triggering message appears when user opens it
-                    var arr = self.geoTimelines[gh] ?? []
-                    let senderSuffix = String(event.pubkey.suffix(4))
-                    let nick = self.geoNicknames[event.pubkey.lowercased()]
-                    let senderName = (nick?.isEmpty == false ? nick! : "anon") + "#" + senderSuffix
-                    let ts = Date(timeIntervalSince1970: TimeInterval(event.created_at))
-                    let mentions = self.parseMentions(from: content)
-                    let msg = BitchatMessage(
-                        id: event.id,
-                        sender: senderName,
-                        content: content,
-                        timestamp: ts,
-                        isRelay: false,
-                        originalSender: nil,
-                        isPrivate: false,
-                        recipientNickname: nil,
-                        senderPeerID: "nostr:\(event.pubkey.prefix(TransportConfig.nostrShortKeyDisplayLength))",
-                        mentions: mentions.isEmpty ? nil : mentions
-                    )
-                    if !arr.contains(where: { $0.id == msg.id }) {
-                        arr.append(msg)
-                        if arr.count > self.geoTimelineCap { arr = Array(arr.suffix(self.geoTimelineCap)) }
-                        self.geoTimelines[gh] = arr
-                    }
                     NotificationService.shared.sendGeohashActivityNotification(geohash: gh, bodyPreview: preview)
                 }
             }
@@ -2613,17 +2540,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
     
     @MainActor
     @objc private func userDidTakeScreenshot() {
-        // Respect privacy: do not broadcast screenshots taken from non-chat sheets
-        if isLocationChannelsSheetPresented {
-            // Show a warning about sharing location screenshots publicly
-            showScreenshotPrivacyWarning = true
-            return
-        }
-        if isAppInfoPresented {
-            // Silently ignore screenshots of app info
-            return
-        }
-
         // Send screenshot notification based on current context
         let screenshotMessage = "* \(nickname) took a screenshot *"
         
@@ -2643,7 +2559,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 }
             }
             
-            // Show local notification immediately as system message (only in chat)
+            // Show local notification immediately as system message
             let localNotification = BitchatMessage(
                 sender: "system",
                 content: "you took a screenshot",
@@ -2694,7 +2610,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             }
             
 
-            // Show local notification immediately as system message (only in chat)
+            // Show local notification immediately as system message
             let localNotification = BitchatMessage(
                 sender: "system",
                 content: "you took a screenshot",
@@ -3079,10 +2995,8 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         let mentionRegex = try? NSRegularExpression(pattern: mentionPattern, options: [])
         let hashtagRegex = try? NSRegularExpression(pattern: hashtagPattern, options: [])
         
-        let nsContent = contentText as NSString
+        let mentionMatches = mentionRegex?.matches(in: contentText, options: [], range: NSRange(location: 0, length: contentText.count)) ?? []
-        let nsLen = nsContent.length
+        let hashtagMatches = hashtagRegex?.matches(in: contentText, options: [], range: NSRange(location: 0, length: contentText.count)) ?? []
-        let mentionMatches = mentionRegex?.matches(in: contentText, options: [], range: NSRange(location: 0, length: nsLen)) ?? []
-        let hashtagMatches = hashtagRegex?.matches(in: contentText, options: [], range: NSRange(location: 0, length: nsLen)) ?? []
         
         // Combine and sort all matches
         var allMatches: [(range: NSRange, type: String)] = []
@@ -3099,7 +3013,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         for (matchRange, matchType) in allMatches {
             // Add text before the match
             if let range = Range(matchRange, in: contentText) {
-                if lastEndIndex < range.lowerBound {
                 let beforeText = String(contentText[lastEndIndex..<range.lowerBound])
                 if !beforeText.isEmpty {
                     var normalStyle = AttributeContainer()
@@ -3107,7 +3020,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                     normalStyle.foregroundColor = isDark ? Color.white : Color.black
                     processedContent.append(AttributedString(beforeText).mergingAttributes(normalStyle))
                 }
-                }
                 
                 // Add the match with appropriate styling
                 let matchText = String(contentText[range])
@@ -3124,7 +3036,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                 
                 processedContent.append(AttributedString(matchText).mergingAttributes(matchStyle))
                 
-                if lastEndIndex < range.upperBound { lastEndIndex = range.upperBound }
+                lastEndIndex = range.upperBound
             }
         }
         
@@ -3201,12 +3113,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             
             // For extremely long content, render as plain text to avoid heavy regex/layout work,
             // unless the content includes Cashu tokens we want to chip-render below
-            // Compute NSString-backed length for regex/nsrange correctness with multi-byte characters
-            let nsContent = content as NSString
-            let nsLen = nsContent.length
             let containsCashuEarly: Bool = {
                 let rx = Regexes.quickCashuPresence
-                return rx.numberOfMatches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) > 0
+                return rx.numberOfMatches(in: content, options: [], range: NSRange(location: 0, length: content.count)) > 0
             }()
             if (content.count > 4000 || content.hasVeryLongToken(threshold: 1024)) && !containsCashuEarly {
                 var plainStyle = AttributeContainer()
@@ -3224,6 +3133,8 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             let lnurlRegex = Regexes.lnurl
             let lightningSchemeRegex = Regexes.lightningScheme
             let detector = Regexes.linkDetector
+            
+            let nsLen = content.count
             let hasMentionsHint = content.contains("@")
             let hasHashtagsHint = content.contains("#")
             let hasURLHint = content.contains("://") || content.contains("www.") || content.contains("http")
@@ -3303,7 +3214,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             for (range, type) in allMatches {
                 // Add text before match
                 if let nsRange = Range(range, in: content) {
-                    if lastEnd < nsRange.lowerBound {
                     let beforeText = String(content[lastEnd..<nsRange.lowerBound])
                     if !beforeText.isEmpty {
                         var beforeStyle = AttributeContainer()
@@ -3316,7 +3226,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                         }
                         result.append(AttributedString(beforeText).mergingAttributes(beforeStyle))
                     }
-                    }
                     
                     // Add styled match
                     let matchText = String(content[nsRange])
@@ -3423,12 +3332,9 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                             result.append(AttributedString(matchText).mergingAttributes(matchStyle))
                         }
                     }
-                    // Advance lastEnd safely in case of overlaps
-                    if lastEnd < nsRange.upperBound {
                     lastEnd = nsRange.upperBound
                 }
             }
-            }
             
             // Add remaining text
             if lastEnd < content.endIndex {
@@ -3524,16 +3430,13 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
             // Regular expression to find @mentions
             let pattern = "@([\\p{L}0-9_]+)"
             let regex = try? NSRegularExpression(pattern: pattern, options: [])
-            let nsContent = contentText as NSString
+            let matches = regex?.matches(in: contentText, options: [], range: NSRange(location: 0, length: contentText.count)) ?? []
-            let nsLen = nsContent.length
-            let matches = regex?.matches(in: contentText, options: [], range: NSRange(location: 0, length: nsLen)) ?? []
             
             var lastEndIndex = contentText.startIndex
             
             for match in matches {
                 // Add text before the mention
                 if let range = Range(match.range(at: 0), in: contentText) {
-                    if lastEndIndex < range.lowerBound {
                     let beforeText = String(contentText[lastEndIndex..<range.lowerBound])
                     if !beforeText.isEmpty {
                         var normalStyle = AttributeContainer()
@@ -3541,7 +3444,6 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                         normalStyle.foregroundColor = isDark ? Color.white : Color.black
                         processedContent.append(AttributedString(beforeText).mergingAttributes(normalStyle))
                     }
-                    }
                     
                     // Add the mention with highlight
                     let mentionText = String(contentText[range])
@@ -3550,7 +3452,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                     mentionStyle.foregroundColor = Color.orange
                     processedContent.append(AttributedString(mentionText).mergingAttributes(mentionStyle))
                     
-                    if lastEndIndex < range.upperBound { lastEndIndex = range.upperBound }
+                    lastEndIndex = range.upperBound
                 }
             }
             
@@ -4627,10 +4529,14 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                     self.meshService.isPeerConnected(peerID) || self.meshService.isPeerReachable(peerID)
                 }
                 
-                // Rising-edge only: previously zero peers, now > 0 peers
+                // Check if we have new mesh peers we haven't seen recently
                 let currentPeerSet = Set(meshPeers)
-                let hadNone = self.recentlySeenPeers.isEmpty
+                let newPeers = currentPeerSet.subtracting(self.recentlySeenPeers)
-                if meshPeers.count > 0 && hadNone && !self.hasNotifiedNetworkAvailable {
+                // Send notification if:
+                // 1. We have mesh peers (not just Nostr-only)
+                // 2. There are new peers we haven't seen (rising-edge)
+                // 3. We haven't already notified since the last sustained-empty period
+                if meshPeers.count > 0 && !newPeers.isEmpty && !self.hasNotifiedNetworkAvailable {
                     self.hasNotifiedNetworkAvailable = true
                     self.lastNetworkNotificationTime = Date()
                     self.recentlySeenPeers = currentPeerSet
@@ -4639,14 +4545,16 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
                                    category: SecureLogger.session, level: .info)
                 }
             } else {
-                // No peers — immediately reset to allow next rising-edge to notify
+                // No peers - schedule a graceful reset to avoid refiring on brief drops
+                if self.networkResetTimer == nil {
+                    self.networkResetTimer = Timer.scheduledTimer(withTimeInterval: self.networkResetGraceSeconds, repeats: false) { [weak self] _ in
+                        guard let self = self else { return }
                         self.hasNotifiedNetworkAvailable = false
                         self.recentlySeenPeers.removeAll()
-                if self.networkResetTimer != nil {
-                    self.networkResetTimer?.invalidate()
                         self.networkResetTimer = nil
+                        SecureLogger.log("⏳ Mesh empty for \(Int(self.networkResetGraceSeconds))s — reset network notification state", category: SecureLogger.session, level: .debug)
+                    }
                 }
-                SecureLogger.log("⏳ Mesh empty — reset network notification state", category: SecureLogger.session, level: .debug)
             }
             
             // Register ephemeral sessions for all connected peers
@@ -4748,9 +4656,7 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         // Allow optional disambiguation suffix '#abcd' for duplicate nicknames
         let pattern = "@([\\p{L}0-9_]+(?:#[a-fA-F0-9]{4})?)"
         let regex = try? NSRegularExpression(pattern: pattern, options: [])
-        let nsContent = content as NSString
+        let matches = regex?.matches(in: content, options: [], range: NSRange(location: 0, length: content.count)) ?? []
-        let nsLen = nsContent.length
-        let matches = regex?.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) ?? []
         
         var mentions: [String] = []
         let peerNicknames = meshService.getPeerNicknames()
@@ -5817,14 +5723,11 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
         if isGeo && finalMessage.sender != "system" {
             if let gh = currentGeohash {
                 var arr = geoTimelines[gh] ?? []
-                // Dedup by message ID before appending to per-geohash timeline
-                if !arr.contains(where: { $0.id == finalMessage.id }) {
                 arr.append(finalMessage)
                 if arr.count > geoTimelineCap { arr = Array(arr.suffix(geoTimelineCap)) }
                 geoTimelines[gh] = arr
             }
         }
-        }
 
         // Only add message to current timeline if it matches active channel or is system
         let isSystem = finalMessage.sender == "system"
@@ -5837,15 +5740,13 @@ class ChatViewModel: ObservableObject, BitchatDelegate {
 
         guard channelMatches else { return }
 
-        // Removed background nudge notification for generic "new chats!"
         
-        // Append via batching buffer (skip empty content) with simple dedup by ID
+
+        // Append via batching buffer (skip empty content)
         if !finalMessage.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
-            if !messages.contains(where: { $0.id == finalMessage.id }) {
             enqueuePublic(finalMessage)
         }
     }
-    }
 
     // MARK: - Public message batching helpers
     @MainActor

bitchat/Views/ContentView.swift

@@ -24,7 +24,6 @@ struct ContentView: View {
     
     @EnvironmentObject var viewModel: ChatViewModel
     @ObservedObject private var locationManager = LocationChannelManager.shared
-    @ObservedObject private var bookmarks = GeohashBookmarksStore.shared
     @State private var messageText = ""
     @State private var textFieldSelection: NSRange? = nil
     @FocusState private var isTextFieldFocused: Bool
@@ -165,8 +164,6 @@ struct ContentView: View {
         }
         .sheet(isPresented: $showAppInfo) {
             AppInfoView()
-                .onAppear { viewModel.isAppInfoPresented = true }
-                .onDisappear { viewModel.isAppInfoPresented = false }
         }
         .sheet(isPresented: Binding(
             get: { viewModel.showingFingerprintFor != nil },
@@ -281,10 +278,8 @@ struct ContentView: View {
                         }
                     }()
                     let items = windowedMessages.map { (uiID: "\(contextKey)|\($0.id)", message: $0) }
-                    // Filter out empty/whitespace-only messages to avoid blank rows
-                    let filteredItems = items.filter { !$0.message.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
                     
-                    ForEach(filteredItems, id: \.uiID) { item in
+                    ForEach(items, id: \.uiID) { item in
                         let message = item.message
                         VStack(alignment: .leading, spacing: 0) {
                             // Check if current user is mentioned
@@ -1123,15 +1118,6 @@ struct ContentView: View {
                     .buttonStyle(.plain)
                     .accessibilityLabel("Open unread private chat")
                 }
-                // Bookmark toggle for current geohash (not shown for mesh)
-                if case .location(let ch) = locationManager.selectedChannel {
-                    Button(action: { GeohashBookmarksStore.shared.toggle(ch.geohash) }) {
-                        Image(systemName: GeohashBookmarksStore.shared.isBookmarked(ch.geohash) ? "bookmark.fill" : "bookmark")
-                            .font(.system(size: 12))
-                    }
-                    .buttonStyle(.plain)
-                    .accessibilityLabel("Toggle bookmark for #\(ch.geohash)")
-                }
                 // Location channels button '#'
                 Button(action: { showLocationChannelsSheet = true }) {
                     let badgeText: String = {
@@ -1186,13 +1172,6 @@ struct ContentView: View {
         .padding(.horizontal, 12)
         .sheet(isPresented: $showLocationChannelsSheet) {
             LocationChannelsSheet(isPresented: $showLocationChannelsSheet)
-                .onAppear { viewModel.isLocationChannelsSheetPresented = true }
-                .onDisappear { viewModel.isLocationChannelsSheetPresented = false }
-        }
-        .alert("heads up", isPresented: $viewModel.showScreenshotPrivacyWarning) {
-            Button("ok", role: .cancel) {}
-        } message: {
-            Text("screenshots of location channels will reveal your location. think before sharing publicly.")
         }
         .background(backgroundColor.opacity(0.95))
     }

bitchat/Views/LocationChannelsSheet.swift

@@ -8,7 +8,6 @@ import AppKit
 struct LocationChannelsSheet: View {
     @Binding var isPresented: Bool
     @ObservedObject private var manager = LocationChannelManager.shared
-    @ObservedObject private var bookmarks = GeohashBookmarksStore.shared
     @EnvironmentObject var viewModel: ChatViewModel
     @Environment(\.colorScheme) var colorScheme
     @State private var customGeohash: String = ""
@@ -99,7 +98,7 @@ struct LocationChannelsSheet: View {
 
     private var channelList: some View {
         List {
-            // Mesh option first (no bookmark)
+            // Mesh option first
             channelRow(title: meshTitleWithCount(), subtitlePrefix: "#bluetooth • \(bluetoothRangeString())", isSelected: isMeshSelected, titleColor: standardBlue, titleBold: meshCount() > 0) {
                 manager.select(ChannelID.mesh)
                 isPresented = false
@@ -113,21 +112,7 @@ struct LocationChannelsSheet: View {
                     let namePart = nameBase.map { formattedNamePrefix(for: channel.level) + $0 }
                     let subtitlePrefix = "#\(channel.geohash) • \(coverage)"
                     let highlight = viewModel.geohashParticipantCount(for: channel.geohash) > 0
-                    channelRow(
+                    channelRow(title: geohashTitleWithCount(for: channel), subtitlePrefix: subtitlePrefix, subtitleName: namePart, isSelected: isSelected(channel), titleBold: highlight) {
-                        title: geohashTitleWithCount(for: channel),
-                        subtitlePrefix: subtitlePrefix,
-                        subtitleName: namePart,
-                        isSelected: isSelected(channel),
-                        titleBold: highlight,
-                        trailingAccessory: {
-                            Button(action: { bookmarks.toggle(channel.geohash) }) {
-                                Image(systemName: bookmarks.isBookmarked(channel.geohash) ? "bookmark.fill" : "bookmark")
-                                    .font(.system(size: 14))
-                            }
-                            .buttonStyle(.plain)
-                            .padding(.leading, 8)
-                        }
-                    ) {
                         // Selecting a suggested nearby channel is not a teleport. Persist this.
                         manager.markTeleported(for: channel.geohash, false)
                         manager.select(ChannelID.location(channel))
@@ -203,48 +188,6 @@ struct LocationChannelsSheet: View {
                 }
             }
 
-            // Bookmarked geohashes
-            if !bookmarks.bookmarks.isEmpty {
-                VStack(alignment: .leading, spacing: 6) {
-                    Text("bookmarked")
-                        .font(.system(size: 12, design: .monospaced))
-                        .foregroundColor(.secondary)
-                }
-                .listRowSeparator(.hidden)
-                ForEach(bookmarks.bookmarks, id: \.self) { gh in
-                    let level = levelForLength(gh.count)
-                    let channel = GeohashChannel(level: level, geohash: gh)
-                    let coverage = coverageString(forPrecision: gh.count)
-                    let subtitle = "#\(gh) • \(coverage)"
-                    let name = bookmarks.bookmarkNames[gh]
-                    channelRow(
-                        title: geohashHashTitleWithCount(gh),
-                        subtitlePrefix: subtitle,
-                        subtitleName: name.map { formattedNamePrefix(for: level) + $0 },
-                        isSelected: isSelected(channel),
-                        trailingAccessory: {
-                            Button(action: { bookmarks.toggle(gh) }) {
-                                Image(systemName: bookmarks.isBookmarked(gh) ? "bookmark.fill" : "bookmark")
-                                    .font(.system(size: 14))
-                            }
-                            .buttonStyle(.plain)
-                            .padding(.leading, 8)
-                        }
-                    ) {
-                        // For bookmarked selection, mark teleported based on regional membership
-                        let inRegional = manager.availableChannels.contains { $0.geohash == gh }
-                        if !inRegional && !manager.availableChannels.isEmpty {
-                            manager.markTeleported(for: gh, true)
-                        } else {
-                            manager.markTeleported(for: gh, false)
-                        }
-                        manager.select(ChannelID.location(channel))
-                        isPresented = false
-                    }
-                    .onAppear { bookmarks.resolveNameIfNeeded(for: gh) }
-                }
-            }
-
             // Footer action inside the list
             if manager.permissionState == LocationChannelManager.PermissionState.authorized {
                 Button(action: {
@@ -277,19 +220,9 @@ struct LocationChannelsSheet: View {
         return false
     }
 
-    @ViewBuilder
+    private func channelRow(title: String, subtitlePrefix: String, subtitleName: String? = nil, subtitleNameBold: Bool = false, isSelected: Bool, titleColor: Color? = nil, titleBold: Bool = false, action: @escaping () -> Void) -> some View {
-    private func channelRow(
+        Button(action: action) {
-        title: String,
+            HStack {
-        subtitlePrefix: String,
-        subtitleName: String? = nil,
-        subtitleNameBold: Bool = false,
-        isSelected: Bool,
-        titleColor: Color? = nil,
-        titleBold: Bool = false,
-        @ViewBuilder trailingAccessory: () -> some View = { EmptyView() },
-        action: @escaping () -> Void
-    ) -> some View {
-        HStack(alignment: .center, spacing: 8) {
                 VStack(alignment: .leading) {
                     // Render title with smaller font for trailing count in parentheses
                     let parts = splitTitleAndCount(title)
@@ -304,17 +237,20 @@ struct LocationChannelsSheet: View {
                                 .foregroundColor(.secondary)
                         }
                     }
-                let subtitleFull: String = {
+                    HStack(spacing: 0) {
-                    if let name = subtitleName, !name.isEmpty {
+                        Text(subtitlePrefix)
-                        return subtitlePrefix + " • " + name
-                    }
-                    return subtitlePrefix
-                }()
-                Text(subtitleFull)
                             .font(.system(size: 12, design: .monospaced))
                             .foregroundColor(.secondary)
-                    .lineLimit(1)
+                        if let name = subtitleName {
-                    .truncationMode(.tail)
+                            Text(" • ")
+                                .font(.system(size: 12, design: .monospaced))
+                                .foregroundColor(.secondary)
+                            Text(name)
+                                .font(.system(size: 12, design: .monospaced))
+                                .fontWeight(subtitleNameBold ? .bold : .regular)
+                                .foregroundColor(.secondary)
+                        }
+                    }
                 }
                 Spacer()
                 if isSelected {
@@ -322,11 +258,11 @@ struct LocationChannelsSheet: View {
                         .font(.system(size: 16, design: .monospaced))
                         .foregroundColor(standardGreen)
                 }
-                trailingAccessory()
             }
             .frame(maxWidth: .infinity, alignment: .leading)
             .contentShape(Rectangle())
-        .onTapGesture(perform: action)
+        }
+        .buttonStyle(.plain)
     }
 
     // Split a title like "#mesh [3 people]" into base and suffix "[3 people]"
@@ -355,19 +291,12 @@ struct LocationChannelsSheet: View {
     }
 
     private func geohashTitleWithCount(for channel: GeohashChannel) -> String {
-        // Main list: keep level labels (block/neighborhood/city/province/region)
+        // Use ViewModel's 5-minute activity counts; may be 0 for non-selected channels
         let count = viewModel.geohashParticipantCount(for: channel.geohash)
         let noun = count == 1 ? "person" : "people"
         return "\(channel.level.displayName.lowercased()) [\(count) \(noun)]"
     }
 
-    private func geohashHashTitleWithCount(_ geohash: String) -> String {
-        // Bookmarked list: show the #geohash as the main label
-        let count = viewModel.geohashParticipantCount(for: geohash)
-        let noun = count == 1 ? "person" : "people"
-        return "#\(geohash) [\(count) \(noun)]"
-    }
-
     private func validateGeohash(_ s: String) -> Bool {
         let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
         guard !s.isEmpty, s.count <= 12 else { return false }

bitchatTests/GeohashBookmarksStoreTests.swift

@@ -1,51 +0,0 @@
-import XCTest
-@testable import bitchat
-
-final class GeohashBookmarksStoreTests: XCTestCase {
-    let storeKey = "locationChannel.bookmarks"
-
-    override func setUp() {
-        super.setUp()
-        // Clear persisted state before each test
-        UserDefaults.standard.removeObject(forKey: storeKey)
-        GeohashBookmarksStore.shared._resetForTesting()
-    }
-
-    override func tearDown() {
-        // Clean after each test
-        UserDefaults.standard.removeObject(forKey: storeKey)
-        GeohashBookmarksStore.shared._resetForTesting()
-        super.tearDown()
-    }
-
-    func testToggleAndNormalize() {
-        let store = GeohashBookmarksStore.shared
-        // Start clean
-        XCTAssertTrue(store.bookmarks.isEmpty)
-
-        // Add with mixed case and hash prefix
-        store.toggle("#U4PRUY")
-        XCTAssertTrue(store.isBookmarked("u4pruy"))
-        XCTAssertEqual(store.bookmarks.first, "u4pruy")
-
-        // Toggling again removes
-        store.toggle("u4pruy")
-        XCTAssertFalse(store.isBookmarked("u4pruy"))
-        XCTAssertTrue(store.bookmarks.isEmpty)
-    }
-
-    func testPersistenceWritten() throws {
-        let store = GeohashBookmarksStore.shared
-        store.toggle("ezs42")
-        store.toggle("u4pruy")
-
-        // Verify persisted JSON contains both (order not enforced here)
-        guard let data = UserDefaults.standard.data(forKey: storeKey) else {
-            XCTFail("No persisted data found")
-            return
-        }
-        let arr = try JSONDecoder().decode([String].self, from: data)
-        XCTAssertTrue(arr.contains("ezs42"))
-        XCTAssertTrue(arr.contains("u4pruy"))
-    }
-}