Bump marketing version to 1.4.2

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

.gitattributes

@@ -0,0 +1,20 @@
+# Prevent Github Languages stats skewing:
+
+# Binaries and assets
+**/*.xcframework/** linguist-vendored
+**/*.xcassets/** linguist-vendored
+
+# Generated files
+**/*.pbxproj linguist-generated
+**/*.storyboard linguist-generated
+Package.resolved linguist-generated
+
+# Downloaded CSVs
+relays/online_relays_gps.csv linguist-vendored
+
+# Docs
+**/*.md linguist-documentation
+
+# Configs
+Configs/*.xcconfig linguist-documentation
+**/*.plist linguist-documentation

Configs/Release.xcconfig

@@ -1,4 +1,4 @@
-MARKETING_VERSION = 1.4.0
+MARKETING_VERSION = 1.4.2
 CURRENT_PROJECT_VERSION = 1
 
 IPHONEOS_DEPLOYMENT_TARGET = 16.0

Justfile

@@ -14,7 +14,6 @@ default:
 # Check prerequisites
 check:
     @echo "Checking prerequisites..."
-    @command -v xcodegen >/dev/null 2>&1 || (echo "❌ XcodeGen not found. Install with: brew install xcodegen" && exit 1)
     @command -v xcodebuild >/dev/null 2>&1 || (echo "❌ Xcode not found. Install Xcode from App Store" && exit 1)
     @security find-identity -v -p codesigning | grep -q "Developer ID" || (echo "⚠️  No Developer ID found - code signing may fail" && exit 0)
     @echo "✅ All prerequisites met"
@@ -22,8 +21,6 @@ check:
 # Backup original files
 backup:
     @echo "Backing up original project configuration..."
-    @cp project.yml project.yml.backup 2>/dev/null || true
-    @# Backup other files that get modified by xcodegen
     @if [ -f bitchat.xcodeproj/project.pbxproj ]; then cp bitchat.xcodeproj/project.pbxproj bitchat.xcodeproj/project.pbxproj.backup; fi
     @if [ -f bitchat/Info.plist ]; then cp bitchat/Info.plist bitchat/Info.plist.backup; fi
 
@@ -44,15 +41,10 @@ patch-for-macos: backup
     @# Move iOS-specific files out of the way temporarily
     @if [ -f bitchat/LaunchScreen.storyboard ]; then mv bitchat/LaunchScreen.storyboard bitchat/LaunchScreen.storyboard.ios; fi
 
-# Generate Xcode project with patches
-generate: patch-for-macos
-    @echo "Generating Xcode project..."
-    @xcodegen generate
-
 # Build the macOS app
-build: check generate
+build: #check generate
     @echo "Building BitChat for macOS..."
-    @xcodebuild -project bitchat.xcodeproj -scheme "bitchat (macOS)" -configuration Debug CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO CODE_SIGN_ENTITLEMENTS="" build
+    @xcodebuild -project bitchat.xcodeproj -scheme "bitchat_macOS" -configuration Debug CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO CODE_SIGN_ENTITLEMENTS="" build
 
 # Run the macOS app
 run: build
@@ -75,9 +67,7 @@ clean: restore
 # Quick run without cleaning (for development)
 dev-run: check
     @echo "Quick development build..."
-    @if [ ! -f project.yml.backup ]; then just patch-for-macos; fi
-    @xcodegen generate
-    @xcodebuild -project bitchat.xcodeproj -scheme "bitchat (macOS)" -configuration Debug CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO CODE_SIGN_ENTITLEMENTS="" build
+    @xcodebuild -project bitchat.xcodeproj -scheme "bitchat_macOS" -configuration Debug CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO CODE_SIGN_ENTITLEMENTS="" build
     @find ~/Library/Developer/Xcode/DerivedData -name "bitchat.app" -path "*/Debug/*" -not -path "*/Index.noindex/*" | head -1 | xargs -I {} open "{}"
 
 # Show app info
@@ -106,11 +96,9 @@ nuke:
     @echo "🧨 Nuclear clean - removing all build artifacts and backups..."
     @rm -rf ~/Library/Developer/Xcode/DerivedData/bitchat-* 2>/dev/null || true
     @rm -rf bitchat.xcodeproj 2>/dev/null || true
-    @rm -f project.yml.backup 2>/dev/null || true
-    @rm -f project-macos.yml 2>/dev/null || true
     @rm -f bitchat.xcodeproj/project.pbxproj.backup 2>/dev/null || true
     @rm -f bitchat/Info.plist.backup 2>/dev/null || true
     @# Restore iOS-specific files if they were moved
     @if [ -f bitchat/LaunchScreen.storyboard.ios ]; then mv bitchat/LaunchScreen.storyboard.ios bitchat/LaunchScreen.storyboard; fi
-    @git checkout -- project.yml bitchat.xcodeproj/project.pbxproj bitchat/Info.plist 2>/dev/null || echo "⚠️  Not a git repo or no changes to restore"
+    @git checkout bitchat.xcodeproj/project.pbxproj bitchat/Info.plist 2>/dev/null || echo "⚠️  Not a git repo or no changes to restore"
     @echo "✅ Nuclear clean complete"

bitchat.xcodeproj/project.pbxproj

@@ -604,6 +604,7 @@
 				ENABLE_PREVIEWS = YES;
 				INFOPLIST_FILE = bitchat/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = bitchat;
+				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/../Frameworks",
@@ -695,6 +696,7 @@
 				ENABLE_PREVIEWS = NO;
 				INFOPLIST_FILE = bitchat/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = bitchat;
+				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/../Frameworks",

bitchat/Noise/NoiseSecurityConsiderations.swift

@@ -210,6 +210,15 @@ final class NoiseRateLimiter {
             self.messageTimestamps.removeValue(forKey: peerID)
         }
     }
+
+    func resetAll() {
+        queue.async(flags: .barrier) {
+            self.handshakeTimestamps.removeAll()
+            self.messageTimestamps.removeAll()
+            self.globalHandshakeTimestamps.removeAll()
+            self.globalMessageTimestamps.removeAll()
+        }
+    }
 }
 
 // MARK: - Security Errors

bitchat/Noise/NoiseSession.swift

@@ -309,6 +309,15 @@ final class NoiseSessionManager {
         }
     }
 
+    func removeAllSessions() {
+        managerQueue.sync(flags: .barrier) {
+            for (_, session) in sessions {
+                session.reset()
+            }
+            sessions.removeAll()
+        }
+    }
+    
     func getEstablishedSessions() -> [String: NoiseSession] {
         return managerQueue.sync {
             return sessions.filter { $0.value.isEstablished() }

bitchat/Nostr/NostrIdentity.swift

@@ -150,13 +150,31 @@ struct NostrIdentityBridge {
     
     /// Clear all Nostr identity associations and current identity
     static func clearAllAssociations() {
-        // Delete current Nostr identity
-        KeychainHelper.delete(key: currentIdentityKey, service: keychainService)
-        KeychainHelper.delete(key: deviceSeedKey, service: keychainService)
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: keychainService,
+            kSecMatchLimit as String: kSecMatchLimitAll,
+            kSecReturnAttributes as String: true
+        ]
 
-        // Note: We can't efficiently delete all noise-nostr associations 
-        // without tracking them, but they'll be orphaned and eventually cleaned up
-        // The important part is deleting the current identity so a new one is generated
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        if status == errSecSuccess, let items = result as? [[String: Any]] {
+            for item in items {
+                var deleteQuery: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: keychainService
+                ]
+                if let account = item[kSecAttrAccount as String] as? String {
+                    deleteQuery[kSecAttrAccount as String] = account
+                }
+                SecItemDelete(deleteQuery as CFDictionary)
+            }
+        } else if status == errSecItemNotFound {
+            // nothing persisted; no action needed
+        }
+
+        deviceSeedCache = nil
     }
 
     // MARK: - Per-Geohash Identities (Location Channels)

bitchat/Nostr/NostrRelayManager.swift

@@ -35,10 +35,12 @@ final class NostrRelayManager: ObservableObject {
         "wss://nostr21.com"
         // For local testing, you can add: "ws://localhost:8080"
     ]
+    private static let defaultRelaySet = Set(defaultRelays)
     
     @Published private(set) var relays: [Relay] = []
     @Published private(set) var isConnected = false
     
+    private var allowDefaultRelays: Bool = false
     private var connections: [String: URLSessionWebSocketTask] = [:]
     private var subscriptions: [String: Set<String>] = [:] // relay URL -> active subscription IDs
     private var pendingSubscriptions: [String: [String: String]] = [:] // relay URL -> (subscription id -> encoded REQ JSON)
@@ -65,6 +67,8 @@ final class NostrRelayManager: ObservableObject {
     private let messageQueueLock = NSLock()
     private let encoder = JSONEncoder()
     private let decoder = JSONDecoder()
+    private var networkService: NetworkActivationService { NetworkActivationService.shared }
+    private var shouldUseTor: Bool { networkService.userTorEnabled }
     
     // Exponential backoff configuration
     private let initialBackoffInterval: TimeInterval = TransportConfig.nostrRelayInitialBackoffSeconds
@@ -78,29 +82,45 @@ final class NostrRelayManager: ObservableObject {
     private var connectionGeneration: Int = 0
     
     init() {
-        // Initialize with default relays
-        self.relays = Self.defaultRelays.map { Relay(url: $0) }
+        let hasMutual = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
+        allowDefaultRelays = hasMutual
+        if hasMutual {
+            self.relays = Self.defaultRelays.map { Relay(url: $0) }
+        }
         // Deterministic JSON shape for outbound requests
         self.encoder.outputFormatting = .sortedKeys
+        FavoritesPersistenceService.shared.$mutualFavorites
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] favorites in
+                self?.updateDefaultRelayPolicy(hasMutual: !favorites.isEmpty)
+            }
+            .store(in: &cancellables)
     }
     
     /// Connect to all configured relays
     func connect() {
         // Global network policy gate
-        if !TorManager.shared.isAutoStartAllowed() { return }
-        // Ensure Tor is started early and wait for readiness off-main; then hop back to connect.
-        Task.detached {
-            let ready = await TorManager.shared.awaitReady()
-            await MainActor.run {
-                if !ready {
-                    SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
-                    return
-                }
-                SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
-                for relay in self.relays {
-                    self.connectToRelay(relay.url)
+        guard networkService.activationAllowed else { return }
+        if shouldUseTor {
+            // Ensure Tor is started early and wait for readiness off-main; then hop back to connect.
+            Task.detached {
+                let ready = await TorManager.shared.awaitReady()
+                await MainActor.run {
+                    if !ready {
+                        SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
+                        return
+                    }
+                    SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
+                    for relay in self.relays {
+                        self.connectToRelay(relay.url)
+                    }
                 }
             }
+        } else {
+            SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (direct)", category: .session)
+            for relay in self.relays {
+                connectToRelay(relay.url)
+            }
         }
     }
     
@@ -120,8 +140,10 @@ final class NostrRelayManager: ObservableObject {
     /// Ensure connections exist to the given relay URLs (idempotent).
     func ensureConnections(to relayUrls: [String]) {
         // Global network policy gate
-        if !TorManager.shared.isAutoStartAllowed() { return }
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        guard networkService.activationAllowed else { return }
+        let targets = allowedRelayList(from: relayUrls)
+        guard !targets.isEmpty else { return }
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer until Tor is fully ready; avoid queuing connection attempts early
             Task.detached { [weak self] in
                 guard let self = self else { return }
@@ -130,22 +152,21 @@ final class NostrRelayManager: ObservableObject {
             }
             return
         }
-        let existing = Set(relays.map { $0.url })
-        for url in Set(relayUrls) {
-            if !existing.contains(url) {
-                relays.append(Relay(url: url))
-            }
-            if connections[url] == nil {
-                connectToRelay(url)
-            }
+        var existing = Set(relays.map { $0.url })
+        for url in targets where !existing.contains(url) {
+            relays.append(Relay(url: url))
+            existing.insert(url)
+        }
+        for url in targets where connections[url] == nil {
+            connectToRelay(url)
         }
     }
 
     /// Send an event to specified relays (or all if none specified)
     func sendEvent(_ event: NostrEvent, to relayUrls: [String]? = nil) {
         // Global network policy gate
-        if !TorManager.shared.isAutoStartAllowed() { return }
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        guard networkService.activationAllowed else { return }
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer sends until Tor is ready to avoid premature queueing
             Task.detached { [weak self] in
                 guard let self = self else { return }
@@ -154,7 +175,9 @@ final class NostrRelayManager: ObservableObject {
             }
             return
         }
-        let targetRelays = relayUrls ?? Self.defaultRelays
+        let requestedRelays = relayUrls ?? Self.defaultRelays
+        let targetRelays = allowedRelayList(from: requestedRelays)
+        guard !targetRelays.isEmpty else { return }
         ensureConnections(to: targetRelays)
 
         // Attempt immediate send to relays with active connections; queue the rest
@@ -220,7 +243,7 @@ final class NostrRelayManager: ObservableObject {
         onEOSE: (() -> Void)? = nil
     ) {
         // Global network policy gate
-        if !TorManager.shared.isAutoStartAllowed() { return }
+        guard networkService.activationAllowed else { return }
         // Coalesce rapid duplicate subscribe requests only if a handler already exists
         let now = Date()
         if messageHandlers[id] != nil {
@@ -229,7 +252,7 @@ final class NostrRelayManager: ObservableObject {
             }
         }
         subscribeCoalesce[id] = now
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer subscription setup until Tor is ready; avoid queuing subs early
             Task.detached { [weak self] in
                 guard let self = self else { return }
@@ -257,32 +280,37 @@ final class NostrRelayManager: ObservableObject {
             
             // Target specific relays if provided; else default. Filter permanently failed relays.
             let baseUrls = relayUrls ?? Self.defaultRelays
-            let urls = baseUrls.filter { !isPermanentlyFailed($0) }
+            let candidateUrls = baseUrls.filter { !isPermanentlyFailed($0) }
+            let urls = allowedRelayList(from: candidateUrls)
             // Always queue subscriptions; sending happens when a relay reports connected
             let existingSet = Set(relays.map { $0.url })
             for url in urls where !existingSet.contains(url) {
                 relays.append(Relay(url: url))
             }
-            for url in urls {
+            for url in candidateUrls {
                 var map = self.pendingSubscriptions[url] ?? [:]
                 map[id] = messageString
                 self.pendingSubscriptions[url] = map
             }
             // Initialize EOSE tracking if requested
             if let onEOSE = onEOSE {
-                var tracker = EOSETracker(pendingRelays: Set(urls), callback: onEOSE, timer: nil)
-                // Fallback timeout to avoid hanging if a relay never sends EOSE
-                tracker.timer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
-                    Task { @MainActor in
-                        guard let self = self else { return }
-                        if let t = self.eoseTrackers[id] {
-                            t.timer?.invalidate()
-                            self.eoseTrackers.removeValue(forKey: id)
-                            onEOSE()
+                if urls.isEmpty {
+                    onEOSE()
+                } else {
+                    var tracker = EOSETracker(pendingRelays: Set(urls), callback: onEOSE, timer: nil)
+                    // Fallback timeout to avoid hanging if a relay never sends EOSE
+                    tracker.timer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
+                        Task { @MainActor in
+                            guard let self = self else { return }
+                            if let t = self.eoseTrackers[id] {
+                                t.timer?.invalidate()
+                                self.eoseTrackers.removeValue(forKey: id)
+                                onEOSE()
+                            }
                         }
                     }
+                    eoseTrackers[id] = tracker
                 }
-                eoseTrackers[id] = tracker
             }
             SecureLogger.debug("📋 Queued subscription id=\(id) for \(urls.count) relay(s)", category: .session)
             // Ensure we actually have sockets opening to these relays so queued REQs can flush
@@ -298,6 +326,54 @@ final class NostrRelayManager: ObservableObject {
         }
     }
 
+    private func updateDefaultRelayPolicy(hasMutual: Bool) {
+        guard hasMutual != allowDefaultRelays else { return }
+        allowDefaultRelays = hasMutual
+        if hasMutual {
+            var existing = Set(relays.map { $0.url })
+            for url in Self.defaultRelays where !existing.contains(url) {
+                relays.append(Relay(url: url))
+                existing.insert(url)
+            }
+            if networkService.activationAllowed {
+                ensureConnections(to: Self.defaultRelays)
+            }
+        } else {
+            for url in Self.defaultRelays {
+                if let connection = connections[url] {
+                    connection.cancel(with: .goingAway, reason: nil)
+                }
+                connections.removeValue(forKey: url)
+                subscriptions.removeValue(forKey: url)
+            }
+            messageQueueLock.lock()
+            for index in (0..<messageQueue.count).reversed() {
+                var item = messageQueue[index]
+                item.pendingRelays.subtract(Self.defaultRelaySet)
+                if item.pendingRelays.isEmpty {
+                    messageQueue.remove(at: index)
+                } else {
+                    messageQueue[index] = item
+                }
+            }
+            messageQueueLock.unlock()
+            relays.removeAll { Self.defaultRelaySet.contains($0.url) }
+            updateConnectionStatus()
+        }
+    }
+
+    private func allowedRelayList(from urls: [String]) -> [String] {
+        var seen = Set<String>()
+        var result: [String] = []
+        for url in urls {
+            if !allowDefaultRelays && Self.defaultRelaySet.contains(url) { continue }
+            if seen.insert(url).inserted {
+                result.append(url)
+            }
+        }
+        return result
+    }
+    
     /// Unsubscribe from a subscription
     func unsubscribe(id: String) {
         messageHandlers.removeValue(forKey: id)
@@ -326,14 +402,14 @@ final class NostrRelayManager: ObservableObject {
     
     private func connectToRelay(_ urlString: String) {
         // Global network policy gate
-        if !TorManager.shared.isAutoStartAllowed() { return }
+        guard networkService.activationAllowed else { return }
         guard let url = URL(string: urlString) else { 
             SecureLogger.warning("Invalid relay URL: \(urlString)", category: .session)
             return 
         }
 
         // Avoid initiating connections while app is backgrounded; we'll reconnect on foreground
-        if TorManager.shared.torEnforced && !TorManager.shared.isForeground() {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isForeground() {
             return
         }
         
@@ -348,7 +424,7 @@ final class NostrRelayManager: ObservableObject {
         // Attempting to connect to Nostr relay via the proxied session
         
         // If Tor is enforced but not ready, delay connection until it is.
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             Task.detached { [weak self] in
                 guard let self = self else { return }
                 let ready = await TorManager.shared.awaitReady()
@@ -534,7 +610,7 @@ final class NostrRelayManager: ObservableObject {
     
     private func handleDisconnection(relayUrl: String, error: Error) {
         // If networking is disallowed, do not schedule reconnection
-        if !TorManager.shared.isAutoStartAllowed() {
+        if !networkService.activationAllowed {
             connections.removeValue(forKey: relayUrl)
             subscriptions.removeValue(forKey: relayUrl)
             updateRelayStatus(relayUrl, isConnected: false, error: error)

bitchat/Services/BLEService.swift

@@ -89,8 +89,9 @@ final class BLEService: NSObject {
     
     var myPeerID: String = ""
     var myNickname: String = "anon"
-    private let noiseService: NoiseEncryptionService
+    private var noiseService: NoiseEncryptionService
     private let identityManager: SecureIdentityStateManagerProtocol
+    private let keychain: KeychainManagerProtocol
     private var myPeerIDData: Data = Data()
 
     // MARK: - Advertising Privacy
@@ -330,33 +331,44 @@ final class BLEService: NSObject {
         }
     }
     
-    init(keychain: KeychainManagerProtocol, identityManager: SecureIdentityStateManagerProtocol) {
-        noiseService = NoiseEncryptionService(keychain: keychain)
-        self.identityManager = identityManager
-        super.init()
-        
-        // 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: ())
-        
-        // Set up Noise session establishment callback
-        // This ensures we send pending messages only when session is truly established
-        noiseService.onPeerAuthenticated = { [weak self] peerID, fingerprint in
+    private func configureNoiseServiceCallbacks(for service: NoiseEncryptionService) {
+        service.onPeerAuthenticated = { [weak self] peerID, fingerprint in
             SecureLogger.debug("🔐 Noise session authenticated with \(peerID), fingerprint: \(fingerprint.prefix(16))...")
-            // Send any messages that were queued during handshake
             self?.messageQueue.async { [weak self] in
                 self?.sendPendingMessagesAfterHandshake(for: peerID)
                 self?.sendPendingNoisePayloadsAfterHandshake(for: peerID)
             }
-            // Proactive presence nudge: announce immediately after handshake
             self?.messageQueue.async { [weak self] in
                 self?.sendAnnounce(forceSend: true)
             }
         }
+    }
+
+    private func refreshPeerIdentity() {
+        let fingerprint = noiseService.getIdentityFingerprint()
+        myPeerID = String(fingerprint.prefix(16))
+        myPeerIDData = Data(hexString: myPeerID) ?? Data()
+    }
+
+    private func restartGossipManager() {
+        gossipSyncManager?.stop()
+        let sync = GossipSyncManager(myPeerID: myPeerID)
+        sync.delegate = self
+        sync.start()
+        gossipSyncManager = sync
+    }
+
+    init(keychain: KeychainManagerProtocol, identityManager: SecureIdentityStateManagerProtocol) {
+        self.keychain = keychain
+        noiseService = NoiseEncryptionService(keychain: keychain)
+        self.identityManager = identityManager
+        super.init()
+        
+        configureNoiseServiceCallbacks(for: noiseService)
+        refreshPeerIdentity()
+        
+        // Set queue key for identification
+        messageQueue.setSpecific(key: messageQueueKey, value: ())
         
         // Set up application state tracking (iOS only)
         #if os(iOS)
@@ -407,10 +419,7 @@ final class BLEService: NSObject {
         requestPeerDataPublish()
 
         // Initialize gossip sync manager
-        let sync = GossipSyncManager(myPeerID: myPeerID)
-        sync.delegate = self
-        sync.start()
-        self.gossipSyncManager = sync
+        restartGossipManager()
     }
     
     func setNickname(_ nickname: String) {
@@ -739,6 +748,46 @@ final class BLEService: NSObject {
         centralToPeerID.removeAll()
     }
 
+    func resetIdentityForPanic(currentNickname: String) {
+        messageQueue.sync(flags: .barrier) {
+            pendingMessagesAfterHandshake.removeAll()
+            pendingNoisePayloadsAfterHandshake.removeAll()
+        }
+
+        collectionsQueue.sync(flags: .barrier) {
+            recentAnnounceBySender.removeAll()
+            recentAnnounceOrder.removeAll()
+            pendingPeripheralWrites.removeAll()
+            pendingNotifications.removeAll()
+            pendingDirectedRelays.removeAll()
+            ingressByMessageID.removeAll()
+            recentPacketTimestamps.removeAll()
+            scheduledRelays.values.forEach { $0.cancel() }
+            scheduledRelays.removeAll()
+        }
+
+        bleQueue.sync {
+            pendingWriteBuffers.removeAll()
+            recentConnectTimeouts.removeAll()
+        }
+        recentDisconnectNotifies.removeAll()
+
+        noiseService.clearEphemeralStateForPanic()
+        noiseService.clearPersistentIdentity()
+
+        let newNoise = NoiseEncryptionService(keychain: keychain)
+        noiseService = newNoise
+        configureNoiseServiceCallbacks(for: newNoise)
+        refreshPeerIdentity()
+        restartGossipManager()
+
+        setNickname(currentNickname)
+
+        messageDeduplicator.reset()
+        requestPeerDataPublish()
+        startServices()
+    }
+    
     func getNoiseService() -> NoiseEncryptionService {
         return noiseService
     }

bitchat/Services/KeychainManager.swift

@@ -282,6 +282,7 @@ final class KeychainManager: KeychainManagerProtocol {
             "com.bitchat.deviceidentity", 
             "com.bitchat.noise.identity",
             "chat.bitchat.passwords",
+            "chat.bitchat.nostr",
             "bitchat.keychain",
             "bitchat",
             "com.bitchat"

bitchat/Services/NetworkActivationService.swift

@@ -10,9 +10,12 @@ final class NetworkActivationService: ObservableObject {
     static let shared = NetworkActivationService()
 
     @Published private(set) var activationAllowed: Bool = false
+    @Published private(set) var userTorEnabled: Bool = true
 
     private var cancellables = Set<AnyCancellable>()
     private var started = false
+    private let torPreferenceKey = "networkActivationService.userTorEnabled"
+    private var torAutoStartDesired: Bool = false
 
     private init() {}
 
@@ -20,9 +23,23 @@ final class NetworkActivationService: ObservableObject {
         guard !started else { return }
         started = true
 
+        if let stored = UserDefaults.standard.object(forKey: torPreferenceKey) as? Bool {
+            userTorEnabled = stored
+        } else {
+            userTorEnabled = true
+        }
+
         // Initial compute
-        activationAllowed = Self.computeAllowed()
-        TorManager.shared.setAutoStartAllowed(activationAllowed)
+        let allowed = basePolicyAllowed()
+        activationAllowed = allowed
+        torAutoStartDesired = allowed && userTorEnabled
+        TorManager.shared.setAutoStartAllowed(torAutoStartDesired)
+        applyTorState(torDesired: torAutoStartDesired)
+        if allowed {
+            NostrRelayManager.shared.connect()
+        } else {
+            NostrRelayManager.shared.disconnect()
+        }
 
         // React to location permission changes
         LocationChannelManager.shared.$permissionState
@@ -41,30 +58,56 @@ final class NetworkActivationService: ObservableObject {
             .store(in: &cancellables)
     }
 
+    func setUserTorEnabled(_ enabled: Bool) {
+        guard enabled != userTorEnabled else { return }
+        userTorEnabled = enabled
+        UserDefaults.standard.set(enabled, forKey: torPreferenceKey)
+        NotificationCenter.default.post(
+            name: .TorUserPreferenceChanged,
+            object: nil,
+            userInfo: ["enabled": enabled]
+        )
+        reevaluate()
+    }
+
     private func reevaluate() {
-        let allowed = Self.computeAllowed()
-        if allowed != activationAllowed {
+        let allowed = basePolicyAllowed()
+        let torDesired = allowed && userTorEnabled
+        let statusChanged = allowed != activationAllowed
+        let torChanged = torDesired != torAutoStartDesired
+        if statusChanged {
             SecureLogger.info("NetworkActivationService: activationAllowed -> \(allowed)", category: .session)
             activationAllowed = allowed
-            TorManager.shared.setAutoStartAllowed(allowed)
-            if allowed {
-                // Kick Tor + relays if we're now permitted
-                TorManager.shared.startIfNeeded()
-                // If app is in foreground, begin relay connections
-                if TorManager.shared.isForeground() {
-                    NostrRelayManager.shared.connect()
-                }
-            } else {
-                // Transitioned to disallowed: disconnect relays and shut down Tor
+        }
+        if statusChanged || torChanged {
+            torAutoStartDesired = torDesired
+            TorManager.shared.setAutoStartAllowed(torDesired)
+            applyTorState(torDesired: torDesired)
+        }
+
+        if allowed {
+            if torChanged {
+                // Reset relay sockets when switching transport path (Tor ↔︎ direct)
                 NostrRelayManager.shared.disconnect()
-                TorManager.shared.goDormantOnBackground()
             }
+            NostrRelayManager.shared.connect()
+        } else if statusChanged {
+            NostrRelayManager.shared.disconnect()
         }
     }
 
-    private static func computeAllowed() -> Bool {
+    private func basePolicyAllowed() -> Bool {
         let permOK = LocationChannelManager.shared.permissionState == .authorized
         let hasMutual = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
         return permOK || hasMutual
     }
+
+    private func applyTorState(torDesired: Bool) {
+        TorURLSession.shared.setProxyMode(useTor: torDesired)
+        if torDesired {
+            TorManager.shared.startIfNeeded()
+        } else {
+            TorManager.shared.shutdownCompletely()
+        }
+    }
 }

bitchat/Services/NoiseEncryptionService.swift

@@ -527,6 +527,15 @@ final class NoiseEncryptionService {
         SecureLogger.info(.sessionExpired(peerID: peerID))
     }
 
+    func clearEphemeralStateForPanic() {
+        sessionManager.removeAllSessions()
+        serviceQueue.sync(flags: .barrier) {
+            peerFingerprints.removeAll()
+            fingerprintToPeerID.removeAll()
+        }
+        rateLimiter.resetAll()
+    }
+    
     // MARK: - Private Helpers
     
     private func handleSessionEstablished(peerID: String, remoteStaticKey: Curve25519.KeyAgreement.PublicKey) {

bitchat/Services/Tor/TorManager.swift

@@ -68,6 +68,7 @@ final class TorManager: ObservableObject {
     private var controlMonitorStarted = false
     private var pathMonitor: NWPathMonitor?
     private var isAppForeground: Bool = true
+    private var isDormant: Bool = false
     private var lastRestartAt: Date? = nil
     // Global policy gate: only allow Tor to start when true
     private(set) var allowAutoStart: Bool = false
@@ -83,6 +84,7 @@ final class TorManager: ObservableObject {
         guard isAppForeground else { return }
         guard !didStart else { return }
         didStart = true
+        isDormant = false
         isStarting = true
         lastError = nil
         // Announce initial start so UI can show a status message
@@ -492,18 +494,39 @@ final class TorManager: ObservableObject {
                 return true
             }
             if !claimed { return }
+            if await self.resumeTorIfPossible() {
+                await MainActor.run {
+                    self.restarting = false
+                    self.isStarting = false
+                }
+                return
+            }
             await self.restartTor()
             await MainActor.run { self.restarting = false }
         }
     }
 
     func goDormantOnBackground() {
-        // Stricter model: fully stop Tor when app backgrounds to save power
-        // and avoid half-suspended states. We'll restart cleanly on .active.
+        // Prefer Tor's DORMANT mode so we can resume on foreground without a full restart.
+        // If the control port is unreachable, fall back to a hard shutdown.
         Task.detached { [weak self] in
             guard let self = self else { return }
+            let signaled = await self.controlSendSignal("DORMANT")
+            if signaled {
+                SecureLogger.info("TorManager: signalled DORMANT", category: .session)
+                await MainActor.run {
+                    self.isDormant = true
+                    self.isReady = false
+                    self.socksReady = false
+                    self.isStarting = false
+                }
+                return
+            }
+
+            SecureLogger.warning("TorManager: DORMANT signal failed; shutting down", category: .session)
             _ = tor_host_shutdown()
             await MainActor.run {
+                self.isDormant = false
                 self.isReady = false
                 self.socksReady = false
                 self.bootstrapProgress = 0
@@ -516,6 +539,24 @@ final class TorManager: ObservableObject {
         }
     }
 
+    func shutdownCompletely() {
+        Task.detached { [weak self] in
+            guard let self = self else { return }
+            _ = tor_host_shutdown()
+            await MainActor.run {
+                self.isDormant = false
+                self.isReady = false
+                self.socksReady = false
+                self.bootstrapProgress = 0
+                self.bootstrapSummary = ""
+                self.isStarting = false
+                self.didStart = false
+                self.restarting = false
+                self.controlMonitorStarted = false
+            }
+        }
+    }
+
     private func restartTor() async {
         await MainActor.run {
             // Announce restart so UI can notify the user
@@ -525,14 +566,28 @@ final class TorManager: ObservableObject {
             self.bootstrapProgress = 0
             self.bootstrapSummary = ""
             self.isStarting = true
+            self.isDormant = false
             self.lastRestartAt = Date()
         }
         // Prefer clean shutdown via owning controller FD; join the tor thread
         _ = tor_host_shutdown()
         // As a fallback, try control signal if needed (harmless if tor already down)
         _ = await controlSendSignal("SHUTDOWN")
+        // Allow Tor thread to fully terminate before re-starting.
+        var waited = 0
+        while tor_host_is_running() != 0 && waited < 40 {
+            try? await Task.sleep(nanoseconds: 100_000_000) // 100ms
+            waited += 1
+        }
+        if waited >= 40 {
+            SecureLogger.warning("TorManager: tor_host_is_running still true before restart", category: .session)
+        }
+        // Allow control monitor and start logic to reinitialize cleanly
+        await MainActor.run {
+            self.controlMonitorStarted = false
+            self.didStart = false
+        }
         // Now start fresh
-        await MainActor.run { self.didStart = false }
         await MainActor.run { self.startIfNeeded() }
     }
 
@@ -598,6 +653,62 @@ final class TorManager: ObservableObject {
         return (text?.contains("250")) == true
     }
 
+    private func resumeTorIfPossible() async -> Bool {
+        let wasDormant = await MainActor.run { self.isDormant }
+        let pendingReady = await MainActor.run { self.socksReady && !self.isReady }
+        let needsWake = wasDormant || pendingReady
+        if !needsWake {
+            return false
+        }
+
+        let activated = await controlSendSignal("ACTIVE")
+        let pinged = await controlPingBootstrap(timeout: 3.0)
+        if !activated && !pinged {
+            SecureLogger.warning("TorManager: ACTIVE signal failed", category: .session)
+            return false
+        }
+
+        if let info = await controlGetBootstrapInfo() {
+            await MainActor.run {
+                self.bootstrapProgress = info.progress
+                self.bootstrapSummary = info.summary
+            }
+        }
+
+        await MainActor.run {
+            self.isDormant = false
+            self.isStarting = true
+            self.socksReady = false
+        }
+
+        let firstReady = await waitForSocksReady(timeout: 12.0)
+        if firstReady {
+            await MainActor.run {
+                self.socksReady = true
+                self.isStarting = false
+            }
+            SecureLogger.info("TorManager: resumed Tor via ACTIVE signal", category: .session)
+            return true
+        }
+
+        if pinged {
+            let secondReady = await waitForSocksReady(timeout: 20.0)
+            await MainActor.run {
+                self.socksReady = secondReady
+                self.isStarting = !secondReady
+            }
+            if secondReady {
+                SecureLogger.info("TorManager: resumed Tor after extended wait", category: .session)
+                return true
+            }
+        } else {
+            await MainActor.run { self.isStarting = false }
+        }
+
+        SecureLogger.warning("TorManager: ACTIVE resume failed; will restart", category: .session)
+        return false
+    }
+
     private func controlExchange(lines: [String], timeout: TimeInterval) async -> String? {
         guard let cookiePath = dataDirectoryURL()?.appendingPathComponent("control_auth_cookie"),
               let cookie = try? Data(contentsOf: cookiePath) else { return nil }

bitchat/Services/Tor/TorNotifications.swift

@@ -4,4 +4,5 @@ extension Notification.Name {
     static let TorDidBecomeReady = Notification.Name("TorDidBecomeReady")
     static let TorWillRestart = Notification.Name("TorWillRestart")
     static let TorWillStart = Notification.Name("TorWillStart")
+    static let TorUserPreferenceChanged = Notification.Name("TorUserPreferenceChanged")
 }

bitchat/Services/Tor/TorURLSession.swift

@@ -4,43 +4,34 @@ import CFNetwork
 #endif
 
 /// Provides a shared URLSession that routes traffic via Tor's SOCKS5 proxy
-/// when Tor is enforced/ready. Falls back to a default session only when
-/// compiled with the `BITCHAT_DEV_ALLOW_CLEARNET` flag.
+/// when Tor is enforced/ready. Allows swapping between proxied and direct
+/// sessions so UI can toggle Tor usage at runtime.
 final class TorURLSession {
     static let shared = TorURLSession()
 
-    // Default (no proxy) session for local development when dev bypass is enabled.
-    private var defaultSession: URLSession = {
-        let cfg = URLSessionConfiguration.default
-        cfg.waitsForConnectivity = true
-        return URLSession(configuration: cfg)
-    }()
+    // Default (no proxy) session for direct Nostr access when Tor is disabled.
+    private var defaultSession: URLSession = TorURLSession.makeDefaultSession()
 
     // Proxied (SOCKS5) session that routes through Tor.
     private var torSession: URLSession = TorURLSession.makeTorSession()
+    private var useTorProxy: Bool = true
 
     var session: URLSession {
-        #if BITCHAT_DEV_ALLOW_CLEARNET
-        // Dev bypass: use direct session. Call sites may still await Tor if desired.
-        return defaultSession
-        #else
-        // Production: always use the Tor-proxied session. Call sites ensure readiness.
-        return torSession
-        #endif
+        useTorProxy ? torSession : defaultSession
     }
 
     // Recreate sessions so new clients bind to the fresh SOCKS/control ports after a Tor restart.
     func rebuild() {
-        #if BITCHAT_DEV_ALLOW_CLEARNET
-        defaultSession = {
-            let cfg = URLSessionConfiguration.default
-            cfg.waitsForConnectivity = true
-            return URLSession(configuration: cfg)
-        }()
-        #endif
+        defaultSession = TorURLSession.makeDefaultSession()
         torSession = TorURLSession.makeTorSession()
     }
 
+    func setProxyMode(useTor: Bool) {
+        guard useTorProxy != useTor else { return }
+        useTorProxy = useTor
+        rebuild()
+    }
+
     private static func makeTorSession() -> URLSession {
         let cfg = URLSessionConfiguration.ephemeral
         cfg.waitsForConnectivity = true
@@ -63,4 +54,10 @@ final class TorURLSession {
         #endif
         return URLSession(configuration: cfg)
     }
+
+    private static func makeDefaultSession() -> URLSession {
+        let cfg = URLSessionConfiguration.default
+        cfg.waitsForConnectivity = true
+        return URLSession(configuration: cfg)
+    }
 }

bitchat/ViewModels/ChatViewModel.swift

@@ -778,6 +778,12 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             name: .TorWillStart,
             object: nil
         )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleTorPreferenceChanged(_:)),
+            name: .TorUserPreferenceChanged,
+            object: nil
+        )
         #else
         NotificationCenter.default.addObserver(
             self,
@@ -828,6 +834,12 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             name: .TorWillStart,
             object: nil
         )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleTorPreferenceChanged(_:)),
+            name: .TorUserPreferenceChanged,
+            object: nil
+        )
         #endif
     }
     
@@ -870,6 +882,14 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         }
     }
 
+    @objc private func handleTorPreferenceChanged(_ notification: Notification) {
+        Task { @MainActor in
+            self.torStatusAnnounced = false
+            self.torInitialReadyAnnounced = false
+            self.torRestartPending = false
+        }
+    }
+    
     // Resubscribe to the active geohash channel without clearing timeline
     @MainActor
     private func resubscribeCurrentGeohash() {
@@ -1489,6 +1509,8 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
 
             // Track ourselves as active participant
             recordGeoParticipant(pubkeyHex: identity.publicKeyHex)
+            let shortKey = "nostr:" + identity.publicKeyHex.prefix(TransportConfig.nostrShortKeyDisplayLength)
+            nostrKeyMapping[shortKey] = identity.publicKeyHex
             SecureLogger.debug("GeoTeleport: sent geo message pub=\(identity.publicKeyHex.prefix(8))… teleported=\(LocationChannelManager.shared.teleported)", category: .session)
             
             // If we tagged this as teleported, also mark our pubkey in teleportedGeo for UI
@@ -1884,6 +1906,33 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         geohashPeople = people
     }
 
+    @MainActor
+    func isSelfSender(peerID: String?, displayName: String?) -> Bool {
+        guard let peerID else { return false }
+        if peerID == meshService.myPeerID { return true }
+        let lowerPeer = peerID.lowercased()
+        guard lowerPeer.hasPrefix("nostr") else { return false }
+
+        if let mapped = nostrKeyMapping[peerID]?.lowercased(),
+           let gh = currentGeohash,
+           let myIdentity = try? NostrIdentityBridge.deriveIdentity(forGeohash: gh) {
+            if mapped == myIdentity.publicKeyHex.lowercased() { return true }
+        }
+
+        if let gh = currentGeohash,
+           let myIdentity = try? NostrIdentityBridge.deriveIdentity(forGeohash: gh) {
+            let myLower = myIdentity.publicKeyHex.lowercased()
+            let shortLen = TransportConfig.nostrShortKeyDisplayLength
+            let shortKey = "nostr:" + myLower.prefix(shortLen)
+            if lowerPeer == shortKey { return true }
+            let suffix = myIdentity.publicKeyHex.suffix(4)
+            let expected = (nickname + "#" + suffix).lowercased()
+            if let display = displayName?.lowercased(), display == expected { return true }
+        }
+
+        return false
+    }
+
     private func startGeoParticipantsTimer() {
         stopGeoParticipantsTimer()
         geoParticipantsTimer = Timer.scheduledTimer(withTimeInterval: 30.0, repeats: true) { [weak self] _ in
@@ -3088,8 +3137,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         // Clear persistent favorites from keychain
         FavoritesPersistenceService.shared.clearAllFavorites()
         
-        // Clear identity data from secure storage
-        identityManager.clearAllIdentityData()
+        // Identity manager has cleared persisted identity data above
         
         // Clear autocomplete state
         autocompleteSuggestions.removeAll()
@@ -3119,6 +3167,9 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         // Disconnect from all peers and clear persistent identity
         // This will force creation of a new identity (new fingerprint) on next launch
         meshService.emergencyDisconnectAll()
+        if let bleService = meshService as? BLEService {
+            bleService.resetIdentityForPanic(currentNickname: nickname)
+        }
         
         // No need to force UserDefaults synchronization
         

bitchat/Views/ContentView.swift

@@ -462,7 +462,12 @@ struct ContentView: View {
                         selectedMessageSender = viewModel.messages.last(where: { $0.senderPeerID == peerID && $0.sender != "system" })?.sender
                     }
                 }
-                showMessageActions = true
+                if viewModel.isSelfSender(peerID: selectedMessageSenderID, displayName: selectedMessageSender) {
+                    selectedMessageSender = nil
+                    selectedMessageSenderID = nil
+                } else {
+                    showMessageActions = true
+                }
             }
             .onOpenURL { url in
                 guard url.scheme == "bitchat", url.host == "geohash" else { return }

bitchat/Views/LocationChannelsSheet.swift

@@ -9,6 +9,7 @@ struct LocationChannelsSheet: View {
     @Binding var isPresented: Bool
     @ObservedObject private var manager = LocationChannelManager.shared
     @ObservedObject private var bookmarks = GeohashBookmarksStore.shared
+    @ObservedObject private var network = NetworkActivationService.shared
     @EnvironmentObject var viewModel: ChatViewModel
     @Environment(\.colorScheme) var colorScheme
     @State private var customGeohash: String = ""
@@ -266,6 +267,7 @@ struct LocationChannelsSheet: View {
 
             // Footer action inside the list
             if manager.permissionState == LocationChannelManager.PermissionState.authorized {
+                torToggleSection
                 Button(action: {
                     openSystemLocationSettings()
                 }) {
@@ -409,8 +411,36 @@ struct LocationChannelsSheet: View {
     }
 }
 
-// MARK: - Standardized Colors
+// MARK: - TOR Toggle & Standardized Colors
 extension LocationChannelsSheet {
+    private var torToggleBinding: Binding<Bool> {
+        Binding(
+            get: { network.userTorEnabled },
+            set: { network.setUserTorEnabled($0) }
+        )
+    }
+
+    private var torToggleSection: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Toggle(isOn: torToggleBinding) {
+                VStack(alignment: .leading, spacing: 2) {
+                    Text("tor routing")
+                        .font(.system(size: 12, weight: .semibold, design: .monospaced))
+                        .foregroundColor(.primary)
+                    Text("hides your ip for location channels. recommended: on.")
+                        .font(.system(size: 11, design: .monospaced))
+                        .foregroundColor(.secondary)
+                }
+            }
+            .toggleStyle(IRCToggleStyle(accent: standardGreen))
+        }
+        .padding(12)
+        .background(Color.secondary.opacity(0.12))
+        .cornerRadius(8)
+        .listRowSeparator(.hidden)
+        .listRowBackground(Color.clear)
+    }
+
     private var standardGreen: Color {
         (colorScheme == .dark) ? Color.green : Color(red: 0, green: 0.5, blue: 0)
     }
@@ -419,6 +449,34 @@ extension LocationChannelsSheet {
     }
 }
 
+private struct IRCToggleStyle: ToggleStyle {
+    let accent: Color
+
+    func makeBody(configuration: Configuration) -> some View {
+        Button(action: { configuration.isOn.toggle() }) {
+            HStack(spacing: 12) {
+                configuration.label
+                Spacer()
+                Text(configuration.isOn ? "on" : "off")
+                    .textCase(.uppercase)
+                    .font(.system(size: 12, weight: .semibold, design: .monospaced))
+                    .foregroundColor(configuration.isOn ? accent : .secondary)
+                    .padding(.vertical, 4)
+                    .padding(.horizontal, 10)
+                    .background(
+                        RoundedRectangle(cornerRadius: 6)
+                            .fill(accent.opacity(configuration.isOn ? 0.18 : 0.08))
+                    )
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 6)
+                            .stroke(accent.opacity(configuration.isOn ? 0.35 : 0.15), lineWidth: 1)
+                    )
+            }
+        }
+        .buttonStyle(.plain)
+    }
+}
+
 // MARK: - Coverage helpers
 extension LocationChannelsSheet {
     private func coverageString(forPrecision len: Int) -> String {