Limit PhotosPicker to iOS only to fix CI

PhotosPickerItem has SDK availability issues on macOS in CI.
Change PhotosPicker from canImport(PhotosUI) to os(iOS) only.

macOS users can still import images via file importer (.fileImporter).
This is actually cleaner as macOS file picker is more familiar to users.

Fixes CI build failures.

Justfile

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

bitchat/BitchatApp.swift

@@ -221,7 +221,7 @@ final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
             // Get peer ID from userInfo
             if let peerID = userInfo["peerID"] as? String {
                 DispatchQueue.main.async {
-                    self.chatViewModel?.startPrivateChat(with: PeerID(str: peerID))
+                    self.chatViewModel?.startPrivateChat(with: peerID)
                 }
             }
         }

bitchat/Noise/NoiseProtocol.swift

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

bitchat/Noise/NoiseRateLimiter.swift

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

bitchat/Noise/NoiseSecurityConsiderations.swift

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

bitchat/Noise/NoiseSecurityConstants.swift

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

bitchat/Noise/NoiseSecurityError.swift

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

bitchat/Noise/NoiseSecurityValidator.swift

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

bitchat/Noise/NoiseSession.swift

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

bitchat/Noise/NoiseSessionError.swift

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

bitchat/Noise/NoiseSessionManager.swift

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

bitchat/Noise/SecureNoiseSession.swift

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

bitchat/Nostr/GeoRelayDirectory.swift

@@ -33,32 +33,13 @@ final class GeoRelayDirectory {
 
     /// Returns up to `count` relay URLs (wss://) closest to the given coordinate.
     func closestRelays(toLat lat: Double, lon: Double, count: Int = 5) -> [String] {
-        guard !entries.isEmpty, count > 0 else { return [] }
+        guard !entries.isEmpty else { return [] }
-
+        let sorted = entries
-        if entries.count <= count {
-            return entries
             .sorted { a, b in
                 haversineKm(lat, lon, a.lat, a.lon) < haversineKm(lat, lon, b.lat, b.lon)
             }
-                .map { "wss://\($0.host)" }
+            .prefix(count)
-        }
+        return sorted.map { "wss://\($0.host)" }
-
-        var best: [(entry: Entry, distance: Double)] = []
-        best.reserveCapacity(count)
-
-        for entry in entries {
-            let distance = haversineKm(lat, lon, entry.lat, entry.lon)
-            if best.count < count {
-                let idx = best.firstIndex { $0.distance > distance } ?? best.count
-                best.insert((entry, distance), at: idx)
-            } else if let worstDistance = best.last?.distance, distance < worstDistance {
-                let idx = best.firstIndex { $0.distance > distance } ?? best.count
-                best.insert((entry, distance), at: idx)
-                best.removeLast()
-            }
-        }
-
-        return best.map { "wss://\($0.entry.host)" }
     }
 
     // MARK: - Remote Fetch

bitchat/Services/BLEService.swift

@@ -728,7 +728,7 @@ final class BLEService: NSObject {
         switch MessageType(rawValue: type) {
         case .noiseEncrypted, .noiseHandshake:
             return true
-        case .none, .announce, .message, .leave, .requestSync, .fragment, .fileTransfer:
+        default:
             return false
         }
     }
@@ -1142,19 +1142,9 @@ final class BLEService: NSObject {
 
             // Check cumulative size before storing this fragment
             let currentSize = incomingFragments[key]?.values.reduce(0) { $0 + $1.count } ?? 0
-            let assemblyLimit: Int = {
+            guard currentSize + fragmentData.count <= FileTransferLimits.maxPayloadBytes else {
-                if originalType == MessageType.fileTransfer.rawValue {
-                    // Allow headroom for TLV metadata and binary framing overhead.
-                    return FileTransferLimits.maxFramedFileBytes
-                }
-                return FileTransferLimits.maxPayloadBytes
-            }()
-            guard currentSize + fragmentData.count <= assemblyLimit else {
                 // Exceeds size limit - evict this assembly
-                SecureLogger.warning(
+                SecureLogger.warning("🚫 Fragment assembly exceeds size limit (\(currentSize + fragmentData.count) bytes), evicting", category: .security)
-                    "🚫 Fragment assembly exceeds size limit (\(currentSize + fragmentData.count) bytes > \(assemblyLimit)), evicting",
-                    category: .security
-                )
                 incomingFragments.removeValue(forKey: key)
                 fragmentMetadata.removeValue(forKey: key)
                 shouldReassemble = false
@@ -1281,7 +1271,7 @@ final class BLEService: NSObject {
         case .leave:
             handleLeave(packet, from: PeerID(str: senderID))
             
-        case .none:
+        default:
             SecureLogger.warning("⚠️ Unknown message type: \(packet.type)", category: .session)
             break
         }
@@ -3540,13 +3530,10 @@ extension BLEService {
         case .fragment:
             handleFragment(packet, from: senderID)
             
-        case .fileTransfer:
-            handleFileTransfer(packet, from: senderID.id)
-            
         case .leave:
             handleLeave(packet, from: senderID)
             
-        case .none:
+        default:
             SecureLogger.warning("⚠️ Unknown message type: \(packet.type)", category: .session)
             break
         }
@@ -3814,20 +3801,18 @@ extension BLEService {
 
         var accepted = false
         var senderNickname: String = ""
-        // Snapshot peers to avoid concurrent mutation while iterating during nickname collision checks.
-        let peersSnapshot = collectionsQueue.sync { peers }
 
         // If the packet is from ourselves (e.g., recovered via sync TTL==0), accept immediately
         if peerID == myPeerID {
             accepted = true
             senderNickname = myNickname
         }
-        else if let info = peersSnapshot[peerID], info.isVerifiedNickname {
+        else if let info = peers[peerID], info.isVerifiedNickname {
             // Known verified peer path
             accepted = true
             senderNickname = info.nickname
             // Handle nickname collisions
-            let hasCollision = peersSnapshot.values.contains { $0.isConnected && $0.nickname == info.nickname && $0.peerID != peerID } || (myNickname == info.nickname)
+            let hasCollision = peers.values.contains { $0.isConnected && $0.nickname == info.nickname && $0.peerID != peerID } || (myNickname == info.nickname)
             if hasCollision {
                 senderNickname += "#" + String(peerID.id.prefix(4))
             }
@@ -3974,7 +3959,7 @@ extension BLEService {
                 notifyUI { [weak self] in
                     self?.delegate?.didReceiveNoisePayload(from: peerID, type: .verifyResponse, payload: Data(payloadData), timestamp: ts)
                 }
-            case .none:
+            default:
                 SecureLogger.warning("⚠️ Unknown noise payload type: \(payloadType)")
             }
         } catch NoiseEncryptionError.sessionNotEstablished {

bitchat/Services/CommandProcessor.swift

@@ -65,6 +65,9 @@ final class CommandProcessor {
         case "/unfav":
             if inGeoPublic || inGeoDM { return .error(message: "favorites are only for mesh peers in #mesh") }
             return handleFavorite(args, add: false)
+        //
+        case "/help", "/h":
+            return .error(message: "unknown command: \(cmd)")
         default:
             return .error(message: "unknown command: \(cmd)")
         }
@@ -145,9 +148,9 @@ final class CommandProcessor {
         
         if chatViewModel?.selectedPrivateChatPeer != nil {
             // In private chat
-            if let peerNickname = meshService?.peerNickname(peerID: targetPeerID) {
+            if let peerNickname = meshService?.peerNickname(peerID: PeerID(str: targetPeerID)) {
                 let personalMessage = "* \(emoji) \(myNickname) \(action) you\(suffix) *"
-                meshService?.sendPrivateMessage(personalMessage, to: targetPeerID,
+                meshService?.sendPrivateMessage(personalMessage, to: PeerID(str: targetPeerID),
                                                recipientNickname: peerNickname,
                                                messageID: UUID().uuidString)
                 // Also add a local system message so the sender sees a natural-language confirmation
@@ -211,7 +214,7 @@ final class CommandProcessor {
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
         if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-           let fingerprint = meshService?.getFingerprint(for: peerID) {
+           let fingerprint = meshService?.getFingerprint(for: PeerID(str: peerID)) {
             if identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is already blocked")
             }
@@ -255,7 +258,7 @@ final class CommandProcessor {
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
         if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-           let fingerprint = meshService?.getFingerprint(for: peerID) {
+           let fingerprint = meshService?.getFingerprint(for: PeerID(str: peerID)) {
             if !identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is not blocked")
             }
@@ -282,7 +285,7 @@ final class CommandProcessor {
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
         guard let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-              let noisePublicKey = Data(hexString: peerID.id) else {
+              let noisePublicKey = Data(hexString: peerID) else {
             return .error(message: "can't find peer: \(nickname)")
         }
         
@@ -308,4 +311,19 @@ final class CommandProcessor {
         }
     }
     
+    private func handleHelp() -> CommandResult {
+        let helpText = """
+        commands:
+        /msg @name - start private chat
+        /who - list who's online
+        /clear - clear messages
+        /hug @name - send a hug
+        /slap @name - slap with a trout
+        /fav @name - add to favorites
+        /unfav @name - remove from favorites
+        /block @name - block
+        /unblock @name - unblock
+        """
+        return .success(message: helpText)
+    }
 }

bitchat/Services/GeohashBookmarksStore.swift

@@ -216,4 +216,15 @@ final class GeohashBookmarksStore: ObservableObject {
         }
     }
     #endif
+
+    #if DEBUG
+    /// Testing-only reset helper
+    func _resetForTesting() {
+        bookmarks.removeAll()
+        membership.removeAll()
+        bookmarkNames.removeAll()
+        persist()
+        persistNames()
+    }
+    #endif
 }

bitchat/Services/KeychainManager.swift

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

bitchat/Services/LocationChannelManager.swift

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

bitchat/Services/NotificationStreamAssembler.swift

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

bitchat/Services/UnifiedPeerService.swift

@@ -235,10 +235,10 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     }
     
     /// Get peer ID for nickname
-    func getPeerID(for nickname: String) -> PeerID? {
+    func getPeerID(for nickname: String) -> String? {
         for peer in peers {
             if peer.displayName == nickname || peer.nickname == nickname {
-                return peer.peerID
+                return peer.peerID.id
             }
         }
         return nil
@@ -347,7 +347,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     // MARK: - Compatibility Methods (for easy migration)
     
     var allPeers: [BitchatPeer] { peers }
-    var connectedPeers: Set<PeerID> { connectedPeerIDs }
+    var connectedPeers: [PeerID] { Array(connectedPeerIDs) }
     var favoritePeers: Set<String> {
         Set(favorites.compactMap { getFingerprint(for: $0.peerID) })
     }

bitchat/Utils/FileTransferLimits.swift

@@ -8,16 +8,6 @@ enum FileTransferLimits {
     static let maxVoiceNoteBytes: Int = 1 * 1024 * 1024 // 1 MiB
     /// Compressed images after downscaling should comfortably fit under this budget.
     static let maxImageBytes: Int = 1 * 1024 * 1024 // 1 MiB
-    /// Worst-case size once TLV metadata and binary packet framing are included for the largest payloads.
-    static let maxFramedFileBytes: Int = {
-        let maxMetadataBytes = Int(UInt16.max) * 2 // fileName + mimeType TLVs
-        let tlvEnvelopeOverhead = 18 + maxMetadataBytes // TLV tags + lengths + metadata bytes
-        let binaryEnvelopeOverhead = BinaryProtocol.v2HeaderSize
-            + BinaryProtocol.senderIDSize
-            + BinaryProtocol.recipientIDSize
-            + BinaryProtocol.signatureSize
-        return maxPayloadBytes + tlvEnvelopeOverhead + binaryEnvelopeOverhead
-    }()
 
     static func isValidPayload(_ size: Int) -> Bool {
         size <= maxPayloadBytes

bitchat/Views/ContentView.swift

@@ -207,7 +207,7 @@ struct ContentView: View {
             set: { _ in viewModel.showingFingerprintFor = nil }
         )) {
             if let peerID = viewModel.showingFingerprintFor {
-                FingerprintView(viewModel: viewModel, peerID: peerID.id)
+                FingerprintView(viewModel: viewModel, peerID: peerID)
             }
         }
 #if os(iOS)
@@ -262,11 +262,11 @@ struct ContentView: View {
             Button("content.actions.direct_message") {
                 if let peerID = selectedMessageSenderID {
                     if peerID.hasPrefix("nostr:") {
-                        if let full = viewModel.fullNostrHex(forSenderPeerID: PeerID(str: peerID)) {
+                        if let full = viewModel.fullNostrHex(forSenderPeerID: peerID) {
                             viewModel.startGeohashDM(withPubkeyHex: full)
                         }
                     } else {
-                        viewModel.startPrivateChat(with: PeerID(str: peerID))
+                        viewModel.startPrivateChat(with: peerID)
                     }
                     withAnimation(.easeInOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
                         showSidebar = true
@@ -289,7 +289,7 @@ struct ContentView: View {
             Button("content.actions.block", role: .destructive) {
                 // Prefer direct geohash block when we have a Nostr sender ID
                 if let peerID = selectedMessageSenderID, peerID.hasPrefix("nostr:"),
-                   let full = viewModel.fullNostrHex(forSenderPeerID: PeerID(str: peerID)),
+                   let full = viewModel.fullNostrHex(forSenderPeerID: peerID),
                    let sender = selectedMessageSender {
                     viewModel.blockGeohashUser(pubkeyHexLowercased: full, displayName: sender)
                 } else if let sender = selectedMessageSender {
@@ -322,8 +322,8 @@ struct ContentView: View {
     
     private func messagesView(privatePeer: String?, isAtBottom: Binding<Bool>) -> some View {
         let messages: [BitchatMessage] = {
-            if let peerID = PeerID(str: privatePeer) {
+            if let privatePeer = privatePeer {
-                return viewModel.getPrivateChatMessages(for: peerID)
+                return viewModel.getPrivateChatMessages(for: privatePeer)
             }
             return viewModel.messages
         }()
@@ -517,7 +517,7 @@ struct ContentView: View {
             }
             .onAppear {
                 // Also check when view appears
-                if let peerID = PeerID(str: privatePeer) {
+                if let peerID = privatePeer {
                     // Try multiple times to ensure read receipts are sent
                     viewModel.markPrivateMessagesAsRead(from: peerID)
                     
@@ -765,63 +765,34 @@ struct ContentView: View {
     }
 
     private func handleOpenURL(_ url: URL) {
-        guard url.scheme == "bitchat" else { return }
+        guard url.scheme == "bitchat", url.host == "user" else { return }
-        switch url.host {
-        case "user":
         let id = url.path.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
-            let peerID = PeerID(str: id.removingPercentEncoding ?? id)
+        let peerID = id.removingPercentEncoding ?? id
-            selectedMessageSenderID = peerID.id
+        selectedMessageSenderID = peerID
 
-            if peerID.isGeoDM || peerID.isGeoChat {
+        if peerID.hasPrefix("nostr") {
             selectedMessageSender = viewModel.geohashDisplayName(for: peerID)
-            } else if let name = viewModel.meshService.peerNickname(peerID: peerID) {
+        } else {
+            if let name = viewModel.meshService.peerNickname(peerID: PeerID(str: peerID)) {
                 selectedMessageSender = name
             } else {
                 selectedMessageSender = viewModel.messages.last(where: { $0.senderPeerID == peerID && $0.sender != "system" })?.sender
             }
+        }
 
-            if viewModel.isSelfSender(peerID: peerID, displayName: selectedMessageSender) {
+        if viewModel.isSelfSender(peerID: selectedMessageSenderID, displayName: selectedMessageSender) {
             selectedMessageSender = nil
             selectedMessageSenderID = nil
         } else {
             showMessageActions = true
         }
-
-        case "geohash":
-            let gh = url.path.trimmingCharacters(in: CharacterSet(charactersIn: "/")).lowercased()
-            let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
-            guard (2...12).contains(gh.count), gh.allSatisfy({ allowed.contains($0) }) else { return }
-
-            func levelForLength(_ len: Int) -> GeohashChannelLevel {
-                switch len {
-                case 0...2: return .region
-                case 3...4: return .province
-                case 5: return .city
-                case 6: return .neighborhood
-                case 7: return .block
-                default: return .block
-                }
-            }
-
-            let level = levelForLength(gh.count)
-            let channel = GeohashChannel(level: level, geohash: gh)
-
-            let inRegional = LocationChannelManager.shared.availableChannels.contains { $0.geohash == gh }
-            if !inRegional && !LocationChannelManager.shared.availableChannels.isEmpty {
-                LocationChannelManager.shared.markTeleported(for: gh, true)
-            }
-            LocationChannelManager.shared.select(ChannelID.location(channel))
-
-        default:
-            return
-        }
     }
 
     private func scrollToBottom(on proxy: ScrollViewProxy,
                                 privatePeer: String?,
                                 isAtBottom: Binding<Bool>) {
         let targetID: String? = {
-            if let peer = PeerID(str: privatePeer),
+            if let peer = privatePeer,
                let last = viewModel.getPrivateChatMessages(for: peer).suffix(300).last?.id {
                 return "dm:\(peer)|\(last)"
             }
@@ -831,41 +802,17 @@ struct ContentView: View {
                 case .location(let ch): return "geo:\(ch.geohash)"
                 }
             }()
-            if let last = viewModel.messages.suffix(300).last?.id {
+            if let last = viewModel.messages.suffix(300).last?.id { return "\(contextKey)|\(last)" }
-                return "\(contextKey)|\(last)"
-            }
             return nil
         }()
 
         isAtBottom.wrappedValue = true
-
+        guard let target = targetID else { return }
         DispatchQueue.main.async {
-            if let targetID {
+            proxy.scrollTo(target, anchor: .bottom)
-                proxy.scrollTo(targetID, anchor: .bottom)
-            }
-        }
-
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
-            let secondTarget: String? = {
-                if let peer = PeerID(str: privatePeer),
-                   let last = viewModel.getPrivateChatMessages(for: peer).suffix(300).last?.id {
-                    return "dm:\(peer)|\(last)"
-                }
-                let contextKey: String = {
-                    switch locationManager.selectedChannel {
-                    case .mesh: return "mesh"
-                    case .location(let ch): return "geo:\(ch.geohash)"
-                    }
-                }()
-                if let last = viewModel.messages.suffix(300).last?.id {
-                    return "\(contextKey)|\(last)"
-                }
-                return nil
-            }()
-
-            if let secondTarget {
-                proxy.scrollTo(secondTarget, anchor: .bottom)
         }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+            proxy.scrollTo(target, anchor: .bottom)
         }
     }
     // MARK: - Actions
@@ -984,14 +931,14 @@ struct ContentView: View {
                             textColor: textColor,
                             secondaryTextColor: secondaryTextColor,
                             onTapPeer: { peerID in
-                                viewModel.startPrivateChat(with: PeerID(str: peerID))
+                                viewModel.startPrivateChat(with: peerID)
                                 showSidebar = true
                             },
                             onToggleFavorite: { peerID in
-                                viewModel.toggleFavorite(peerID: PeerID(str: peerID))
+                                viewModel.toggleFavorite(peerID: peerID)
                             },
                             onShowFingerprint: { peerID in
-                                viewModel.showFingerprint(for: PeerID(str: peerID))
+                                viewModel.showFingerprint(for: peerID)
                             }
                         )
                     }
@@ -1030,20 +977,18 @@ struct ContentView: View {
 
                     HStack(spacing: 8) {
                         privateHeaderInfo(context: headerContext, privatePeerID: privatePeerID)
-                        let peerID = PeerID(str: headerContext.headerPeerID)
-                        let isFavorite = viewModel.isFavorite(peerID: peerID)
 
                         if !privatePeerID.hasPrefix("nostr_") {
                             Button(action: {
-                                viewModel.toggleFavorite(peerID: peerID)
+                                viewModel.toggleFavorite(peerID: headerContext.headerPeerID)
                             }) {
-                                Image(systemName: isFavorite ? "star.fill" : "star")
+                                Image(systemName: viewModel.isFavorite(peerID: headerContext.headerPeerID) ? "star.fill" : "star")
                                     .font(.bitchatSystem(size: 14))
-                                    .foregroundColor(isFavorite ? Color.yellow : textColor)
+                                    .foregroundColor(viewModel.isFavorite(peerID: headerContext.headerPeerID) ? Color.yellow : textColor)
                             }
                             .buttonStyle(.plain)
                             .accessibilityLabel(
-                                isFavorite
+                                viewModel.isFavorite(peerID: headerContext.headerPeerID)
                                 ? String(localized: "content.accessibility.remove_favorite", comment: "Accessibility label to remove a favorite")
                                 : String(localized: "content.accessibility.add_favorite", comment: "Accessibility label to add a favorite")
                             )
@@ -1098,7 +1043,7 @@ struct ContentView: View {
 
     private func privateHeaderInfo(context: PrivateHeaderContext, privatePeerID: String) -> some View {
         Button(action: {
-            viewModel.showFingerprint(for: PeerID(str: context.headerPeerID))
+            viewModel.showFingerprint(for: context.headerPeerID)
         }) {
             HStack(spacing: 6) {
                 if let connectionState = context.peer?.connectionState {
@@ -1131,7 +1076,7 @@ struct ContentView: View {
                         .font(.bitchatSystem(size: 14))
                         .foregroundColor(.purple)
                         .accessibilityLabel(String(localized: "content.accessibility.available_nostr", comment: "Accessibility label for Nostr-available peer indicator"))
-                } else if viewModel.meshService.isPeerConnected(PeerID(str: context.headerPeerID)) || viewModel.connectedPeers.contains(PeerID(str: context.headerPeerID)) {
+                } else if viewModel.meshService.isPeerConnected(PeerID(str: context.headerPeerID)) || viewModel.connectedPeers.contains(context.headerPeerID) {
                     Image(systemName: "dot.radiowaves.left.and.right")
                         .font(.bitchatSystem(size: 14))
                         .foregroundColor(textColor)
@@ -1145,11 +1090,11 @@ struct ContentView: View {
                 if !privatePeerID.hasPrefix("nostr_") {
                     let statusPeerID: String = {
                         if privatePeerID.count == 64, let short = viewModel.getShortIDForNoiseKey(privatePeerID) {
-                            return short.id
+                            return short
                         }
                         return context.headerPeerID
                     }()
-                    let encryptionStatus = viewModel.getEncryptionStatus(for: PeerID(str: statusPeerID))
+                    let encryptionStatus = viewModel.getEncryptionStatus(for: statusPeerID)
                     if let icon = encryptionStatus.icon {
                         Image(systemName: icon)
                             .font(.bitchatSystem(size: 14))
@@ -1184,16 +1129,16 @@ struct ContentView: View {
     private func makePrivateHeaderContext(for privatePeerID: String) -> PrivateHeaderContext {
         let headerPeerID: String = {
             if privatePeerID.count == 64, let short = viewModel.getShortIDForNoiseKey(privatePeerID) {
-                return short.id
+                return short
             }
             return privatePeerID
         }()
 
-        let peer = viewModel.getPeer(byID: PeerID(str: headerPeerID))
+        let peer = viewModel.getPeer(byID: headerPeerID)
 
         let displayName: String = {
             if privatePeerID.hasPrefix("nostr_"), case .location(let ch) = locationManager.selectedChannel {
-                let disp = viewModel.geohashDisplayName(for: PeerID(str: privatePeerID))
+                let disp = viewModel.geohashDisplayName(for: privatePeerID)
                 return "#\(ch.geohash)/@\(disp)"
             }
             if let name = peer?.displayName { return name }
@@ -1646,7 +1591,7 @@ private extension ContentView {
                     isSending = true
                     progress = Double(reached) / Double(total)
                 }
-            case .sent, .read, .delivered, .failed:
+            default:
                 break
             }
         }

bitchat/Views/FingerprintView.swift

@@ -66,12 +66,12 @@ struct FingerprintView: View {
             VStack(alignment: .leading, spacing: 16) {
                 // Prefer short mesh ID for session/encryption status
                 let statusPeerID: String = {
-                    if peerID.count == 64, let short = viewModel.getShortIDForNoiseKey(peerID) { return short.id }
+                    if peerID.count == 64, let short = viewModel.getShortIDForNoiseKey(peerID) { return short }
                     return peerID
                 }()
                 // Resolve a friendly name
                 let peerNickname: String = {
-                    if let p = viewModel.getPeer(byID: PeerID(str: statusPeerID)) { return p.displayName }
+                    if let p = viewModel.getPeer(byID: statusPeerID) { return p.displayName }
                     if let name = viewModel.meshService.peerNickname(peerID: PeerID(str: statusPeerID)) { return name }
                     if peerID.count == 64, let data = Data(hexString: peerID) {
                         if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: data), !fav.peerNickname.isEmpty { return fav.peerNickname }
@@ -84,7 +84,7 @@ struct FingerprintView: View {
                     return Strings.unknownPeer()
                 }()
                 // Accurate encryption state based on short ID session
-                let encryptionStatus = viewModel.getEncryptionStatus(for: PeerID(str: statusPeerID))
+                let encryptionStatus = viewModel.getEncryptionStatus(for: statusPeerID)
                 
                 HStack {
                     if let icon = encryptionStatus.icon {
@@ -115,7 +115,7 @@ struct FingerprintView: View {
                         .font(.bitchatSystem(size: 12, weight: .bold, design: .monospaced))
                         .foregroundColor(textColor.opacity(0.7))
                     
-                    if let fingerprint = viewModel.getFingerprint(for: PeerID(str: statusPeerID)) {
+                    if let fingerprint = viewModel.getFingerprint(for: statusPeerID) {
                         Text(formatFingerprint(fingerprint))
                             .font(.bitchatSystem(size: 14, design: .monospaced))
                             .foregroundColor(textColor)
@@ -176,7 +176,6 @@ struct FingerprintView: View {
                 // Verification status
                 if encryptionStatus == .noiseSecured || encryptionStatus == .noiseVerified {
                     let isVerified = encryptionStatus == .noiseVerified
-                    let peerID = PeerID(str: peerID)
                     
                     VStack(spacing: 12) {
                         Text(isVerified ? Strings.verifiedBadge : Strings.notVerifiedBadge)

bitchat/Views/LocationChannelsSheet.swift

@@ -599,7 +599,7 @@ extension LocationChannelsSheet {
         switch level {
         case .region:
             return ""
-        case .building, .block, .neighborhood, .city, .province:
+        default:
             return "~"
         }
     }

bitchat/Views/MeshPeerList.swift

@@ -21,8 +21,8 @@ struct MeshPeerList: View {
         let myPeerID = viewModel.meshService.myPeerID
         let mapped: [(peer: BitchatPeer, isMe: Bool, hasUnread: Bool, enc: EncryptionStatus)] = viewModel.allPeers.map { peer in
             let isMe = peer.peerID == myPeerID
-            let hasUnread = viewModel.hasUnreadMessages(for: peer.peerID)
+            let hasUnread = viewModel.hasUnreadMessages(for: peer.peerID.id)
-            let enc = viewModel.getEncryptionStatus(for: peer.peerID)
+            let enc = viewModel.getEncryptionStatus(for: peer.peerID.id)
             return (peer, isMe, hasUnread, enc)
         }
         // Stable visual order without mutating state here
@@ -47,7 +47,7 @@ struct MeshPeerList: View {
                     let peer = item.peer
                     let isMe = item.isMe
                     HStack(spacing: 4) {
-                        let assigned = viewModel.colorForMeshPeer(id: peer.peerID, isDark: colorScheme == .dark)
+                        let assigned = viewModel.colorForMeshPeer(id: peer.peerID.id, isDark: colorScheme == .dark)
                         let baseColor = isMe ? Color.orange : assigned
                         if isMe {
                             Image(systemName: "person.fill")
@@ -89,7 +89,7 @@ struct MeshPeerList: View {
                             }
                         }
 
-                        if !isMe, viewModel.isPeerBlocked(peer.peerID) {
+                        if !isMe, viewModel.isPeerBlocked(peer.peerID.id) {
                             Image(systemName: "nosign")
                                 .font(.bitchatSystem(size: 10))
                                 .foregroundColor(.red)
@@ -105,7 +105,7 @@ struct MeshPeerList: View {
                                 }
                             } else {
                                 // Offline: prefer showing verified badge from persisted fingerprints
-                                if let fp = viewModel.getFingerprint(for: peer.peerID),
+                                if let fp = viewModel.getFingerprint(for: peer.peerID.id),
                                    viewModel.verifiedFingerprints.contains(fp) {
                                     Image(systemName: "checkmark.seal.fill")
                                         .font(.bitchatSystem(size: 10))

bitchat/Views/VerificationViews.swift

@@ -373,7 +373,7 @@ struct VerificationSheetView: View {
                 }
 
                 // Optional: Remove verification for selected peer (if verified)
-                if let pid = viewModel.selectedPrivateChatPeer,
+                if let pid = viewModel.selectedPrivateChatPeer?.id,
                    let fp = viewModel.getFingerprint(for: pid),
                    viewModel.verifiedFingerprints.contains(fp) {
                     Button(action: { viewModel.unverifyFingerprint(for: pid) }) {

bitchatTests/BLEServiceTests.swift

@@ -6,128 +6,122 @@
 // For more information, see <https://unlicense.org>
 //
 
-import Testing
+import XCTest
 import CoreBluetooth
 @testable import bitchat
 
-struct BLEServiceTests {
+final class BLEServiceTests: XCTestCase {
-    private let service: MockBLEService
-    private let myUUID = UUID()
-    private let bus = MockBLEBus()
     
-    init() {
+    var service: MockBLEService!
-        service = MockBLEService.init(bus: bus)
+    
-        service.myPeerID = PeerID(str: myUUID.uuidString)
+    override func setUp() {
+        super.setUp()
+        service = MockBLEService()
+        service.myPeerID = "TEST1234"
         service.mockNickname = "TestUser"
     }
     
+    override func tearDown() {
+        service = nil
+        super.tearDown()
+    }
+    
     // MARK: - Basic Functionality Tests
     
-    @Test func serviceInitialization() {
+    func testServiceInitialization() {
-        #expect(service.myPeerID == PeerID(str: myUUID.uuidString))
+        XCTAssertNotNil(service)
-        #expect(service.myNickname == "TestUser")
+        XCTAssertEqual(service.myPeerID, "TEST1234")
+        XCTAssertEqual(service.myNickname, "TestUser")
     }
     
-    @Test func peerConnection() {
+    func testPeerConnection() {
-        let somePeerID = PeerID(str: UUID().uuidString)
+        // Test connecting a peer
+        service.simulateConnectedPeer("PEER5678")
+        XCTAssertTrue(service.isPeerConnected("PEER5678"))
+        XCTAssertEqual(service.getConnectedPeers().count, 1)
         
-        service.simulateConnectedPeer(somePeerID)
+        // Test disconnecting a peer
-        #expect(service.isPeerConnected(somePeerID))
+        service.simulateDisconnectedPeer("PEER5678")
-        #expect(service.getConnectedPeers().count == 1)
+        XCTAssertFalse(service.isPeerConnected("PEER5678"))
-        
+        XCTAssertEqual(service.getConnectedPeers().count, 0)
-        service.simulateDisconnectedPeer(somePeerID)
-        #expect(!service.isPeerConnected(somePeerID))
-        #expect(service.getConnectedPeers().count == 0)
     }
     
-    @Test func multiplePeerConnections() {
+    func testMultiplePeerConnections() {
-        let peerID1 = PeerID(str: UUID().uuidString)
+        service.simulateConnectedPeer("PEER1")
-        let peerID2 = PeerID(str: UUID().uuidString)
+        service.simulateConnectedPeer("PEER2")
-        let peerID3 = PeerID(str: UUID().uuidString)
+        service.simulateConnectedPeer("PEER3")
         
-        service.simulateConnectedPeer(peerID1)
+        XCTAssertEqual(service.getConnectedPeers().count, 3)
-        service.simulateConnectedPeer(peerID2)
+        XCTAssertTrue(service.isPeerConnected("PEER1"))
-        service.simulateConnectedPeer(peerID3)
+        XCTAssertTrue(service.isPeerConnected("PEER2"))
+        XCTAssertTrue(service.isPeerConnected("PEER3"))
         
-        #expect(service.getConnectedPeers().count == 3)
+        service.simulateDisconnectedPeer("PEER2")
-        #expect(service.isPeerConnected(peerID1))
+        XCTAssertEqual(service.getConnectedPeers().count, 2)
-        #expect(service.isPeerConnected(peerID2))
+        XCTAssertFalse(service.isPeerConnected("PEER2"))
-        #expect(service.isPeerConnected(peerID3))
-        
-        service.simulateDisconnectedPeer(peerID2)
-        #expect(service.getConnectedPeers().count == 2)
-        #expect(!service.isPeerConnected(peerID2))
     }
     
     // MARK: - Message Sending Tests
     
-    @Test func sendPublicMessage() async throws {
+    func testSendPublicMessage() {
-        try await confirmation { receivedPublicMessage in
+        let expectation = XCTestExpectation(description: "Message sent")
+        
         let delegate = MockBitchatDelegate { message in
-                #expect(message.content == "Hello, world!")
+            XCTAssertEqual(message.content, "Hello, world!")
-                #expect(message.sender == "TestUser")
+            XCTAssertEqual(message.sender, "TestUser")
-                #expect(!message.isPrivate)
+            XCTAssertFalse(message.isPrivate)
-                receivedPublicMessage()
+            expectation.fulfill()
         }
         service.delegate = delegate
+        
         service.sendMessage("Hello, world!")
         
-            // Allow async processing
+        wait(for: [expectation], timeout: 1.0)
-            try await sleep(0.5)
+        XCTAssertEqual(service.sentMessages.count, 1)
-        }
-        #expect(service.sentMessages.count == 1)
     }
     
-    @Test func sendPrivateMessage() async throws {
+    func testSendPrivateMessage() {
-        try await confirmation { receivedPrivateMessage in
+        let expectation = XCTestExpectation(description: "Private message sent")
+        
         let delegate = MockBitchatDelegate { message in
-                #expect(message.content == "Secret message")
+            XCTAssertEqual(message.content, "Secret message")
-                #expect(message.sender == "TestUser")
+            XCTAssertEqual(message.sender, "TestUser")
-                #expect(message.senderPeerID == PeerID(str: myUUID.uuidString))
+            XCTAssertTrue(message.isPrivate)
-                #expect(message.isPrivate)
+            XCTAssertEqual(message.recipientNickname, "Bob")
-                #expect(message.recipientNickname == "Bob")
+            expectation.fulfill()
-                receivedPrivateMessage()
         }
         service.delegate = delegate
-            service.sendPrivateMessage(
-                "Secret message",
-                to: PeerID(str: UUID().uuidString),
-                recipientNickname: "Bob",
-                messageID: "MSG123"
-            )
         
-            // Allow async processing
+        service.sendPrivateMessage("Secret message", to: "PEER5678", recipientNickname: "Bob", messageID: "MSG123")
-            try await sleep(0.5)
+        
-        }
+        wait(for: [expectation], timeout: 1.0)
-        #expect(service.sentMessages.count == 1)
+        XCTAssertEqual(service.sentMessages.count, 1)
     }
     
-    @Test func sendMessageWithMentions() async throws {
+    func testSendMessageWithMentions() {
-        try await confirmation { receivedMessageWithMentions in
+        let expectation = XCTestExpectation(description: "Message with mentions sent")
+        
         let delegate = MockBitchatDelegate { message in
-                #expect(message.content == "@alice @bob check this out")
+            XCTAssertEqual(message.content, "@alice @bob check this out")
-                #expect(message.mentions == ["alice", "bob"])
+            XCTAssertEqual(message.mentions, ["alice", "bob"])
-                receivedMessageWithMentions()
+            expectation.fulfill()
         }
         service.delegate = delegate
+        
         service.sendMessage("@alice @bob check this out", mentions: ["alice", "bob"])
         
-            // Allow async processing
+        wait(for: [expectation], timeout: 1.0)
-            try await sleep(0.5)
-        }
     }
     
     // MARK: - Message Reception Tests
     
-    @Test func simulateIncomingMessage() async throws {
+    func testSimulateIncomingMessage() {
-        try await confirmation { receiveMessage in
+        let expectation = XCTestExpectation(description: "Message received")
-            let peerID = PeerID(str: UUID().uuidString)
         
         let delegate = MockBitchatDelegate { message in
-                #expect(message.content == "Incoming message")
+            XCTAssertEqual(message.content, "Incoming message")
-                #expect(message.sender == "RemoteUser")
+            XCTAssertEqual(message.sender, "RemoteUser")
-                #expect(message.senderPeerID == peerID)
+            expectation.fulfill()
-                receiveMessage()
         }
         service.delegate = delegate
         
@@ -140,24 +134,21 @@ struct BLEServiceTests {
             originalSender: nil,
             isPrivate: false,
             recipientNickname: nil,
-                senderPeerID: peerID,
+            senderPeerID: "REMOTE123",
             mentions: nil
         )
+        
         service.simulateIncomingMessage(incomingMessage)
         
-            // Allow async processing
+        wait(for: [expectation], timeout: 1.0)
-            try await sleep(0.5)
-        }
     }
     
-    @Test func simulateIncomingPacket() async throws {
+    func testSimulateIncomingPacket() {
-        try await confirmation { processPacket in
+        let expectation = XCTestExpectation(description: "Packet processed")
-            let peerID = PeerID(str: UUID().uuidString)
         
         let delegate = MockBitchatDelegate { message in
-                #expect(message.content == "Packet message")
+            XCTAssertEqual(message.content, "Packet message")
-                #expect(message.senderPeerID == peerID)
+            expectation.fulfill()
-                processPacket()
         }
         service.delegate = delegate
         
@@ -170,15 +161,18 @@ struct BLEServiceTests {
             originalSender: nil,
             isPrivate: false,
             recipientNickname: nil,
-                senderPeerID: peerID,
+            senderPeerID: "PACKET123",
             mentions: nil
         )
         
-            let payload = try #require(message.toBinaryPayload(), "Failed to create binary payload")
+        guard let payload = message.toBinaryPayload() else {
+            XCTFail("Failed to create binary payload")
+            return
+        }
         
         let packet = BitchatPacket(
             type: 0x01,
-                senderID: peerID.id.data(using: .utf8)!,
+            senderID: "PACKET123".data(using: .utf8)!,
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -188,61 +182,56 @@ struct BLEServiceTests {
         
         service.simulateIncomingPacket(packet)
         
-            // Allow async processing
+        wait(for: [expectation], timeout: 1.0)
-            try await sleep(0.5)
-        }
     }
     
     // MARK: - Peer Nickname Tests
     
-    @Test func getPeerNicknames() {
+    func testGetPeerNicknames() {
-        let peerID1 = PeerID(str: UUID().uuidString)
+        service.simulateConnectedPeer("PEER1")
-        let peerID2 = PeerID(str: UUID().uuidString)
+        service.simulateConnectedPeer("PEER2")
-
-        service.simulateConnectedPeer(peerID1)
-        service.simulateConnectedPeer(peerID2)
         
         let nicknames = service.getPeerNicknames()
-        #expect(nicknames.count == 2)
+        XCTAssertEqual(nicknames.count, 2)
-        #expect(nicknames[peerID1] == "MockPeer_\(peerID1)")
+        XCTAssertEqual(nicknames["PEER1"], "MockPeer_PEER1")
-        #expect(nicknames[peerID2] == "MockPeer_\(peerID2)")
+        XCTAssertEqual(nicknames["PEER2"], "MockPeer_PEER2")
     }
     
     // MARK: - Service State Tests
     
-    @Test func startStopServices() {
+    func testStartStopServices() {
+        // These are mock implementations, just ensure they don't crash
         service.startServices()
         service.stopServices()
-        let somePeerID = PeerID(str: UUID().uuidString)
+        
-        service.simulateConnectedPeer(somePeerID)
+        // Service should still be functional after start/stop
-        #expect(service.isPeerConnected(somePeerID))
+        service.simulateConnectedPeer("PEER999")
+        XCTAssertTrue(service.isPeerConnected("PEER999"))
     }
     
     // MARK: - Message Delivery Handler Tests
     
-    @Test func messageDeliveryHandler() async throws {
+    func testMessageDeliveryHandler() {
-        try await confirmation { deliveryHandler in
+        let expectation = XCTestExpectation(description: "Delivery handler called")
+        
         service.packetDeliveryHandler = { packet in
             if let msg = BitchatMessage(packet.payload) {
-                    #expect(msg.content == "Test delivery")
+                XCTAssertEqual(msg.content, "Test delivery")
-                    deliveryHandler()
+                expectation.fulfill()
             }
         }
+        
         service.sendMessage("Test delivery")
         
-            // Allow async processing
+        wait(for: [expectation], timeout: 1.0)
-            try await sleep(0.5)
-        }
     }
     
-    @Test func packetDeliveryHandler() async throws {
+    func testPacketDeliveryHandler() {
-        try await confirmation("Packet handler called") { packetHandler in
+        let expectation = XCTestExpectation(description: "Packet handler called")
-            let peerID = PeerID(str: UUID().uuidString)
         
         service.packetDeliveryHandler = { packet in
-                #expect(packet.type == 0x01)
+            XCTAssertEqual(packet.type, 0x01)
-                #expect(packet.senderID == Data(peerID.id.utf8))
+            expectation.fulfill()
-                packetHandler()
         }
         
         let message = BitchatMessage(
@@ -254,15 +243,18 @@ struct BLEServiceTests {
             originalSender: nil,
             isPrivate: false,
             recipientNickname: nil,
-                senderPeerID: peerID,
+            senderPeerID: "TEST123",
             mentions: nil
         )
         
-            let payload = try #require(message.toBinaryPayload(), "Failed to create payload")
+        guard let payload = message.toBinaryPayload() else {
+            XCTFail("Failed to create payload")
+            return
+        }
         
         let packet = BitchatPacket(
             type: 0x01,
-                senderID: peerID.id.data(using: .utf8)!,
+            senderID: "TEST123".data(using: .utf8)!,
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -272,9 +264,7 @@ struct BLEServiceTests {
         
         service.simulateIncomingPacket(packet)
         
-            // Allow async processing
+        wait(for: [expectation], timeout: 1.0)
-            try await sleep(0.5)
-        }
     }
 }
 

bitchatTests/CommandProcessorTests.swift

@@ -1,42 +1,54 @@
-import Testing
+import XCTest
 @testable import bitchat
 
-struct CommandProcessorTests {
+final class CommandProcessorTests: XCTestCase {
-    private var identityManager = MockIdentityManager(MockKeychain())
+    
+    var identityManager: MockIdentityManager!
+    
+    override func setUp() {
+        super.setUp()
+        // Provide a minimal identity manager for commands that query identity/block lists
+        identityManager = MockIdentityManager(MockKeychain())
+    }
+    
+    override func tearDown() {
+        identityManager = nil
+        super.tearDown()
+    }
 
     @MainActor
-    @Test func slapNotFoundGrammar() {
+    func test_slap_notFoundGrammar() {
         let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/slap @system")
         switch result {
         case .error(let message):
-            #expect(message == "cannot slap system: not found")
+            XCTAssertEqual(message, "cannot slap system: not found")
         default:
-            Issue.record("Expected error result")
+            XCTFail("Expected error result")
         }
     }
 
     @MainActor
-    @Test func hugNotFoundGrammar() {
+    func test_hug_notFoundGrammar() {
         let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/hug @system")
         switch result {
         case .error(let message):
-            #expect(message == "cannot hug system: not found")
+            XCTAssertEqual(message, "cannot hug system: not found")
         default:
-            Issue.record("Expected error result")
+            XCTFail("Expected error result")
         }
     }
 
     @MainActor
-    @Test func slapUsageMessage() {
+    func test_slap_usageMessage() {
         let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/slap")
         switch result {
         case .error(let message):
-            #expect(message == "usage: /slap <nickname>")
+            XCTAssertEqual(message, "usage: /slap <nickname>")
         default:
-            Issue.record("Expected error result for usage message")
+            XCTFail("Expected error result for usage message")
         }
     }
 }

bitchatTests/EndToEnd/PrivateChatE2ETests.swift

@@ -11,19 +11,21 @@ import CryptoKit
 import struct Foundation.UUID
 @testable import bitchat
 
+// TODO: Remove once MockBLEService is refactored to fix race condition
+@Suite(.serialized)
 struct PrivateChatE2ETests {
     
     private let alice: MockBLEService
     private let bob: MockBLEService
     private let charlie: MockBLEService
-    private let mockKeychain = MockKeychain()
+    private let mockKeychain: MockKeychain
-    private let bus = MockBLEBus()
     
     init() {
         // Create services with unique peer IDs to avoid any collision
-        alice = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname1, bus: bus)
+        alice = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname1)
-        bob = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname2, bus: bus)
+        bob = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname2)
-        charlie = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname3, bus: bus)
+        charlie = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname3)
+        mockKeychain = MockKeychain()
     }
     
     // MARK: - Basic Private Messaging Tests
@@ -51,7 +53,7 @@ struct PrivateChatE2ETests {
             )
 
             // Wait a bit to ensure message would have been delivered if it was going to be
-            try? await sleep(0.1)
+            try? await Task.sleep(nanoseconds: UInt64(TestConstants.shortTimeout * 1_000_000_000))
         }
 
         #expect(!bobReceivedMessage, "Bob should not have received the message")
@@ -169,7 +171,7 @@ struct PrivateChatE2ETests {
             // Send encrypted private message
             alice.sendPrivateMessage(
                 TestConstants.testMessage1,
-                to: bob.peerID,
+                to: TestConstants.testPeerID2,
                 recipientNickname: TestConstants.testNickname2
             )
         }
@@ -233,7 +235,7 @@ struct PrivateChatE2ETests {
             for i in 0..<messageCount {
                 alice.sendPrivateMessage(
                     "Private message \(i)",
-                    to: bob.peerID,
+                    to: TestConstants.testPeerID2,
                     recipientNickname: TestConstants.testNickname2
                 )
             }
@@ -252,7 +254,7 @@ struct PrivateChatE2ETests {
 
             alice.sendPrivateMessage(
                 TestConstants.testLongMessage,
-                to: bob.peerID,
+                to: TestConstants.testPeerID2,
                 recipientNickname: TestConstants.testNickname2
             )
         }

bitchatTests/EndToEnd/PublicChatE2ETests.swift

@@ -10,22 +10,22 @@ import Testing
 import struct Foundation.UUID
 @testable import bitchat
 
+@Suite(.serialized)
 struct PublicChatE2ETests {
     
     private let alice: MockBLEService
     private let bob: MockBLEService
     private let charlie: MockBLEService
     private let david: MockBLEService
-    private let bus = MockBLEBus()
     
     private var receivedMessages: [String: [BitchatMessage]] = [:]
     
     init() {
         // Create mock services with unique peer IDs to avoid any collision
-        alice = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname1, bus: bus)
+        alice = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname1)
-        bob = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname2, bus: bus)
+        bob = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname2)
-        charlie = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname3, bus: bus)
+        charlie = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname3)
-        david = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname4, bus: bus)
+        david = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname4)
     }
     
     // MARK: - Basic Broadcasting Tests

bitchatTests/Fragmentation/FragmentationTests.swift

@@ -34,7 +34,7 @@ struct FragmentationTests {
         ble.delegate = capture
         
         // Construct a big packet (3KB) from a remote sender (not our own ID)
-        let remoteShortID = PeerID(str: "1122334455667788")
+        let remoteShortID: PeerID = "1122334455667788"
         let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 3_000)
         
         // Use a small fragment size to ensure multiple pieces
@@ -45,15 +45,15 @@ struct FragmentationTests {
         
         // Inject fragments spaced out to avoid concurrent mutation inside BLEService
         for (i, fragment) in shuffled.enumerated() {
-            let delay = 5 * Double(i) * 0.001
+            let delay = UInt64(5 * i) * 1_000_000 // nanoseconds
             Task {
-                try await sleep(delay)
+                try await Task.sleep(nanoseconds: delay)
                 ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
             }
         }
         
         // Allow async processing
-        try await sleep(0.5)
+        try await Task.sleep(nanoseconds: 500_000_000) // 0.5s
         
         #expect(capture.publicMessages.count == 1)
         #expect(capture.publicMessages.first?.content.count == 3_000)
@@ -69,7 +69,7 @@ struct FragmentationTests {
         let capture = CaptureDelegate()
         ble.delegate = capture
         
-        let remoteShortID = PeerID(str: "A1B2C3D4E5F60708")
+        let remoteShortID: PeerID = "A1B2C3D4E5F60708"
         let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 2048)
         var frags = fragmentPacket(original, fragmentSize: 300)
         
@@ -79,76 +79,20 @@ struct FragmentationTests {
         }
         
         for (i, fragment) in frags.enumerated() {
-            let delay = 5 * Double(i) * 0.001
+            let delay = UInt64(5 * i) * 1_000_000 // nanoseconds
             Task {
-                try await sleep(delay)
+                try await Task.sleep(nanoseconds: delay)
                 ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
             }
         }
         
         // Allow async processing
-        try await sleep(0.5)
+        try await Task.sleep(nanoseconds: 500_000_000) // 0.5s
         
         #expect(capture.publicMessages.count == 1)
         #expect(capture.publicMessages.first?.content.count == 2048)
     }
     
-    @Test("Max-sized file transfer survives reassembly")
-    func maxSizedFileTransferSurvivesReassembly() async throws {
-        let ble = BLEService(
-            keychain: mockKeychain,
-            idBridge: idBridge,
-            identityManager: mockIdentityManager
-        )
-        let capture = CaptureDelegate()
-        ble.delegate = capture
-
-        let remoteID = PeerID(str: "CAFEBABECAFEBABE")
-        let fileContent = Data(repeating: 0x42, count: FileTransferLimits.maxPayloadBytes)
-        let filePacket = BitchatFilePacket(
-            fileName: "limit.bin",
-            fileSize: UInt64(fileContent.count),
-            mimeType: "application/octet-stream",
-            content: fileContent
-        )
-        let encoded = try #require(filePacket.encode(), "File packet encoding failed")
-
-        let packet = BitchatPacket(
-            type: MessageType.fileTransfer.rawValue,
-            senderID: Data(hexString: remoteID.id) ?? Data(),
-            recipientID: nil,
-            timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
-            payload: encoded,
-            signature: nil,
-            ttl: 7,
-            version: 2
-        )
-
-        let fragments = fragmentPacket(packet, fragmentSize: 4096, pad: false)
-        #expect(!fragments.isEmpty)
-
-        for (i, fragment) in fragments.enumerated() {
-            let delay = 5 * Double(i) * 0.001
-            Task {
-                try await sleep(delay)
-                ble._test_handlePacket(fragment, fromPeerID: remoteID)
-            }
-        }
-
-        try await sleep(1.0)
-
-        let message = try #require(capture.receivedMessages.first, "Expected file transfer message")
-        #expect(message.content.hasPrefix("[file]"))
-
-        if let fileName = message.content.split(separator: " ").last {
-            let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
-            let filesRoot = base.appendingPathComponent("files", isDirectory: true)
-            let incoming = filesRoot.appendingPathComponent("files/incoming", isDirectory: true)
-            let url = incoming.appendingPathComponent(String(fileName))
-            try? FileManager.default.removeItem(at: url)
-        }
-    }
-    
     @Test("Invalid fragment header is ignored")
     func invalidFragmentHeaderIsIgnored() async throws {
         let ble = BLEService(
@@ -159,7 +103,7 @@ struct FragmentationTests {
         let capture = CaptureDelegate()
         ble.delegate = capture
         
-        let remoteShortID = PeerID(str: "0011223344556677")
+        let remoteShortID: PeerID = "0011223344556677"
         let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 1000)
         let fragments = fragmentPacket(original, fragmentSize: 250)
         
@@ -180,15 +124,15 @@ struct FragmentationTests {
         }
         
         for (i, fragment) in corrupted.enumerated() {
-            let delay = 5 * Double(i) * 0.001
+            let delay = UInt64(5 * i) * 1_000_000 // nanoseconds
             Task {
-                try await sleep(delay)
+                try await Task.sleep(nanoseconds: delay)
                 ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
             }
         }
         
         // Allow async processing
-        try await sleep(0.5)
+        try await Task.sleep(nanoseconds: 500_000_000) // 0.5s
         
         // Should not deliver since one fragment is invalid and reassembly can't complete
         #expect(capture.publicMessages.isEmpty)
@@ -198,10 +142,7 @@ struct FragmentationTests {
 extension FragmentationTests {
     private final class CaptureDelegate: BitchatDelegate {
         var publicMessages: [(peerID: PeerID, nickname: String, content: String)] = []
-        var receivedMessages: [BitchatMessage] = []
+        func didReceiveMessage(_ message: BitchatMessage) {}
-        func didReceiveMessage(_ message: BitchatMessage) {
-            receivedMessages.append(message)
-        }
         func didConnectToPeer(_ peerID: PeerID) {}
         func didDisconnectFromPeer(_ peerID: PeerID) {}
         func didUpdatePeerList(_ peers: [PeerID]) {}
@@ -232,8 +173,8 @@ extension FragmentationTests {
     }
 
     // Helper: fragment a packet using the same header format BLEService expects
-    private func fragmentPacket(_ packet: BitchatPacket, fragmentSize: Int, fragmentID: Data? = nil, pad: Bool = true) -> [BitchatPacket] {
+    private func fragmentPacket(_ packet: BitchatPacket, fragmentSize: Int, fragmentID: Data? = nil) -> [BitchatPacket] {
-        guard let fullData = packet.toBinaryData(padding: pad) else { return [] }
+        let fullData = packet.toBinaryData() ?? Data()
         let fid = fragmentID ?? Data((0..<8).map { _ in UInt8.random(in: 0...255) })
         let chunks: [Data] = stride(from: 0, to: fullData.count, by: fragmentSize).map { off in
             Data(fullData[off..<min(off + fragmentSize, fullData.count)])

bitchatTests/GCSFilterTests.swift

@@ -1,23 +1,22 @@
-import Testing
+import XCTest
-import struct Foundation.Data
 @testable import bitchat
 
-struct GCSFilterTests {
+final class GCSFilterTests: XCTestCase {
-    @Test func buildFilterWithDuplicateIdsProducesStableEncoding() {
+    func testBuildFilterWithDuplicateIdsProducesStableEncoding() {
         let id = Data(repeating: 0xAB, count: 16)
         let ids = Array(repeating: id, count: 64)
 
         let params = GCSFilter.buildFilter(ids: ids, maxBytes: 128, targetFpr: 0.01)
-        #expect(params.m >= 1)
+        XCTAssertGreaterThanOrEqual(params.m, 1)
 
         let decoded = GCSFilter.decodeToSortedSet(p: params.p, m: params.m, data: params.data)
-        #expect(decoded.count <= 1)
+        XCTAssertLessThanOrEqual(decoded.count, 1)
     }
 
-    @Test func bucketAvoidsZeroCandidate() {
+    func testBucketAvoidsZeroCandidate() {
         let id = Data(repeating: 0x01, count: 16)
         let bucket = GCSFilter.bucket(for: id, modulus: 2)
-        #expect(bucket != 0)
+        XCTAssertNotEqual(bucket, 0)
-        #expect(bucket < 2)
+        XCTAssertLessThan(bucket, 2)
     }
 }

bitchatTests/GeohashBookmarksStoreTests.swift

@@ -1,38 +1,52 @@
-import Testing
+import XCTest
-import Foundation
 @testable import bitchat
 
-struct GeohashBookmarksStoreTests {
+final class GeohashBookmarksStoreTests: XCTestCase {
-    private let storeKey = "locationChannel.bookmarks"
+    let storeKey = "locationChannel.bookmarks"
-    private let storage = UserDefaults(suiteName: UUID().uuidString)!
+    var storage: UserDefaults!
-    private let store: GeohashBookmarksStore
+    var store: GeohashBookmarksStore!
 
-    init() {
+    override func setUp() {
-        store = GeohashBookmarksStore(storage: storage)
+        super.setUp()
+        // Unique instance for each test to avoid race condition
+        storage = UserDefaults(suiteName: UUID().uuidString)
+        store = GeohashBookmarksStore(storage: storage!)
     }
 
-    @Test func toggleAndNormalize() {
+    override func tearDown() {
+        storage.removeObject(forKey: storeKey)
+        store._resetForTesting()
+        store = nil
+        storage = nil
+        super.tearDown()
+    }
+
+    func testToggleAndNormalize() {
         // Start clean
-        #expect(store.bookmarks.isEmpty)
+        XCTAssertTrue(store.bookmarks.isEmpty)
 
         // Add with mixed case and hash prefix
         store.toggle("#U4PRUY")
-        #expect(store.isBookmarked("u4pruy"))
+        XCTAssertTrue(store.isBookmarked("u4pruy"))
-        #expect(store.bookmarks.first == "u4pruy")
+        XCTAssertEqual(store.bookmarks.first, "u4pruy")
 
         // Toggling again removes
         store.toggle("u4pruy")
-        #expect(!store.isBookmarked("u4pruy"))
+        XCTAssertFalse(store.isBookmarked("u4pruy"))
-        #expect(store.bookmarks.isEmpty)
+        XCTAssertTrue(store.bookmarks.isEmpty)
     }
 
-    @Test func persistenceWritten() throws {
+    func testPersistenceWritten() throws {
         store.toggle("ezs42")
         store.toggle("u4pruy")
+
         // Verify persisted JSON contains both (order not enforced here)
-        let data = try #require(storage.data(forKey: storeKey), "No persisted data found")
+        guard let data = storage.data(forKey: storeKey) else {
+            XCTFail("No persisted data found")
+            return
+        }
         let arr = try JSONDecoder().decode([String].self, from: data)
-        #expect(arr.contains("ezs42"))
+        XCTAssertTrue(arr.contains("ezs42"))
-        #expect(arr.contains("u4pruy"))
+        XCTAssertTrue(arr.contains("u4pruy"))
     }
 }

bitchatTests/GossipSyncManagerTests.swift

@@ -1,28 +1,24 @@
 import Foundation
-import Testing
+import XCTest
 @testable import bitchat
 
-struct GossipSyncManagerTests {
+final class GossipSyncManagerTests: XCTestCase {
-
+    func testConcurrentPacketIntakeAndSyncRequest() {
-    private let myPeerID = PeerID(str: "0102030405060708")
+        let manager = GossipSyncManager(myPeerID: "0102030405060708")
-    
-    @Test func concurrentPacketIntakeAndSyncRequest() async throws {
-        let manager = GossipSyncManager(myPeerID: myPeerID)
         let delegate = RecordingDelegate()
+        let sendExpectation = expectation(description: "sync request sent")
+        delegate.onSend = { sendExpectation.fulfill() }
         manager.delegate = delegate
 
-        try await confirmation("sync request sent") { sent in
-            delegate.onSend = {
-                sent()
-            }
-
         let iterations = 200
-            let senderID = try #require(Data(hexString: "1122334455667788"))
+        let group = DispatchGroup()
 
         for i in 0..<iterations {
+            group.enter()
+            DispatchQueue.global(qos: .userInitiated).async {
                 let packet = BitchatPacket(
                     type: MessageType.message.rawValue,
-                    senderID: senderID,
+                    senderID: Data(hexString: "1122334455667788") ?? Data(),
                     recipientID: nil,
                     timestamp: 1_000_000 + UInt64(i),
                     payload: Data([UInt8(truncatingIfNeeded: i)]),
@@ -30,26 +26,35 @@ struct GossipSyncManagerTests {
                     ttl: 1
                 )
                 manager.onPublicPacketSeen(packet)
-                try await sleep(0.001)
+                Thread.sleep(forTimeInterval: 0.001)
+                group.leave()
+            }
         }
 
-            manager.scheduleInitialSyncToPeer(PeerID(str: "FFFFFFFFFFFFFFFF"), delaySeconds: 0.0)
+        DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + 0.002) {
-            try await sleep(0.002)
+            manager.scheduleInitialSyncToPeer("FFFFFFFFFFFFFFFF", delaySeconds: 0.0)
         }
 
-        let lastPacket = try #require(delegate.lastPacket, "Expected sync packet to be sent")
+        group.wait()
-        #expect(lastPacket.type == MessageType.requestSync.rawValue)
+        wait(for: [sendExpectation], timeout: 2.0)
-        #expect(RequestSyncPacket.decode(from: lastPacket.payload) != nil)
+
+        guard let lastPacket = delegate.lastPacket else {
+            XCTFail("Expected sync packet to be sent")
+            return
         }
 
-    @Test func staleAnnouncementsArePurgedWithMessages() throws {
+        XCTAssertEqual(lastPacket.type, MessageType.requestSync.rawValue)
+        XCTAssertNotNil(RequestSyncPacket.decode(from: lastPacket.payload))
+    }
+
+    func testStaleAnnouncementsArePurgedWithMessages() {
         var config = GossipSyncManager.Config()
         config.stalePeerCleanupIntervalSeconds = 0
         config.stalePeerTimeoutSeconds = 5
 
-        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
+        let manager = GossipSyncManager(myPeerID: "0102030405060708", config: config)
         let peerHex = "0011223344556677"
-        let senderData = try #require(Data(hexString: peerHex))
+        let senderData = Data(hexString: peerHex) ?? Data()
         let initialTimestampMs = UInt64(Date().timeIntervalSince1970 * 1000)
 
         let announcePacket = BitchatPacket(
@@ -77,24 +82,24 @@ struct GossipSyncManagerTests {
 
         // Flush queue without triggering stale cleanup yet
         manager._performMaintenanceSynchronously(now: Date())
-        #expect(manager._hasAnnouncement(for: PeerID(str: peerHex)))
+        XCTAssertTrue(manager._hasAnnouncement(for: PeerID(str: peerHex)))
-        #expect(manager._messageCount(for: PeerID(str: peerHex)) == 1)
+        XCTAssertEqual(manager._messageCount(for: PeerID(str: peerHex)), 1)
 
         // Run cleanup past the timeout
         let future = Date().addingTimeInterval(config.stalePeerTimeoutSeconds + 1)
         manager._performMaintenanceSynchronously(now: future)
-        #expect(manager._hasAnnouncement(for: PeerID(str: peerHex)) == false)
+        XCTAssertFalse(manager._hasAnnouncement(for: PeerID(str: peerHex)))
-        #expect(manager._messageCount(for: PeerID(str: peerHex)) == 0)
+        XCTAssertEqual(manager._messageCount(for: PeerID(str: peerHex)), 0)
     }
 
-    @Test func ignoresAnnounceOlderThanStaleTimeout() throws {
+    func testIgnoresAnnounceOlderThanStaleTimeout() {
         var config = GossipSyncManager.Config()
         config.stalePeerTimeoutSeconds = 5
         config.maxMessageAgeSeconds = 100
 
-        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
+        let manager = GossipSyncManager(myPeerID: "0102030405060708", config: config)
         let peerHex = "8899aabbccddeeff"
-        let senderData = try #require(Data(hexString: peerHex))
+        let senderData = Data(hexString: peerHex) ?? Data()
         let staleTimestampMs = UInt64(Date().addingTimeInterval(-(config.stalePeerTimeoutSeconds + 1)).timeIntervalSince1970 * 1000)
 
         let freshMessage = BitchatPacket(
@@ -122,8 +127,8 @@ struct GossipSyncManagerTests {
 
         manager._performMaintenanceSynchronously()
 
-        #expect(manager._hasAnnouncement(for: PeerID(str: peerHex)) == false)
+        XCTAssertFalse(manager._hasAnnouncement(for: PeerID(str: peerHex)))
-        #expect(manager._messageCount(for: PeerID(str: peerHex)) == 0)
+        XCTAssertEqual(manager._messageCount(for: PeerID(str: peerHex)), 0)
     }
 }
 

bitchatTests/Integration/IntegrationTests.swift

@@ -6,31 +6,52 @@
 // For more information, see <https://unlicense.org>
 //
 
-import Foundation
+import XCTest
 import CryptoKit
-import Testing
 @testable import bitchat
 
-struct IntegrationTests {
+final class IntegrationTests: XCTestCase {
     
-    private var helper = TestNetworkHelper()
+    var nodes: [String: MockBLEService] = [:]
+    var noiseManagers: [String: NoiseSessionManager] = [:]
+    private var mockKeychain: MockKeychain!
     
-    init() {
+    override func setUp() {
-        helper.createNode("Alice", peerID: PeerID(str: UUID().uuidString))
+        super.setUp()
-        helper.createNode("Bob", peerID: PeerID(str: UUID().uuidString))
+        // Use the in-memory test bus with autoFlood enabled to simulate
-        helper.createNode("Charlie", peerID: PeerID(str: UUID().uuidString))
+        // broadcast propagation across a larger mesh. Integration-only.
-        helper.createNode("David", peerID: PeerID(str: UUID().uuidString))
+        MockBLEService.resetTestBus()
+        MockBLEService.autoFloodEnabled = true
+        mockKeychain = MockKeychain()
+        
+        // Create a network of nodes
+        createNode("Alice", peerID: TestConstants.testPeerID1)
+        createNode("Bob", peerID: TestConstants.testPeerID2)
+        createNode("Charlie", peerID: TestConstants.testPeerID3)
+        createNode("David", peerID: TestConstants.testPeerID4)
+    }
+    
+    override func tearDown() {
+        // Disable flooding to avoid cross-test interference
+        MockBLEService.autoFloodEnabled = false
+        nodes.removeAll()
+        noiseManagers.removeAll()
+        mockKeychain = nil
+        super.tearDown()
     }
     
     // MARK: - Multi-Peer Scenarios
     
-    @Test func fullMeshCommunication() async throws {
+    func testFullMeshCommunication() {
-        helper.connectFullMesh()
+        // Create full mesh - everyone connected to everyone
+        connectFullMesh()
         
+        let expectation = XCTestExpectation(description: "All nodes communicate")
         var messageMatrix: [String: Set<String>] = [:]
-        for (senderName, _) in helper.nodes { messageMatrix[senderName] = [] }
         
-        for (receiverName, receiver) in helper.nodes {
+        // Track all receivers; parse sender name from message content "Hello from <Name>"
+        for (senderName, _) in nodes { messageMatrix[senderName] = [] }
+        for (receiverName, receiver) in nodes {
             receiver.messageDeliveryHandler = { message in
                 let parts = message.content.components(separatedBy: " ")
                 if let last = parts.last, message.content.contains("Hello from") {
@@ -41,96 +62,108 @@ struct IntegrationTests {
             }
         }
         
-        for (name, node) in helper.nodes {
+        // Each node sends a message
-            node.sendMessage("Hello from \(name)")
+        for (name, node) in nodes {
+            node.sendMessage("Hello from \(name)", mentions: [], to: nil)
         }
         
+        // Wait and verify
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
             // Each sender should have reached all other nodes
             for (sender, receivers) in messageMatrix {
-            let expectedReceivers = Set(helper.nodes.keys.filter { $0 != sender })
+                let expectedReceivers = Set(self.nodes.keys.filter { $0 != sender })
-            #expect(receivers == expectedReceivers, "\(sender) didn't reach all nodes")
+                XCTAssertEqual(receivers, expectedReceivers, "\(sender) didn't reach all nodes")
             }
+            expectation.fulfill()
         }
         
-    @Test func dynamicTopologyChanges() async throws {
+        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
+    }
+    
+    func testDynamicTopologyChanges() {
         // Start with Alice -> Bob -> Charlie
-        helper.connect("Alice", "Bob")
+        connect("Alice", "Bob")
-        helper.connect("Bob", "Charlie")
+        connect("Bob", "Charlie")
         
-        try await confirmation("Topology changes handled") { receiveMessage in
+        let expectation = XCTestExpectation(description: "Topology changes handled")
         var phase = 1
         
-            helper.nodes["Charlie"]!.messageDeliveryHandler = { message in
+        // Phase 1: Test initial topology
+        nodes["Charlie"]!.messageDeliveryHandler = { message in
             if phase == 1 && message.sender == "Alice" {
                 // Now change topology: disconnect Bob, connect Alice-Charlie
-                    helper.disconnect("Alice", "Bob")
+                self.disconnect("Alice", "Bob")
-                    helper.disconnect("Bob", "Charlie")
+                self.disconnect("Bob", "Charlie")
-                    helper.connect("Alice", "Charlie")
+                self.connect("Alice", "Charlie")
                 phase = 2
                 
                 // Send another message
-                    helper.nodes["Alice"]!.sendMessage("Direct message")
+                self.nodes["Alice"]!.sendMessage("Direct message", mentions: [], to: nil)
             } else if phase == 2 && message.content == "Direct message" {
-                    receiveMessage()
+                expectation.fulfill()
             }
         }
         
+        // Initial message through relay
         // Allow relay handler to be set before first send
-            try await sleep(0.05)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
-            helper.nodes["Alice"]!.sendMessage("Relayed message")
+            self.nodes["Alice"]!.sendMessage("Relayed message", mentions: [], to: nil)
-        }
         }
         
-    @Test func networkPartitionRecovery() async throws {
+        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
+    }
+    
+    func testNetworkPartitionRecovery() {
         // Create two partitions
-        helper.connect("Alice", "Bob")
+        connect("Alice", "Bob")
-        helper.connect("Charlie", "David")
+        connect("Charlie", "David")
         
+        let expectation = XCTestExpectation(description: "Partitions merge and communicate")
         let messagesBeforeMerge = 0
         var messagesAfterMerge = 0
         
-        try await confirmation("Partitions merge and communicate") { receiveMessage in
         // Monitor cross-partition messages
-            helper.nodes["David"]!.messageDeliveryHandler = { message in
+        nodes["David"]!.messageDeliveryHandler = { message in
             if message.sender == "Alice" {
                 messagesAfterMerge += 1
                 if messagesAfterMerge == 1 {
-                        receiveMessage()
+                    expectation.fulfill()
                 }
             }
         }
         
         // Try to send across partition (should fail)
-            helper.nodes["Alice"]!.sendMessage("Before merge")
+        nodes["Alice"]!.sendMessage("Before merge", mentions: [], to: nil)
         
         // Merge partitions after delay
-            try await sleep(0.05)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
             // Connect partitions
-            helper.connect("Bob", "Charlie")
+            self.connect("Bob", "Charlie")
             
             // Enable relay
-            helper.setupRelay("Bob", nextHops: ["Charlie"])
+            self.setupRelay("Bob", nextHops: ["Charlie"])
-            helper.setupRelay("Charlie", nextHops: ["David"])
+            self.setupRelay("Charlie", nextHops: ["David"])
             
             // Send message across merged network
-            helper.nodes["Alice"]!.sendMessage("After merge")
+            self.nodes["Alice"]!.sendMessage("After merge", mentions: [], to: nil)
         }
         
-        #expect(messagesBeforeMerge == 0)
+        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
-        #expect(messagesAfterMerge == 1)
+        XCTAssertEqual(messagesBeforeMerge, 0)
+        XCTAssertEqual(messagesAfterMerge, 1)
     }
     
     // MARK: - Mixed Message Type Scenarios
     
-    @Test func mixedPublicPrivateMessages() async throws {
+    func testMixedPublicPrivateMessages() throws {
-        helper.connectFullMesh()
+        connectFullMesh()
         
+        let expectation = XCTestExpectation(description: "Mixed messages handled correctly")
         var publicCount = 0
         var privateCount = 0
         
-        await confirmation("Mixed messages handled correctly") { completion in
         // Bob monitors messages
-            helper.nodes["Bob"]!.messageDeliveryHandler = { message in
+        nodes["Bob"]!.messageDeliveryHandler = { message in
             if message.isPrivate && message.recipientNickname == "Bob" {
                 privateCount += 1
             } else if !message.isPrivate {
@@ -138,239 +171,261 @@ struct IntegrationTests {
             }
             
             if publicCount == 2 && privateCount == 1 {
-                    completion()
+                expectation.fulfill()
             }
         }
         
         // Alice sends mixed messages
-            helper.nodes["Alice"]!.sendMessage("Public 1")
+        nodes["Alice"]!.sendMessage("Public 1", mentions: [], to: nil)
-            helper.nodes["Alice"]!.sendPrivateMessage("Private to Bob", to: helper.nodes["Bob"]!.peerID, recipientNickname: "Bob")
+        nodes["Alice"]!.sendPrivateMessage("Private to Bob", to: TestConstants.testPeerID2, recipientNickname: "Bob")
-            helper.nodes["Alice"]!.sendMessage("Public 2")
+        nodes["Alice"]!.sendMessage("Public 2", mentions: [], to: nil)
+        
+        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
+        XCTAssertEqual(publicCount, 2)
+        XCTAssertEqual(privateCount, 1)
     }
     
-        #expect(publicCount == 2)
+    func testEncryptedAndUnencryptedMix() throws {
-        #expect(privateCount == 1)
+        connect("Alice", "Bob")
-    }
-    
-    @Test func encryptedAndUnencryptedMix() async throws {
-        helper.connect("Alice", "Bob")
         
         // Setup Noise session
-        try helper.establishNoiseSession("Alice", "Bob")
+        try establishNoiseSession("Alice", "Bob")
         
+        let expectation = XCTestExpectation(description: "Both encrypted and plain messages work")
         var plainCount = 0
         var encryptedCount = 0
         
-        try await confirmation("Both encrypted and plain messages work") { completion in
+        // Setup handlers
         // Plain path: send public message and count at Bob
-            helper.nodes["Bob"]!.messageDeliveryHandler = { message in
+        nodes["Bob"]!.messageDeliveryHandler = { message in
-                if message.content == "Plain message" {
+            if message.content == "Plain message" { plainCount += 1 }
-                    plainCount += 1
+            if plainCount == 1 && encryptedCount == 1 { expectation.fulfill() }
-                }
-                if plainCount == 1 && encryptedCount == 1 {
-                    completion()
-                }
         }
 
         // Encrypted path: use NoiseSessionManager explicitly
         let plaintext = "Encrypted message".data(using: .utf8)!
-            let ciphertext = try helper.noiseManagers["Alice"]!.encrypt(plaintext, for: helper.nodes["Bob"]!.peerID)
+        let ciphertext = try noiseManagers["Alice"]!.encrypt(plaintext, for: TestConstants.testPeerID2)
-            
+        nodes["Bob"]!.packetDeliveryHandler = { packet in
-            helper.nodes["Bob"]!.packetDeliveryHandler = { packet in
             if packet.type == MessageType.noiseEncrypted.rawValue {
-                    if let data = try? helper.noiseManagers["Bob"]!.decrypt(ciphertext, from: helper.nodes["Alice"]!.peerID),
+                if let data = try? self.noiseManagers["Bob"]!.decrypt(ciphertext, from: TestConstants.testPeerID1),
                    data == plaintext {
                     encryptedCount = 1
-                        if plainCount == 1 {
+                    if plainCount == 1 { expectation.fulfill() }
-                            completion()
-                        }
                 }
             }
         }
 
-            helper.nodes["Alice"]!.sendMessage("Plain message")
+        nodes["Alice"]!.sendMessage("Plain message", mentions: [], to: nil)
         // Deliver encrypted packet directly
         let encPacket = TestHelpers.createTestPacket(type: MessageType.noiseEncrypted.rawValue, payload: ciphertext)
-            helper.nodes["Bob"]!.simulateIncomingPacket(encPacket)
+        nodes["Bob"]!.simulateIncomingPacket(encPacket)
-        }
+        
+        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
     // MARK: - Network Resilience Tests
     
-    @Test func messageDeliveryUnderChurn() async throws {
+    func testMessageDeliveryUnderChurn() {
         // Start with stable network
-        helper.connectFullMesh()
+        connectFullMesh()
         
+        let expectation = XCTestExpectation(description: "Messages delivered despite churn")
+        var receivedMessages = Set<String>()
         let totalMessages = 10
         
-        try await confirmation("Messages delivered despite churn", expectedCount: totalMessages) { completion in
         // David tracks received messages
-            helper.nodes["David"]!.messageDeliveryHandler = { message in
+        nodes["David"]!.messageDeliveryHandler = { message in
-                completion()
+            receivedMessages.insert(message.content)
+            if receivedMessages.count == totalMessages {
+                expectation.fulfill()
+            }
         }
         
         // Send messages while churning network
         for i in 0..<totalMessages {
-                helper.nodes["Alice"]!.sendMessage("Message \(i)")
+            nodes["Alice"]!.sendMessage("Message \(i)", mentions: [], to: nil)
             
             // Simulate churn
             if i % 3 == 0 {
                 // Disconnect and reconnect random connection
                 let pairs = [("Alice", "Bob"), ("Bob", "Charlie"), ("Charlie", "David")]
                 let randomPair = pairs.randomElement()!
-                    helper.disconnect(randomPair.0, randomPair.1)
+                disconnect(randomPair.0, randomPair.1)
-                    try await sleep(0.01)
+                
-                    helper.connect(randomPair.0, randomPair.1)
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-                }
+                    self.connect(randomPair.0, randomPair.1)
                 }
             }
         }
         
-    @Test func peerPresenceTrackingAndReconnection() async throws {
+        wait(for: [expectation], timeout: TestConstants.longTimeout)
-        helper.connect("Alice", "Bob")
+        XCTAssertEqual(receivedMessages.count, totalMessages)
+    }
     
-        await confirmation("Delivery after reconnection") { delivered in
+    func testPeerPresenceTrackingAndReconnection() {
-            helper.nodes["Bob"]!.messageDeliveryHandler = { message in
+        // Test that after disconnect/reconnect, message delivery resumes
-                if message.content == "After reconnect" {
+        connect("Alice", "Bob")
-                    delivered()
+
+        let expectation = XCTestExpectation(description: "Delivery after reconnection")
+        var delivered = false
+
+        nodes["Bob"]!.messageDeliveryHandler = { message in
+            if message.content == "After reconnect" && !delivered {
+                delivered = true
+                expectation.fulfill()
             }
         }
 
         // Simulate disconnect (out of range)
-            helper.disconnect("Alice", "Bob")
+        disconnect("Alice", "Bob")
         // Reconnect
-            helper.connect("Alice", "Bob")
+        connect("Alice", "Bob")
 
         // Send after reconnection
-            helper.nodes["Alice"]!.sendMessage("After reconnect")
+        nodes["Alice"]!.sendMessage("After reconnect", mentions: [], to: nil)
-        }
+
+        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
+        XCTAssertTrue(delivered)
     }
     
-    @Test func encryptedMessageAfterPeerRestart() async throws {
+    func testEncryptedMessageAfterPeerRestart() {
-        helper.connect("Alice", "Bob")
+        // Test that encrypted messages work after one peer restarts
+        connect("Alice", "Bob")
         do {
-            try helper.establishNoiseSession("Alice", "Bob")
+            try establishNoiseSession("Alice", "Bob")
         } catch {
-            Issue.record("Failed to establish Noise session: \(error)")
+            XCTFail("Failed to establish Noise session: \(error)")
         }
         
         // Exchange an encrypted message
-        await confirmation("First message received") { received in
+        let firstExpectation = XCTestExpectation(description: "First message received")
-            helper.nodes["Bob"]!.messageDeliveryHandler = { message in
+        nodes["Bob"]!.messageDeliveryHandler = { message in
             if message.content == "Before restart" && message.isPrivate {
-                    received()
+                firstExpectation.fulfill()
             }
         }
-            helper.nodes["Alice"]!.sendPrivateMessage("Before restart", to: helper.nodes["Bob"]!.peerID, recipientNickname: "Bob")
+        
-        }
+        nodes["Alice"]!.sendPrivateMessage("Before restart", to: TestConstants.testPeerID2, recipientNickname: "Bob")
+        wait(for: [firstExpectation], timeout: TestConstants.defaultTimeout)
         
         // Simulate Bob restart by recreating his Noise manager
         let bobKey = Curve25519.KeyAgreement.PrivateKey()
-        helper.noiseManagers["Bob"] = NoiseSessionManager(localStaticKey: bobKey, keychain: helper.mockKeychain)
+        noiseManagers["Bob"] = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Re-establish Noise handshake explicitly via managers
         do {
-            let m1 = try helper.noiseManagers["Bob"]!.initiateHandshake(with: helper.nodes["Alice"]!.peerID)
+            let m1 = try noiseManagers["Bob"]!.initiateHandshake(with: TestConstants.testPeerID1)
-            let m2 = try helper.noiseManagers["Alice"]!.handleIncomingHandshake(from: helper.nodes["Bob"]!.peerID, message: m1)!
+            let m2 = try noiseManagers["Alice"]!.handleIncomingHandshake(from: TestConstants.testPeerID2, message: m1)!
-            let m3 = try helper.noiseManagers["Bob"]!.handleIncomingHandshake(from: helper.nodes["Alice"]!.peerID, message: m2)!
+            let m3 = try noiseManagers["Bob"]!.handleIncomingHandshake(from: TestConstants.testPeerID1, message: m2)!
-            _ = try helper.noiseManagers["Alice"]!.handleIncomingHandshake(from: helper.nodes["Bob"]!.peerID, message: m3)
+            _ = try noiseManagers["Alice"]!.handleIncomingHandshake(from: TestConstants.testPeerID2, message: m3)
         } catch {
-            Issue.record("Failed to re-establish Noise session after restart: \(error)")
+            XCTFail("Failed to re-establish Noise session after restart: \(error)")
         }
         
-        // Now messages should work again - simulate encrypted packet
+        // Now messages should work again
-        await confirmation("Message after restart received") { received in
+        let secondExpectation = XCTestExpectation(description: "Message after restart received")
-            helper.nodes["Alice"]!.messageDeliveryHandler = { message in
+        nodes["Alice"]!.messageDeliveryHandler = { message in
             if message.content == "After restart success" && message.isPrivate {
-                    received()
+                secondExpectation.fulfill()
             }
         }
         
+        // Simulate encrypted message using managers
         do {
             let plaintext = "After restart success".data(using: .utf8)!
-                let ciphertext = try helper.noiseManagers["Bob"]!.encrypt(plaintext, for: helper.nodes["Alice"]!.peerID)
+            let ciphertext = try noiseManagers["Bob"]!.encrypt(plaintext, for: TestConstants.testPeerID1)
             let packet = TestHelpers.createTestPacket(type: MessageType.noiseEncrypted.rawValue, payload: ciphertext)
-                helper.nodes["Alice"]!.packetDeliveryHandler = { pkt in
+            nodes["Alice"]!.packetDeliveryHandler = { pkt in
                 if pkt.type == MessageType.noiseEncrypted.rawValue {
-                        if let data = try? helper.noiseManagers["Alice"]!.decrypt(pkt.payload, from: helper.nodes["Bob"]!.peerID),
+                    if let data = try? self.noiseManagers["Alice"]!.decrypt(pkt.payload, from: TestConstants.testPeerID2),
                        String(data: data, encoding: .utf8) == "After restart success" {
-                            received()
+                        secondExpectation.fulfill()
                     }
                 }
             }
-                helper.nodes["Alice"]!.simulateIncomingPacket(packet)
+            nodes["Alice"]!.simulateIncomingPacket(packet)
         } catch {
-                Issue.record("Encryption after restart failed: \(error)")
+            XCTFail("Encryption after restart failed: \(error)")
-            }
         }
+        wait(for: [secondExpectation], timeout: TestConstants.defaultTimeout)
     }
     
-    @Test func largeScaleNetwork() async throws {
+    func testLargeScaleNetwork() {
         // Create larger network
         for i in 5...10 {
-            helper.createNode("Node\(i)", peerID: PeerID(str: "PEER\(i)"))
+            createNode("Node\(i)", peerID: "PEER\(i)")
         }
         
         // Connect in ring topology with cross-connections
-        let allNodes = Array(helper.nodes.keys).sorted()
+        let allNodes = Array(nodes.keys).sorted()
         for i in 0..<allNodes.count {
             // Ring connection
-            helper.connect(allNodes[i], allNodes[(i + 1) % allNodes.count])
+            connect(allNodes[i], allNodes[(i + 1) % allNodes.count])
             
             // Cross connection
             if i + 3 < allNodes.count {
-                helper.connect(allNodes[i], allNodes[i + 3])
+                connect(allNodes[i], allNodes[i + 3])
             }
         }
         
-        await confirmation("Large network handles broadcast", expectedCount: helper.nodes.count - 1) { nodeReaced in
+        let expectation = XCTestExpectation(description: "Large network handles broadcast")
+        var nodesReached = Set<String>()
+        
         // All nodes except Alice listen
-            for (name, node) in helper.nodes where name != "Alice" {
+        for (name, node) in nodes where name != "Alice" {
             node.messageDeliveryHandler = { message in
                 if message.content == "Broadcast test" {
-                        nodeReaced()
+                    nodesReached.insert(name)
+                    if nodesReached.count == self.nodes.count - 1 {
+                        expectation.fulfill()
+                    }
                 }
             }
         }
         
         // Alice broadcasts
-            helper.nodes["Alice"]!.sendMessage("Broadcast test")
+        nodes["Alice"]!.sendMessage("Broadcast test", mentions: [], to: nil)
-        }
+        
+        wait(for: [expectation], timeout: TestConstants.longTimeout)
+        XCTAssertEqual(nodesReached.count, nodes.count - 1)
     }
     
     // MARK: - Stress Tests
     
-    @Test func highLoadScenario() async throws {
+    func testHighLoadScenario() {
-        helper.connectFullMesh()
+        connectFullMesh()
         
         let messagesPerNode = 25
-        let expectedTotal = messagesPerNode * helper.nodes.count * (helper.nodes.count - 1)
+        let expectedTotal = messagesPerNode * nodes.count * (nodes.count - 1)
+        var receivedTotal = 0
+        let expectation = XCTestExpectation(description: "High load handled")
         
-        await confirmation("High load handled", expectedCount: expectedTotal) { received in
         // Each node tracks messages
-            for (_, node) in helper.nodes {
+        for (_, node) in nodes {
             node.messageDeliveryHandler = { _ in
-                    received()
+                receivedTotal += 1
+                if receivedTotal >= (expectedTotal - 2) {
+                    expectation.fulfill()
+                }
             }
         }
         
         // All nodes send many messages simultaneously
-            await withTaskGroup(of: Void.self) { group in
+        DispatchQueue.concurrentPerform(iterations: nodes.count) { index in
-                for (name, node) in helper.nodes {
+            let nodeName = Array(nodes.keys).sorted()[index]
-                    group.addTask {
             for i in 0..<messagesPerNode {
-                            node.sendMessage("\(name) message \(i)")
+                nodes[nodeName]!.sendMessage("\(nodeName) message \(i)", mentions: [], to: nil)
-                        }
-                    }
-                }
-                await group.waitForAll()
-            }
             }
         }
         
-    @Test func mixedTrafficPatterns() async throws {
+        wait(for: [expectation], timeout: TestConstants.longTimeout)
-        helper.connectFullMesh()
+        XCTAssertGreaterThanOrEqual(receivedTotal, expectedTotal - 2)
+    }
     
+    func testMixedTrafficPatterns() {
+        connectFullMesh()
+        
+        let expectation = XCTestExpectation(description: "Mixed traffic handled")
         var metrics = [
             "public": 0,
             "private": 0,
@@ -379,7 +434,7 @@ struct IntegrationTests {
         ]
         
         // Setup complex handlers
-        for (name, node) in helper.nodes {
+        for (name, node) in nodes {
             node.messageDeliveryHandler = { message in
                 if message.isPrivate {
                     metrics["private"]! += 1
@@ -398,78 +453,88 @@ struct IntegrationTests {
         }
         
         // Generate mixed traffic
-        helper.nodes["Alice"]!.sendMessage("Public broadcast")
+        nodes["Alice"]!.sendMessage("Public broadcast", mentions: [], to: nil)
-        helper.nodes["Alice"]!.sendPrivateMessage("Private to Bob", to: helper.nodes["Bob"]!.peerID, recipientNickname: "Bob")
+        nodes["Alice"]!.sendPrivateMessage("Private to Bob", to: TestConstants.testPeerID2, recipientNickname: "Bob")
-        helper.nodes["Bob"]!.sendMessage("Mentioning @Charlie", mentions: ["Charlie"])
+        nodes["Bob"]!.sendMessage("Mentioning @Charlie", mentions: ["Charlie"], to: nil)
         
         // Disconnect to force relay
-        helper.disconnect("Alice", "David")
+        disconnect("Alice", "David")
-        helper.nodes["Alice"]!.sendMessage("Needs relay to David")
+        nodes["Alice"]!.sendMessage("Needs relay to David", mentions: [], to: nil)
         
-        #expect(metrics["public", default: 0] > 0)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
-        #expect(metrics["private", default: 0] > 0)
+            XCTAssertGreaterThan(metrics["public"]!, 0)
-        #expect(metrics["mentions", default: 0] > 0)
+            XCTAssertGreaterThan(metrics["private"]!, 0)
+            XCTAssertGreaterThan(metrics["mentions"]!, 0)
+            expectation.fulfill()
+        }
+        
+        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
     // MARK: - Security Integration Tests
     // Replacement for the legacy NACK test: verifies that after a
     // decryption failure, peers can rehandshake via NoiseSessionManager
     // and resume secure communication.
-    @Test func rehandshakeAfterDecryptionFailure() throws {
+    func testRehandshakeAfterDecryptionFailure() throws {
         // Alice <-> Bob connected
-        helper.connect("Alice", "Bob")
+        connect("Alice", "Bob")
 
         // Establish initial Noise session
-        try helper.establishNoiseSession("Alice", "Bob")
+        try establishNoiseSession("Alice", "Bob")
 
-        guard let aliceManager = helper.noiseManagers["Alice"],
+        guard let aliceManager = noiseManagers["Alice"],
-              let bobManager = helper.noiseManagers["Bob"],
+              let bobManager = noiseManagers["Bob"],
-              let alicePeerID = helper.nodes["Alice"]?.peerID,
+              let alicePeerID = nodes["Alice"]?.peerID,
-              let bobPeerID = helper.nodes["Bob"]?.peerID
+              let bobPeerID = nodes["Bob"]?.peerID else {
-        else {
+            return XCTFail("Missing managers or peer IDs")
-            Issue.record("Missing managers or peer IDs")
-            return
         }
 
         // Baseline: encrypt from Alice, decrypt at Bob
         let plaintext1 = Data("hello-secure".utf8)
         let encrypted1 = try aliceManager.encrypt(plaintext1, for: bobPeerID)
         let decrypted1 = try bobManager.decrypt(encrypted1, from: alicePeerID)
-        #expect(decrypted1 == plaintext1)
+        XCTAssertEqual(decrypted1, plaintext1)
 
         // Simulate decryption failure by corrupting ciphertext
-        let corrupted = encrypted1.prefix(15)
+        var corrupted = encrypted1
-        #expect(throws: NoiseError.invalidCiphertext) {
+        if !corrupted.isEmpty { corrupted[corrupted.count - 1] ^= 0xFF }
+        do {
             _ = try bobManager.decrypt(corrupted, from: alicePeerID)
+            XCTFail("Corrupted ciphertext should not decrypt")
+        } catch {
+            // Expected: treat as session desync and rehandshake
         }
 
         // Bob initiates a new handshake; clear Bob's session first so initiateHandshake won't throw
         bobManager.removeSession(for: alicePeerID)
-        try helper.establishNoiseSession("Bob", "Alice")
+        try establishNoiseSession("Bob", "Alice")
 
         // After rehandshake, encryption/decryption works again
         let plaintext2 = Data("hello-again".utf8)
         let encrypted2 = try aliceManager.encrypt(plaintext2, for: bobPeerID)
         let decrypted2 = try bobManager.decrypt(encrypted2, from: alicePeerID)
-        #expect(decrypted2 == plaintext2)
+        XCTAssertEqual(decrypted2, plaintext2)
     }
 
-    @Test func endToEndSecurityScenario() async throws {
+    
-        helper.connect("Alice", "Bob")
+    func testEndToEndSecurityScenario() throws {
-        helper.connect("Bob", "Charlie") // Charlie will try to eavesdrop
+        connect("Alice", "Bob")
+        connect("Bob", "Charlie") // Charlie will try to eavesdrop
         
         // Establish secure session between Alice and Bob only
-        try helper.establishNoiseSession("Alice", "Bob")
+        try establishNoiseSession("Alice", "Bob")
         
-        await confirmation("Secure communication maintained", expectedCount: 2) { receivedPacket in
+        let expectation = XCTestExpectation(description: "Secure communication maintained")
+        var bobDecrypted = false
+        var charlieIntercepted = false
         
         // Setup encryption at Alice
-            helper.nodes["Alice"]!.packetDeliveryHandler = { packet in
+        nodes["Alice"]!.packetDeliveryHandler = { packet in
             if packet.type == 0x01,
                let message = BitchatMessage(packet.payload),
                message.isPrivate && packet.recipientID != nil {
                 // Encrypt private messages
-                    if let encrypted = try? helper.noiseManagers["Alice"]!.encrypt(packet.payload, for: helper.nodes["Bob"]!.peerID) {
+                if let encrypted = try? self.noiseManagers["Alice"]!.encrypt(packet.payload, for: TestConstants.testPeerID2) {
                     let encPacket = BitchatPacket(
                         type: 0x02,
                         senderID: packet.senderID,
@@ -479,38 +544,131 @@ struct IntegrationTests {
                         signature: packet.signature,
                         ttl: packet.ttl
                     )
-                        helper.nodes["Bob"]!.simulateIncomingPacket(encPacket)
+                    self.nodes["Bob"]!.simulateIncomingPacket(encPacket)
                 }
             }
         }
         
         // Bob can decrypt
-            helper.nodes["Bob"]!.packetDeliveryHandler = { packet in
+        nodes["Bob"]!.packetDeliveryHandler = { packet in
             if packet.type == 0x02 {
-                    receivedPacket()
+                if let decrypted = try? self.noiseManagers["Bob"]!.decrypt(packet.payload, from: TestConstants.testPeerID1),
-                    if let decrypted = try? helper.noiseManagers["Bob"]!.decrypt(packet.payload, from: helper.nodes["Alice"]!.peerID) {
+                   let message = BitchatMessage(decrypted) {
-                        #expect(BitchatMessage(decrypted)?.content == "Secret message")
+                    bobDecrypted = message.content == "Secret message"
-                    } else {
+                    expectation.fulfill()
-                        Issue.record("Bob was unable to decrypt the message")
                 }
                 
                 // Relay encrypted packet to Charlie
-                    helper.nodes["Charlie"]!.simulateIncomingPacket(packet)
+                self.nodes["Charlie"]!.simulateIncomingPacket(packet)
             }
         }
         
         // Charlie cannot decrypt
-            helper.nodes["Charlie"]!.packetDeliveryHandler = { packet in
+        nodes["Charlie"]!.packetDeliveryHandler = { packet in
             if packet.type == 0x02 {
-                    receivedPacket()
+                charlieIntercepted = true
-                    #expect(throws: NoiseSessionError.sessionNotFound, "Charlie should not be able to decrypt") {
+                // Try to decrypt (should fail)
-                        _ = try helper.noiseManagers["Charlie"]?.decrypt(packet.payload, from: helper.nodes["Alice"]!.peerID)
+                do {
+                    _ = try self.noiseManagers["Charlie"]?.decrypt(packet.payload, from: TestConstants.testPeerID1)
+                    XCTFail("Charlie should not be able to decrypt")
+                } catch {
+                    // Expected
                 }
             }
         }
         
         // Send encrypted private message
-            helper.nodes["Alice"]!.sendPrivateMessage("Secret message", to: helper.nodes["Bob"]!.peerID, recipientNickname: "Bob")
+        nodes["Alice"]!.sendPrivateMessage("Secret message", to: TestConstants.testPeerID2, recipientNickname: "Bob")
+        
+        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
+        XCTAssertTrue(bobDecrypted)
+        XCTAssertTrue(charlieIntercepted)
+    }
+    
+    // MARK: - Helper Methods
+    
+    private func createNode(_ name: String, peerID: PeerID) {
+        let node = MockBLEService()
+        node.myPeerID = peerID
+        node.mockNickname = name
+        nodes[name] = node
+        
+        // Create Noise manager
+        let key = Curve25519.KeyAgreement.PrivateKey()
+        noiseManagers[name] = NoiseSessionManager(localStaticKey: key, keychain: mockKeychain)
+    }
+    
+    private func connect(_ node1: String, _ node2: String) {
+        guard let n1 = nodes[node1], let n2 = nodes[node2] else { return }
+        n1.simulateConnectedPeer(n2.peerID)
+        n2.simulateConnectedPeer(n1.peerID)
+    }
+    
+    private func disconnect(_ node1: String, _ node2: String) {
+        guard let n1 = nodes[node1], let n2 = nodes[node2] else { return }
+        n1.simulateDisconnectedPeer(n2.peerID)
+        n2.simulateDisconnectedPeer(n1.peerID)
+    }
+    
+    private func connectFullMesh() {
+        let nodeNames = Array(nodes.keys)
+        for i in 0..<nodeNames.count {
+            for j in i+1..<nodeNames.count {
+                connect(nodeNames[i], nodeNames[j])
             }
         }
     }
+    
+    private func setupRelay(_ nodeName: String, nextHops: [String]) {
+        guard let node = nodes[nodeName] else { return }
+        
+        node.packetDeliveryHandler = { packet in
+            guard packet.ttl > 1 else { return }
+            
+            if let message = BitchatMessage(packet.payload) {
+                guard message.senderPeerID != node.peerID else { return }
+                
+                let relayMessage = BitchatMessage(
+                    id: message.id,
+                    sender: message.sender,
+                    content: message.content,
+                    timestamp: message.timestamp,
+                    isRelay: true,
+                    originalSender: message.isRelay ? message.originalSender : message.sender,
+                    isPrivate: message.isPrivate,
+                    recipientNickname: message.recipientNickname,
+                    senderPeerID: message.senderPeerID,
+                    mentions: message.mentions
+                )
+                
+                if let relayPayload = relayMessage.toBinaryPayload() {
+                    let relayPacket = BitchatPacket(
+                        type: packet.type,
+                        senderID: packet.senderID,
+                        recipientID: packet.recipientID,
+                        timestamp: packet.timestamp,
+                        payload: relayPayload,
+                        signature: packet.signature,
+                        ttl: packet.ttl - 1
+                    )
+                    
+                    for hop in nextHops {
+                        self.nodes[hop]?.simulateIncomingPacket(relayPacket)
+                    }
+                }
+            }
+        }
+    }
+    
+    private func establishNoiseSession(_ node1: String, _ node2: String) throws {
+        guard let manager1 = noiseManagers[node1],
+              let manager2 = noiseManagers[node2],
+              let peer1ID = nodes[node1]?.peerID,
+              let peer2ID = nodes[node2]?.peerID else { return }
+        
+        let msg1 = try manager1.initiateHandshake(with: peer2ID)
+        let msg2 = try manager2.handleIncomingHandshake(from: peer1ID, message: msg1)!
+        let msg3 = try manager1.handleIncomingHandshake(from: peer2ID, message: msg2)!
+        _ = try manager2.handleIncomingHandshake(from: peer1ID, message: msg3)
+    }
+}

bitchatTests/Integration/TestNetworkHelper.swift

@@ -1,123 +0,0 @@
-//
-// TestNetworkHelper.swift
-// bitchatTests
-//
-// Extracted shared, mutable integration state for nodes and noise sessions.
-// Keeps test containers nonmutating (Swift Testing-friendly).
-//
-
-import Foundation
-import CryptoKit
-@testable import bitchat
-
-final class TestNetworkHelper {
-    // Public, read-only views for tests; mutation only through methods
-    var nodes: [String: MockBLEService] = [:]
-    var noiseManagers: [String: NoiseSessionManager] = [:]
-    let mockKeychain = MockKeychain()
-    private let bus = MockBLEBus(autoFloodEnabled: true)
-    
-    // MARK: - Node/Manager management
-    
-    @discardableResult
-    func createNode(_ name: String, peerID: PeerID) -> MockBLEService {
-        let node = MockBLEService(bus: bus)
-        node.myPeerID = peerID
-        node.mockNickname = name
-        nodes[name] = node
-        
-        // Create/replace Noise manager for this node
-        let key = Curve25519.KeyAgreement.PrivateKey()
-        noiseManagers[name] = NoiseSessionManager(localStaticKey: key, keychain: mockKeychain)
-        return node
-    }
-    
-    func getNode(_ name: String) -> MockBLEService? {
-        nodes[name]
-    }
-    
-    func getManager(_ name: String) -> NoiseSessionManager? {
-        noiseManagers[name]
-    }
-    
-    // MARK: - Topology
-    
-    func connect(_ a: String, _ b: String) {
-        guard let n1 = nodes[a], let n2 = nodes[b] else { return }
-        n1.simulateConnectedPeer(n2.peerID)
-        n2.simulateConnectedPeer(n1.peerID)
-    }
-    
-    func disconnect(_ a: String, _ b: String) {
-        guard let n1 = nodes[a], let n2 = nodes[b] else { return }
-        n1.simulateDisconnectedPeer(n2.peerID)
-        n2.simulateDisconnectedPeer(n1.peerID)
-    }
-    
-    func connectFullMesh() {
-        let names = Array(nodes.keys)
-        for i in 0..<names.count {
-            for j in (i+1)..<names.count {
-                connect(names[i], names[j])
-            }
-        }
-    }
-    
-    // MARK: - Relay
-    
-    func setupRelay(_ nodeName: String, nextHops: [String]) {
-        guard let node = nodes[nodeName] else { return }
-        node.packetDeliveryHandler = { [weak self] packet in
-            guard let self else { return }
-            guard packet.ttl > 1 else { return }
-            
-            if let message = BitchatMessage(packet.payload) {
-                guard message.senderPeerID != node.peerID else { return }
-                
-                let relayMessage = BitchatMessage(
-                    id: message.id,
-                    sender: message.sender,
-                    content: message.content,
-                    timestamp: message.timestamp,
-                    isRelay: true,
-                    originalSender: message.isRelay ? message.originalSender : message.sender,
-                    isPrivate: message.isPrivate,
-                    recipientNickname: message.recipientNickname,
-                    senderPeerID: message.senderPeerID,
-                    mentions: message.mentions
-                )
-                
-                if let relayPayload = relayMessage.toBinaryPayload() {
-                    let relayPacket = BitchatPacket(
-                        type: packet.type,
-                        senderID: packet.senderID,
-                        recipientID: packet.recipientID,
-                        timestamp: packet.timestamp,
-                        payload: relayPayload,
-                        signature: packet.signature,
-                        ttl: packet.ttl - 1
-                    )
-                    
-                    for hop in nextHops {
-                        self.nodes[hop]?.simulateIncomingPacket(relayPacket)
-                    }
-                }
-            }
-        }
-    }
-    
-    // MARK: - Noise sessions
-    
-    func establishNoiseSession(_ node1: String, _ node2: String) throws {
-        guard let manager1 = noiseManagers[node1],
-              let manager2 = noiseManagers[node2],
-              let peer1ID = nodes[node1]?.peerID,
-              let peer2ID = nodes[node2]?.peerID else { return }
-        
-        let msg1 = try manager1.initiateHandshake(with: peer2ID)
-        let msg2 = try manager2.handleIncomingHandshake(from: peer1ID, message: msg1)!
-        let msg3 = try manager1.handleIncomingHandshake(from: peer2ID, message: msg2)!
-        _ = try manager2.handleIncomingHandshake(from: peer1ID, message: msg3)
-    }
-}
-

bitchatTests/LocationChannelsTests.swift

@@ -1,9 +1,8 @@
-import Testing
+import XCTest
-import Foundation
 @testable import bitchat
 
-struct LocationChannelsTests {
+final class LocationChannelsTests: XCTestCase {
-    @Test func geohashEncoderPrecisionMapping() {
+    func testGeohashEncoderPrecisionMapping() {
         // Sanity: known coords (Statue of Liberty approx)
         let lat = 40.6892
         let lon = -74.0445
@@ -13,35 +12,35 @@ struct LocationChannelsTests {
         let region = Geohash.encode(latitude: lat, longitude: lon, precision: GeohashChannelLevel.province.precision)
         let country = Geohash.encode(latitude: lat, longitude: lon, precision: GeohashChannelLevel.region.precision)
         
-        #expect(block.count == 7)
+        XCTAssertEqual(block.count, 7)
-        #expect(neighborhood.count == 6)
+        XCTAssertEqual(neighborhood.count, 6)
-        #expect(city.count == 5)
+        XCTAssertEqual(city.count, 5)
-        #expect(region.count == 4)
+        XCTAssertEqual(region.count, 4)
-        #expect(country.count == 2)
+        XCTAssertEqual(country.count, 2)
         
         // All prefixes must match progressively
-        #expect(block.hasPrefix(neighborhood))
+        XCTAssertTrue(block.hasPrefix(neighborhood))
-        #expect(neighborhood.hasPrefix(city))
+        XCTAssertTrue(neighborhood.hasPrefix(city))
-        #expect(city.hasPrefix(region))
+        XCTAssertTrue(city.hasPrefix(region))
-        #expect(region.hasPrefix(country))
+        XCTAssertTrue(region.hasPrefix(country))
     }
 
-    @Test func nostrGeohashFilterEncoding() throws {
+    func testNostrGeohashFilterEncoding() throws {
         let gh = "u4pruy"
         let filter = NostrFilter.geohashEphemeral(gh)
         let data = try JSONEncoder().encode(filter)
         let json = String(data: data, encoding: .utf8) ?? ""
         // Expect kinds includes 20000 and tag filter '#g':[gh]
-        #expect(json.contains("20000"))
+        XCTAssertTrue(json.contains("20000"))
-        #expect(json.contains("\"#g\":[\"\(gh)\"]"))
+        XCTAssertTrue(json.contains("\"#g\":[\"\(gh)\"]"))
     }
 
-    @Test func perGeohashIdentityDeterministic() throws {
+    func testPerGeohashIdentityDeterministic() throws {
         // Derive twice for same geohash; should be identical
         let idBridge = NostrIdentityBridge(keychain: MockKeychainHelper())
         let gh = "u4pruy"
         let id1 = try idBridge.deriveIdentity(forGeohash: gh)
         let id2 = try idBridge.deriveIdentity(forGeohash: gh)
-        #expect(id1.publicKeyHex == id2.publicKeyHex)
+        XCTAssertEqual(id1.publicKeyHex, id2.publicKeyHex)
     }
 }

bitchatTests/LocationNotesManagerTests.swift

@@ -1,9 +1,8 @@
-import Testing
+import XCTest
-import Foundation
 @testable import bitchat
 
 @MainActor
-struct LocationNotesManagerTests {
+final class LocationNotesManagerTests: XCTestCase {
 //    func testSubscribeWithoutRelaysSetsNoRelaysState() {
 //        var subscribeCalled = false
 //        let deps = LocationNotesDependencies(
@@ -48,15 +47,15 @@ struct LocationNotesManagerTests {
 //        XCTAssertNotEqual(manager.errorMessage, "location_notes.error.no_relays")
 //    }
 
-    @Test func subscribeUsesGeoRelaysAndAppendsNotes() {
+    func testSubscribeUsesGeoRelaysAndAppendsNotes() {
         var relaysCaptured: [String] = []
         var storedHandler: ((NostrEvent) -> Void)?
         var storedEOSE: (() -> Void)?
         let deps = LocationNotesDependencies(
             relayLookup: { _, _ in ["wss://relay.one"] },
             subscribe: { filter, id, relays, handler, eose in
-                #expect(filter.kinds == [1])
+                XCTAssertEqual(filter.kinds, [1])
-                #expect(!id.isEmpty)
+                XCTAssertFalse(id.isEmpty)
                 relaysCaptured = relays
                 storedHandler = handler
                 storedEOSE = eose
@@ -68,8 +67,8 @@ struct LocationNotesManagerTests {
         )
 
         let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
-        #expect(relaysCaptured == ["wss://relay.one"])
+        XCTAssertEqual(relaysCaptured, ["wss://relay.one"])
-        #expect(manager.state == .loading)
+        XCTAssertEqual(manager.state, .loading)
 
         var event = NostrEvent(
             pubkey: "pub",
@@ -82,9 +81,9 @@ struct LocationNotesManagerTests {
         storedHandler?(event)
         storedEOSE?()
 
-        #expect(manager.state == .ready)
+        XCTAssertEqual(manager.state, .ready)
-        #expect(manager.notes.count == 1)
+        XCTAssertEqual(manager.notes.count, 1)
-        #expect(manager.notes.first?.content == "hi")
+        XCTAssertEqual(manager.notes.first?.content, "hi")
     }
 
     private enum TestError: Error {
@@ -93,8 +92,8 @@ struct LocationNotesManagerTests {
 }
 
 @MainActor
-struct LocationNotesCounterTests {
+final class LocationNotesCounterTests: XCTestCase {
-    @Test func subscribeWithoutRelaysMarksUnavailable() {
+    func testSubscribeWithoutRelaysMarksUnavailable() {
         var subscribeCalled = false
         let deps = LocationNotesCounterDependencies(
             relayLookup: { _, _ in [] },
@@ -105,21 +104,21 @@ struct LocationNotesCounterTests {
         let counter = LocationNotesCounter(testDependencies: deps)
         counter.subscribe(geohash: "u4pruydq")
 
-        #expect(!subscribeCalled)
+        XCTAssertFalse(subscribeCalled)
-        #expect(!counter.relayAvailable)
+        XCTAssertFalse(counter.relayAvailable)
-        #expect(counter.initialLoadComplete)
+        XCTAssertTrue(counter.initialLoadComplete)
-        #expect(counter.count == 0)
+        XCTAssertEqual(counter.count, 0)
     }
 
-    @Test func subscribeCountsUniqueNotes() {
+    func testSubscribeCountsUniqueNotes() {
         var storedHandler: ((NostrEvent) -> Void)?
         var storedEOSE: (() -> Void)?
         let deps = LocationNotesCounterDependencies(
             relayLookup: { _, _ in ["wss://relay.geo"] },
             subscribe: { filter, id, relays, handler, eose in
-                #expect(relays == ["wss://relay.geo"])
+                XCTAssertEqual(relays, ["wss://relay.geo"])
-                #expect(filter.kinds == [1])
+                XCTAssertEqual(filter.kinds, [1])
-                #expect(!id.isEmpty)
+                XCTAssertFalse(id.isEmpty)
                 storedHandler = handler
                 storedEOSE = eose
             },
@@ -144,8 +143,8 @@ struct LocationNotesCounterTests {
 
         storedEOSE?()
 
-        #expect(counter.relayAvailable)
+        XCTAssertTrue(counter.relayAvailable)
-        #expect(counter.count == 1)
+        XCTAssertEqual(counter.count, 1)
-        #expect(counter.initialLoadComplete)
+        XCTAssertTrue(counter.initialLoadComplete)
     }
 }

bitchatTests/Mocks/MockBLEBus.swift

@@ -1,57 +0,0 @@
-//
-// MockBLEBus.swift
-// bitchatTests
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import Foundation
-@testable import bitchat
-
-final class MockBLEBus {
-    private var registry: [PeerID: MockBLEService] = [:]
-    private var adjacency: [PeerID: Set<PeerID>] = [:]
-
-    // Enable automatic flooding for public messages in integration tests only
-    let autoFloodEnabled: Bool
-    
-    init(autoFloodEnabled: Bool = false) {
-        self.autoFloodEnabled = autoFloodEnabled
-    }
-
-    func register(_ service: MockBLEService, for peerID: PeerID) {
-        registry[peerID] = service
-        if adjacency[peerID] == nil { adjacency[peerID] = [] }
-    }
-
-    func connect(_ a: PeerID, _ b: PeerID) {
-        var setA = adjacency[a] ?? []
-        setA.insert(b)
-        adjacency[a] = setA
-        var setB = adjacency[b] ?? []
-        setB.insert(a)
-        adjacency[b] = setB
-    }
-
-    func disconnect(_ a: PeerID, _ b: PeerID) {
-        if var setA = adjacency[a] { setA.remove(b); adjacency[a] = setA }
-        if var setB = adjacency[b] { setB.remove(a); adjacency[b] = setB }
-    }
-
-    func neighbors(of peerID: PeerID) -> [MockBLEService] {
-        let ids = adjacency[peerID] ?? []
-        let result = ids.compactMap { registry[$0] }
-        return result
-    }
-
-    func isDirectNeighbor(_ a: PeerID, _ b: PeerID) -> Bool {
-        let res = adjacency[a]?.contains(b) ?? false
-        return res
-    }
-
-    func service(for peerID: PeerID) -> MockBLEService? {
-        let svc = registry[peerID]
-        return svc
-    }
-}

bitchatTests/Mocks/MockBLEService.swift

@@ -26,12 +26,13 @@ import CoreBluetooth
 ///   simulate broadcast propagation across the mesh. E2E tests keep it off and perform explicit
 ///   relays when needed.
 final class MockBLEService: NSObject {
-    private let bus: MockBLEBus
+    // Enable automatic flooding for public messages in integration tests only
+    static var autoFloodEnabled: Bool = false
     
     // MARK: - Properties matching BLEService
     
     weak var delegate: BitchatDelegate?
-    var myPeerID = PeerID(str: "MOCK1234")
+    var myPeerID: PeerID = "MOCK1234"
     var myNickname: String = "MockUser"
     
     private let mockKeychain = MockKeychain()
@@ -59,8 +60,8 @@ final class MockBLEService: NSObject {
     
     // MARK: - Initialization
     
-    init(bus: MockBLEBus) {
+    override init() {
-        self.bus = bus
+        super.init()
     }
     
     // MARK: - Methods matching BLEService
@@ -70,15 +71,42 @@ final class MockBLEService: NSObject {
     }
     
     // MARK: - In-memory test bus (for E2E/Integration)
+    /// Global per-process bus for deterministic routing in tests.
+    private static var registry: [PeerID: MockBLEService] = [:]
+    private static var adjacency: [PeerID: Set<PeerID>] = [:]
+
+    /// Clears global bus state. Call from test `setUp()`.
+    static func resetTestBus() {
+        registry.removeAll()
+        adjacency.removeAll()
+    }
 
     /// Registers this instance on first use.
     private func registerIfNeeded() {
-        bus.register(self, for: myPeerID)
+        MockBLEService.registry[myPeerID] = self
+        if MockBLEService.adjacency[myPeerID] == nil { MockBLEService.adjacency[myPeerID] = [] }
     }
 
     /// Returns adjacent neighbors based on the current simulated topology.
     private func neighbors() -> [MockBLEService] {
-        bus.neighbors(of: myPeerID)
+        guard let ids = MockBLEService.adjacency[myPeerID] else { return [] }
+        return ids.compactMap { MockBLEService.registry[$0] }
+    }
+
+    /// Adds an undirected edge between two peerIDs.
+    private static func connectPeers(_ a: PeerID, _ b: PeerID) {
+        var setA = adjacency[a] ?? []
+        setA.insert(b)
+        adjacency[a] = setA
+        var setB = adjacency[b] ?? []
+        setB.insert(a)
+        adjacency[b] = setB
+    }
+
+    /// Removes an undirected edge between two peerIDs.
+    private static func disconnectPeers(_ a: PeerID, _ b: PeerID) {
+        if var setA = adjacency[a] { setA.remove(b); adjacency[a] = setA }
+        if var setB = adjacency[b] { setB.remove(a); adjacency[b] = setB }
     }
 
     func startServices() {
@@ -145,7 +173,7 @@ final class MockBLEService: NSObject {
             // Surface raw packet to tests that intercept/relay/encrypt
             packetDeliveryHandler?(packet)
 
-            // Deliver public messages to adjacent peers via bus
+            // Deliver public messages to adjacent peers via test bus
             if recipientID == nil {
                 for neighbor in neighbors() {
                     neighbor.simulateIncomingPacket(packet)
@@ -199,20 +227,24 @@ final class MockBLEService: NSObject {
             packetDeliveryHandler?(packet)
 
             // If directly connected to recipient, deliver only to them.
-            if bus.isDirectNeighbor(myPeerID, recipientPeerID),
+            if let neighbors = MockBLEService.adjacency[myPeerID], neighbors.contains(recipientPeerID),
-               let target = bus.service(for: recipientPeerID) {
+               let target = MockBLEService.registry[recipientPeerID] {
                 target.simulateIncomingPacket(packet)
             } else {
                 // Not directly connected: deliver to neighbors for relay; also deliver directly if target is known
-                if let target = bus.service(for: recipientPeerID) {
+                if let target = MockBLEService.registry[recipientPeerID] {
                     target.simulateIncomingPacket(packet)
                 }
-                for neighbor in neighbors() where neighbor.peerID != recipientPeerID {
+                if let neighbors = MockBLEService.adjacency[myPeerID] {
+                    for peer in neighbors where peer != recipientPeerID {
+                        if let neighbor = MockBLEService.registry[peer] {
                             neighbor.simulateIncomingPacket(packet)
                         }
                     }
                 }
             }
+        }
+    }
     
     func sendFavoriteNotification(to peerID: String, isFavorite: Bool) {
         // Mock implementation
@@ -255,14 +287,14 @@ final class MockBLEService: NSObject {
     
     func simulateConnectedPeer(_ peerID: PeerID) {
         registerIfNeeded()
-        bus.connect(myPeerID, peerID)
+        MockBLEService.connectPeers(myPeerID, peerID)
         connectedPeers.insert(peerID)
         delegate?.didConnectToPeer(peerID)
         delegate?.didUpdatePeerList(Array(connectedPeers))
     }
     
     func simulateDisconnectedPeer(_ peerID: PeerID) {
-        bus.disconnect(myPeerID, peerID)
+        MockBLEService.disconnectPeers(myPeerID, peerID)
         connectedPeers.remove(peerID)
         delegate?.didDisconnectFromPeer(peerID)
         delegate?.didUpdatePeerList(Array(connectedPeers))
@@ -295,7 +327,7 @@ final class MockBLEService: NSObject {
                 // When enabled, propagate a public broadcast across the entire connected
                 // component regardless of the original TTL to better emulate large-network
                 // broadcast expectations. De-duplication via seenMessageIDs prevents loops.
-                if bus.autoFloodEnabled,
+                if MockBLEService.autoFloodEnabled,
                    packet.recipientID == nil,
                    !message.isPrivate {
                     let nextTTL = packet.ttl > 0 ? packet.ttl - 1 : 0
@@ -329,8 +361,8 @@ typealias MockSimplifiedBluetoothService = MockBLEService
 // MARK: - Helpers
 
 extension MockBLEService {
-    convenience init(peerID: PeerID, nickname: String, bus: MockBLEBus) {
+    convenience init(peerID: PeerID, nickname: String) {
-        self.init(bus: bus)
+        self.init()
         myPeerID = peerID
         mockNickname = nickname
     }

bitchatTests/Noise/NoiseProtocolTests.swift

@@ -6,123 +6,135 @@
 // For more information, see <https://unlicense.org>
 //
 
-import Testing
+import XCTest
 import CryptoKit
-import Foundation
 @testable import bitchat
 
-struct NoiseProtocolTests {
+final class NoiseProtocolTests: XCTestCase {
     
-    private let aliceKey = Curve25519.KeyAgreement.PrivateKey()
+    var aliceKey: Curve25519.KeyAgreement.PrivateKey!
-    private let bobKey = Curve25519.KeyAgreement.PrivateKey()
+    var bobKey: Curve25519.KeyAgreement.PrivateKey!
-    private let mockKeychain = MockKeychain()
+    var aliceSession: NoiseSession!
+    var bobSession: NoiseSession!
+    private var mockKeychain: MockKeychain!
     
-    private let alicePeerID = PeerID(str: UUID().uuidString)
+    override func setUp() {
-    private let bobPeerID = PeerID(str: UUID().uuidString)
+        super.setUp()
+        aliceKey = Curve25519.KeyAgreement.PrivateKey()
+        bobKey = Curve25519.KeyAgreement.PrivateKey()
+        mockKeychain = MockKeychain()
+    }
     
-    private let aliceSession: NoiseSession
+    override func tearDown() {
-    private let bobSession: NoiseSession
+        aliceSession = nil
+        bobSession = nil
+        mockKeychain = nil
+        super.tearDown()
+    }
     
-    init() {
+    // MARK: - Basic Handshake Tests
+    
+    func testXXPatternHandshake() throws {
+        // Create sessions
         aliceSession = NoiseSession(
-            peerID: alicePeerID,
+            peerID: TestConstants.testPeerID2,
             role: .initiator,
             keychain: mockKeychain,
             localStaticKey: aliceKey
         )
         
         bobSession = NoiseSession(
-            peerID: bobPeerID,
+            peerID: TestConstants.testPeerID1,
             role: .responder,
             keychain: mockKeychain,
             localStaticKey: bobKey
         )
-    }
         
-    // MARK: - Basic Handshake Tests
-    
-    @Test func xxPatternHandshake() throws {
         // Alice starts handshake (message 1)
         let message1 = try aliceSession.startHandshake()
-        #expect(!message1.isEmpty)
+        XCTAssertFalse(message1.isEmpty)
-        #expect(aliceSession.getState() == .handshaking)
+        XCTAssertEqual(aliceSession.getState(), .handshaking)
         
         // Bob processes message 1 and creates message 2
         let message2 = try bobSession.processHandshakeMessage(message1)
-        #expect(message2 != nil)
+        XCTAssertNotNil(message2)
-        #expect(!message2!.isEmpty)
+        XCTAssertFalse(message2!.isEmpty)
-        #expect(bobSession.getState() == .handshaking)
+        XCTAssertEqual(bobSession.getState(), .handshaking)
         
         // Alice processes message 2 and creates message 3
         let message3 = try aliceSession.processHandshakeMessage(message2!)
-        #expect(message3 != nil)
+        XCTAssertNotNil(message3)
-        #expect(!message3!.isEmpty)
+        XCTAssertFalse(message3!.isEmpty)
-        #expect(aliceSession.getState() == .established)
+        XCTAssertEqual(aliceSession.getState(), .established)
         
         // Bob processes message 3 and completes handshake
         let finalMessage = try bobSession.processHandshakeMessage(message3!)
-        #expect(finalMessage == nil) // No more messages needed
+        XCTAssertNil(finalMessage) // No more messages needed
-        #expect(bobSession.getState() == .established)
+        XCTAssertEqual(bobSession.getState(), .established)
         
         // Verify both sessions are established
-        #expect(aliceSession.isEstablished())
+        XCTAssertTrue(aliceSession.isEstablished())
-        #expect(bobSession.isEstablished())
+        XCTAssertTrue(bobSession.isEstablished())
         
         // Verify they have each other's static keys
-        #expect(aliceSession.getRemoteStaticPublicKey()?.rawRepresentation == bobKey.publicKey.rawRepresentation)
+        XCTAssertEqual(aliceSession.getRemoteStaticPublicKey()?.rawRepresentation, bobKey.publicKey.rawRepresentation)
-        #expect(bobSession.getRemoteStaticPublicKey()?.rawRepresentation == aliceKey.publicKey.rawRepresentation)
+        XCTAssertEqual(bobSession.getRemoteStaticPublicKey()?.rawRepresentation, aliceKey.publicKey.rawRepresentation)
     }
     
-    @Test func handshakeStateValidation() throws {
+    func testHandshakeStateValidation() throws {
+        aliceSession = NoiseSession(
+            peerID: TestConstants.testPeerID2,
+            role: .initiator,
+            keychain: mockKeychain,
+            localStaticKey: aliceKey
+        )
+        
         // Cannot process message before starting handshake
-        #expect(throws: NoiseSessionError.invalidState) {
+        XCTAssertThrowsError(try aliceSession.processHandshakeMessage(Data()))
-            try aliceSession.processHandshakeMessage(Data())
-        }
         
         // Start handshake
         _ = try aliceSession.startHandshake()
         
         // Cannot start handshake twice
-        #expect(throws: NoiseSessionError.invalidState) {
+        XCTAssertThrowsError(try aliceSession.startHandshake())
-            try aliceSession.startHandshake()
-        }
     }
     
     // MARK: - Encryption/Decryption Tests
     
-    @Test func basicEncryptionDecryption() throws {
+    func testBasicEncryptionDecryption() throws {
-        try performHandshake(initiator: aliceSession, responder: bobSession)
+        // Establish sessions
+        try establishSessions()
         
         let plaintext = "Hello, Bob!".data(using: .utf8)!
         
         // Alice encrypts
         let ciphertext = try aliceSession.encrypt(plaintext)
-        #expect(ciphertext != plaintext)
+        XCTAssertNotEqual(ciphertext, plaintext)
-        #expect(ciphertext.count > plaintext.count) // Should have overhead
+        XCTAssertGreaterThan(ciphertext.count, plaintext.count) // Should have overhead
         
         // Bob decrypts
         let decrypted = try bobSession.decrypt(ciphertext)
-        #expect(decrypted == plaintext)
+        XCTAssertEqual(decrypted, plaintext)
     }
     
-    @Test func bidirectionalEncryption() throws {
+    func testBidirectionalEncryption() throws {
-        try performHandshake(initiator: aliceSession, responder: bobSession)
+        try establishSessions()
         
         // Alice -> Bob
         let aliceMessage = "Hello from Alice".data(using: .utf8)!
         let aliceCiphertext = try aliceSession.encrypt(aliceMessage)
         let bobReceived = try bobSession.decrypt(aliceCiphertext)
-        #expect(bobReceived == aliceMessage)
+        XCTAssertEqual(bobReceived, aliceMessage)
         
         // Bob -> Alice
         let bobMessage = "Hello from Bob".data(using: .utf8)!
         let bobCiphertext = try bobSession.encrypt(bobMessage)
         let aliceReceived = try aliceSession.decrypt(bobCiphertext)
-        #expect(aliceReceived == bobMessage)
+        XCTAssertEqual(aliceReceived, bobMessage)
     }
     
-    @Test func largeMessageEncryption() throws {
+    func testLargeMessageEncryption() throws {
-        try performHandshake(initiator: aliceSession, responder: bobSession)
+        try establishSessions()
         
         // Create a large message
         let largeMessage = TestHelpers.generateRandomData(length: 100_000)
@@ -131,78 +143,81 @@ struct NoiseProtocolTests {
         let ciphertext = try aliceSession.encrypt(largeMessage)
         let decrypted = try bobSession.decrypt(ciphertext)
         
-        #expect(decrypted == largeMessage)
+        XCTAssertEqual(decrypted, largeMessage)
     }
     
-    @Test func encryptionBeforeHandshake() {
+    func testEncryptionBeforeHandshake() {
+        aliceSession = NoiseSession(
+            peerID: TestConstants.testPeerID2,
+            role: .initiator,
+            keychain: mockKeychain,
+            localStaticKey: aliceKey
+        )
+        
         let plaintext = "test".data(using: .utf8)!
         
-        #expect(throws: NoiseSessionError.notEstablished) {
+        // Should throw when not established
-            try aliceSession.encrypt(plaintext)
+        XCTAssertThrowsError(try aliceSession.encrypt(plaintext))
-        }
+        XCTAssertThrowsError(try aliceSession.decrypt(plaintext))
-        
-        #expect(throws: NoiseSessionError.notEstablished) {
-            try aliceSession.decrypt(plaintext)
-        }
     }
     
     // MARK: - Session Manager Tests
     
-    @Test func sessionManagerBasicOperations() throws {
+    func testSessionManagerBasicOperations() throws {
         let manager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         
-        #expect(manager.getSession(for: alicePeerID) == nil)
+        // Create session
-
+        let session = manager.createSession(for: TestConstants.testPeerID2, role: .initiator)
-        _ = try manager.initiateHandshake(with: alicePeerID)
+        XCTAssertNotNil(session)
-        #expect(manager.getSession(for: alicePeerID) != nil)
         
         // Get session
-        let retrieved = manager.getSession(for: alicePeerID)
+        let retrieved = manager.getSession(for: TestConstants.testPeerID2)
-        #expect(retrieved != nil)
+        XCTAssertNotNil(retrieved)
+        XCTAssertTrue(session === retrieved)
         
         // Remove session
-        manager.removeSession(for: alicePeerID)
+        manager.removeSession(for: TestConstants.testPeerID2)
-        #expect(manager.getSession(for: alicePeerID) == nil)
+        XCTAssertNil(manager.getSession(for: TestConstants.testPeerID2))
     }
     
-    @Test func sessionManagerHandshakeInitiation() throws {
+    func testSessionManagerHandshakeInitiation() throws {
         let manager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         
         // Initiate handshake
-        let handshakeData = try manager.initiateHandshake(with: alicePeerID)
+        let handshakeData = try manager.initiateHandshake(with: TestConstants.testPeerID2)
-        #expect(!handshakeData.isEmpty)
+        XCTAssertFalse(handshakeData.isEmpty)
         
         // Session should exist
-        let session = manager.getSession(for: alicePeerID)
+        let session = manager.getSession(for: TestConstants.testPeerID2)
-        #expect(session != nil)
+        XCTAssertNotNil(session)
-        #expect(session?.getState() == .handshaking)
+        XCTAssertEqual(session?.getState(), .handshaking)
     }
     
-    @Test func sessionManagerIncomingHandshake() throws {
+    func testSessionManagerIncomingHandshake() throws {
         let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Alice initiates
-        let message1 = try aliceManager.initiateHandshake(with: alicePeerID)
+        let message1 = try aliceManager.initiateHandshake(with: TestConstants.testPeerID2)
         
         // Bob responds
-        let message2 = try bobManager.handleIncomingHandshake(from: bobPeerID, message: message1)
+        let message2 = try bobManager.handleIncomingHandshake(from: TestConstants.testPeerID1, message: message1)
-        #expect(message2 != nil)
+        XCTAssertNotNil(message2)
         
         // Continue handshake
-        let message3 = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: message2!)
+        let message3 = try aliceManager.handleIncomingHandshake(from: TestConstants.testPeerID2, message: message2!)
-        #expect(message3 != nil)
+        XCTAssertNotNil(message3)
         
         // Complete handshake
-        let finalMessage = try bobManager.handleIncomingHandshake(from: bobPeerID, message: message3!)
+        let finalMessage = try bobManager.handleIncomingHandshake(from: TestConstants.testPeerID1, message: message3!)
-        #expect(finalMessage == nil)
+        XCTAssertNil(finalMessage)
         
         // Both should have established sessions
-        #expect(aliceManager.getSession(for: alicePeerID)?.isEstablished() == true)
+        XCTAssertTrue(aliceManager.getSession(for: TestConstants.testPeerID2)?.isEstablished() ?? false)
-        #expect(bobManager.getSession(for: bobPeerID)?.isEstablished() == true)
+        XCTAssertTrue(bobManager.getSession(for: TestConstants.testPeerID1)?.isEstablished() ?? false)
     }
     
-    @Test func sessionManagerEncryptionDecryption() throws {
+    func testSessionManagerEncryptionDecryption() throws {
         let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
@@ -211,17 +226,17 @@ struct NoiseProtocolTests {
         
         // Encrypt with manager
         let plaintext = "Test message".data(using: .utf8)!
-        let ciphertext = try aliceManager.encrypt(plaintext, for: alicePeerID)
+        let ciphertext = try aliceManager.encrypt(plaintext, for: TestConstants.testPeerID2)
         
         // Decrypt with manager
-        let decrypted = try bobManager.decrypt(ciphertext, from: bobPeerID)
+        let decrypted = try bobManager.decrypt(ciphertext, from: TestConstants.testPeerID1)
-        #expect(decrypted == plaintext)
+        XCTAssertEqual(decrypted, plaintext)
     }
     
     // MARK: - Security Tests
     
-    @Test func tamperedCiphertextDetection() throws {
+    func testTamperedCiphertextDetection() throws {
-        try performHandshake(initiator: aliceSession, responder: bobSession)
+        try establishSessions()
         
         let plaintext = "Secret message".data(using: .utf8)!
         var ciphertext = try aliceSession.encrypt(plaintext)
@@ -230,19 +245,11 @@ struct NoiseProtocolTests {
         ciphertext[ciphertext.count / 2] ^= 0xFF
         
         // Decryption should fail
-        if #available(macOS 14.4, iOS 17.4, *) {
+        XCTAssertThrowsError(try bobSession.decrypt(ciphertext))
-            #expect(throws: CryptoKitError.authenticationFailure) {
-                try bobSession.decrypt(ciphertext)
-            }
-        } else {
-            #expect(throws: (any Error).self) {
-                try bobSession.decrypt(ciphertext)
-            }
-        }
     }
     
-    @Test func replayPrevention() throws {
+    func testReplayPrevention() throws {
-        try performHandshake(initiator: aliceSession, responder: bobSession)
+        try establishSessions()
         
         let plaintext = "Test message".data(using: .utf8)!
         let ciphertext = try aliceSession.encrypt(plaintext)
@@ -251,18 +258,16 @@ struct NoiseProtocolTests {
         _ = try bobSession.decrypt(ciphertext)
         
         // Replaying the same ciphertext should fail
-        #expect(throws: NoiseError.replayDetected) {
+        XCTAssertThrowsError(try bobSession.decrypt(ciphertext))
-            try bobSession.decrypt(ciphertext)
-        }
     }
     
-    @Test func sessionIsolation() throws {
+    func testSessionIsolation() throws {
         // Create two separate session pairs
-        let aliceSession1 = NoiseSession(peerID: PeerID(str: "peer1"), role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+        let aliceSession1 = NoiseSession(peerID: "peer1", role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
-        let bobSession1 = NoiseSession(peerID: PeerID(str: "alice1"), role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
+        let bobSession1 = NoiseSession(peerID: "alice1", role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
         
-        let aliceSession2 = NoiseSession(peerID: PeerID(str: "peer2"), role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+        let aliceSession2 = NoiseSession(peerID: "peer2", role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
-        let bobSession2 = NoiseSession(peerID: PeerID(str: "alice2"), role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
+        let bobSession2 = NoiseSession(peerID: "alice2", role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
         
         // Establish both pairs
         try performHandshake(initiator: aliceSession1, responder: bobSession1)
@@ -273,24 +278,16 @@ struct NoiseProtocolTests {
         let ciphertext1 = try aliceSession1.encrypt(plaintext)
         
         // Should not be able to decrypt with session 2
-        if #available(macOS 14.4, iOS 17.4, *) {
+        XCTAssertThrowsError(try bobSession2.decrypt(ciphertext1))
-            #expect(throws: CryptoKitError.authenticationFailure) {
-                try bobSession2.decrypt(ciphertext1)
-            }
-        } else {
-            #expect(throws: (any Error).self) {
-                try bobSession2.decrypt(ciphertext1)
-            }
-        }
         
         // But should work with correct session
         let decrypted = try bobSession1.decrypt(ciphertext1)
-        #expect(decrypted == plaintext)
+        XCTAssertEqual(decrypted, plaintext)
     }
     
     // MARK: - Session Recovery Tests
     
-    @Test func peerRestartDetection() throws {
+    func testPeerRestartDetection() throws {
         // Establish initial sessions
         let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
@@ -298,38 +295,38 @@ struct NoiseProtocolTests {
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
         // Exchange some messages to establish nonce state
-        let message1 = try aliceManager.encrypt("Hello".data(using: .utf8)!, for: alicePeerID)
+        let message1 = try aliceManager.encrypt("Hello".data(using: .utf8)!, for: TestConstants.testPeerID2)
-        _ = try bobManager.decrypt(message1, from: bobPeerID)
+        _ = try bobManager.decrypt(message1, from: TestConstants.testPeerID1)
         
-        let message2 = try bobManager.encrypt("World".data(using: .utf8)!, for: bobPeerID)
+        let message2 = try bobManager.encrypt("World".data(using: .utf8)!, for: TestConstants.testPeerID1)
-        _ = try aliceManager.decrypt(message2, from: alicePeerID)
+        _ = try aliceManager.decrypt(message2, from: TestConstants.testPeerID2)
         
         // Simulate Bob restart by creating new manager with same key
         let bobManagerRestarted = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Bob initiates new handshake after restart
-        let newHandshake1 = try bobManagerRestarted.initiateHandshake(with: bobPeerID)
+        let newHandshake1 = try bobManagerRestarted.initiateHandshake(with: TestConstants.testPeerID1)
         
         // Alice should accept the new handshake (clearing old session)
-        let newHandshake2 = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: newHandshake1)
+        let newHandshake2 = try aliceManager.handleIncomingHandshake(from: TestConstants.testPeerID2, message: newHandshake1)
-        #expect(newHandshake2 != nil)
+        XCTAssertNotNil(newHandshake2)
         
         // Complete the new handshake
-        let newHandshake3 = try bobManagerRestarted.handleIncomingHandshake(from: bobPeerID, message: newHandshake2!)
+        let newHandshake3 = try bobManagerRestarted.handleIncomingHandshake(from: TestConstants.testPeerID1, message: newHandshake2!)
-        #expect(newHandshake3 != nil)
+        XCTAssertNotNil(newHandshake3)
-        _ = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: newHandshake3!)
+        _ = try aliceManager.handleIncomingHandshake(from: TestConstants.testPeerID2, message: newHandshake3!)
         
         // Should be able to exchange messages with new sessions
         let testMessage = "After restart".data(using: .utf8)!
-        let encrypted = try bobManagerRestarted.encrypt(testMessage, for: bobPeerID)
+        let encrypted = try bobManagerRestarted.encrypt(testMessage, for: TestConstants.testPeerID1)
-        let decrypted = try aliceManager.decrypt(encrypted, from: alicePeerID)
+        let decrypted = try aliceManager.decrypt(encrypted, from: TestConstants.testPeerID2)
-        #expect(decrypted == testMessage)
+        XCTAssertEqual(decrypted, testMessage)
     }
     
-    @Test func nonceDesynchronizationRecovery() throws {
+    func testNonceDesynchronizationRecovery() throws {
         // Create two sessions
-        let aliceSession = NoiseSession(peerID: alicePeerID, role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+        aliceSession = NoiseSession(peerID: TestConstants.testPeerID2, role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
-        let bobSession = NoiseSession(peerID: bobPeerID, role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
+        bobSession = NoiseSession(peerID: TestConstants.testPeerID1, role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
         
         // Establish sessions
         try performHandshake(initiator: aliceSession, responder: bobSession)
@@ -347,12 +344,10 @@ struct NoiseProtocolTests {
         
         // With per-packet nonce carried, decryption should not throw here
         let desyncMessage = try aliceSession.encrypt("This now succeeds".data(using: .utf8)!)
-        #expect(throws: Never.self) {
+        XCTAssertNoThrow(try bobSession.decrypt(desyncMessage))
-            try bobSession.decrypt(desyncMessage)
-        }
     }
     
-    @Test func concurrentEncryption() async throws {
+    func testConcurrentEncryption() throws {
         // Test thread safety of encryption operations
         let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
@@ -360,13 +355,14 @@ struct NoiseProtocolTests {
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
         let messageCount = 100
+        let expectation = XCTestExpectation(description: "All messages encrypted and decrypted")
+        expectation.expectedFulfillmentCount = messageCount
 
-        try await confirmation("All messages encrypted and decrypted", expectedCount: messageCount) { completion in
         var encryptedMessages: [Int: Data] = [:]
         // Encrypt messages sequentially to avoid nonce races in manager
         for i in 0..<messageCount {
             let plaintext = "Concurrent message \(i)".data(using: .utf8)!
-                let encrypted = try aliceManager.encrypt(plaintext, for: alicePeerID)
+            let encrypted = try aliceManager.encrypt(plaintext, for: TestConstants.testPeerID2)
             encryptedMessages[i] = encrypted
         }
         
@@ -374,21 +370,22 @@ struct NoiseProtocolTests {
         for i in 0..<messageCount {
             do {
                 guard let encrypted = encryptedMessages[i] else {
-                        Issue.record("Missing encrypted message \(i)")
+                    XCTFail("Missing encrypted message \(i)")
                     return
                 }
-                    let decrypted = try bobManager.decrypt(encrypted, from: bobPeerID)
+                let decrypted = try bobManager.decrypt(encrypted, from: TestConstants.testPeerID1)
                 let expected = "Concurrent message \(i)".data(using: .utf8)!
-                    #expect(decrypted == expected)
+                XCTAssertEqual(decrypted, expected)
-                    completion()
+                expectation.fulfill()
             } catch {
-                    Issue.record("Decryption failed for message \(i): \(error)")
+                XCTFail("Decryption failed for message \(i): \(error)")
-                }
-            }
             }
         }
         
-    @Test func sessionStaleDetection() throws {
+        wait(for: [expectation], timeout: 10.0)
+    }
+    
+    func testSessionStaleDetection() throws {
         // Test that sessions are properly marked as stale
         let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
@@ -399,10 +396,10 @@ struct NoiseProtocolTests {
         let sessions = aliceManager.getSessionsNeedingRekey()
         
         // New session should not need rekey
-        #expect(sessions.isEmpty || sessions.allSatisfy { !$0.needsRekey })
+        XCTAssertTrue(sessions.isEmpty || sessions.allSatisfy { !$0.needsRekey })
     }
     
-    @Test func handshakeAfterDecryptionFailure() throws {
+    func testHandshakeAfterDecryptionFailure() throws {
         // Test that handshake is properly initiated after decryption failure
         let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
@@ -411,25 +408,17 @@ struct NoiseProtocolTests {
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
         // Create a corrupted message
-        var encrypted = try aliceManager.encrypt("Test".data(using: .utf8)!, for: alicePeerID)
+        var encrypted = try aliceManager.encrypt("Test".data(using: .utf8)!, for: TestConstants.testPeerID2)
         encrypted[10] ^= 0xFF // Corrupt the data
         
         // Decryption should fail
-        if #available(macOS 14.4, iOS 17.4, *) {
+        XCTAssertThrowsError(try bobManager.decrypt(encrypted, from: TestConstants.testPeerID1))
-            #expect(throws: CryptoKitError.authenticationFailure) {
-                try bobManager.decrypt(encrypted, from: bobPeerID)
-            }
-        } else {
-            #expect(throws: (any Error).self) {
-                try bobManager.decrypt(encrypted, from: bobPeerID)
-            }
-        }
         
         // Bob should still have the session (it's not removed on single failure)
-        #expect(bobManager.getSession(for: bobPeerID) != nil)
+        XCTAssertNotNil(bobManager.getSession(for: TestConstants.testPeerID1))
     }
     
-    @Test func handshakeAlwaysAcceptedWithExistingSession() throws {
+    func testHandshakeAlwaysAcceptedWithExistingSession() throws {
         // Test that handshake is always accepted even with existing valid session
         let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
@@ -438,38 +427,38 @@ struct NoiseProtocolTests {
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
         // Verify sessions are established
-        #expect(aliceManager.getSession(for: alicePeerID)?.isEstablished() == true)
+        XCTAssertTrue(aliceManager.getSession(for: TestConstants.testPeerID2)?.isEstablished() ?? false)
-        #expect(bobManager.getSession(for: bobPeerID)?.isEstablished() == true)
+        XCTAssertTrue(bobManager.getSession(for: TestConstants.testPeerID1)?.isEstablished() ?? false)
         
         // Exchange messages to verify sessions work
         let testMessage = "Session works".data(using: .utf8)!
-        let encrypted = try aliceManager.encrypt(testMessage, for: alicePeerID)
+        let encrypted = try aliceManager.encrypt(testMessage, for: TestConstants.testPeerID2)
-        let decrypted = try bobManager.decrypt(encrypted, from: bobPeerID)
+        let decrypted = try bobManager.decrypt(encrypted, from: TestConstants.testPeerID1)
-        #expect(decrypted == testMessage)
+        XCTAssertEqual(decrypted, testMessage)
         
         // Alice clears her session (simulating decryption failure)
-        aliceManager.removeSession(for: alicePeerID)
+        aliceManager.removeSession(for: TestConstants.testPeerID2)
         
         // Alice initiates new handshake despite Bob having valid session
-        let newHandshake1 = try aliceManager.initiateHandshake(with: alicePeerID)
+        let newHandshake1 = try aliceManager.initiateHandshake(with: TestConstants.testPeerID2)
         
         // Bob should accept the new handshake even though he has a valid session
-        let newHandshake2 = try bobManager.handleIncomingHandshake(from: bobPeerID, message: newHandshake1)
+        let newHandshake2 = try bobManager.handleIncomingHandshake(from: TestConstants.testPeerID1, message: newHandshake1)
-        #expect(newHandshake2 != nil, "Bob should accept handshake despite having valid session")
+        XCTAssertNotNil(newHandshake2, "Bob should accept handshake despite having valid session")
         
         // Complete the handshake
-        let newHandshake3 = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: newHandshake2!)
+        let newHandshake3 = try aliceManager.handleIncomingHandshake(from: TestConstants.testPeerID2, message: newHandshake2!)
-        #expect(newHandshake3 != nil)
+        XCTAssertNotNil(newHandshake3)
-        _ = try bobManager.handleIncomingHandshake(from: bobPeerID, message: newHandshake3!)
+        _ = try bobManager.handleIncomingHandshake(from: TestConstants.testPeerID1, message: newHandshake3!)
         
         // Verify new sessions work
         let testMessage2 = "New session works".data(using: .utf8)!
-        let encrypted2 = try aliceManager.encrypt(testMessage2, for: alicePeerID)
+        let encrypted2 = try aliceManager.encrypt(testMessage2, for: TestConstants.testPeerID2)
-        let decrypted2 = try bobManager.decrypt(encrypted2, from: bobPeerID)
+        let decrypted2 = try bobManager.decrypt(encrypted2, from: TestConstants.testPeerID1)
-        #expect(decrypted2 == testMessage2)
+        XCTAssertEqual(decrypted2, testMessage2)
     }
     
-    @Test func nonceDesynchronizationCausesRehandshake() throws {
+    func testNonceDesynchronizationCausesRehandshake() throws {
         // Test that nonce desynchronization leads to proper re-handshake
         let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
@@ -479,43 +468,89 @@ struct NoiseProtocolTests {
         
         // Exchange messages normally
         for i in 0..<5 {
-            let msg = try aliceManager.encrypt("Message \(i)".data(using: .utf8)!, for: alicePeerID)
+            let msg = try aliceManager.encrypt("Message \(i)".data(using: .utf8)!, for: TestConstants.testPeerID2)
-            _ = try bobManager.decrypt(msg, from: bobPeerID)
+            _ = try bobManager.decrypt(msg, from: TestConstants.testPeerID1)
         }
         
         // Simulate desynchronization - Alice sends messages that Bob doesn't receive
         for i in 0..<3 {
-            _ = try aliceManager.encrypt("Lost message \(i)".data(using: .utf8)!, for: alicePeerID)
+            _ = try aliceManager.encrypt("Lost message \(i)".data(using: .utf8)!, for: TestConstants.testPeerID2)
         }
         
         // With nonce carried in packet, decryption should not throw here
-        let desyncMessage = try aliceManager.encrypt("This now succeeds".data(using: .utf8)!, for: alicePeerID)
+        let desyncMessage = try aliceManager.encrypt("This now succeeds".data(using: .utf8)!, for: TestConstants.testPeerID2)
-        #expect(throws: Never.self) {
+        XCTAssertNoThrow(try bobManager.decrypt(desyncMessage, from: TestConstants.testPeerID1))
-            try bobManager.decrypt(desyncMessage, from: bobPeerID)
-        }
         
         // Bob clears session and initiates new handshake
-        bobManager.removeSession(for: bobPeerID)
+        bobManager.removeSession(for: TestConstants.testPeerID1)
-        let rehandshake1 = try bobManager.initiateHandshake(with: bobPeerID)
+        let rehandshake1 = try bobManager.initiateHandshake(with: TestConstants.testPeerID1)
         
         // Alice should accept despite having a "valid" (but desynced) session
-        let rehandshake2 = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: rehandshake1)
+        let rehandshake2 = try aliceManager.handleIncomingHandshake(from: TestConstants.testPeerID2, message: rehandshake1)
-        #expect(rehandshake2 != nil, "Alice should accept handshake to fix desync")
+        XCTAssertNotNil(rehandshake2, "Alice should accept handshake to fix desync")
         
         // Complete handshake
-        let rehandshake3 = try bobManager.handleIncomingHandshake(from: bobPeerID, message: rehandshake2!)
+        let rehandshake3 = try bobManager.handleIncomingHandshake(from: TestConstants.testPeerID1, message: rehandshake2!)
-        #expect(rehandshake3 != nil)
+        XCTAssertNotNil(rehandshake3)
-        _ = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: rehandshake3!)
+        _ = try aliceManager.handleIncomingHandshake(from: TestConstants.testPeerID2, message: rehandshake3!)
         
         // Verify communication works again
         let testResynced = "Resynced".data(using: .utf8)!
-        let encryptedResync = try aliceManager.encrypt(testResynced, for: alicePeerID)
+        let encryptedResync = try aliceManager.encrypt(testResynced, for: TestConstants.testPeerID2)
-        let decryptedResync = try bobManager.decrypt(encryptedResync, from: bobPeerID)
+        let decryptedResync = try bobManager.decrypt(encryptedResync, from: TestConstants.testPeerID1)
-        #expect(decryptedResync == testResynced)
+        XCTAssertEqual(decryptedResync, testResynced)
+    }
+    
+    // MARK: - Performance Tests
+    
+    func testHandshakePerformance() throws {
+        measure {
+            do {
+                let alice = NoiseSession(peerID: "bob", role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+                let bob = NoiseSession(peerID: "alice", role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
+                try performHandshake(initiator: alice, responder: bob)
+            } catch {
+                XCTFail("Handshake failed: \(error)")
+            }
+        }
+    }
+    
+    func testEncryptionPerformance() throws {
+        try establishSessions()
+        let message = TestHelpers.generateRandomData(length: 1024)
+        
+        measure {
+            do {
+                for _ in 0..<100 {
+                    let ciphertext = try aliceSession.encrypt(message)
+                    _ = try bobSession.decrypt(ciphertext)
+                }
+            } catch {
+                XCTFail("Encryption/decryption failed: \(error)")
+            }
+        }
     }
     
     // MARK: - Helper Methods
     
+    private func establishSessions() throws {
+        aliceSession = NoiseSession(
+            peerID: TestConstants.testPeerID2,
+            role: .initiator,
+            keychain: mockKeychain,
+            localStaticKey: aliceKey
+        )
+        
+        bobSession = NoiseSession(
+            peerID: TestConstants.testPeerID1,
+            role: .responder,
+            keychain: mockKeychain,
+            localStaticKey: bobKey
+        )
+        
+        try performHandshake(initiator: aliceSession, responder: bobSession)
+    }
+    
     private func performHandshake(initiator: NoiseSession, responder: NoiseSession) throws {
         let msg1 = try initiator.startHandshake()
         let msg2 = try responder.processHandshakeMessage(msg1)!
@@ -524,9 +559,9 @@ struct NoiseProtocolTests {
     }
     
     private func establishManagerSessions(aliceManager: NoiseSessionManager, bobManager: NoiseSessionManager) throws {
-        let msg1 = try aliceManager.initiateHandshake(with: alicePeerID)
+        let msg1 = try aliceManager.initiateHandshake(with: TestConstants.testPeerID2)
-        let msg2 = try bobManager.handleIncomingHandshake(from: bobPeerID, message: msg1)!
+        let msg2 = try bobManager.handleIncomingHandshake(from: TestConstants.testPeerID1, message: msg1)!
-        let msg3 = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: msg2)!
+        let msg3 = try aliceManager.handleIncomingHandshake(from: TestConstants.testPeerID2, message: msg2)!
-        _ = try bobManager.handleIncomingHandshake(from: bobPeerID, message: msg3)
+        _ = try bobManager.handleIncomingHandshake(from: TestConstants.testPeerID1, message: msg3)
     }
 }

bitchatTests/NostrProtocolTests.swift

@@ -5,20 +5,20 @@
 // Tests for NIP-17 gift-wrapped private messages
 //
 
-import Testing
+import XCTest
-import CryptoKit
-import Foundation
 @testable import bitchat
 
-struct NostrProtocolTests {
+final class NostrProtocolTests: XCTestCase {
     
-    @Test func nip17MessageRoundTrip() throws {
+    func testNIP17MessageRoundTrip() throws {
         // Create sender and recipient identities
         let sender = try NostrIdentity.generate()
         let recipient = try NostrIdentity.generate()
         
+        #if DEBUG
         print("Sender pubkey: \(sender.publicKeyHex)")
         print("Recipient pubkey: \(recipient.publicKeyHex)")
+        #endif
         
         // Create a test message
         let originalContent = "Hello from NIP-17 test!"
@@ -30,8 +30,10 @@ struct NostrProtocolTests {
             senderIdentity: sender
         )
         
+        #if DEBUG
         print("Gift wrap created with ID: \(giftWrap.id)")
         print("Gift wrap pubkey: \(giftWrap.pubkey)")
+        #endif
         
         // Decrypt the gift wrap
         let (decryptedContent, senderPubkey, timestamp) = try NostrProtocol.decryptPrivateMessage(
@@ -40,18 +42,20 @@ struct NostrProtocolTests {
         )
         
         // Verify
-        #expect(decryptedContent == originalContent)
+        XCTAssertEqual(decryptedContent, originalContent)
-        #expect(senderPubkey == sender.publicKeyHex)
+        XCTAssertEqual(senderPubkey, sender.publicKeyHex)
         
         // Verify timestamp is reasonable (within last minute)
         let messageDate = Date(timeIntervalSince1970: TimeInterval(timestamp))
         let timeDiff = abs(messageDate.timeIntervalSinceNow)
-        #expect(timeDiff < 60, "Message timestamp should be recent")
+        XCTAssertLessThan(timeDiff, 60, "Message timestamp should be recent")
         
+        #if DEBUG
         print("✅ Successfully decrypted message: '\(decryptedContent)' from \(senderPubkey) at \(messageDate)")
+        #endif
     }
     
-    @Test func giftWrapUsesUniqueEphemeralKeys() throws {
+    func testGiftWrapUsesUniqueEphemeralKeys() throws {
         // Create identities
         let sender = try NostrIdentity.generate()
         let recipient = try NostrIdentity.generate()
@@ -70,10 +74,11 @@ struct NostrProtocolTests {
         )
         
         // Gift wrap pubkeys should be different (unique ephemeral keys)
-        #expect(message1.pubkey != message2.pubkey)
+        XCTAssertNotEqual(message1.pubkey, message2.pubkey)
-        
+        #if DEBUG
         print("Message 1 gift wrap pubkey: \(message1.pubkey)")
         print("Message 2 gift wrap pubkey: \(message2.pubkey)")
+        #endif
         
         // Both should decrypt successfully
         let (content1, _, _) = try NostrProtocol.decryptPrivateMessage(
@@ -85,11 +90,11 @@ struct NostrProtocolTests {
             recipientIdentity: recipient
         )
         
-        #expect(content1 == "Message 1")
+        XCTAssertEqual(content1, "Message 1")
-        #expect(content2 == "Message 2")
+        XCTAssertEqual(content2, "Message 2")
     }
     
-    @Test func decryptionFailsWithWrongRecipient() throws {
+    func testDecryptionFailsWithWrongRecipient() throws {
         let sender = try NostrIdentity.generate()
         let recipient = try NostrIdentity.generate()
         let wrongRecipient = try NostrIdentity.generate()
@@ -102,20 +107,13 @@ struct NostrProtocolTests {
         )
         
         // Try to decrypt with wrong recipient
-        if #available(macOS 14.4, iOS 17.4, *) {
+        XCTAssertThrowsError(try NostrProtocol.decryptPrivateMessage(
-            #expect(throws: CryptoKitError.authenticationFailure) {
-                try NostrProtocol.decryptPrivateMessage(
             giftWrap: giftWrap,
             recipientIdentity: wrongRecipient
-                )
+        )) { error in
-            }
+            #if DEBUG
-        } else {
+            print("Expected error when decrypting with wrong key: \(error)")
-            #expect(throws: (any Error).self) {
+            #endif
-                try NostrProtocol.decryptPrivateMessage(
-                    giftWrap: giftWrap,
-                    recipientIdentity: wrongRecipient
-                )
-            }
         }
     }
 
@@ -127,11 +125,10 @@ struct NostrProtocolTests {
         // Build a DELIVERED ack embedded payload (geohash-style, no recipient peer ID)
         let messageID = "TEST-MSG-DELIVERED-1"
         let senderPeerID = "0123456789abcdef" // 8-byte hex peer ID
-
+        guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID) else {
-        let embedded = try #require(
+            XCTFail("Failed to embed delivered ack")
-            NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID),
+            return
-            "Failed to embed delivered ack"
+        }
-        )
 
         // Create NIP-17 gift wrap to recipient (uses NIP-44 v2 internally)
         let giftWrap = try NostrProtocol.createPrivateMessage(
@@ -141,7 +138,7 @@ struct NostrProtocolTests {
         )
 
         // Ensure v2 format was used for ciphertext
-        #expect(giftWrap.content.hasPrefix("v2:"))
+        XCTAssertTrue(giftWrap.content.hasPrefix("v2:"))
 
         // Decrypt as recipient
         let (content, senderPubkey, _) = try NostrProtocol.decryptPrivateMessage(
@@ -150,37 +147,39 @@ struct NostrProtocolTests {
         )
 
         // Verify sender is correct
-        #expect(senderPubkey == sender.publicKeyHex)
+        XCTAssertEqual(senderPubkey, sender.publicKeyHex)
 
         // Parse BitChat payload
-        #expect(content.hasPrefix("bitchat1:"))
+        XCTAssertTrue(content.hasPrefix("bitchat1:"))
         let base64url = String(content.dropFirst("bitchat1:".count))
-        let packetData = try #require(Self.base64URLDecode(base64url))
+        guard let packetData = Self.base64URLDecode(base64url),
-        let packet = try #require(BitchatPacket.from(packetData), "Failed to decode bitchat packet")
+              let packet = BitchatPacket.from(packetData) else {
-        
+            return XCTFail("Failed to decode bitchat packet")
-        #expect(packet.type == MessageType.noiseEncrypted.rawValue)
+        }
-        let payload = try #require(NoisePayload.decode(packet.payload), "Failed to decode NoisePayload")
+        XCTAssertEqual(packet.type, MessageType.noiseEncrypted.rawValue)
-        
+        guard let payload = NoisePayload.decode(packet.payload) else {
+            return XCTFail("Failed to decode NoisePayload")
+        }
         switch payload.type {
         case .delivered:
             let mid = String(data: payload.data, encoding: .utf8)
-            #expect(mid == messageID)
+            XCTAssertEqual(mid, messageID)
         default:
-            Issue.record("Unexpected payload type: \(payload.type)")
+            XCTFail("Unexpected payload type: \(payload.type)")
         }
     }
 
-    @Test func ackRoundTripNIP44V2_ReadReceipt() throws {
+    func testAckRoundTripNIP44V2_ReadReceipt() throws {
         // Identities
         let sender = try NostrIdentity.generate()
         let recipient = try NostrIdentity.generate()
 
         let messageID = "TEST-MSG-READ-1"
         let senderPeerID = "fedcba9876543210" // 8-byte hex peer ID
-        let embedded = try #require(
+        guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID) else {
-            NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID),
+            XCTFail("Failed to embed read ack")
-            "Failed to embed read ack"
+            return
-        )
+        }
 
         let giftWrap = try NostrProtocol.createPrivateMessage(
             content: embedded,
@@ -188,28 +187,30 @@ struct NostrProtocolTests {
             senderIdentity: sender
         )
 
-        #expect(giftWrap.content.hasPrefix("v2:"))
+        XCTAssertTrue(giftWrap.content.hasPrefix("v2:"))
 
         let (content, senderPubkey, _) = try NostrProtocol.decryptPrivateMessage(
             giftWrap: giftWrap,
             recipientIdentity: recipient
         )
-        #expect(senderPubkey == sender.publicKeyHex)
+        XCTAssertEqual(senderPubkey, sender.publicKeyHex)
 
-        #expect(content.hasPrefix("bitchat1:"))
+        XCTAssertTrue(content.hasPrefix("bitchat1:"))
         let base64url = String(content.dropFirst("bitchat1:".count))
-        let packetData = try #require(Self.base64URLDecode(base64url))
+        guard let packetData = Self.base64URLDecode(base64url),
-        let packet = try #require(BitchatPacket.from(packetData), "Failed to decode bitchat packet")
+              let packet = BitchatPacket.from(packetData) else {
-        
+            return XCTFail("Failed to decode bitchat packet")
-        #expect(packet.type == MessageType.noiseEncrypted.rawValue)
+        }
-        let payload = try #require(NoisePayload.decode(packet.payload), "Failed to decode NoisePayload")
+        XCTAssertEqual(packet.type, MessageType.noiseEncrypted.rawValue)
-        
+        guard let payload = NoisePayload.decode(packet.payload) else {
+            return XCTFail("Failed to decode NoisePayload")
+        }
         switch payload.type {
         case .readReceipt:
             let mid = String(data: payload.data, encoding: .utf8)
-            #expect(mid == messageID)
+            XCTAssertEqual(mid, messageID)
         default:
-            Issue.record("Unexpected payload type: \(payload.type)")
+            XCTFail("Unexpected payload type: \(payload.type)")
         }
     }
 

bitchatTests/NotificationStreamAssemblerTests.swift

@@ -1,8 +1,7 @@
-import Testing
+import XCTest
-import Foundation
 @testable import bitchat
 
-struct NotificationStreamAssemblerTests {
+final class NotificationStreamAssemblerTests: XCTestCase {
     private func makePacket(timestamp: UInt64 = 0x0102030405) -> BitchatPacket {
         let sender = Data([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77])
         return BitchatPacket(
@@ -16,51 +15,60 @@ struct NotificationStreamAssemblerTests {
         )
     }
 
-    @Test func assemblesSingleFrameAcrossChunks() throws {
+    func testAssemblesSingleFrameAcrossChunks() {
         var assembler = NotificationStreamAssembler()
         let packet = makePacket()
-        let frame = try #require(packet.toBinaryData(padding: false), "Failed to encode packet")
+        guard let frame = packet.toBinaryData(padding: false) else {
-
+            return XCTFail("Failed to encode packet")
-        #expect(BinaryProtocol.decode(frame) != nil)
+        }
+        XCTAssertNotNil(BinaryProtocol.decode(frame))
         let payloadLen = (Int(frame[12]) << 8) | Int(frame[13])
-        #expect(payloadLen == packet.payload.count)
+        XCTAssertEqual(payloadLen, packet.payload.count)
 
         let splitIndex = min(20, max(1, frame.count / 2))
         let first = frame.prefix(splitIndex)
         let second = frame.suffix(from: splitIndex)
-        #expect(first.count + second.count == frame.count)
+        XCTAssertEqual(first.count + second.count, frame.count)
 
         var result = assembler.append(first)
-        #expect(result.frames.isEmpty)
+        XCTAssertTrue(result.frames.isEmpty)
-        #expect(result.droppedPrefixes.isEmpty)
+        XCTAssertTrue(result.droppedPrefixes.isEmpty)
-        #expect(!result.reset)
+        XCTAssertFalse(result.reset)
 
         result = assembler.append(second)
-        #expect(result.frames.count == 1)
+        XCTAssertEqual(result.frames.count, 1)
-        #expect(result.droppedPrefixes.isEmpty)
+        XCTAssertTrue(result.droppedPrefixes.isEmpty)
-        #expect(!result.reset)
+        XCTAssertFalse(result.reset)
 
-        let frameData = try #require(result.frames.first, "Missing frame data")
+        guard let frameData = result.frames.first else {
-        #expect(frameData.count == frame.count)
+            return XCTFail("Missing frame data")
-        
+        }
-        let decoded = try #require(BinaryProtocol.decode(frameData), "Failed to decode frame")
+        if frameData.count != frame.count {
-        #expect(decoded.type == packet.type)
+            XCTFail("Frame size mismatch: expected \(frame.count) got \(frameData.count)\nframe=\(Array(frame))\nassembled=\(Array(frameData))")
-        #expect(decoded.payload == packet.payload)
+            return
-        #expect(decoded.senderID == packet.senderID)
+        }
-        #expect(decoded.timestamp == packet.timestamp)
+        guard let decoded = BinaryProtocol.decode(frameData) else {
+            return XCTFail("Failed to decode frame")
+        }
+        XCTAssertEqual(decoded.type, packet.type)
+        XCTAssertEqual(decoded.payload, packet.payload)
+        XCTAssertEqual(decoded.senderID, packet.senderID)
+        XCTAssertEqual(decoded.timestamp, packet.timestamp)
 
         var directAssembler = NotificationStreamAssembler()
         let directResult = directAssembler.append(frame)
-        #expect(directResult.frames.first?.count == frame.count)
+        XCTAssertEqual(directResult.frames.first?.count, frame.count)
     }
 
-    @Test func assemblesMultipleFramesSequentially() throws {
+    func testAssemblesMultipleFramesSequentially() {
         var assembler = NotificationStreamAssembler()
         let packet1 = makePacket(timestamp: 0xABC)
         let packet2 = makePacket(timestamp: 0xDEF)
 
-        let frame1 = try #require(packet1.toBinaryData(padding: false), "Failed to encode packet")
+        guard let frame1 = packet1.toBinaryData(padding: false),
-        let frame2 = try #require(packet2.toBinaryData(padding: false), "Failed to encode packet")
+              let frame2 = packet2.toBinaryData(padding: false) else {
+            return XCTFail("Failed to encode packets")
+        }
 
         var combined = Data()
         combined.append(frame1)
@@ -69,31 +77,36 @@ struct NotificationStreamAssemblerTests {
         let secondChunk = combined.suffix(from: 20)
 
         var result = assembler.append(firstChunk)
-        #expect(result.frames.isEmpty)
+        XCTAssertTrue(result.frames.isEmpty)
 
         result = assembler.append(secondChunk)
-        #expect(result.frames.count == 2)
+        XCTAssertEqual(result.frames.count, 2)
-        
+        guard let decoded1 = BinaryProtocol.decode(result.frames[0]),
-        let decoded1 = try #require(BinaryProtocol.decode(result.frames[0]), "Failed to decode frame")
+              let decoded2 = BinaryProtocol.decode(result.frames[1]) else {
-        let decoded2 = try #require(BinaryProtocol.decode(result.frames[1]), "Failed to decode frame")
+            return XCTFail("Failed to decode frames")
-        #expect(decoded1.timestamp == packet1.timestamp)
+        }
-        #expect(decoded2.timestamp == packet2.timestamp)
+        XCTAssertEqual(decoded1.timestamp, packet1.timestamp)
+        XCTAssertEqual(decoded2.timestamp, packet2.timestamp)
     }
 
-    @Test func dropsInvalidPrefixByte() throws {
+    func testDropsInvalidPrefixByte() {
         var assembler = NotificationStreamAssembler()
         let packet = makePacket(timestamp: 0xF00)
-        let frame = try #require(packet.toBinaryData(padding: false), "Failed to encode packet")
+        guard let frame = packet.toBinaryData(padding: false) else {
+            return XCTFail("Failed to encode packet")
+        }
         var noisyFrame = Data([0x00])
         noisyFrame.append(frame)
 
         let result = assembler.append(noisyFrame)
-        #expect(result.droppedPrefixes == [0x00])
+        XCTAssertEqual(result.droppedPrefixes, [0x00])
-        #expect(result.frames.count == 1)
+        XCTAssertEqual(result.frames.count, 1)
-        #expect(result.reset == false)
+        XCTAssertFalse(result.reset)
 
-        let decoded = try #require(BinaryProtocol.decode(result.frames[0]), "Failed to decode frame after drop")
+        guard let decoded = BinaryProtocol.decode(result.frames[0]) else {
-        #expect(decoded.timestamp == packet.timestamp)
+            return XCTFail("Failed to decode frame after drop")
+        }
+        XCTAssertEqual(decoded.timestamp, packet.timestamp)
     }
 
     func testAssemblesCompressedLargeFrame() throws {
@@ -107,7 +120,9 @@ struct NotificationStreamAssemblerTests {
             mimeType: "application/octet-stream",
             content: largeContent
         )
-        let tlvPayload = try #require(filePacket.encode(), "Failed to encode file packet")
+        guard let tlvPayload = filePacket.encode() else {
+            return XCTFail("Failed to encode file packet")
+        }
 
         let senderID = Data(repeating: 0xAA, count: BinaryProtocol.senderIDSize)
         let packet = BitchatPacket(
@@ -121,31 +136,39 @@ struct NotificationStreamAssemblerTests {
             version: 2
         )
 
-        let frame = try #require(packet.toBinaryData(padding: false), "Failed to encode packet frame")
+        guard let frame = packet.toBinaryData(padding: false) else {
+            return XCTFail("Failed to encode packet frame")
+        }
 
-        #expect(BinaryProtocol.Offsets.flags < frame.count)
+        XCTAssertLessThan(BinaryProtocol.Offsets.flags, frame.count)
         let flags = frame[frame.startIndex + BinaryProtocol.Offsets.flags]
-        #expect((flags & BinaryProtocol.Flags.isCompressed) != 0, "Frame should be compressed for large payloads")
+        XCTAssertNotEqual(flags & BinaryProtocol.Flags.isCompressed, 0, "Frame should be compressed for large payloads")
 
         let splitIndex = min(4096, frame.count / 2)
         var result = assembler.append(frame.prefix(splitIndex))
-        #expect(result.frames.isEmpty)
+        XCTAssertTrue(result.frames.isEmpty)
 
         result = assembler.append(frame.suffix(from: splitIndex))
-        #expect(result.frames.count == 1)
+        XCTAssertEqual(result.frames.count, 1)
-        #expect(result.droppedPrefixes.isEmpty)
+        XCTAssertTrue(result.droppedPrefixes.isEmpty)
-        #expect(result.reset == false)
+        XCTAssertFalse(result.reset)
 
-        let assembled = try #require(result.frames.first, "Missing assembled frame")
+        guard let assembled = result.frames.first else {
-        #expect(assembled.count == frame.count)
+            return XCTFail("Missing assembled frame")
+        }
+        XCTAssertEqual(assembled.count, frame.count)
 
-        let decodedPacket = try #require(BinaryProtocol.decode(assembled), "Failed to decode compressed frame")
+        guard let decodedPacket = BinaryProtocol.decode(assembled) else {
-        #expect(decodedPacket.payload.count == tlvPayload.count)
+            return XCTFail("Failed to decode compressed frame")
+        }
+        XCTAssertEqual(decodedPacket.payload.count, tlvPayload.count)
 
-        let decodedFile = try #require(BitchatFilePacket.decode(decodedPacket.payload), "Failed to decode TLV payload")
+        guard let decodedFile = BitchatFilePacket.decode(decodedPacket.payload) else {
-        #expect(decodedFile.fileName == filePacket.fileName)
+            return XCTFail("Failed to decode TLV payload")
-        #expect(decodedFile.mimeType == filePacket.mimeType)
+        }
-        #expect(decodedFile.content.count == largeContent.count)
+        XCTAssertEqual(decodedFile.fileName, filePacket.fileName)
-        #expect(decodedFile.content.prefix(32) == largeContent.prefix(32))
+        XCTAssertEqual(decodedFile.mimeType, filePacket.mimeType)
+        XCTAssertEqual(decodedFile.content.count, largeContent.count)
+        XCTAssertEqual(decodedFile.content.prefix(32), largeContent.prefix(32))
     }
 }

bitchatTests/Protocol/BinaryProtocolPaddingTests.swift

@@ -5,29 +5,30 @@
 // This is free and unencumbered software released into the public domain.
 //
 
-import Testing
+import XCTest
 @testable import bitchat
 
-struct BinaryProtocolPaddingTests {
+final class BinaryProtocolPaddingTests: XCTestCase {
-    @Test func padded_vs_unpadded_length() throws {
+    func test_padded_vs_unpadded_length() throws {
         // Use helper to create a small test packet
         let packet = TestHelpers.createTestPacket()
-        let padded = try #require(BinaryProtocol.encode(packet, padding: true), "encode padded")
+        guard let padded = BinaryProtocol.encode(packet, padding: true) else { return XCTFail("encode padded") }
-        let unpadded = try #require(BinaryProtocol.encode(packet, padding: false), "encode unpadded")
+        guard let unpadded = BinaryProtocol.encode(packet, padding: false) else { return XCTFail("encode unpadded") }
-        #expect(padded.count >= unpadded.count, "Padded frame should be >= unpadded")
+        XCTAssertGreaterThanOrEqual(padded.count, unpadded.count, "Padded frame should be >= unpadded")
     }
 
-    @Test func decode_padded_and_unpadded_round_trip() throws {
+    func test_decode_padded_and_unpadded_round_trip() throws {
         let packet = TestHelpers.createTestPacket()
-
+        // Padded
-        let padded = try #require(BinaryProtocol.encode(packet, padding: true), "encode padded")
+        guard let padded = BinaryProtocol.encode(packet, padding: true) else { return XCTFail("encode padded") }
-        let dec1 = try #require(BinaryProtocol.decode(padded), "decode padded")
+        guard let dec1 = BinaryProtocol.decode(padded) else { return XCTFail("decode padded") }
-        #expect(dec1.type == packet.type)
+        XCTAssertEqual(dec1.type, packet.type)
-        #expect(dec1.payload == packet.payload)
+        XCTAssertEqual(dec1.payload, packet.payload)
-
+        // Unpadded
-        let unpadded = try #require(BinaryProtocol.encode(packet, padding: false), "encode unpadded")
+        guard let unpadded = BinaryProtocol.encode(packet, padding: false) else { return XCTFail("encode unpadded") }
-        let dec2 = try #require(BinaryProtocol.decode(unpadded), "decode unpadded")
+        guard let dec2 = BinaryProtocol.decode(unpadded) else { return XCTFail("decode unpadded") }
-        #expect(dec2.type == packet.type)
+        XCTAssertEqual(dec2.type, packet.type)
-        #expect(dec2.payload == packet.payload)
+        XCTAssertEqual(dec2.payload, packet.payload)
     }
 }
+

bitchatTests/Protocol/BinaryProtocolTests.swift

@@ -6,90 +6,123 @@
 // For more information, see <https://unlicense.org>
 //
 
-import Testing
+import XCTest
-import Foundation
 @testable import bitchat
 
-struct BinaryProtocolTests {
+final class BinaryProtocolTests: XCTestCase {
     
     // MARK: - Basic Encoding/Decoding Tests
     
-    @Test func basicPacketEncodingDecoding() throws {
+    func testBasicPacketEncodingDecoding() throws {
         let originalPacket = TestHelpers.createTestPacket()
         
-        let encodedData = try #require(BinaryProtocol.encode(originalPacket), "Failed to encode packet")
+        // Encode
-        let decodedPacket = try #require(BinaryProtocol.decode(encodedData), "Failed to decode packet")
+        guard let encodedData = BinaryProtocol.encode(originalPacket) else {
+            XCTFail("Failed to encode packet")
+            return
+        }
+        
+        // Decode
+        guard let decodedPacket = BinaryProtocol.decode(encodedData) else {
+            XCTFail("Failed to decode packet")
+            return
+        }
         
         // Verify
-        #expect(decodedPacket.type == originalPacket.type)
+        XCTAssertEqual(decodedPacket.type, originalPacket.type)
-        #expect(decodedPacket.ttl == originalPacket.ttl)
+        XCTAssertEqual(decodedPacket.ttl, originalPacket.ttl)
-        #expect(decodedPacket.timestamp == originalPacket.timestamp)
+        XCTAssertEqual(decodedPacket.timestamp, originalPacket.timestamp)
-        #expect(decodedPacket.payload == originalPacket.payload)
+        XCTAssertEqual(decodedPacket.payload, originalPacket.payload)
         
         // Sender ID should match (accounting for padding)
         let originalSenderID = originalPacket.senderID.prefix(BinaryProtocol.senderIDSize)
         let decodedSenderID = decodedPacket.senderID.trimmingNullBytes()
-        #expect(decodedSenderID == originalSenderID)
+        XCTAssertEqual(decodedSenderID, originalSenderID)
     }
     
-    @Test func packetWithRecipient() throws {
+    func testPacketWithRecipient() throws {
-        let recipientID = PeerID(str: "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789")
+        let recipientID = TestConstants.testPeerID2
         let packet = TestHelpers.createTestPacket(recipientID: recipientID)
-        let encodedData = try #require(BinaryProtocol.encode(packet), "Failed to encode packet with recipient")
+        
-        let decodedPacket = try #require(BinaryProtocol.decode(encodedData), "Failed to decode packet with recipient")
+        // Encode and decode
+        guard let encodedData = BinaryProtocol.encode(packet),
+              let decodedPacket = BinaryProtocol.decode(encodedData) else {
+            XCTFail("Failed to encode/decode packet with recipient")
+            return
+        }
         
         // Verify recipient
-        #expect(decodedPacket.recipientID != nil)
+        XCTAssertNotNil(decodedPacket.recipientID)
         let decodedRecipientID = decodedPacket.recipientID?.trimmingNullBytes()
-        // TODO: Check if this is intended that the decoding only gets the first 8
+        XCTAssertTrue(String(data: decodedRecipientID!, encoding: .utf8) == recipientID)
-        #expect(String(data: decodedRecipientID!, encoding: .utf8) == "abcdef01")
     }
     
-    @Test func packetWithSignature() throws {
+    func testPacketWithSignature() throws {
-        let packet = TestHelpers.createTestPacket(signature: TestConstants.testSignature)
+        let packet = TestHelpers.createTestPacket(
-        let encodedData = try #require(BinaryProtocol.encode(packet), "Failed to encode packet with signature")
+            signature: TestConstants.testSignature
-        let decodedPacket = try #require(BinaryProtocol.decode(encodedData), "Failed to decode packet with signature")
+        )
+        
+        // Encode and decode
+        guard let encodedData = BinaryProtocol.encode(packet),
+              let decodedPacket = BinaryProtocol.decode(encodedData) else {
+            XCTFail("Failed to encode/decode packet with signature")
+            return
+        }
         
         // Verify signature
-        #expect(decodedPacket.signature != nil)
+        XCTAssertNotNil(decodedPacket.signature)
-        #expect(decodedPacket.signature == TestConstants.testSignature)
+        XCTAssertEqual(decodedPacket.signature, TestConstants.testSignature)
     }
     
     // MARK: - Compression Tests
     
-    @Test("Create a large, compressible payload above current threshold (2048B)")
+    func testPayloadCompression() throws {
-    func payloadCompression() throws {
+        // Create a large, compressible payload above current threshold (2048B)
         let repeatedString = String(repeating: "This is a test message. ", count: 200)
         let largePayload = repeatedString.data(using: .utf8)!
         
         let packet = TestHelpers.createTestPacket(payload: largePayload)
         
         // Encode (should compress)
-        let encodedData = try #require(BinaryProtocol.encode(packet), "Failed to encode packet with large payload")
+        guard let encodedData = BinaryProtocol.encode(packet) else {
-        
+            XCTFail("Failed to encode packet with large payload")
-        // The encoded size should be smaller than uncompressed due to compression
+            return
-        let headerSize = try #require(BinaryProtocol.headerSize(for: packet.version), "Invalid packet version")
-        let uncompressedSize = headerSize + BinaryProtocol.senderIDSize + largePayload.count
-        #expect(encodedData.count < uncompressedSize, "Compressed packet should be smaller than uncompressed form")
-        
-        // Decode and verify
-        let decodedPacket = try #require(BinaryProtocol.decode(encodedData), "Failed to decode compressed packet")
-        
-        #expect(decodedPacket.payload == largePayload)
         }
         
-    @Test("Small payloads should not be compressed")
+        // The encoded size should be smaller than uncompressed due to compression
-    func smallPayloadNoCompression() throws {
+        guard let headerSize = BinaryProtocol.headerSize(for: packet.version) else {
+            XCTFail("Invalid version")
+            return
+        }
+        let uncompressedSize = headerSize + BinaryProtocol.senderIDSize + largePayload.count
+        XCTAssertLessThan(encodedData.count, uncompressedSize)
+        
+        // Decode and verify
+        guard let decodedPacket = BinaryProtocol.decode(encodedData) else {
+            XCTFail("Failed to decode compressed packet")
+            return
+        }
+        
+        XCTAssertEqual(decodedPacket.payload, largePayload)
+    }
+    
+    func testSmallPayloadNoCompression() throws {
+        // Small payloads should not be compressed
         let smallPayload = "Hi".data(using: .utf8)!
         let packet = TestHelpers.createTestPacket(payload: smallPayload)
-        let encodedData = try #require(BinaryProtocol.encode(packet), "Failed to encode small packet")
+        
-        let decodedPacket = try #require(BinaryProtocol.decode(encodedData), "Failed to decode small packet")
+        guard let encodedData = BinaryProtocol.encode(packet),
-        #expect(decodedPacket.payload == smallPayload)
+              let decodedPacket = BinaryProtocol.decode(encodedData) else {
+            XCTFail("Failed to encode/decode small packet")
+            return
+        }
+        
+        XCTAssertEqual(decodedPacket.payload, smallPayload)
     }
     
     // MARK: - Message Padding Tests
     
-    @Test func messagePadding() throws {
+    func testMessagePadding() throws {
         let payloads = [
             "Short",
             String(repeating: "Medium length message content ", count: 10), // ~300 bytes  
@@ -101,32 +134,43 @@ struct BinaryProtocolTests {
         
         for payload in payloads {
             let packet = TestHelpers.createTestPacket(payload: payload.data(using: .utf8)!)
-            let encodedData = try #require(BinaryProtocol.encode(packet), "Failed to encode packet")
+            
+            guard let encodedData = BinaryProtocol.encode(packet) else {
+                XCTFail("Failed to encode packet")
+                continue
+            }
             
             // Verify padding creates standard block sizes up to configured limit (no 4096 bucket currently)
             let blockSizes = [256, 512, 1024, 2048]
             if encodedData.count <= 2048 {
-                #expect(blockSizes.contains(encodedData.count), "Encoded size \(encodedData.count) is not a standard block size")
+                XCTAssertTrue(blockSizes.contains(encodedData.count), "Encoded size \(encodedData.count) is not a standard block size")
             } else {
                 // For very large payloads we expect no additional padding beyond raw size
-                #expect(encodedData.count > 2048)
+                XCTAssertGreaterThan(encodedData.count, 2048)
             }
             
             encodedSizes.insert(encodedData.count)
             
             // Verify decoding works
-            let decodedPacket = try #require(BinaryProtocol.decode(encodedData), "Failed to decode padded packet")
+            guard let decodedPacket = BinaryProtocol.decode(encodedData) else {
-            #expect(String(data: decodedPacket.payload, encoding: .utf8) == payload)
+                XCTFail("Failed to decode padded packet")
+                continue
+            }
+            
+            XCTAssertEqual(String(data: decodedPacket.payload, encoding: .utf8), payload)
         }
         
         // Different payload sizes (within <=2048) may map to the same bucket depending on compression.
         // Require at least one padded size to be present.
-        #expect(encodedSizes.filter { $0 <= 2048 }.count >= 1, "Expected at least one padded size up to 2048, got \(encodedSizes)")
+        XCTAssertGreaterThanOrEqual(encodedSizes.filter { $0 <= 2048 }.count, 1, "Expected at least one padded size up to 2048, got \(encodedSizes)")
     }
 
-    @Test func invalidPKCS7PaddingIsRejected() throws {
+    func testInvalidPKCS7PaddingIsRejected() throws {
         let pkt = TestHelpers.createTestPacket(payload: Data(repeating: 0x41, count: 50)) // small
-        let enc0 = try #require(BinaryProtocol.encode(pkt), "encode failed")
+        guard let enc0 = BinaryProtocol.encode(pkt) else {
+            XCTFail("encode failed")
+            return
+        }
         // Force padding to known block for test stability
         var enc = MessagePadding.pad(enc0, toSize: 256)
         let unpadded = MessagePadding.unpad(enc)
@@ -137,33 +181,39 @@ struct BinaryProtocolTests {
             let maybe = BinaryProtocol.decode(enc)
             // If decode still succeeds (nested pad edge case), at least ensure payload integrity
             if let pkt2 = maybe {
-                #expect(pkt2.payload == pkt.payload)
+                XCTAssertEqual(pkt2.payload, pkt.payload)
             } else {
-                #expect(maybe == nil)
+                XCTAssertNil(maybe)
             }
         } else {
             // If no padding was applied, just assert decode succeeds (nothing to test)
-            #expect(BinaryProtocol.decode(enc) != nil)
+            XCTAssertNotNil(BinaryProtocol.decode(enc))
         }
     }
     
     // MARK: - Message Encoding/Decoding Tests
     
-    @Test func messageEncodingDecoding() throws {
+    func testMessageEncodingDecoding() throws {
         let message = TestHelpers.createTestMessage()
         
-        let payload = try #require(message.toBinaryPayload(), "Failed to encode message to binary")
+        guard let payload = message.toBinaryPayload() else {
+            XCTFail("Failed to encode message to binary")
+            return
+        }
         
-        let decodedMessage = try #require(BitchatMessage(payload), "Failed to decode message from binary")
+        guard let decodedMessage = BitchatMessage(payload) else {
+            XCTFail("Failed to decode message from binary")
+            return
+        }
         
-        #expect(decodedMessage.content == message.content)
+        XCTAssertEqual(decodedMessage.content, message.content)
-        #expect(decodedMessage.sender == message.sender)
+        XCTAssertEqual(decodedMessage.sender, message.sender)
-        #expect(decodedMessage.senderPeerID == message.senderPeerID)
+        XCTAssertEqual(decodedMessage.senderPeerID, message.senderPeerID)
-        #expect(decodedMessage.isPrivate == message.isPrivate)
+        XCTAssertEqual(decodedMessage.isPrivate, message.isPrivate)
         
         // Timestamp should be close (within 1 second due to conversion)
         let timeDiff = abs(decodedMessage.timestamp.timeIntervalSince(message.timestamp))
-        #expect(timeDiff < 1)
+        XCTAssertLessThan(timeDiff, 1.0)
     }
     
     func testPrivateMessageEncoding() throws {
@@ -172,22 +222,30 @@ struct BinaryProtocolTests {
             recipientNickname: TestConstants.testNickname2
         )
         
-        let payload = try #require(message.toBinaryPayload(), "Failed to encode private message")
+        guard let payload = message.toBinaryPayload(),
-        let decodedMessage = try #require(BitchatMessage(payload), "Failed to decode private message")
+              let decodedMessage = BitchatMessage(payload) else {
-        
+            XCTFail("Failed to encode/decode private message")
-        #expect(decodedMessage.isPrivate)
+            return
-        #expect(decodedMessage.recipientNickname == TestConstants.testNickname2)
         }
         
-    @Test func messageWithMentions() throws {
+        XCTAssertTrue(decodedMessage.isPrivate)
+        XCTAssertEqual(decodedMessage.recipientNickname, TestConstants.testNickname2)
+    }
+    
+    func testMessageWithMentions() throws {
         let mentions = [TestConstants.testNickname2, TestConstants.testNickname3]
         let message = TestHelpers.createTestMessage(mentions: mentions)
-        let payload = try #require(message.toBinaryPayload(), "Failed to encode message with mentions")
+        
-        let decodedMessage = try #require(BitchatMessage(payload), "Failed to decode message with mentions")
+        guard let payload = message.toBinaryPayload(),
-        #expect(decodedMessage.mentions == mentions)
+              let decodedMessage = BitchatMessage(payload) else {
+            XCTFail("Failed to encode/decode message with mentions")
+            return
         }
         
-    @Test func relayMessageEncoding() throws {
+        XCTAssertEqual(decodedMessage.mentions, mentions)
+    }
+    
+    func testRelayMessageEncoding() throws {
         let message = BitchatMessage(
             id: UUID().uuidString,
             sender: TestConstants.testNickname1,
@@ -197,77 +255,105 @@ struct BinaryProtocolTests {
             originalSender: TestConstants.testNickname3,
             isPrivate: false,
             recipientNickname: nil,
+            senderPeerID: TestConstants.testPeerID1,
             mentions: nil
         )
-        let payload = try #require(message.toBinaryPayload(), "Failed to encode relay message")
+        
-        let decodedMessage = try #require(BitchatMessage(payload), "Failed to decode relay message")
+        guard let payload = message.toBinaryPayload(),
-        #expect(decodedMessage.isRelay)
+              let decodedMessage = BitchatMessage(payload) else {
-        #expect(decodedMessage.originalSender == TestConstants.testNickname3)
+            XCTFail("Failed to encode/decode relay message")
+            return
+        }
+        
+        XCTAssertTrue(decodedMessage.isRelay)
+        XCTAssertEqual(decodedMessage.originalSender, TestConstants.testNickname3)
     }
     
     // MARK: - Edge Cases and Error Handling
     
-    @Test("Too small data")
+    func testInvalidDataDecoding() {
-    func invalidDataDecoding() throws {
+        // Too small data
         let tooSmall = Data(repeating: 0, count: 5)
-        #expect(BinaryProtocol.decode(tooSmall) == nil)
+        XCTAssertNil(BinaryProtocol.decode(tooSmall))
         
         // Random data
         let random = TestHelpers.generateRandomData(length: 100)
-        #expect(BinaryProtocol.decode(random) == nil)
+        XCTAssertNil(BinaryProtocol.decode(random))
         
         // Corrupted header
         let packet = TestHelpers.createTestPacket()
-        var encoded = try #require(BinaryProtocol.encode(packet), "Failed to encode test packet")
+        guard var encoded = BinaryProtocol.encode(packet) else {
+            XCTFail("Failed to encode test packet")
+            return
+        }
         
         // Corrupt the version byte
         encoded[0] = 0xFF
-        #expect(BinaryProtocol.decode(encoded) == nil)
+        XCTAssertNil(BinaryProtocol.decode(encoded))
     }
     
-    @Test("Test maximum size handling")
+    func testLargeMessageHandling() throws {
-    func largeMessageHandling() throws {
+        // Test maximum size handling
         let largeContent = String(repeating: "X", count: 65535) // Max uint16
         let message = TestHelpers.createTestMessage(content: largeContent)
-        let payload = try #require(message.toBinaryPayload(), "Failed to handle large message")
+        
-        let decodedMessage = try #require(BitchatMessage(payload), "Failed to handle large message")
+        guard let payload = message.toBinaryPayload(),
-        #expect(decodedMessage.content == largeContent)
+              let decodedMessage = BitchatMessage(payload) else {
+            XCTFail("Failed to handle large message")
+            return
         }
         
-    @Test("Test message with empty content")
+        XCTAssertEqual(decodedMessage.content, largeContent)
-    func emptyFieldsHandling() throws {
+    }
+    
+    func testEmptyFieldsHandling() throws {
+        // Test message with empty content
         let emptyMessage = TestHelpers.createTestMessage(content: "")
-        let payload = try #require(emptyMessage.toBinaryPayload(), "Failed to handle empty message")
+        
-        let decodedMessage = try #require(BitchatMessage(payload), "Failed to handle empty message")
+        guard let payload = emptyMessage.toBinaryPayload(),
-        #expect(decodedMessage.content.isEmpty)
+              let decodedMessage = BitchatMessage(payload) else {
+            XCTFail("Failed to handle empty message")
+            return
+        }
+        
+        XCTAssertEqual(decodedMessage.content, "")
     }
     
     // MARK: - Protocol Version Tests
     
-    @Test("Test with supported version (version is always 1 in init)")
+    func testProtocolVersionHandling() throws {
-    func protocolVersionHandling() throws {
+        // Test with supported version (version is always 1 in init)
         let packet = TestHelpers.createTestPacket()
-        let encoded = try #require(BinaryProtocol.encode(packet), "Failed to encode packet with version")
+        
-        let decoded = try #require(BinaryProtocol.decode(encoded), "Failed to decode packet with version")
+        guard let encoded = BinaryProtocol.encode(packet),
-        #expect(decoded.version == 1)
+              let decoded = BinaryProtocol.decode(encoded) else {
+            XCTFail("Failed to encode/decode packet with version")
+            return
         }
         
-    @Test("Create packet data with unsupported version")
+        XCTAssertEqual(decoded.version, 1)
-    func unsupportedProtocolVersion() throws {
+    }
+    
+    func testUnsupportedProtocolVersion() throws {
+        // Create packet data with unsupported version
         let packet = TestHelpers.createTestPacket()
-        var encoded = try #require(BinaryProtocol.encode(packet), "Failed to encode packet")
+        
+        guard var encoded = BinaryProtocol.encode(packet) else {
+            XCTFail("Failed to encode packet")
+            return
+        }
         
         // Manually change version byte to unsupported value
         encoded[0] = 99 // Unsupported version
         
         // Should fail to decode
-        #expect(BinaryProtocol.decode(encoded) == nil)
+        XCTAssertNil(BinaryProtocol.decode(encoded))
     }
     
     // MARK: - Bounds Checking Tests (Crash Prevention)
     
-    @Test("Test the specific crash scenario: payloadLength = 193 (0xc1) but only 30 bytes available")
+    func testMalformedPacketWithInvalidPayloadLength() throws {
-    func malformedPacketWithInvalidPayloadLength() throws {
+        // Test the specific crash scenario: payloadLength = 193 (0xc1) but only 30 bytes available
         var malformedData = Data()
         
         // Valid header (13 bytes)
@@ -297,17 +383,20 @@ struct BinaryProtocolTests {
         }
         
         // Total data is now 30 bytes, but payloadLength claims 193
-        #expect(malformedData.count == 30)
+        XCTAssertEqual(malformedData.count, 30)
         
         // This should not crash - should return nil gracefully
         let result = BinaryProtocol.decode(malformedData)
-        #expect(result == nil, "Malformed packet with invalid payload length should return nil, not crash")
+        XCTAssertNil(result, "Malformed packet with invalid payload length should return nil, not crash")
     }
     
-    @Test("Test various truncation scenarios")
+    func testTruncatedPacketHandling() throws {
-    func truncatedPacketHandling() throws {
+        // Test various truncation scenarios
         let packet = TestHelpers.createTestPacket()
-        let validEncoded = try #require(BinaryProtocol.encode(packet), "Failed to encode test packet")
+        guard let validEncoded = BinaryProtocol.encode(packet) else {
+            XCTFail("Failed to encode test packet")
+            return
+        }
         
         // Test truncation at various points
         let truncationPoints = [0, 5, 10, 15, 20, 25]
@@ -315,12 +404,12 @@ struct BinaryProtocolTests {
         for point in truncationPoints {
             let truncated = validEncoded.prefix(point)
             let result = BinaryProtocol.decode(truncated)
-            #expect(result == nil, "Truncated packet at \(point) bytes should return nil, not crash")
+            XCTAssertNil(result, "Truncated packet at \(point) bytes should return nil, not crash")
         }
     }
     
-    @Test("Test compressed packet with invalid original size")
+    func testMalformedCompressedPacket() throws {
-    func malformedCompressedPacket() throws {
+        // Test compressed packet with invalid original size
         var malformedData = Data()
         
         // Valid header
@@ -349,11 +438,11 @@ struct BinaryProtocolTests {
         
         // Should handle this gracefully
         let result = BinaryProtocol.decode(malformedData)
-        #expect(result == nil, "Malformed compressed packet should return nil, not crash")
+        XCTAssertNil(result, "Malformed compressed packet should return nil, not crash")
     }
     
-    @Test("Test packet claiming extremely large payload")
+    func testExcessivelyLargePayloadLength() throws {
-    func excessivelyLargePayloadLength() throws {
+        // Test packet claiming extremely large payload
         var malformedData = Data()
         
         // Valid header
@@ -382,11 +471,11 @@ struct BinaryProtocolTests {
         
         // Should handle this gracefully without trying to allocate massive amounts of memory
         let result = BinaryProtocol.decode(malformedData)
-        #expect(result == nil, "Packet with excessive payload length should return nil, not crash")
+        XCTAssertNil(result, "Packet with excessive payload length should return nil, not crash")
     }
     
-    @Test("Test compressed packet with unreasonable original size")
+    func testCompressedPacketWithInvalidOriginalSize() throws {
-    func compressedPacketWithInvalidOriginalSize() throws {
+        // Test compressed packet with unreasonable original size
         var malformedData = Data()
         
         // Valid header
@@ -424,11 +513,11 @@ struct BinaryProtocolTests {
         }
         
         let result = BinaryProtocol.decode(malformedData)
-        #expect(result == nil, "Compressed packet with invalid original size should return nil, not crash")
+        XCTAssertNil(result, "Compressed packet with invalid original size should return nil, not crash")
     }
     
-    @Test("Test packet designed to cause integer overflow")
+    func testMaliciousPacketWithIntegerOverflow() throws {
-    func maliciousPacketWithIntegerOverflow() throws {
+        // Test packet designed to cause integer overflow
         var maliciousData = Data()
         
         // Valid header
@@ -463,24 +552,27 @@ struct BinaryProtocolTests {
         
         // Should handle gracefully without integer overflow issues
         let result = BinaryProtocol.decode(maliciousData)
-        #expect(result == nil, "Malicious packet designed for integer overflow should return nil, not crash")
+        XCTAssertNil(result, "Malicious packet designed for integer overflow should return nil, not crash")
     }
     
-    @Test("Test packets with incomplete headers")
+    func testPartialHeaderData() throws {
-    func partialHeaderData() throws {
+        // Test packets with incomplete headers
         let headerSizes = [0, 1, 5, 10, 12] // Various incomplete header sizes
         
         for size in headerSizes {
             let partialData = Data(repeating: 0x01, count: size)
             let result = BinaryProtocol.decode(partialData)
-            #expect(result == nil, "Partial header data (\(size) bytes) should return nil, not crash")
+            XCTAssertNil(result, "Partial header data (\(size) bytes) should return nil, not crash")
         }
     }
     
-    @Test("Test exact boundary conditions")
+    func testBoundaryConditions() throws {
-    func boundaryConditions() throws {
+        // Test exact boundary conditions
         let packet = TestHelpers.createTestPacket()
-        let validEncoded = try #require(BinaryProtocol.encode(packet), "Failed to encode test packet")
+        guard let validEncoded = BinaryProtocol.encode(packet) else {
+            XCTFail("Failed to encode test packet")
+            return
+        }
         
         // If truncation only removes padding, decode may still succeed. Compute unpadded size.
         let unpadded = MessagePadding.unpad(validEncoded)
@@ -488,7 +580,7 @@ struct BinaryProtocolTests {
         let cut = max(1, unpadded.count - 10)
         let truncatedCore = unpadded.prefix(cut)
         let result = BinaryProtocol.decode(truncatedCore)
-        #expect(result == nil, "Truncated core frame should return nil, not crash")
+        XCTAssertNil(result, "Truncated core frame should return nil, not crash")
         
         // Test minimum valid size - create a valid minimal packet
         var minData = Data()

bitchatTests/TestUtilities/TestConstants.swift

@@ -14,6 +14,11 @@ struct TestConstants {
     static let shortTimeout: TimeInterval = 1.0
     static let longTimeout: TimeInterval = 10.0
     
+    static let testPeerID1: PeerID = "PEER1234"
+    static let testPeerID2: PeerID = "PEER5678"
+    static let testPeerID3: PeerID = "PEER9012"
+    static let testPeerID4: PeerID = "PEER3456"
+    
     static let testNickname1 = "Alice"
     static let testNickname2 = "Bob"
     static let testNickname3 = "Charlie"

bitchatTests/TestUtilities/TestHelpers.swift

@@ -30,7 +30,7 @@ final class TestHelpers {
     static func createTestMessage(
         content: String = TestConstants.testMessage1,
         sender: String = TestConstants.testNickname1,
-        senderPeerID: PeerID = PeerID(str: UUID().uuidString),
+        senderPeerID: PeerID = TestConstants.testPeerID1,
         isPrivate: Bool = false,
         recipientNickname: String? = nil,
         mentions: [String]? = nil
@@ -51,7 +51,7 @@ final class TestHelpers {
     
     static func createTestPacket(
         type: UInt8 = 0x01,
-        senderID: PeerID = PeerID(str: UUID().uuidString),
+        senderID: PeerID = TestConstants.testPeerID1,
         recipientID: PeerID? = nil,
         payload: Data = "test payload".data(using: .utf8)!,
         signature: Data? = nil,
@@ -90,7 +90,7 @@ final class TestHelpers {
             if Date().timeIntervalSince(start) > timeout {
                 throw TestError.timeout
             }
-            try await sleep(0.01)
+            try await Task.sleep(nanoseconds: 10_000_000) // 10ms
         }
     }
     
@@ -104,7 +104,7 @@ final class TestHelpers {
             }
             
             group.addTask {
-                try await sleep(1)
+                try await Task.sleep(nanoseconds: UInt64(timeout * 1_000_000_000))
                 throw TestError.timeout
             }
             
@@ -121,6 +121,14 @@ enum TestError: Error {
     case testFailure(String)
 }
 
-func sleep(_ seconds: TimeInterval) async throws {
+// MARK: - PeerID String Helpers
-    try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
+
+/// Raw String can be passed as PeerID
+extension PeerID: @retroactive ExpressibleByStringLiteral {
+    public init(stringLiteral value: String) {
+        self.init(str: value)
     }
+}
+
+/// Interpolated String can be passed as PeerID
+extension PeerID: @retroactive ExpressibleByStringInterpolation {}

bitchatTests/Utils/PeerIDTests.swift

@@ -6,11 +6,11 @@
 // For more information, see <https://unlicense.org>
 //
 
-import Testing
+import XCTest
-import Foundation
 @testable import bitchat
 
-struct PeerIDTests {
+final class PeerIDTests: XCTestCase {
+    
     private let hex16 = "0011223344556677"
     private let hex64 = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
     
@@ -22,205 +22,212 @@ struct PeerIDTests {
     
     // MARK: - Empty prefix
     
-    @Test func empty_prefix_with16() {
+    func test_init_empty_prefix_with16() {
         let peerID = PeerID(str: hex16)
-        #expect(peerID.id == hex16)
+        XCTAssertEqual(peerID.id, hex16)
-        #expect(peerID.bare == hex16)
+        XCTAssertEqual(peerID.bare, hex16)
-        #expect(peerID.prefix == .empty)
+        XCTAssertEqual(peerID.prefix, .empty)
     }
     
-    @Test func empty_prefix_with64() {
+    func test_init_empty_prefix_with64() {
         let peerID = PeerID(str: hex64)
-        #expect(peerID.id == hex64)
+        XCTAssertEqual(peerID.id, hex64)
-        #expect(peerID.bare == hex64)
+        XCTAssertEqual(peerID.bare, hex64)
-        #expect(peerID.prefix == .empty)
+        XCTAssertEqual(peerID.prefix, .empty)
     }
     
     // MARK: - Mesh prefix
     
-    @Test func mesh_prefix_with16() {
+    func test_init_mesh_prefix_with16() {
         let str = "mesh:" + hex16
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == hex16)
+        XCTAssertEqual(peerID.bare, hex16)
-        #expect(peerID.prefix == .mesh)
+        XCTAssertEqual(peerID.prefix, .mesh)
     }
     
-    @Test func mesh_prefix_with64() {
+    func test_init_mesh_prefix_with64() {
         let str = "mesh:" + hex64
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == hex64)
+        XCTAssertEqual(peerID.bare, hex64)
-        #expect(peerID.prefix == .mesh)
+        XCTAssertEqual(peerID.prefix, .mesh)
     }
     
     // MARK: - Name prefix
     
-    @Test func name_prefix() {
+    func test_init_name_prefix() {
         let str = "name:some_name"
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == "some_name")
+        XCTAssertEqual(peerID.bare, "some_name")
-        #expect(peerID.prefix == .name)
+        XCTAssertEqual(peerID.prefix, .name)
     }
     
     // MARK: - Noise prefix
     
-    @Test func noise_prefix_with16() {
+    func test_init_noise_prefix_with16() {
         let str = "noise:" + hex16
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == hex16)
+        XCTAssertEqual(peerID.bare, hex16)
-        #expect(peerID.prefix == .noise)
+        XCTAssertEqual(peerID.prefix, .noise)
     }
     
-    @Test func noise_prefix_with64() {
+    func test_init_noise_prefix_with64() {
         let str = "noise:" + hex64
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == hex64)
+        XCTAssertEqual(peerID.bare, hex64)
-        #expect(peerID.prefix == .noise)
+        XCTAssertEqual(peerID.prefix, .noise)
     }
     
     // MARK: - GeoDM prefix
     
-    @Test func geoDM_prefix_with16() {
+    func test_init_geoDM_prefix_with16() {
         let str = "nostr_" + hex16
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == hex16)
+        XCTAssertEqual(peerID.bare, hex16)
-        #expect(peerID.prefix == .geoDM)
+        XCTAssertEqual(peerID.prefix, .geoDM)
     }
     
-    @Test func geoDM_prefix_with64() {
+    func test_init_geoDM_prefix_with64() {
         let str = "nostr_" + hex64
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == hex64)
+        XCTAssertEqual(peerID.bare, hex64)
-        #expect(peerID.prefix == .geoDM)
+        XCTAssertEqual(peerID.prefix, .geoDM)
     }
     
     // MARK: - GeoChat prefix
     
-    @Test func geoChat_prefix_with16() {
+    func test_init_geoChat_prefix_with16() {
         let str = "nostr:" + hex16
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == hex16)
+        XCTAssertEqual(peerID.bare, hex16)
-        #expect(peerID.prefix == .geoChat)
+        XCTAssertEqual(peerID.prefix, .geoChat)
     }
     
-    @Test func geoChat_prefix_with64() {
+    func test_init_geoChat_prefix_with64() {
         let str = "nostr:" + hex64
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == hex64)
+        XCTAssertEqual(peerID.bare, hex64)
-        #expect(peerID.prefix == .geoChat)
+        XCTAssertEqual(peerID.prefix, .geoChat)
     }
     
     // MARK: - Edge cases
     
-    @Test func with_unknown_prefix() {
+    func test_init_with_unknown_prefix() {
         let str = "unknown:" + hex16
         let peerID = PeerID(str: str)
         // Falls back to .empty
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == str)
+        XCTAssertEqual(peerID.bare, str)
-        #expect(peerID.prefix == .empty)
+        XCTAssertEqual(peerID.prefix, .empty)
     }
     
-    @Test func with_only_prefix_no_bare() {
+    func test_init_with_only_prefix_no_bare() {
         let str = "mesh:"
         let peerID = PeerID(str: str)
-        #expect(peerID.id == str)
+        XCTAssertEqual(peerID.id, str)
-        #expect(peerID.bare == "")
+        XCTAssertEqual(peerID.bare, "")
-        #expect(peerID.prefix == .mesh)
+        XCTAssertEqual(peerID.prefix, .mesh)
     }
     
     // MARK: - init?(data:)
     
-    @Test func data_valid_utf8() {
+    func test_init_data_valid_utf8() {
         let peerID = PeerID(data: Data(hex16.utf8))
-        #expect(peerID != nil)
+        XCTAssertNotNil(peerID)
-        #expect(peerID?.bare == hex16)
+        XCTAssertEqual(peerID?.bare, hex16)
-        #expect(peerID?.prefix == .empty)
+        XCTAssertEqual(peerID?.prefix, .empty)
     }
     
-    @Test func data_invalid_utf8() {
+    func test_init_data_invalid_utf8() {
         // Random invalid UTF8
         let bytes: [UInt8] = [0xFF, 0xFE, 0xFA]
         let peerID = PeerID(data: Data(bytes))
-        #expect(peerID == nil)
+        XCTAssertNil(peerID)
     }
     
     // MARK: - init(str: Substring)
     
-    @Test func substring() {
+    func test_init_substring() {
         let substring = hex64.prefix(16)
         let peerID = PeerID(str: substring)
-        #expect(peerID.id == String(substring))
+        XCTAssertEqual(peerID.id, String(substring))
-        #expect(peerID.bare == String(substring))
+        XCTAssertEqual(peerID.bare, String(substring))
-        #expect(peerID.prefix == .empty)
+        XCTAssertEqual(peerID.prefix, .empty)
     }
     
     // MARK: - init(nostr_ pubKey:)
     
-    @Test func nostrUnderscore_pubKey() {
+    func test_init_nostrUnderscore_pubKey() {
         let pubKey = hex64
         let peerID = PeerID(nostr_: pubKey)
-        #expect(peerID.id == "nostr_\(pubKey.prefix(TransportConfig.nostrConvKeyPrefixLength))")
+        XCTAssertEqual(peerID.id, "nostr_\(pubKey.prefix(TransportConfig.nostrConvKeyPrefixLength))")
-        #expect(peerID.bare == String(pubKey.prefix(TransportConfig.nostrConvKeyPrefixLength)))
+        XCTAssertEqual(peerID.bare, String(pubKey.prefix(TransportConfig.nostrConvKeyPrefixLength)))
-        #expect(peerID.prefix == .geoDM)
+        XCTAssertEqual(peerID.prefix, .geoDM)
     }
     
     // MARK: - init(nostr pubKey:)
     
-    @Test func nostr_pubKey() {
+    func test_init_nostr_pubKey() {
         let pubKey = hex64
         let peerID = PeerID(nostr: pubKey)
-        #expect(peerID.id == "nostr:\(pubKey.prefix(TransportConfig.nostrShortKeyDisplayLength))")
+        XCTAssertEqual(peerID.id, "nostr:\(pubKey.prefix(TransportConfig.nostrShortKeyDisplayLength))")
-        #expect(peerID.bare == String(pubKey.prefix(TransportConfig.nostrShortKeyDisplayLength)))
+        XCTAssertEqual(peerID.bare, String(pubKey.prefix(TransportConfig.nostrShortKeyDisplayLength)))
-        #expect(peerID.prefix == .geoChat)
+        XCTAssertEqual(peerID.prefix, .geoChat)
     }
     
     // MARK: - init(publicKey:)
     
-    @Test func publicKey_derivesFingerprint() {
+    func test_init_publicKey_derivesFingerprint() {
         let publicKey = Data(hex64.utf8)
         let expected = publicKey.sha256Fingerprint().prefix(16)
         let peerID = PeerID(publicKey: publicKey)
-        #expect(peerID.bare == String(expected))
+        XCTAssertEqual(peerID.bare, String(expected))
-        #expect(peerID.prefix == .empty)
+        XCTAssertEqual(peerID.prefix, .empty)
     }
     
     // MARK: - toShort()
     
-    @Test func toShort_whenNoiseKeyExists() {
+    func test_toShort_whenNoiseKeyExists() {
         let peerID = PeerID(str: hex64)
         let short = peerID.toShort()
+        
+        // `toShort()` should derive 16-hex peerID
         let expected = Data(hexString: hex64)!.sha256Fingerprint().prefix(16)
-        #expect(short.bare == String(expected))
+        
-        #expect(short.prefix == .empty)
+        XCTAssertEqual(short.bare, String(expected))
+        XCTAssertEqual(short.prefix, .empty)
     }
     
-    @Test func toShort_whenNoiseKeyExists_withNoisePrefix() {
+    func test_toShort_whenNoiseKeyExists_withNoisePrefix() {
         let peerID = PeerID(str: "noise:" + hex64)
         let short = peerID.toShort()
+        
+        // `toShort()` should derive 16-hex peerID
         let expected = Data(hexString: hex64)!.sha256Fingerprint().prefix(16)
-        #expect(short.bare == String(expected))
+        
-        #expect(short.prefix == .empty)
+        XCTAssertEqual(short.bare, String(expected))
-        #expect(peerID.prefix == .noise)
+        XCTAssertEqual(short.prefix, .empty)
+        XCTAssertEqual(peerID.prefix, .noise)
     }
     
-    @Test func toShort_whenNoNoiseKey() {
+    func test_toShort_whenNoNoiseKey() {
         let peerID = PeerID(str: "some_random_key")
         let short = peerID.toShort()
-        #expect(short == peerID)
+        XCTAssertEqual(short, peerID) // unchanged
     }
 
+    
     // MARK: - Codable
 
-    @Test func codable_emptyPrefix() throws {
+    func test_codable_emptyPrefix() throws {
         struct Dummy: Codable, Equatable {
             let name: String
             let peerID: PeerID
@@ -230,13 +237,13 @@ struct PeerIDTests {
         let jsonString = "{\"name\":\"some name\",\"peerID\":\"\(str)\"}"
         
         let decoded = try JSONDecoder().decode(Dummy.self, from: Data(jsonString.utf8))
-        #expect(decoded.peerID == PeerID(str: str))
+        XCTAssertEqual(decoded.peerID, PeerID(str: str))
         
         let encoded = try encoder.encode(decoded)
-        #expect(String(data: encoded, encoding: .utf8) == jsonString)
+        XCTAssertEqual(String(data: encoded, encoding: .utf8), jsonString)
     }
 
-    @Test func codable_withPrefix() throws {
+    func test_codable_withPrefix() throws {
         struct Dummy: Codable, Equatable {
             let peerID: PeerID
         }
@@ -245,191 +252,193 @@ struct PeerIDTests {
         let jsonString = "{\"peerID\":\"\(str)\"}"
         
         let decoded = try JSONDecoder().decode(Dummy.self, from: Data(jsonString.utf8))
-        #expect(decoded.peerID == PeerID(str: str))
+        XCTAssertEqual(decoded.peerID, PeerID(str: str))
-        #expect(decoded.peerID.bare == hex16)
+        XCTAssertEqual(decoded.peerID.bare, hex16)
-        #expect(decoded.peerID.prefix == .geoDM)
+        XCTAssertEqual(decoded.peerID.prefix, .geoDM)
         
         let encoded = try encoder.encode(decoded)
-        #expect(String(data: encoded, encoding: .utf8) == jsonString)
+        XCTAssertEqual(String(data: encoded, encoding: .utf8), jsonString)
     }
 
-    @Test func codable_multiplePrefixes() throws {
+    func test_codable_multiplePrefixes() throws {
         // Loop across all Prefix cases (except .empty since already tested)
         for prefix in PeerID.Prefix.allCases where prefix != .empty {
             let bare = hex16
             let str = prefix.rawValue + bare
             
             let decoded = try JSONDecoder().decode(PeerID.self, from: Data("\"\(str)\"".utf8))
-            #expect(decoded.prefix == prefix)
+            XCTAssertEqual(decoded.prefix, prefix)
-            #expect(decoded.bare == bare)
+            XCTAssertEqual(decoded.bare, bare)
             
             let encoded = try encoder.encode(decoded)
-            #expect(String(data: encoded, encoding: .utf8) == "\"\(str)\"")
+            XCTAssertEqual(String(data: encoded, encoding: .utf8), "\"\(str)\"")
         }
     }
     
     // MARK: - Comparable
     
-    @Test func comparable_sorting_and_equality() {
+    func test_comparable_sorting_and_equality() {
         let p1 = PeerID(str: "aaa")
         let p2 = PeerID(str: "bbb")
         let p3 = PeerID(str: "bbb")
         
-        #expect(p1 < p2)
+        XCTAssertTrue(p1 < p2)
-        #expect(p2 >= p1)
+        XCTAssertFalse(p2 < p1)
-        #expect(p2 == p3)
+        XCTAssertEqual(p2, p3)
         
         let sorted = [p2, p1].sorted()
-        #expect(sorted == [p1, p2])
+        XCTAssertEqual(sorted, [p1, p2])
     }
     
-    @Test func equality() {
+    func test_equality() {
         let string = "aaa"
         let peerID = PeerID(str: string)
         let badString = "bbb"
         
         // PeerID == String
-        #expect(peerID == string)
+        XCTAssertTrue(peerID == string)
-        #expect(peerID == Optional(string))
+        XCTAssertTrue(peerID == Optional(string))
-        #expect(Optional(peerID) == string)
+        XCTAssertTrue(Optional(peerID) == string)
-        #expect(Optional(peerID) == Optional(string))
+        XCTAssertTrue(Optional(peerID) == Optional(string))
 
         // PeerID != String
-        #expect(peerID != badString)
+        XCTAssertTrue(peerID != badString)
-        #expect(peerID != Optional(badString))
+        XCTAssertTrue(peerID != Optional(badString))
-        #expect(Optional(peerID) != badString)
+        XCTAssertTrue(Optional(peerID) != badString)
-        #expect(Optional(peerID) != Optional(badString))
+        XCTAssertTrue(Optional(peerID) != Optional(badString))
         
         // String == PeerID
-        #expect(string == peerID)
+        XCTAssertTrue(string == peerID)
-        #expect(Optional(string) == peerID)
+        XCTAssertTrue(Optional(string) == peerID)
-        #expect(string == Optional(peerID))
+        XCTAssertTrue(string == Optional(peerID))
-        #expect(Optional(string) == Optional(peerID))
+        XCTAssertTrue(Optional(string) == Optional(peerID))
 
         // String != PeerID
-        #expect(badString != peerID)
+        XCTAssertTrue(badString != peerID)
-        #expect(Optional(badString) != peerID)
+        XCTAssertTrue(Optional(badString) != peerID)
-        #expect(badString != Optional(peerID))
+        XCTAssertTrue(badString != Optional(peerID))
-        #expect(Optional(badString) != Optional(peerID))
+        XCTAssertTrue(Optional(badString) != Optional(peerID))
         
-        // Regular PeerID <> PeerID
-        #expect(peerID == PeerID(str: "aaa"))
-        #expect(peerID == Optional(PeerID(str: "aaa")))
-        #expect(PeerID(str: "aaa") == peerID)
-        #expect(Optional(PeerID(str: "aaa")) == Optional(peerID))
         
-        #expect(peerID != PeerID(str: "bbb"))
+        // Make sure the regular PeerID <> PeerID is not broken
-        #expect(peerID != Optional(PeerID(str: "bbb")))
+        XCTAssertTrue(peerID == PeerID(str: "aaa"))
-        #expect(PeerID(str: "bbb") != peerID)
+        XCTAssertTrue(peerID == Optional(PeerID(str: "aaa")))
-        #expect(Optional(PeerID(str: "bbb")) != Optional(peerID))
+        XCTAssertTrue(PeerID(str: "aaa") == peerID)
+        XCTAssertTrue(Optional(PeerID(str: "aaa")) == Optional(peerID))
+        
+        XCTAssertTrue(peerID != PeerID(str: "bbb"))
+        XCTAssertTrue(peerID != Optional(PeerID(str: "bbb")))
+        XCTAssertTrue(PeerID(str: "bbb") != peerID)
+        XCTAssertTrue(Optional(PeerID(str: "bbb")) != Optional(peerID))
     }
     
     // MARK: - Computed properties
     
-    @Test func isEmpty_true_and_false() {
+    func test_isEmpty_true_and_false() {
-        #expect(PeerID(str: "").isEmpty)
+        XCTAssertTrue(PeerID(str: "").isEmpty)
-        #expect(!PeerID(str: "abc").isEmpty)
+        XCTAssertFalse(PeerID(str: "abc").isEmpty)
     }
     
-    @Test func isGeoChat() {
+    func test_isGeoChat() {
-        #expect(PeerID(str: "nostr:abcdef").isGeoChat)
+        XCTAssertTrue(PeerID(str: "nostr:abcdef").isGeoChat)
-        #expect(!PeerID(str: "nostr_abcdef").isGeoChat)
+        XCTAssertFalse(PeerID(str: "nostr_abcdef").isGeoChat) // different prefix
     }
     
-    @Test func isGeoDM() {
+    func test_isGeoDM() {
-        #expect(PeerID(str: "nostr_abcdef").isGeoDM)
+        XCTAssertTrue(PeerID(str: "nostr_abcdef").isGeoDM)
-        #expect(!PeerID(str: "nostr:abcdef").isGeoDM)
+        XCTAssertFalse(PeerID(str: "nostr:abcdef").isGeoDM)
     }
     
-    @Test func toPercentEncoded() {
+    func test_toPercentEncoded() {
         let peerID = PeerID(str: "name:some value/with spaces?")
         let encoded = peerID.toPercentEncoded()
         // spaces and ? should be percent-encoded in urlPathAllowed
-        #expect(encoded == "name%3Asome%20value/with%20spaces%3F")
+        XCTAssertEqual(encoded, "name%3Asome%20value/with%20spaces%3F")
     }
     
     // MARK: - Validation
     
-    @Test func accepts_short_hex_peer_id() {
+    func test_accepts_short_hex_peer_id() {
-        #expect(PeerID(str: "0011223344556677").isValid)
+        XCTAssertTrue(PeerID(str: "0011223344556677").isValid)
-        #expect(PeerID(str: "aabbccddeeff0011").isValid)
+        XCTAssertTrue(PeerID(str: "aabbccddeeff0011").isValid)
     }
     
-    @Test func accepts_full_noise_key_hex() {
+    func test_accepts_full_noise_key_hex() {
         let hex64 = String(repeating: "ab", count: 32) // 64 hex chars
-        #expect(PeerID(str: hex64).isValid)
+        XCTAssertTrue(PeerID(str: hex64).isValid)
     }
     
-    @Test func accepts_internal_alnum_dash_underscore() {
+    func test_accepts_internal_alnum_dash_underscore() {
-        #expect(PeerID(str: "peer_123-ABC").isValid)
+        XCTAssertTrue(PeerID(str: "peer_123-ABC").isValid)
-        #expect(PeerID(str: "nostr_user_01").isValid)
+        XCTAssertTrue(PeerID(str: "nostr_user_01").isValid)
     }
     
-    @Test func rejects_invalid_characters() {
+    func test_rejects_invalid_characters() {
-        #expect(!PeerID(str: "peer!@#").isValid)
+        XCTAssertFalse(PeerID(str: "peer!@#").isValid)
-        #expect(!PeerID(str: "gggggggggggggggg").isValid) // not hex for short form
+        XCTAssertFalse(PeerID(str: "gggggggggggggggg").isValid) // not hex for short form
     }
     
-    @Test func rejects_too_long() {
+    func test_rejects_too_long() {
         let tooLong = String(repeating: "a", count: 65)
-        #expect(!PeerID(str: tooLong).isValid)
+        XCTAssertFalse(PeerID(str: tooLong).isValid)
     }
     
-    @Test func isShort() {
+    func test_isShort() {
-        #expect(PeerID(str: hex16).isShort)
+        XCTAssertTrue(PeerID(str: hex16).isShort)
-        #expect(!PeerID(str: "abcd").isShort) // wrong length
+        XCTAssertFalse(PeerID(str: "abcd").isShort) // wrong length
     }
     
-    @Test func isNoiseKeyHex_and_noiseKey() {
+    func test_isNoiseKeyHex_and_noiseKey() {
         let hex64 = String(repeating: "ab", count: 32) // 64 chars valid hex
         let peerID = PeerID(str: hex64)
-        #expect(peerID.isNoiseKeyHex)
+        XCTAssertTrue(peerID.isNoiseKeyHex)
-        #expect(peerID.noiseKey != nil)
+        XCTAssertNotNil(peerID.noiseKey)
         
         let prefixedPeerID = PeerID(str: "noise:" + hex64)
-        #expect(prefixedPeerID.isNoiseKeyHex)
+        XCTAssertTrue(prefixedPeerID.isNoiseKeyHex)
-        #expect(prefixedPeerID.noiseKey != nil)
+        XCTAssertNotNil(prefixedPeerID.noiseKey)
         
         let bad = String(repeating: "z", count: 64) // invalid hex
         let badPeerID = PeerID(str: bad)
-        #expect(!badPeerID.isNoiseKeyHex)
+        XCTAssertFalse(badPeerID.isNoiseKeyHex)
-        #expect(badPeerID.noiseKey == nil)
+        XCTAssertNil(badPeerID.noiseKey)
     }
     
-    @Test func prefixes() {
+    func test_prefixes() {
         let hex64 = String(repeating: "a", count: 64)
-        #expect(PeerID(str: "noise:\(hex64)").isValid)
+        XCTAssertTrue(PeerID(str: "noise:\(hex64)").isValid)
-        #expect(PeerID(str: "nostr:\(hex64)").isValid)
+        XCTAssertTrue(PeerID(str: "nostr:\(hex64)").isValid)
-        #expect(PeerID(str: "nostr_\(hex64)").isValid)
+        XCTAssertTrue(PeerID(str: "nostr_\(hex64)").isValid)
 
         let hex63 = String(repeating: "a", count: 63)
-        #expect(PeerID(str: "noise:\(hex63)").isValid)
+        XCTAssertTrue(PeerID(str: "noise:\(hex63)").isValid)
-        #expect(PeerID(str: "nostr:\(hex63)").isValid)
+        XCTAssertTrue(PeerID(str: "nostr:\(hex63)").isValid)
-        #expect(PeerID(str: "nostr_\(hex63)").isValid)
+        XCTAssertTrue(PeerID(str: "nostr_\(hex63)").isValid)
 
         let hex16 = String(repeating: "a", count: 16)
-        #expect(PeerID(str: "noise:\(hex16)").isValid)
+        XCTAssertTrue(PeerID(str: "noise:\(hex16)").isValid)
-        #expect(PeerID(str: "nostr:\(hex16)").isValid)
+        XCTAssertTrue(PeerID(str: "nostr:\(hex16)").isValid)
-        #expect(PeerID(str: "nostr_\(hex16)").isValid)
+        XCTAssertTrue(PeerID(str: "nostr_\(hex16)").isValid)
 
         let hex8 = String(repeating: "a", count: 8)
-        #expect(PeerID(str: "noise:\(hex8)").isValid)
+        XCTAssertTrue(PeerID(str: "noise:\(hex8)").isValid)
-        #expect(PeerID(str: "nostr:\(hex8)").isValid)
+        XCTAssertTrue(PeerID(str: "nostr:\(hex8)").isValid)
-        #expect(PeerID(str: "nostr_\(hex8)").isValid)
+        XCTAssertTrue(PeerID(str: "nostr_\(hex8)").isValid)
 
         let mesh = "mesh:abcdefg"
-        #expect(PeerID(str: "name:\(mesh)").isValid)
+        XCTAssertTrue(PeerID(str: "name:\(mesh)").isValid)
 
         let name = "name:some_name"
-        #expect(PeerID(str: "name:\(name)").isValid)
+        XCTAssertTrue(PeerID(str: "name:\(name)").isValid)
 
         let badName = "name:bad:name"
-        #expect(!PeerID(str: "name:\(badName)").isValid)
+        XCTAssertFalse(PeerID(str: "name:\(badName)").isValid)
 
         // Too long
         let hex65 = String(repeating: "a", count: 65)
-        #expect(!PeerID(str: "noise:\(hex65)").isValid)
+        XCTAssertFalse(PeerID(str: "noise:\(hex65)").isValid)
-        #expect(!PeerID(str: "nostr:\(hex65)").isValid)
+        XCTAssertFalse(PeerID(str: "nostr:\(hex65)").isValid)
-        #expect(!PeerID(str: "nostr_\(hex65)").isValid)
+        XCTAssertFalse(PeerID(str: "nostr_\(hex65)").isValid)
     }
 }
+

localPackages/BitLogger/Sources/OSLog+Categories.swift

@@ -6,9 +6,7 @@
 // For more information, see <https://unlicense.org>
 //
 
-#if canImport(os.log)
 import os.log
-#endif
 
 public extension OSLog {
     private static let subsystem = "chat.bitchat"

localPackages/BitLogger/Sources/SecureLogger.swift

@@ -7,53 +7,7 @@
 //
 
 import Foundation
-#if canImport(os.log)
 import os.log
-#else
-public struct OSLog {
-    public let subsystem: String
-    public let category: String
-
-    public init(subsystem: String, category: String) {
-        self.subsystem = subsystem
-        self.category = category
-    }
-}
-
-public struct OSLogType: CustomStringConvertible {
-    private let label: String
-
-    private init(_ label: String) {
-        self.label = label
-    }
-
-    public var description: String { label }
-
-    public static let debug = OSLogType("debug")
-    public static let info = OSLogType("info")
-    public static let `default` = OSLogType("default")
-    public static let error = OSLogType("error")
-    public static let fault = OSLogType("fault")
-}
-
-@usableFromInline
-let secureLoggerFallbackFormatter: ISO8601DateFormatter = {
-    let formatter = ISO8601DateFormatter()
-    formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-    return formatter
-}()
-
-@usableFromInline
-func os_log(_ message: StaticString, log: OSLog, type: OSLogType, _ args: CVarArg...) {
-    let rawFormat = String(describing: message)
-    let format = rawFormat
-        .replacingOccurrences(of: "%{public}@", with: "%@")
-        .replacingOccurrences(of: "%{private}@", with: "%@")
-    let formatted = String(format: format, arguments: args)
-    let timestamp = secureLoggerFallbackFormatter.string(from: Date())
-    print("[\(timestamp)] [\(log.subsystem)::\(log.category)] [\(type.description)] \(formatted)")
-}
-#endif
 
 /// Centralized security-aware logging framework
 /// Provides safe logging that filters sensitive data and security events

localPackages/Tor/Sources/TorManager.swift

@@ -1,23 +1,11 @@
 import BitLogger
 import Foundation
-#if canImport(Network)
 import Network
-#endif
-#if canImport(Darwin)
 import Darwin
-#elseif canImport(Glibc)
-import Glibc
-#endif
 
-#if !canImport(Network)
+// Declare C entrypoint for Tor when statically linked from an xcframework.
-private final class NWPathMonitor {
+@_silgen_name("tor_main")
-    var pathUpdateHandler: ((Any) -> Void)?
+private func tor_main_c(_ argc: Int32, _ argv: UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>?) -> Int32
-
-    func start(queue: DispatchQueue) {
-        // Path monitoring is unavailable on this platform; nothing to do.
-    }
-}
-#endif
 
 // Preferred: tiny C glue that uses Tor's embedding API (tor_api.h)
 @_silgen_name("tor_host_start")
@@ -298,6 +286,150 @@ public final class TorManager: ObservableObject {
         }
     }
 
+    // MARK: - Dynamic loader path (no Swift module required)
+
+    /// Attempt to locate an embedded tor framework binary and launch Tor via `tor_run_main`.
+    /// Returns true if the attempt started and port probing was scheduled.
+    private func startTorViaDlopen() -> Bool {
+        guard let fwURL = frameworkBinaryURL() else {
+            SecureLogger.warning("TorManager: no embedded tor framework found", category: .session)
+            return false
+        }
+
+        // Load the library
+        let mode = RTLD_NOW | RTLD_LOCAL
+        SecureLogger.info("TorManager: dlopen(\(fwURL.lastPathComponent))…", category: .session)
+        guard let handle = dlopen(fwURL.path, mode) else {
+            let err = String(cString: dlerror())
+            self.lastError = NSError(domain: "TorManager", code: -10, userInfo: [NSLocalizedDescriptionKey: "dlopen failed: \(err)"])
+            self.isStarting = false
+            return false
+        }
+
+        // Resolve tor_main(argc, argv)
+        typealias TorMainType = @convention(c) (Int32, UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>?) -> Int32
+        guard let sym = dlsym(handle, "tor_main") else {
+            // Keep handle open but report error
+            let err = String(cString: dlerror())
+            self.lastError = NSError(domain: "TorManager", code: -11, userInfo: [NSLocalizedDescriptionKey: "dlsym tor_main failed: \(err)"])
+            self.isStarting = false
+            return false
+        }
+        let torMain = unsafeBitCast(sym, to: TorMainType.self)
+        self._dlHandle = handle
+
+        // Prepare args: tor -f <torrc>
+        var argv: [String] = ["tor"]
+        if let torrc = torrcURL()?.path {
+            argv.append(contentsOf: ["-f", torrc])
+        }
+        // Run Tor on a background thread to avoid blocking the main actor
+        SecureLogger.info("TorManager: launching tor_main with torrc", category: .session)
+        let argc = Int32(argv.count)
+        DispatchQueue.global(qos: .utility).async {
+            // Build stable C argv in this thread
+            let cStrings: [UnsafeMutablePointer<CChar>?] = argv.map { strdup($0) }
+            let cArgv = UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>.allocate(capacity: cStrings.count + 1)
+            for i in 0..<cStrings.count { cArgv[i] = cStrings[i] }
+            cArgv[cStrings.count] = nil
+
+            _ = torMain(argc, cArgv)
+
+            // Free args after exit (Tor usually never returns)
+            for ptr in cStrings.compactMap({ $0 }) { free(ptr) }
+            cArgv.deallocate()
+        }
+
+        // Start control-port monitor and probe readiness asynchronously
+        startControlMonitorIfNeeded()
+        Task.detached(priority: .userInitiated) { [weak self] in
+            guard let self else { return }
+            let ready = await self.waitForSocksReady(timeout: 60.0)
+            await MainActor.run {
+                self.socksReady = ready
+                if !ready {
+                    self.lastError = NSError(domain: "TorManager", code: -12, userInfo: [NSLocalizedDescriptionKey: "Tor SOCKS not reachable after dlopen start"])
+                    SecureLogger.error("TorManager: SOCKS not reachable (timeout)", category: .session)
+                } else {
+                    SecureLogger.info("TorManager: SOCKS ready at \(self.socksHost):\(self.socksPort)", category: .session)
+                }
+                // isStarting will be cleared when bootstrap reaches 100%
+            }
+        }
+
+        return true
+    }
+
+    private var _dlHandle: UnsafeMutableRawPointer?
+
+    private func frameworkBinaryURL() -> URL? {
+        // Try common embedded locations for the framework binary name
+        let candidates = [
+            "tor-nolzma.framework/tor-nolzma",
+            "Tor.framework/Tor",
+        ]
+        if let base = Bundle.main.privateFrameworksURL {
+            for rel in candidates {
+                let url = base.appendingPathComponent(rel)
+                if FileManager.default.fileExists(atPath: url.path) { return url }
+            }
+        }
+        // For macOS apps, also try Contents/Frameworks explicitly
+        #if os(macOS)
+        if let appURL = Bundle.main.bundleURL as URL?,
+           let frameworksURL = Optional(appURL.appendingPathComponent("Contents/Frameworks", isDirectory: true)) {
+            for rel in candidates {
+                let url = frameworksURL.appendingPathComponent(rel)
+                if FileManager.default.fileExists(atPath: url.path) { return url }
+            }
+        }
+        #endif
+        return nil
+    }
+
+    // MARK: - Static-link path (no module import)
+    private func startTorViaLinkedSymbol() -> Bool {
+        // Attempt to start tor_run_main directly (statically linked). If the
+        // symbol is not present at link-time, builds will fail — which is
+        // expected when the xcframework is absent.
+        var argv: [String] = ["tor"]
+        if let torrc = torrcURL()?.path { argv.append(contentsOf: ["-f", torrc]) }
+
+        SecureLogger.info("TorManager: starting tor_main (static)", category: .session)
+        let argc = Int32(argv.count)
+        DispatchQueue.global(qos: .utility).async {
+            // Build stable C argv in this thread
+            let cStrings: [UnsafeMutablePointer<CChar>?] = argv.map { strdup($0) }
+            let cArgv = UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>.allocate(capacity: cStrings.count + 1)
+            for i in 0..<cStrings.count { cArgv[i] = cStrings[i] }
+            cArgv[cStrings.count] = nil
+
+            _ = tor_main_c(argc, cArgv)
+
+            // If tor_main ever returns, free memory
+            for ptr in cStrings.compactMap({ $0 }) { free(ptr) }
+            cArgv.deallocate()
+        }
+
+        // Start control monitor early
+        startControlMonitorIfNeeded()
+        Task.detached(priority: .userInitiated) { [weak self] in
+            guard let self else { return }
+            let ready = await self.waitForSocksReady(timeout: 60.0)
+            await MainActor.run {
+                self.socksReady = ready
+                if ready {
+                    SecureLogger.info("TorManager: SOCKS ready at \(self.socksHost):\(self.socksPort)", category: .session)
+                } else {
+                    self.lastError = NSError(domain: "TorManager", code: -13, userInfo: [NSLocalizedDescriptionKey: "Tor SOCKS not reachable after static start"])
+                    SecureLogger.error("TorManager: SOCKS not reachable (timeout)", category: .session)
+                }
+                // isStarting will be cleared when bootstrap reaches 100%
+            }
+        }
+        return true
+    }
+    
     // MARK: - ControlPort monitoring (bootstrap progress)
     private func startControlMonitorIfNeeded() {
         guard !controlMonitorStarted else { return }
@@ -308,6 +440,10 @@ public final class TorManager: ObservableObject {
         }
     }
 
+    private func controlMonitorLoop() async {}
+
+    private func tryControlSessionOnce() async -> Bool { false }
+
     // iOS: Poll GETINFO periodically to track bootstrap progress without long-lived control readers.
     private func bootstrapPollLoop() async {
         let deadline = Date().addingTimeInterval(75)