fix: Remove unused variable and bump version to 1.5.1

- Remove unused messageType variable (compiler warning fix)
- Bump marketing version to 1.5.1

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.github/workflows/swift-tests.yml

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

.gitignore

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

Configs/Release.xcconfig

@@ -9,4 +9,3 @@ DEVELOPMENT_TEAM = L3N5LHJD5Y
 CODE_SIGN_STYLE = Automatic
 
 PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat
-APP_GROUP_ID = group.chat.bitchat

Package.swift

@@ -17,7 +17,6 @@ let package = Package(
     ],
     dependencies:[
         .package(path: "localPackages/Arti"),
-        .package(path: "localPackages/BitFoundation"),
         .package(path: "localPackages/BitLogger"),
         .package(url: "https://github.com/21-DOT-DEV/swift-secp256k1", exact: "0.21.1")
     ],
@@ -26,7 +25,6 @@ let package = Package(
             name: "bitchat",
             dependencies: [
                 .product(name: "P256K", package: "swift-secp256k1"),
-                .product(name: "BitFoundation", package: "BitFoundation"),
                 .product(name: "BitLogger", package: "BitLogger"),
                 .product(name: "Tor", package: "Arti")
             ],
@@ -34,7 +32,6 @@ let package = Package(
             exclude: [
                 "Info.plist",
                 "Assets.xcassets",
-                "_PreviewHelpers/PreviewAssets.xcassets",
                 "bitchat.entitlements",
                 "bitchat-macOS.entitlements",
                 "LaunchScreen.storyboard",
@@ -46,10 +43,7 @@ let package = Package(
         ),
         .testTarget(
             name: "bitchatTests",
-            dependencies: [
+            dependencies: ["bitchat"],
-                "bitchat",
-                .product(name: "BitFoundation", package: "BitFoundation")
-            ],
             path: "bitchatTests",
             exclude: [
                 "Info.plist",

bitchat.xcodeproj/project.pbxproj

@@ -10,8 +10,6 @@
 		17901751FD8010AFC8E750F2 /* bitchatShareExtension.appex in Embed Foundation Extensions */ = {isa = PBXBuildFile; fileRef = 61F92EBA29C47C0FCC482F1F /* bitchatShareExtension.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
 		3EE336D150427F736F32B56C /* P256K in Frameworks */ = {isa = PBXBuildFile; productRef = B1D9136AA0083366353BFA2F /* P256K */; };
 		885BBED78092484A5B069461 /* P256K in Frameworks */ = {isa = PBXBuildFile; productRef = 4EB6BA1B8464F1EA38F4E286 /* P256K */; };
-		A6BCF9482F80953E001CF9B9 /* BitFoundation in Frameworks */ = {isa = PBXBuildFile; productRef = A6BCF9472F80953E001CF9B9 /* BitFoundation */; };
-		A6BCF94A2F809550001CF9B9 /* BitFoundation in Frameworks */ = {isa = PBXBuildFile; productRef = A6BCF9492F809550001CF9B9 /* BitFoundation */; };
 		A6E3E5702E77036A0032EA8A /* BitLogger in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3E56F2E77036A0032EA8A /* BitLogger */; };
 		A6E3E5722E7703760032EA8A /* BitLogger in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3E5712E7703760032EA8A /* BitLogger */; };
 		A6E3EA7F2E7706720032EA8A /* Tor in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3EA7E2E7706720032EA8A /* Tor */; };
@@ -158,7 +156,6 @@
 				A6E3E5722E7703760032EA8A /* BitLogger in Frameworks */,
 				3EE336D150427F736F32B56C /* P256K in Frameworks */,
 				A6E3EA812E7706A80032EA8A /* Tor in Frameworks */,
-				A6BCF94A2F809550001CF9B9 /* BitFoundation in Frameworks */,
 			);
 		};
 		B5A5CC493FFB3D8966548140 /* Frameworks */ = {
@@ -167,7 +164,6 @@
 				A6E3E5702E77036A0032EA8A /* BitLogger in Frameworks */,
 				885BBED78092484A5B069461 /* P256K in Frameworks */,
 				A6E3EA7F2E7706720032EA8A /* Tor in Frameworks */,
-				A6BCF9482F80953E001CF9B9 /* BitFoundation in Frameworks */,
 			);
 		};
 /* End PBXFrameworksBuildPhase section */
@@ -227,7 +223,6 @@
 				B1D9136AA0083366353BFA2F /* P256K */,
 				A6E3E5712E7703760032EA8A /* BitLogger */,
 				A6E3EA802E7706A80032EA8A /* Tor */,
-				A6BCF9492F809550001CF9B9 /* BitFoundation */,
 			);
 			productName = bitchat_macOS;
 			productReference = 8F3A7C058C2C8E1A06C8CF8B /* bitchat.app */;
@@ -308,7 +303,6 @@
 				4EB6BA1B8464F1EA38F4E286 /* P256K */,
 				A6E3E56F2E77036A0032EA8A /* BitLogger */,
 				A6E3EA7E2E7706720032EA8A /* Tor */,
-				A6BCF9472F80953E001CF9B9 /* BitFoundation */,
 			);
 			productName = bitchat_iOS;
 			productReference = 96D0D41CA19EE5A772AA8434 /* bitchat.app */;
@@ -350,7 +344,6 @@
 				B8C407587481BBB190741C93 /* XCRemoteSwiftPackageReference "swift-secp256k1" */,
 				A6E3E56E2E77036A0032EA8A /* XCLocalSwiftPackageReference "localPackages/BitLogger" */,
 				A6E3EA7D2E7706720032EA8A /* XCLocalSwiftPackageReference "localPackages/Arti" */,
-				A6BCF9462F80953E001CF9B9 /* XCLocalSwiftPackageReference "localPackages/BitFoundation" */,
 			);
 			preferredProjectObjectVersion = 90;
 			projectDirPath = "";
@@ -555,7 +548,6 @@
 				CODE_SIGNING_REQUIRED = YES;
 				CODE_SIGN_ENTITLEMENTS = bitchat/bitchat.entitlements;
 				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
-				DEVELOPMENT_ASSET_PATHS = bitchat/_PreviewHelpers;
 				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				ENABLE_PREVIEWS = NO;
 				INFOPLIST_FILE = bitchat/Info.plist;
@@ -566,7 +558,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.5.1;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
@@ -616,7 +608,6 @@
 				CODE_SIGNING_REQUIRED = YES;
 				CODE_SIGN_ENTITLEMENTS = bitchat/bitchat.entitlements;
 				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
-				DEVELOPMENT_ASSET_PATHS = bitchat/_PreviewHelpers;
 				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				ENABLE_PREVIEWS = YES;
 				INFOPLIST_FILE = bitchat/Info.plist;
@@ -627,7 +618,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.5.1;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
@@ -663,7 +654,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				MARKETING_VERSION = 1.5.1;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
@@ -755,7 +746,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				MARKETING_VERSION = 1.5.1;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
@@ -916,10 +907,6 @@
 /* End XCConfigurationList section */
 
 /* Begin XCLocalSwiftPackageReference section */
-		A6BCF9462F80953E001CF9B9 /* XCLocalSwiftPackageReference "localPackages/BitFoundation" */ = {
-			isa = XCLocalSwiftPackageReference;
-			relativePath = localPackages/BitFoundation;
-		};
 		A6E3E56E2E77036A0032EA8A /* XCLocalSwiftPackageReference "localPackages/BitLogger" */ = {
 			isa = XCLocalSwiftPackageReference;
 			relativePath = localPackages/BitLogger;
@@ -947,15 +934,6 @@
 			package = B8C407587481BBB190741C93 /* XCRemoteSwiftPackageReference "swift-secp256k1" */;
 			productName = P256K;
 		};
-		A6BCF9472F80953E001CF9B9 /* BitFoundation */ = {
-			isa = XCSwiftPackageProductDependency;
-			productName = BitFoundation;
-		};
-		A6BCF9492F809550001CF9B9 /* BitFoundation */ = {
-			isa = XCSwiftPackageProductDependency;
-			package = A6BCF9462F80953E001CF9B9 /* XCLocalSwiftPackageReference "localPackages/BitFoundation" */;
-			productName = BitFoundation;
-		};
 		A6E3E56F2E77036A0032EA8A /* BitLogger */ = {
 			isa = XCSwiftPackageProductDependency;
 			productName = BitLogger;

bitchat/App/AppArchitecture.swift

@@ -1,363 +0,0 @@
-import BitFoundation
-import Combine
-import Foundation
-
-enum SharedContentKind: String, Sendable, Equatable {
-    case text
-    case url
-}
-
-enum RuntimeScenePhase: String, Sendable, Equatable {
-    case active
-    case inactive
-    case background
-}
-
-enum TorLifecycleEvent: String, Sendable, Equatable {
-    case willStart
-    case willRestart
-    case didBecomeReady
-    case preferenceChanged
-}
-
-enum AppEvent: Sendable, Equatable {
-    case launched
-    case startupCompleted
-    case scenePhaseChanged(RuntimeScenePhase)
-    case openedURL(String)
-    case sharedContentAccepted(SharedContentKind)
-    case notificationOpened(peerID: PeerID?)
-    case deepLinkOpened(String)
-    case torLifecycleChanged(TorLifecycleEvent)
-    case nostrRelayConnectionChanged(Bool)
-    case terminationRequested
-}
-
-actor AppEventStream {
-    private var continuations: [UUID: AsyncStream<AppEvent>.Continuation] = [:]
-
-    func stream() -> AsyncStream<AppEvent> {
-        let id = UUID()
-        return AsyncStream { continuation in
-            continuations[id] = continuation
-            continuation.onTermination = { [id] _ in
-                Task {
-                    await self.removeContinuation(id)
-                }
-            }
-        }
-    }
-
-    func emit(_ event: AppEvent) {
-        for continuation in continuations.values {
-            continuation.yield(event)
-        }
-    }
-
-    func finish() {
-        for continuation in continuations.values {
-            continuation.finish()
-        }
-        continuations.removeAll()
-    }
-
-    private func removeContinuation(_ id: UUID) {
-        continuations.removeValue(forKey: id)
-    }
-}
-
-struct PeerHandle: Sendable, Identifiable {
-    let id: String
-    let routingPeerID: PeerID
-    let displayName: String?
-    let noisePublicKeyHex: String?
-    let nostrPublicKey: String?
-}
-
-extension PeerHandle: Equatable {
-    static func == (lhs: PeerHandle, rhs: PeerHandle) -> Bool {
-        lhs.id == rhs.id
-    }
-}
-
-extension PeerHandle: Hashable {
-    func hash(into hasher: inout Hasher) {
-        hasher.combine(id)
-    }
-}
-
-enum ConversationID: Hashable, Sendable {
-    case mesh
-    case geohash(String)
-    case direct(PeerHandle)
-
-    init(channelID: ChannelID) {
-        switch channelID {
-        case .mesh:
-            self = .mesh
-        case .location(let channel):
-            self = .geohash(channel.geohash.lowercased())
-        }
-    }
-}
-
-@MainActor
-final class IdentityResolver {
-    private var handlesByRoutingPeerID: [PeerID: PeerHandle] = [:]
-    private var handlesByNoiseKey: [String: PeerHandle] = [:]
-    private var handlesByNostrKey: [String: PeerHandle] = [:]
-
-    func register(peers: [BitchatPeer]) {
-        for peer in peers {
-            _ = register(peer: peer)
-        }
-    }
-
-    @discardableResult
-    func register(peer: BitchatPeer) -> PeerHandle {
-        let handle = buildHandle(
-            routingPeerID: peer.peerID,
-            displayName: peer.displayName,
-            noisePublicKeyHex: peer.noisePublicKey.isEmpty ? nil : peer.noisePublicKey.hexEncodedString().lowercased(),
-            nostrPublicKey: normalizedNostrKey(peer.nostrPublicKey)
-        )
-        cache(handle)
-        return handle
-    }
-
-    func canonicalHandle(for peerID: PeerID, displayName: String? = nil) -> PeerHandle {
-        if let handle = handlesByRoutingPeerID[peerID] {
-            return handle
-        }
-
-        if peerID.isNoiseKeyHex, let handle = handlesByNoiseKey[peerID.bare] {
-            return handle
-        }
-
-        if (peerID.isGeoDM || peerID.isGeoChat), let handle = handlesByNostrKey[peerID.bare] {
-            return handle
-        }
-
-        let handle = buildHandle(
-            routingPeerID: peerID,
-            displayName: displayName,
-            noisePublicKeyHex: peerID.isNoiseKeyHex ? peerID.bare : nil,
-            nostrPublicKey: (peerID.isGeoDM || peerID.isGeoChat) ? peerID.bare : nil
-        )
-        cache(handle)
-        return handle
-    }
-
-    private func buildHandle(
-        routingPeerID: PeerID,
-        displayName: String?,
-        noisePublicKeyHex: String?,
-        nostrPublicKey: String?
-    ) -> PeerHandle {
-        let canonicalID: String
-        if let noisePublicKeyHex {
-            canonicalID = "noise:\(noisePublicKeyHex)"
-        } else if let nostrPublicKey {
-            canonicalID = "nostr:\(nostrPublicKey)"
-        } else {
-            canonicalID = "mesh:\(routingPeerID.id)"
-        }
-
-        let normalizedDisplayName: String?
-        if let displayName, !displayName.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
-            normalizedDisplayName = displayName
-        } else {
-            normalizedDisplayName = nil
-        }
-
-        return PeerHandle(
-            id: canonicalID,
-            routingPeerID: routingPeerID,
-            displayName: normalizedDisplayName,
-            noisePublicKeyHex: noisePublicKeyHex,
-            nostrPublicKey: nostrPublicKey
-        )
-    }
-
-    private func normalizedNostrKey(_ nostrPublicKey: String?) -> String? {
-        guard let nostrPublicKey else { return nil }
-        let trimmed = nostrPublicKey.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
-        return trimmed.isEmpty ? nil : trimmed
-    }
-
-    private func cache(_ handle: PeerHandle) {
-        handlesByRoutingPeerID[handle.routingPeerID] = handle
-        if let noisePublicKeyHex = handle.noisePublicKeyHex {
-            handlesByNoiseKey[noisePublicKeyHex] = handle
-        }
-        if let nostrPublicKey = handle.nostrPublicKey {
-            handlesByNostrKey[nostrPublicKey] = handle
-        }
-    }
-}
-
-@MainActor
-final class ConversationStore: ObservableObject {
-    @Published private(set) var activeChannel: ChannelID = .mesh
-    @Published private(set) var selectedPrivatePeerID: PeerID?
-    @Published private(set) var selectedConversationID: ConversationID = .mesh
-    @Published private(set) var unreadConversations: Set<ConversationID> = []
-    @Published private(set) var messagesByConversation: [ConversationID: [BitchatMessage]] = [:]
-
-    private var directHandlesByConversation: [ConversationID: PeerHandle] = [:]
-
-    func setActiveChannel(_ channelID: ChannelID) {
-        activeChannel = channelID
-        if selectedPrivatePeerID == nil {
-            selectedConversationID = ConversationID(channelID: channelID)
-        }
-    }
-
-    func setSelectedPeerID(
-        _ peerID: PeerID?,
-        activeChannel: ChannelID,
-        identityResolver: IdentityResolver
-    ) {
-        self.activeChannel = activeChannel
-        selectedPrivatePeerID = peerID
-
-        if let peerID {
-            selectedConversationID = directConversationID(
-                for: peerID,
-                identityResolver: identityResolver
-            )
-        } else {
-            selectedConversationID = ConversationID(channelID: activeChannel)
-        }
-    }
-
-    func replaceMessages(_ messages: [BitchatMessage], for conversationID: ConversationID) {
-        messagesByConversation[conversationID] = normalized(messages)
-    }
-
-    func replaceMessages(_ messages: [BitchatMessage], for channelID: ChannelID) {
-        replaceMessages(messages, for: ConversationID(channelID: channelID))
-    }
-
-    func synchronizePublicConversation(_ messages: [BitchatMessage], activeChannel: ChannelID) {
-        setActiveChannel(activeChannel)
-        replaceMessages(messages, for: activeChannel)
-    }
-
-    func messages(for conversationID: ConversationID) -> [BitchatMessage] {
-        messagesByConversation[conversationID] ?? []
-    }
-
-    func directMessages(
-        for peerID: PeerID,
-        identityResolver: IdentityResolver
-    ) -> [BitchatMessage] {
-        messages(for: directConversationID(for: peerID, identityResolver: identityResolver))
-    }
-
-    func directMessagesByPeerID() -> [PeerID: [BitchatMessage]] {
-        var messagesByPeerID: [PeerID: [BitchatMessage]] = [:]
-
-        for (conversationID, handle) in directHandlesByConversation {
-            messagesByPeerID[handle.routingPeerID] = messages(for: conversationID)
-        }
-
-        return messagesByPeerID
-    }
-
-    func unreadDirectPeerIDs() -> Set<PeerID> {
-        unreadConversations.reduce(into: Set<PeerID>()) { result, conversationID in
-            guard case .direct(let handle) = conversationID else { return }
-            result.insert(directHandlesByConversation[conversationID]?.routingPeerID ?? handle.routingPeerID)
-        }
-    }
-
-    func synchronizeSelection(
-        activeChannel: ChannelID,
-        selectedPeerID: PeerID?,
-        identityResolver: IdentityResolver
-    ) {
-        setSelectedPeerID(
-            selectedPeerID,
-            activeChannel: activeChannel,
-            identityResolver: identityResolver
-        )
-    }
-
-    func synchronizePrivateChats(
-        _ privateChats: [PeerID: [BitchatMessage]],
-        unreadPeerIDs: Set<PeerID>,
-        identityResolver: IdentityResolver
-    ) {
-        var liveConversations = Set<ConversationID>()
-
-        for (peerID, messages) in privateChats {
-            let handle = identityResolver.canonicalHandle(for: peerID, displayName: messages.last?.sender)
-            let conversationID = ConversationID.direct(handle)
-            liveConversations.insert(conversationID)
-            directHandlesByConversation[conversationID] = handle
-            messagesByConversation[conversationID] = normalized(messages)
-        }
-
-        let staleDirectConversations = messagesByConversation.keys.filter { conversationID in
-            guard case .direct = conversationID else { return false }
-            return !liveConversations.contains(conversationID)
-        }
-
-        for conversationID in staleDirectConversations {
-            messagesByConversation.removeValue(forKey: conversationID)
-            unreadConversations.remove(conversationID)
-            directHandlesByConversation.removeValue(forKey: conversationID)
-        }
-
-        let publicUnread = unreadConversations.filter { conversationID in
-            switch conversationID {
-            case .mesh, .geohash:
-                return true
-            case .direct:
-                return false
-            }
-        }
-
-        unreadConversations = unreadPeerIDs.reduce(into: publicUnread) { result, peerID in
-            let handle = identityResolver.canonicalHandle(for: peerID)
-            result.insert(.direct(handle))
-        }
-    }
-
-    func markRead(_ conversationID: ConversationID) {
-        unreadConversations.remove(conversationID)
-    }
-
-    func markRead(
-        peerID: PeerID,
-        identityResolver: IdentityResolver
-    ) {
-        markRead(directConversationID(for: peerID, identityResolver: identityResolver))
-    }
-
-    private func normalized(_ messages: [BitchatMessage]) -> [BitchatMessage] {
-        var uniqueMessages: [String: BitchatMessage] = [:]
-
-        for message in messages {
-            uniqueMessages[message.id] = message
-        }
-
-        return uniqueMessages.values.sorted { lhs, rhs in
-            if lhs.timestamp != rhs.timestamp {
-                return lhs.timestamp < rhs.timestamp
-            }
-            return lhs.id < rhs.id
-        }
-    }
-
-    private func directConversationID(
-        for peerID: PeerID,
-        identityResolver: IdentityResolver
-    ) -> ConversationID {
-        let handle = identityResolver.canonicalHandle(for: peerID)
-        let conversationID = ConversationID.direct(handle)
-        directHandlesByConversation[conversationID] = handle
-        return conversationID
-    }
-}

bitchat/App/AppChromeModel.swift

@@ -1,100 +0,0 @@
-import BitFoundation
-import Combine
-import CoreBluetooth
-import Foundation
-
-@MainActor
-final class AppChromeModel: ObservableObject {
-    @Published private(set) var hasUnreadPrivateMessages = false
-    @Published var nickname: String
-    @Published var showingFingerprintFor: PeerID?
-    @Published var isAppInfoPresented = false
-    @Published var isLocationChannelsSheetPresented = false
-    @Published var showBluetoothAlert = false
-    @Published var bluetoothAlertMessage = ""
-    @Published var bluetoothState: CBManagerState = .unknown
-    @Published var showScreenshotPrivacyWarning = false
-
-    private let chatViewModel: ChatViewModel
-    private var cancellables = Set<AnyCancellable>()
-
-    init(chatViewModel: ChatViewModel, privateInboxModel: PrivateInboxModel) {
-        self.chatViewModel = chatViewModel
-        self.nickname = chatViewModel.nickname
-
-        bind(privateInboxModel: privateInboxModel)
-    }
-
-    var shouldSuppressScreenshotNotification: Bool {
-        isLocationChannelsSheetPresented || isAppInfoPresented
-    }
-
-    func setNickname(_ nickname: String) {
-        self.nickname = nickname
-        if chatViewModel.nickname != nickname {
-            chatViewModel.nickname = nickname
-        }
-    }
-
-    func validateAndSaveNickname() {
-        chatViewModel.validateAndSaveNickname()
-        if nickname != chatViewModel.nickname {
-            nickname = chatViewModel.nickname
-        }
-    }
-
-    func openMostRelevantPrivateChat() {
-        chatViewModel.openMostRelevantPrivateChat()
-    }
-
-    func showFingerprint(for peerID: PeerID) {
-        showingFingerprintFor = peerID
-    }
-
-    func clearFingerprint() {
-        showingFingerprintFor = nil
-    }
-
-    func presentAppInfo() {
-        isAppInfoPresented = true
-    }
-
-    func triggerScreenshotPrivacyWarning() {
-        showScreenshotPrivacyWarning = true
-    }
-
-    func panicClearAllData() {
-        chatViewModel.panicClearAllData()
-    }
-
-    private func bind(privateInboxModel: PrivateInboxModel) {
-        privateInboxModel.$unreadPeerIDs
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] unreadPeerIDs in
-                self?.hasUnreadPrivateMessages = !unreadPeerIDs.isEmpty
-            }
-            .store(in: &cancellables)
-
-        chatViewModel.$nickname
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] nickname in
-                guard let self, self.nickname != nickname else { return }
-                self.nickname = nickname
-            }
-            .store(in: &cancellables)
-
-        chatViewModel.$showBluetoothAlert
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$showBluetoothAlert)
-
-        chatViewModel.$bluetoothAlertMessage
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$bluetoothAlertMessage)
-
-        chatViewModel.$bluetoothState
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$bluetoothState)
-
-        hasUnreadPrivateMessages = !privateInboxModel.unreadPeerIDs.isEmpty
-    }
-}

bitchat/App/AppRuntime.swift

@@ -1,387 +0,0 @@
-import BitFoundation
-import Combine
-import Foundation
-import SwiftUI
-import Tor
-import UserNotifications
-#if os(iOS)
-import UIKit
-#elseif os(macOS)
-import AppKit
-#endif
-
-@MainActor
-final class AppRuntime: ObservableObject {
-    let chatViewModel: ChatViewModel
-    let events = AppEventStream()
-    let conversationStore: ConversationStore
-    let peerIdentityStore: PeerIdentityStore
-    let locationPresenceStore: LocationPresenceStore
-    let publicChatModel: PublicChatModel
-    let privateInboxModel: PrivateInboxModel
-    let privateConversationModel: PrivateConversationModel
-    let verificationModel: VerificationModel
-    let conversationUIModel: ConversationUIModel
-    let locationChannelsModel: LocationChannelsModel
-    let peerListModel: PeerListModel
-    let appChromeModel: AppChromeModel
-
-    private let idBridge: NostrIdentityBridge
-    private var cancellables = Set<AnyCancellable>()
-    private var started = false
-    private var lastNostrRelayConnectedState = false
-    private var didHandleInitialNostrConnection = false
-
-    #if os(iOS)
-    private var didHandleInitialActive = false
-    private var didEnterBackground = false
-    #endif
-
-    init(
-        keychain: KeychainManagerProtocol = KeychainManager(),
-        idBridge: NostrIdentityBridge = NostrIdentityBridge()
-    ) {
-        self.idBridge = idBridge
-        let identityResolver = IdentityResolver()
-        let conversationStore = ConversationStore()
-        let peerIdentityStore = PeerIdentityStore()
-        let locationPresenceStore = LocationPresenceStore()
-        let locationManager = LocationChannelManager.shared
-        self.conversationStore = conversationStore
-        self.peerIdentityStore = peerIdentityStore
-        self.locationPresenceStore = locationPresenceStore
-        self.chatViewModel = ChatViewModel(
-            keychain: keychain,
-            idBridge: idBridge,
-            identityManager: SecureIdentityStateManager(keychain),
-            conversationStore: conversationStore,
-            identityResolver: identityResolver,
-            peerIdentityStore: peerIdentityStore,
-            locationPresenceStore: locationPresenceStore,
-            locationManager: locationManager
-        )
-        self.publicChatModel = PublicChatModel(conversationStore: conversationStore)
-        self.privateInboxModel = PrivateInboxModel(conversationStore: conversationStore)
-        self.locationChannelsModel = LocationChannelsModel(manager: locationManager)
-        self.privateConversationModel = PrivateConversationModel(
-            chatViewModel: self.chatViewModel,
-            conversationStore: conversationStore,
-            locationChannelsModel: self.locationChannelsModel,
-            peerIdentityStore: peerIdentityStore
-        )
-        self.verificationModel = VerificationModel(
-            chatViewModel: self.chatViewModel,
-            privateConversationModel: self.privateConversationModel,
-            peerIdentityStore: peerIdentityStore
-        )
-        self.conversationUIModel = ConversationUIModel(
-            chatViewModel: self.chatViewModel,
-            privateConversationModel: self.privateConversationModel,
-            conversationStore: conversationStore
-        )
-        self.peerListModel = PeerListModel(
-            chatViewModel: self.chatViewModel,
-            conversationStore: conversationStore,
-            locationChannelsModel: self.locationChannelsModel,
-            peerIdentityStore: peerIdentityStore,
-            locationPresenceStore: locationPresenceStore
-        )
-        self.appChromeModel = AppChromeModel(
-            chatViewModel: self.chatViewModel,
-            privateInboxModel: self.privateInboxModel
-        )
-
-        GeoRelayDirectory.shared.prefetchIfNeeded()
-        bindRuntimeObservers()
-        NotificationDelegate.shared.runtime = self
-    }
-
-    func start() {
-        guard !started else {
-            checkForSharedContent()
-            return
-        }
-
-        started = true
-        NotificationDelegate.shared.runtime = self
-        VerificationService.shared.configure(with: chatViewModel.meshService.getNoiseService())
-        announceInitialTorStatusIfNeeded()
-
-        Task(priority: .utility) { [weak self] in
-            guard let self else { return }
-            let nickname = await MainActor.run { self.chatViewModel.nickname }
-            let npub = await MainActor.run {
-                try? self.idBridge.getCurrentNostrIdentity()?.npub
-            }
-            await MainActor.run {
-                _ = VerificationService.shared.buildMyQRString(nickname: nickname, npub: npub)
-            }
-        }
-
-        NetworkActivationService.shared.start()
-        GeohashPresenceService.shared.start()
-        checkForSharedContent()
-
-        record(.launched)
-        record(.startupCompleted)
-    }
-
-    func handleOpenURL(_ url: URL) {
-        record(.openedURL(url.absoluteString))
-
-        if url.scheme == "bitchat", url.host == "share" {
-            checkForSharedContent()
-        }
-    }
-
-    func handleDidBecomeActiveNotification() {
-        chatViewModel.handleDidBecomeActive()
-        checkForSharedContent()
-    }
-
-    #if os(macOS)
-    func handleMacDidBecomeActiveNotification() {
-        record(.scenePhaseChanged(.active))
-        chatViewModel.handleDidBecomeActive()
-        checkForSharedContent()
-    }
-    #endif
-
-    #if os(iOS)
-    func handleScenePhaseChange(_ newPhase: ScenePhase) {
-        switch newPhase {
-        case .background:
-            record(.scenePhaseChanged(.background))
-            TorManager.shared.setAppForeground(false)
-            TorManager.shared.goDormantOnBackground()
-            chatViewModel.endGeohashSampling()
-            NostrRelayManager.shared.disconnect()
-            didEnterBackground = true
-
-        case .active:
-            record(.scenePhaseChanged(.active))
-            chatViewModel.meshService.startServices()
-            TorManager.shared.setAppForeground(true)
-            let shouldRefreshNostrConnections = didHandleInitialActive && didEnterBackground
-
-            if didHandleInitialActive && didEnterBackground {
-                if TorManager.shared.isAutoStartAllowed() && !TorManager.shared.isReady {
-                    TorManager.shared.ensureRunningOnForeground()
-                }
-            } else {
-                didHandleInitialActive = true
-            }
-
-            didEnterBackground = false
-
-            if shouldRefreshNostrConnections && TorManager.shared.isAutoStartAllowed() {
-                Task.detached {
-                    let _ = await TorManager.shared.awaitReady(timeout: 60)
-                    await MainActor.run {
-                        TorURLSession.shared.rebuild()
-                        NostrRelayManager.shared.resetAllConnections()
-                    }
-                }
-            }
-
-            chatViewModel.handleDidBecomeActive()
-            checkForSharedContent()
-
-        case .inactive:
-            record(.scenePhaseChanged(.inactive))
-
-        @unknown default:
-            break
-        }
-    }
-    #endif
-
-    func applicationWillTerminate() {
-        record(.terminationRequested)
-        chatViewModel.applicationWillTerminate()
-    }
-
-    func handleNotificationResponse(identifier: String, userInfo: [AnyHashable: Any]) {
-        if identifier.hasPrefix("private-"), let peerID = PeerID(str: userInfo["peerID"] as? String) {
-            record(.notificationOpened(peerID: peerID))
-            chatViewModel.startPrivateChat(with: peerID)
-        }
-
-        if let deepLink = userInfo["deeplink"] as? String, let url = URL(string: deepLink) {
-            record(.deepLinkOpened(deepLink))
-            openExternalURL(url)
-        }
-    }
-
-    func presentationOptions(
-        forNotificationIdentifier identifier: String,
-        userInfo: [AnyHashable: Any]
-    ) async -> UNNotificationPresentationOptions {
-        if identifier.hasPrefix("private-"), let peerID = PeerID(str: userInfo["peerID"] as? String) {
-            if conversationStore.selectedPrivatePeerID == peerID {
-                return []
-            }
-            return [.banner, .sound]
-        }
-
-        if identifier.hasPrefix("geo-activity-"),
-           let deepLink = userInfo["deeplink"] as? String,
-           let geohash = deepLink.components(separatedBy: "/").last,
-           case .location(let channel) = locationChannelsModel.selectedChannel,
-           channel.geohash == geohash {
-            return []
-        }
-
-        return [.banner, .sound]
-    }
-}
-
-private extension AppRuntime {
-    func bindRuntimeObservers() {
-        NostrRelayManager.shared.$isConnected
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] isConnected in
-                self?.handleNostrRelayConnectionChanged(isConnected)
-            }
-            .store(in: &cancellables)
-
-        NotificationCenter.default.publisher(for: .TorWillRestart)
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.record(.torLifecycleChanged(.willRestart))
-                self?.chatViewModel.handleTorWillRestart()
-            }
-            .store(in: &cancellables)
-
-        NotificationCenter.default.publisher(for: .TorDidBecomeReady)
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.record(.torLifecycleChanged(.didBecomeReady))
-                self?.chatViewModel.handleTorDidBecomeReady()
-            }
-            .store(in: &cancellables)
-
-        NotificationCenter.default.publisher(for: .TorWillStart)
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.record(.torLifecycleChanged(.willStart))
-                self?.chatViewModel.handleTorWillStart()
-            }
-            .store(in: &cancellables)
-
-        NotificationCenter.default.publisher(for: .TorUserPreferenceChanged)
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] notification in
-                self?.record(.torLifecycleChanged(.preferenceChanged))
-                self?.chatViewModel.handleTorPreferenceChanged(notification)
-            }
-            .store(in: &cancellables)
-
-        #if os(iOS)
-        NotificationCenter.default.publisher(for: UIApplication.userDidTakeScreenshotNotification)
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.handleScreenshotCaptured()
-            }
-            .store(in: &cancellables)
-        #endif
-    }
-
-    func checkForSharedContent() {
-        guard let userDefaults = UserDefaults(suiteName: BitchatApp.groupID),
-              let sharedContent = userDefaults.string(forKey: "sharedContent"),
-              let sharedDate = userDefaults.object(forKey: "sharedContentDate") as? Date else {
-            return
-        }
-
-        guard Date().timeIntervalSince(sharedDate) < TransportConfig.uiShareAcceptWindowSeconds else {
-            return
-        }
-
-        let contentKind = SharedContentKind(rawValue: userDefaults.string(forKey: "sharedContentType") ?? "") ?? .text
-
-        userDefaults.removeObject(forKey: "sharedContent")
-        userDefaults.removeObject(forKey: "sharedContentType")
-        userDefaults.removeObject(forKey: "sharedContentDate")
-
-        switch contentKind {
-        case .url:
-            if let data = sharedContent.data(using: .utf8),
-               let urlData = try? JSONSerialization.jsonObject(with: data) as? [String: String],
-               let url = urlData["url"] {
-                chatViewModel.sendMessage(url)
-            } else {
-                chatViewModel.sendMessage(sharedContent)
-            }
-        case .text:
-            chatViewModel.sendMessage(sharedContent)
-        }
-
-        record(.sharedContentAccepted(contentKind))
-    }
-
-    func handleNostrRelayConnectionChanged(_ isConnected: Bool) {
-        record(.nostrRelayConnectionChanged(isConnected))
-
-        let becameConnected = isConnected && !lastNostrRelayConnectedState
-        lastNostrRelayConnectedState = isConnected
-
-        guard started, becameConnected else { return }
-
-        let isInitialConnection = !didHandleInitialNostrConnection
-        didHandleInitialNostrConnection = true
-
-        if !chatViewModel.nostrHandlersSetup {
-            chatViewModel.setupNostrMessageHandling()
-            chatViewModel.nostrHandlersSetup = true
-        }
-
-        guard !isInitialConnection else { return }
-
-        chatViewModel.resubscribeCurrentGeohash()
-        chatViewModel.geoChannelCoordinator?.refreshSampling()
-    }
-
-    func announceInitialTorStatusIfNeeded() {
-        if TorManager.shared.torEnforced &&
-            !chatViewModel.torStatusAnnounced &&
-            TorManager.shared.isAutoStartAllowed() {
-            chatViewModel.torStatusAnnounced = true
-            chatViewModel.addGeohashOnlySystemMessage(
-                String(localized: "system.tor.starting", comment: "System message when Tor is starting")
-            )
-        } else if !TorManager.shared.torEnforced && !chatViewModel.torStatusAnnounced {
-            chatViewModel.torStatusAnnounced = true
-            chatViewModel.addGeohashOnlySystemMessage(
-                String(localized: "system.tor.dev_bypass", comment: "System message when Tor bypass is enabled in development")
-            )
-        }
-    }
-
-    func handleScreenshotCaptured() {
-        if appChromeModel.isLocationChannelsSheetPresented {
-            appChromeModel.triggerScreenshotPrivacyWarning()
-            return
-        }
-
-        if appChromeModel.isAppInfoPresented {
-            return
-        }
-
-        chatViewModel.handleScreenshotCaptured()
-    }
-
-    func openExternalURL(_ url: URL) {
-        #if os(iOS)
-        UIApplication.shared.open(url)
-        #else
-        NSWorkspace.shared.open(url)
-        #endif
-    }
-
-    func record(_ event: AppEvent) {
-        Task {
-            await events.emit(event)
-        }
-    }
-}

bitchat/App/ConversationUIModel.swift

@@ -1,183 +0,0 @@
-import BitFoundation
-import Combine
-import SwiftUI
-#if os(iOS)
-import UIKit
-#endif
-
-@MainActor
-final class ConversationUIModel: ObservableObject {
-    @Published private(set) var showAutocomplete = false
-    @Published private(set) var autocompleteSuggestions: [String] = []
-    @Published private(set) var currentNickname: String
-    @Published private(set) var isBatchingPublic = false
-    @Published private(set) var canSendMediaInCurrentContext = true
-
-    private let chatViewModel: ChatViewModel
-    private let privateConversationModel: PrivateConversationModel
-    private let conversationStore: ConversationStore
-    private var activeChannel: ChannelID
-    private var cancellables = Set<AnyCancellable>()
-
-    init(
-        chatViewModel: ChatViewModel,
-        privateConversationModel: PrivateConversationModel,
-        conversationStore: ConversationStore
-    ) {
-        self.chatViewModel = chatViewModel
-        self.privateConversationModel = privateConversationModel
-        self.conversationStore = conversationStore
-        self.activeChannel = conversationStore.activeChannel
-        self.currentNickname = chatViewModel.nickname
-        self.isBatchingPublic = chatViewModel.isBatchingPublic
-        self.showAutocomplete = chatViewModel.showAutocomplete
-        self.autocompleteSuggestions = chatViewModel.autocompleteSuggestions
-        self.canSendMediaInCurrentContext = chatViewModel.canSendMediaInCurrentContext
-
-        bind()
-    }
-
-    func setCurrentColorScheme(_ colorScheme: ColorScheme) {
-        chatViewModel.currentColorScheme = colorScheme
-    }
-
-    func sendMessage(_ message: String) {
-        chatViewModel.sendMessage(message)
-    }
-
-    func clearCurrentConversation() {
-        chatViewModel.sendMessage("/clear")
-    }
-
-    func sendHug(to sender: String) {
-        chatViewModel.sendMessage("/hug @\(sender)")
-    }
-
-    func sendSlap(to sender: String) {
-        chatViewModel.sendMessage("/slap @\(sender)")
-    }
-
-    func block(peerID: PeerID?, displayName: String?) {
-        guard let displayName else { return }
-
-        if let peerID, peerID.isGeoChat,
-           let full = chatViewModel.fullNostrHex(forSenderPeerID: peerID) {
-            chatViewModel.blockGeohashUser(pubkeyHexLowercased: full, displayName: displayName)
-        } else {
-            chatViewModel.sendMessage("/block \(displayName)")
-        }
-    }
-
-    func updateAutocomplete(for text: String, cursorPosition: Int) {
-        chatViewModel.updateAutocomplete(for: text, cursorPosition: cursorPosition)
-    }
-
-    func completeNickname(_ nickname: String, in text: inout String) -> Int {
-        chatViewModel.completeNickname(nickname, in: &text)
-    }
-
-    func formatMessage(_ message: BitchatMessage, colorScheme: ColorScheme) -> AttributedString {
-        chatViewModel.formatMessageAsText(message, colorScheme: colorScheme)
-    }
-
-    func formatMessageHeader(_ message: BitchatMessage, colorScheme: ColorScheme) -> AttributedString {
-        chatViewModel.formatMessageHeader(message, colorScheme: colorScheme)
-    }
-
-    func mediaAttachment(for message: BitchatMessage) -> BitchatMessage.Media? {
-        message.mediaAttachment(for: currentNickname)
-    }
-
-    func isSelfSender(peerID: PeerID?, displayName: String?) -> Bool {
-        chatViewModel.isSelfSender(peerID: peerID, displayName: displayName)
-    }
-
-    func isSentByCurrentUser(_ message: BitchatMessage) -> Bool {
-        message.sender == currentNickname || message.sender.hasPrefix(currentNickname + "#")
-    }
-
-    func isMediaMessageFromCurrentUser(_ message: BitchatMessage) -> Bool {
-        message.sender == currentNickname || message.senderPeerID == chatViewModel.meshService.myPeerID
-    }
-
-    func senderDisplayName(for peerID: PeerID, fallbackMessages: [BitchatMessage]) -> String? {
-        if peerID.isGeoDM || peerID.isGeoChat {
-            return chatViewModel.geohashDisplayName(for: peerID)
-        }
-        if let nickname = chatViewModel.meshService.peerNickname(peerID: peerID) {
-            return nickname
-        }
-        return fallbackMessages.last(where: { $0.senderPeerID == peerID && $0.sender != "system" })?.sender
-    }
-
-    #if os(iOS)
-    func processSelectedImage(_ image: UIImage?) {
-        chatViewModel.processThenSendImage(image)
-    }
-    #endif
-
-    func processSelectedImage(from url: URL?) {
-        #if os(macOS)
-        chatViewModel.processThenSendImage(from: url)
-        #endif
-    }
-
-    func sendVoiceNote(at url: URL) {
-        chatViewModel.sendVoiceNote(at: url)
-    }
-
-    func cancelMediaSend(messageID: String) {
-        chatViewModel.cancelMediaSend(messageID: messageID)
-    }
-
-    func deleteMediaMessage(messageID: String) {
-        chatViewModel.deleteMediaMessage(messageID: messageID)
-    }
-
-    private func bind() {
-        chatViewModel.$nickname
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$currentNickname)
-
-        chatViewModel.$showAutocomplete
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$showAutocomplete)
-
-        chatViewModel.$autocompleteSuggestions
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$autocompleteSuggestions)
-
-        chatViewModel.$isBatchingPublic
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$isBatchingPublic)
-
-        conversationStore.$activeChannel
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] channel in
-                self?.activeChannel = channel
-                self?.refreshComputedState()
-            }
-            .store(in: &cancellables)
-
-        privateConversationModel.$selectedPeerID
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refreshComputedState()
-            }
-            .store(in: &cancellables)
-    }
-
-    private func refreshComputedState() {
-        if let selectedPeerID = privateConversationModel.selectedPeerID {
-            canSendMediaInCurrentContext = !(selectedPeerID.isGeoDM || selectedPeerID.isGeoChat)
-            return
-        }
-
-        switch activeChannel {
-        case .mesh:
-            canSendMediaInCurrentContext = true
-        case .location:
-            canSendMediaInCurrentContext = false
-        }
-    }
-}

bitchat/App/LocationChannelsModel.swift

@@ -1,176 +0,0 @@
-import BitFoundation
-import Combine
-import Foundation
-
-@MainActor
-final class LocationChannelsModel: ObservableObject {
-    @Published private(set) var permissionState: LocationChannelManager.PermissionState
-    @Published private(set) var availableChannels: [GeohashChannel]
-    @Published private(set) var selectedChannel: ChannelID
-    @Published private(set) var teleported: Bool
-    @Published private(set) var bookmarks: [String]
-    @Published private(set) var bookmarkNames: [String: String]
-    @Published private(set) var locationNames: [GeohashChannelLevel: String]
-    @Published private(set) var userTorEnabled: Bool
-
-    private let manager: LocationChannelManager
-    private let network: NetworkActivationService
-    private var cancellables = Set<AnyCancellable>()
-
-    init(
-        manager: LocationChannelManager? = nil,
-        network: NetworkActivationService? = nil
-    ) {
-        let manager = manager ?? .shared
-        let network = network ?? .shared
-
-        self.manager = manager
-        self.network = network
-        self.permissionState = manager.permissionState
-        self.availableChannels = manager.availableChannels
-        self.selectedChannel = manager.selectedChannel
-        self.teleported = manager.teleported
-        self.bookmarks = manager.bookmarks
-        self.bookmarkNames = manager.bookmarkNames
-        self.locationNames = manager.locationNames
-        self.userTorEnabled = network.userTorEnabled
-
-        bind()
-    }
-
-    var currentBuildingGeohash: String? {
-        availableChannels.first(where: { $0.level == .building })?.geohash
-    }
-
-    func isSelected(_ channel: GeohashChannel) -> Bool {
-        guard case .location(let selected) = selectedChannel else { return false }
-        return selected == channel
-    }
-
-    func isBookmarked(_ geohash: String) -> Bool {
-        manager.isBookmarked(geohash)
-    }
-
-    func enableLocationChannels() {
-        manager.enableLocationChannels()
-    }
-
-    func refreshChannels() {
-        manager.refreshChannels()
-    }
-
-    func enableAndRefresh() {
-        manager.enableLocationChannels()
-        manager.refreshChannels()
-    }
-
-    func beginLiveRefresh() {
-        manager.beginLiveRefresh()
-    }
-
-    func endLiveRefresh() {
-        manager.endLiveRefresh()
-    }
-
-    func select(_ channel: ChannelID) {
-        manager.select(channel)
-    }
-
-    func markTeleported(for geohash: String, _ flag: Bool) {
-        manager.markTeleported(for: geohash, flag)
-    }
-
-    func toggleBookmark(_ geohash: String) {
-        manager.toggleBookmark(geohash)
-    }
-
-    func resolveBookmarkNameIfNeeded(for geohash: String) {
-        manager.resolveBookmarkNameIfNeeded(for: geohash)
-    }
-
-    func locationName(for level: GeohashChannelLevel) -> String? {
-        locationNames[level]
-    }
-
-    func setUserTorEnabled(_ enabled: Bool) {
-        network.setUserTorEnabled(enabled)
-    }
-
-    func refreshMeshChannelsIfNeeded() {
-        guard case .mesh = selectedChannel,
-              permissionState == .authorized,
-              availableChannels.isEmpty else {
-            return
-        }
-        refreshChannels()
-    }
-
-    func openLocationChannel(for geohash: String) {
-        let normalized = geohash.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
-        let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
-        guard (2...12).contains(normalized.count),
-              normalized.allSatisfy({ allowed.contains($0) }) else {
-            return
-        }
-
-        let channel = GeohashChannel(level: level(forLength: normalized.count), geohash: normalized)
-        let isRegional = availableChannels.contains { $0.geohash == normalized }
-        if !isRegional && !availableChannels.isEmpty {
-            markTeleported(for: normalized, true)
-        }
-        select(.location(channel))
-    }
-
-    func teleport(to geohash: String) {
-        let normalized = geohash.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
-        let channel = GeohashChannel(level: level(forLength: normalized.count), geohash: normalized)
-        markTeleported(for: normalized, true)
-        select(.location(channel))
-    }
-
-    private func bind() {
-        manager.$permissionState
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$permissionState)
-
-        manager.$availableChannels
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$availableChannels)
-
-        manager.$selectedChannel
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$selectedChannel)
-
-        manager.$teleported
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$teleported)
-
-        manager.$bookmarks
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$bookmarks)
-
-        manager.$bookmarkNames
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$bookmarkNames)
-
-        manager.$locationNames
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$locationNames)
-
-        network.$userTorEnabled
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$userTorEnabled)
-    }
-
-    private func level(forLength length: Int) -> GeohashChannelLevel {
-        switch length {
-        case 0...2: return .region
-        case 3...4: return .province
-        case 5: return .city
-        case 6: return .neighborhood
-        case 7: return .block
-        case 8...12: return .building
-        default: return .block
-        }
-    }
-}

bitchat/App/LocationPresenceStore.swift

@@ -1,51 +0,0 @@
-import Combine
-import Foundation
-
-@MainActor
-final class LocationPresenceStore: ObservableObject {
-    @Published private(set) var currentGeohash: String?
-    @Published private(set) var geoNicknames: [String: String] = [:]
-    @Published private(set) var teleportedGeo: Set<String> = []
-
-    func setCurrentGeohash(_ geohash: String?) {
-        currentGeohash = geohash?.lowercased()
-    }
-
-    func setNickname(_ nickname: String, for pubkeyHex: String) {
-        geoNicknames[pubkeyHex.lowercased()] = nickname
-    }
-
-    func replaceGeoNicknames(_ nicknames: [String: String]) {
-        geoNicknames = Dictionary(
-            uniqueKeysWithValues: nicknames.map { key, value in
-                (key.lowercased(), value)
-            }
-        )
-    }
-
-    func clearGeoNicknames() {
-        geoNicknames.removeAll()
-    }
-
-    func markTeleported(_ pubkeyHex: String) {
-        teleportedGeo.insert(pubkeyHex.lowercased())
-    }
-
-    func clearTeleported(_ pubkeyHex: String) {
-        teleportedGeo.remove(pubkeyHex.lowercased())
-    }
-
-    func replaceTeleportedGeo(_ pubkeys: Set<String>) {
-        teleportedGeo = Set(pubkeys.map { $0.lowercased() })
-    }
-
-    func clearTeleportedGeo() {
-        teleportedGeo.removeAll()
-    }
-
-    func reset() {
-        currentGeohash = nil
-        geoNicknames.removeAll()
-        teleportedGeo.removeAll()
-    }
-}

bitchat/App/PeerIdentityStore.swift

@@ -1,125 +0,0 @@
-import BitFoundation
-import Combine
-import Foundation
-
-@MainActor
-final class PeerIdentityStore: ObservableObject {
-    @Published private(set) var encryptionStatuses: [PeerID: EncryptionStatus] = [:]
-    @Published private(set) var verifiedFingerprints: Set<String> = []
-
-    private(set) var peerFingerprintsByPeerID: [PeerID: String] = [:]
-    private(set) var selectedPrivateChatFingerprint: String?
-
-    private var stablePeerIDsByShortID: [PeerID: PeerID] = [:]
-    private var encryptionStatusCache: [PeerID: EncryptionStatus] = [:]
-
-    func stablePeerID(forShortID peerID: PeerID) -> PeerID? {
-        stablePeerIDsByShortID[peerID]
-    }
-
-    func shortPeerID(forStablePeerID stablePeerID: PeerID) -> PeerID? {
-        stablePeerIDsByShortID.first(where: { $0.value == stablePeerID })?.key
-    }
-
-    func setStablePeerID(_ stablePeerID: PeerID, forShortID peerID: PeerID) {
-        stablePeerIDsByShortID[peerID] = stablePeerID
-    }
-
-    func replaceStablePeerIDs(_ mappings: [PeerID: PeerID]) {
-        stablePeerIDsByShortID = mappings
-    }
-
-    func fingerprint(for peerID: PeerID) -> String? {
-        peerFingerprintsByPeerID[peerID]
-    }
-
-    func setFingerprint(_ fingerprint: String?, for peerID: PeerID) {
-        if let fingerprint {
-            peerFingerprintsByPeerID[peerID] = fingerprint
-        } else {
-            peerFingerprintsByPeerID.removeValue(forKey: peerID)
-        }
-    }
-
-    func replaceFingerprintMappings(_ mappings: [PeerID: String]) {
-        peerFingerprintsByPeerID = mappings
-    }
-
-    @discardableResult
-    func migrateFingerprintMapping(
-        from oldPeerID: PeerID,
-        to newPeerID: PeerID,
-        fallback: String? = nil
-    ) -> String? {
-        let fingerprint = peerFingerprintsByPeerID.removeValue(forKey: oldPeerID) ?? fallback
-        if let fingerprint {
-            peerFingerprintsByPeerID[newPeerID] = fingerprint
-            if selectedPrivateChatFingerprint == nil {
-                selectedPrivateChatFingerprint = fingerprint
-            }
-        }
-        return fingerprint
-    }
-
-    func setSelectedPrivateChatFingerprint(_ fingerprint: String?) {
-        selectedPrivateChatFingerprint = fingerprint
-    }
-
-    func cachedEncryptionStatus(for peerID: PeerID) -> EncryptionStatus? {
-        encryptionStatusCache[peerID]
-    }
-
-    func setCachedEncryptionStatus(_ status: EncryptionStatus, for peerID: PeerID) {
-        encryptionStatusCache[peerID] = status
-    }
-
-    func invalidateEncryptionCache(for peerID: PeerID? = nil) {
-        if let peerID {
-            encryptionStatusCache.removeValue(forKey: peerID)
-        } else {
-            encryptionStatusCache.removeAll()
-        }
-    }
-
-    func encryptionStatus(for peerID: PeerID) -> EncryptionStatus? {
-        encryptionStatuses[peerID]
-    }
-
-    func setEncryptionStatus(_ status: EncryptionStatus?, for peerID: PeerID) {
-        if let status {
-            encryptionStatuses[peerID] = status
-        } else {
-            encryptionStatuses.removeValue(forKey: peerID)
-        }
-        invalidateEncryptionCache(for: peerID)
-    }
-
-    func replaceEncryptionStatuses(_ statuses: [PeerID: EncryptionStatus]) {
-        encryptionStatuses = statuses
-    }
-
-    func setVerifiedFingerprints(_ fingerprints: Set<String>) {
-        verifiedFingerprints = fingerprints
-    }
-
-    func setVerified(_ fingerprint: String, verified: Bool) {
-        if verified {
-            verifiedFingerprints.insert(fingerprint)
-        } else {
-            verifiedFingerprints.remove(fingerprint)
-        }
-    }
-
-    func isVerified(_ fingerprint: String) -> Bool {
-        verifiedFingerprints.contains(fingerprint)
-    }
-
-    func clearAll() {
-        encryptionStatuses.removeAll()
-        verifiedFingerprints.removeAll()
-        peerFingerprintsByPeerID.removeAll()
-        selectedPrivateChatFingerprint = nil
-        stablePeerIDsByShortID.removeAll()
-        encryptionStatusCache.removeAll()
-    }
-}

bitchat/App/PeerListModel.swift

@@ -1,260 +0,0 @@
-import BitFoundation
-import Combine
-import SwiftUI
-
-struct MeshPeerRow: Identifiable, Equatable {
-    let peerID: PeerID
-    let displayName: String
-    let isMe: Bool
-    let hasUnread: Bool
-    let isBlocked: Bool
-    let isFavorite: Bool
-    let isConnected: Bool
-    let isReachable: Bool
-    let isMutualFavorite: Bool
-    let encryptionStatus: EncryptionStatus
-    let showsVerifiedBadgeWhenOffline: Bool
-
-    var id: String { peerID.id }
-}
-
-struct GeohashPersonRow: Identifiable, Equatable {
-    let id: String
-    let displayName: String
-    let isMe: Bool
-    let isTeleported: Bool
-    let isBlocked: Bool
-}
-
-@MainActor
-final class PeerListModel: ObservableObject {
-    @Published private(set) var allPeers: [BitchatPeer] = []
-    @Published private(set) var meshRows: [MeshPeerRow] = []
-    @Published private(set) var geohashPeople: [GeohashPersonRow] = []
-    @Published private(set) var reachableMeshPeerCount = 0
-    @Published private(set) var connectedMeshPeerCount = 0
-    @Published private(set) var visibleGeohashPeerCount = 0
-    @Published private(set) var renderID = ""
-
-    private let chatViewModel: ChatViewModel
-    private let conversationStore: ConversationStore
-    private let locationChannelsModel: LocationChannelsModel
-    private let peerIdentityStore: PeerIdentityStore
-    private let locationPresenceStore: LocationPresenceStore
-    private var cancellables = Set<AnyCancellable>()
-
-    init(
-        chatViewModel: ChatViewModel,
-        conversationStore: ConversationStore,
-        locationChannelsModel: LocationChannelsModel? = nil,
-        peerIdentityStore: PeerIdentityStore? = nil,
-        locationPresenceStore: LocationPresenceStore? = nil
-    ) {
-        self.chatViewModel = chatViewModel
-        self.conversationStore = conversationStore
-        self.locationChannelsModel = locationChannelsModel ?? LocationChannelsModel()
-        self.peerIdentityStore = peerIdentityStore ?? chatViewModel.peerIdentityStore
-        self.locationPresenceStore = locationPresenceStore ?? chatViewModel.locationPresenceStore
-        self.allPeers = chatViewModel.allPeers
-
-        bind()
-        refresh()
-    }
-
-    func colorForMeshPeer(id peerID: PeerID, isDark: Bool) -> Color {
-        chatViewModel.colorForMeshPeer(id: peerID, isDark: isDark)
-    }
-
-    func colorForGeohashPerson(id: String, isDark: Bool) -> Color {
-        chatViewModel.colorForNostrPubkey(id, isDark: isDark)
-    }
-
-    func participantCount(for geohash: String) -> Int {
-        chatViewModel.geohashParticipantCount(for: geohash)
-    }
-
-    func startConversation(with peerID: PeerID) {
-        chatViewModel.startPrivateChat(with: peerID)
-    }
-
-    func toggleFavorite(peerID: PeerID) {
-        chatViewModel.toggleFavorite(peerID: peerID)
-    }
-
-    func openGeohashDirectMessage(with pubkeyHex: String) {
-        chatViewModel.startGeohashDM(withPubkeyHex: pubkeyHex)
-    }
-
-    func blockGeohashUser(pubkeyHexLowercased: String, displayName: String) {
-        chatViewModel.blockGeohashUser(
-            pubkeyHexLowercased: pubkeyHexLowercased,
-            displayName: displayName
-        )
-    }
-
-    func unblockGeohashUser(pubkeyHexLowercased: String, displayName: String) {
-        chatViewModel.unblockGeohashUser(
-            pubkeyHexLowercased: pubkeyHexLowercased,
-            displayName: displayName
-        )
-    }
-
-    private func bind() {
-        chatViewModel.$allPeers
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] peers in
-                self?.allPeers = peers
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        chatViewModel.$nickname
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        locationPresenceStore.$teleportedGeo
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        conversationStore.$unreadConversations
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        peerIdentityStore.$encryptionStatuses
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        peerIdentityStore.$verifiedFingerprints
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        NotificationCenter.default.publisher(for: Notification.Name("peerStatusUpdated"))
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        chatViewModel.participantTracker.$visiblePeople
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        locationChannelsModel.$selectedChannel
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        locationChannelsModel.$teleported
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-
-        locationChannelsModel.$availableChannels
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refresh()
-            }
-            .store(in: &cancellables)
-    }
-
-    private func refresh() {
-        let myPeerID = chatViewModel.meshService.myPeerID
-        let meshRows = allPeers.map { peer in
-            let isMe = peer.peerID == myPeerID
-            let verifiedBadge: Bool
-            if !isMe && !peer.isConnected,
-               let fingerprint = chatViewModel.getFingerprint(for: peer.peerID) {
-                verifiedBadge = peerIdentityStore.isVerified(fingerprint)
-            } else {
-                verifiedBadge = false
-            }
-
-            return MeshPeerRow(
-                peerID: peer.peerID,
-                displayName: isMe ? chatViewModel.nickname : peer.nickname,
-                isMe: isMe,
-                hasUnread: chatViewModel.hasUnreadMessages(for: peer.peerID),
-                isBlocked: !isMe && chatViewModel.isPeerBlocked(peer.peerID),
-                isFavorite: peer.favoriteStatus?.isFavorite ?? false,
-                isConnected: peer.isConnected,
-                isReachable: peer.isReachable,
-                isMutualFavorite: peer.isMutualFavorite,
-                encryptionStatus: chatViewModel.getEncryptionStatus(for: peer.peerID),
-                showsVerifiedBadgeWhenOffline: verifiedBadge
-            )
-        }
-
-        let meshCounts = meshRows.reduce(into: (reachable: 0, connected: 0)) { counts, row in
-            guard !row.isMe else { return }
-            if row.isConnected {
-                counts.connected += 1
-                counts.reachable += 1
-            } else if row.isReachable {
-                counts.reachable += 1
-            }
-        }
-
-        let geohashPeople = buildGeohashPeople()
-
-        self.meshRows = meshRows
-        reachableMeshPeerCount = meshCounts.reachable
-        connectedMeshPeerCount = meshCounts.connected
-        self.geohashPeople = geohashPeople
-        visibleGeohashPeerCount = geohashPeople.count
-        renderID = (
-            meshRows.map {
-                "\($0.id)-\($0.isConnected)-\($0.isReachable)-\($0.hasUnread)-\($0.isFavorite)-\($0.isBlocked)"
-            } +
-            geohashPeople.map {
-                "geo:\($0.id)-\($0.isTeleported)-\($0.isBlocked)-\($0.displayName)"
-            }
-        ).joined(separator: "|")
-    }
-
-    private func buildGeohashPeople() -> [GeohashPersonRow] {
-        let myHex = currentGeohashIdentityHex()
-        let teleportedSet = Set(locationPresenceStore.teleportedGeo.map { $0.lowercased() })
-
-        return chatViewModel.visibleGeohashPeople().map { person in
-            let isMe = person.id == myHex
-            return GeohashPersonRow(
-                id: person.id,
-                displayName: person.displayName,
-                isMe: isMe,
-                isTeleported: teleportedSet.contains(person.id.lowercased()) || (isMe && locationChannelsModel.teleported),
-                isBlocked: !isMe && chatViewModel.isGeohashUserBlocked(pubkeyHexLowercased: person.id)
-            )
-        }
-    }
-
-    private func currentGeohashIdentityHex() -> String? {
-        guard case .location(let channel) = locationChannelsModel.selectedChannel,
-              let identity = try? chatViewModel.idBridge.deriveIdentity(forGeohash: channel.geohash) else {
-            return nil
-        }
-
-        return identity.publicKeyHex.lowercased()
-    }
-}

bitchat/App/PrivateConversationModels.swift

@@ -1,298 +0,0 @@
-import BitFoundation
-import Combine
-import Foundation
-
-@MainActor
-final class PrivateInboxModel: ObservableObject {
-    @Published private(set) var selectedPeerID: PeerID?
-    @Published private(set) var unreadPeerIDs: Set<PeerID> = []
-    @Published private(set) var messagesByPeerID: [PeerID: [BitchatMessage]] = [:]
-
-    private let conversationStore: ConversationStore
-    private var cancellables = Set<AnyCancellable>()
-
-    init(conversationStore: ConversationStore) {
-        self.conversationStore = conversationStore
-
-        bind()
-        refreshMessages()
-    }
-
-    func messages(for peerID: PeerID?) -> [BitchatMessage] {
-        guard let peerID else { return [] }
-        return messagesByPeerID[peerID] ?? []
-    }
-
-    private func bind() {
-        conversationStore.$selectedPrivatePeerID
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] peerID in
-                self?.selectedPeerID = peerID
-                self?.refreshMessages()
-            }
-            .store(in: &cancellables)
-
-        conversationStore.$unreadConversations
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.unreadPeerIDs = self?.conversationStore.unreadDirectPeerIDs() ?? []
-                self?.refreshMessages()
-            }
-            .store(in: &cancellables)
-
-        conversationStore.$messagesByConversation
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refreshMessages()
-            }
-            .store(in: &cancellables)
-
-        selectedPeerID = conversationStore.selectedPrivatePeerID
-        unreadPeerIDs = conversationStore.unreadDirectPeerIDs()
-    }
-
-    private func refreshMessages() {
-        var nextMessagesByPeerID = conversationStore.directMessagesByPeerID()
-        var peerIDs = Set(nextMessagesByPeerID.keys)
-        peerIDs.formUnion(conversationStore.unreadDirectPeerIDs())
-        if let selectedPeerID = conversationStore.selectedPrivatePeerID {
-            peerIDs.insert(selectedPeerID)
-        }
-
-        for peerID in peerIDs where nextMessagesByPeerID[peerID] == nil {
-            nextMessagesByPeerID[peerID] = []
-        }
-
-        messagesByPeerID = nextMessagesByPeerID
-    }
-}
-
-enum PrivateConversationAvailability: Equatable {
-    case bluetoothConnected
-    case meshReachable
-    case nostrAvailable
-    case offline
-}
-
-struct PrivateConversationHeaderState: Equatable {
-    let conversationPeerID: PeerID
-    let headerPeerID: PeerID
-    let displayName: String
-    let availability: PrivateConversationAvailability
-    let isFavorite: Bool
-    let encryptionStatus: EncryptionStatus?
-
-    var supportsFavoriteToggle: Bool {
-        !conversationPeerID.isGeoDM
-    }
-}
-
-@MainActor
-final class PrivateConversationModel: ObservableObject {
-    @Published private(set) var selectedPeerID: PeerID?
-    @Published private(set) var selectedHeaderState: PrivateConversationHeaderState?
-
-    private let chatViewModel: ChatViewModel
-    private let conversationStore: ConversationStore
-    private let locationChannelsModel: LocationChannelsModel
-    private let peerIdentityStore: PeerIdentityStore
-    private var cancellables = Set<AnyCancellable>()
-
-    init(
-        chatViewModel: ChatViewModel,
-        conversationStore: ConversationStore,
-        locationChannelsModel: LocationChannelsModel? = nil,
-        peerIdentityStore: PeerIdentityStore? = nil
-    ) {
-        self.chatViewModel = chatViewModel
-        self.conversationStore = conversationStore
-        self.locationChannelsModel = locationChannelsModel ?? LocationChannelsModel()
-        self.peerIdentityStore = peerIdentityStore ?? chatViewModel.peerIdentityStore
-        let initialPeerID = conversationStore.selectedPrivatePeerID
-        self.selectedPeerID = initialPeerID
-        self.selectedHeaderState = initialPeerID.flatMap { peerID in
-            makeHeaderState(for: peerID)
-        }
-
-        bind()
-    }
-
-    func startConversation(with peerID: PeerID) {
-        chatViewModel.startPrivateChat(with: peerID)
-        refreshSelectedConversation()
-    }
-
-    func openConversation(for peerID: PeerID) {
-        if peerID.isGeoChat {
-            guard let full = chatViewModel.fullNostrHex(forSenderPeerID: peerID) else { return }
-            chatViewModel.startGeohashDM(withPubkeyHex: full)
-        } else {
-            chatViewModel.startPrivateChat(with: peerID)
-        }
-
-        refreshSelectedConversation()
-    }
-
-    func endConversation() {
-        chatViewModel.endPrivateChat()
-        refreshSelectedConversation()
-    }
-
-    func toggleFavorite(peerID: PeerID) {
-        chatViewModel.toggleFavorite(peerID: peerID)
-        refreshSelectedConversation()
-    }
-
-    func toggleFavoriteForSelectedConversation() {
-        guard let headerPeerID = selectedHeaderState?.headerPeerID else { return }
-        toggleFavorite(peerID: headerPeerID)
-    }
-
-    func markMessagesAsRead(from peerID: PeerID) {
-        chatViewModel.markPrivateMessagesAsRead(from: peerID)
-    }
-
-    private func bind() {
-        conversationStore.$selectedPrivatePeerID
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refreshSelectedConversation()
-            }
-            .store(in: &cancellables)
-
-        chatViewModel.$allPeers
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refreshSelectedConversation()
-            }
-            .store(in: &cancellables)
-
-        peerIdentityStore.$encryptionStatuses
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refreshSelectedConversation()
-            }
-            .store(in: &cancellables)
-
-        NotificationCenter.default.publisher(for: .favoriteStatusChanged)
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refreshSelectedConversation()
-            }
-            .store(in: &cancellables)
-
-        NotificationCenter.default.publisher(for: Notification.Name("peerStatusUpdated"))
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refreshSelectedConversation()
-            }
-            .store(in: &cancellables)
-
-        locationChannelsModel.$selectedChannel
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refreshSelectedConversation()
-            }
-            .store(in: &cancellables)
-    }
-
-    private func refreshSelectedConversation() {
-        selectedPeerID = conversationStore.selectedPrivatePeerID
-        selectedHeaderState = selectedPeerID.flatMap { peerID in
-            makeHeaderState(for: peerID)
-        }
-    }
-
-    private func makeHeaderState(for conversationPeerID: PeerID) -> PrivateConversationHeaderState {
-        let headerPeerID = chatViewModel.getShortIDForNoiseKey(conversationPeerID)
-        let peer = chatViewModel.getPeer(byID: headerPeerID)
-        let displayName = resolveDisplayName(for: conversationPeerID, headerPeerID: headerPeerID, peer: peer)
-        let availability = resolveAvailability(for: headerPeerID, peer: peer)
-        let encryptionStatus: EncryptionStatus? = conversationPeerID.isGeoDM
-            ? nil
-            : chatViewModel.getEncryptionStatus(for: headerPeerID)
-
-        return PrivateConversationHeaderState(
-            conversationPeerID: conversationPeerID,
-            headerPeerID: headerPeerID,
-            displayName: displayName,
-            availability: availability,
-            isFavorite: chatViewModel.isFavorite(peerID: headerPeerID),
-            encryptionStatus: encryptionStatus
-        )
-    }
-
-    private func resolveDisplayName(
-        for conversationPeerID: PeerID,
-        headerPeerID: PeerID,
-        peer: BitchatPeer?
-    ) -> String {
-        if conversationPeerID.isGeoDM, case .location(let channel) = locationChannelsModel.selectedChannel {
-            return "#\(channel.geohash)/@\(chatViewModel.geohashDisplayName(for: conversationPeerID))"
-        }
-        if let displayName = peer?.displayName {
-            return displayName
-        }
-        if let nickname = chatViewModel.meshService.peerNickname(peerID: headerPeerID) {
-            return nickname
-        }
-        if let favorite = FavoritesPersistenceService.shared.getFavoriteStatus(
-            for: Data(hexString: headerPeerID.id) ?? Data()
-        ), !favorite.peerNickname.isEmpty {
-            return favorite.peerNickname
-        }
-        if headerPeerID.id.count == 16 {
-            let candidates = chatViewModel.identityManager.getCryptoIdentitiesByPeerIDPrefix(headerPeerID)
-            if let identity = candidates.first,
-               let social = chatViewModel.identityManager.getSocialIdentity(for: identity.fingerprint) {
-                if let pet = social.localPetname, !pet.isEmpty {
-                    return pet
-                }
-                if !social.claimedNickname.isEmpty {
-                    return social.claimedNickname
-                }
-            }
-        } else if let noiseKey = headerPeerID.noiseKey {
-            let fingerprint = noiseKey.sha256Fingerprint()
-            if let social = chatViewModel.identityManager.getSocialIdentity(for: fingerprint) {
-                if let pet = social.localPetname, !pet.isEmpty {
-                    return pet
-                }
-                if !social.claimedNickname.isEmpty {
-                    return social.claimedNickname
-                }
-            }
-        }
-
-        return String(localized: "common.unknown", comment: "Fallback label for unknown peer")
-    }
-
-    private func resolveAvailability(for headerPeerID: PeerID, peer: BitchatPeer?) -> PrivateConversationAvailability {
-        if let connectionState = peer?.connectionState {
-            switch connectionState {
-            case .bluetoothConnected:
-                return .bluetoothConnected
-            case .meshReachable:
-                return .meshReachable
-            case .nostrAvailable:
-                return .nostrAvailable
-            case .offline:
-                return .offline
-            }
-        }
-
-        if chatViewModel.meshService.isPeerReachable(headerPeerID) {
-            return .meshReachable
-        }
-        if let noiseKey = Data(hexString: headerPeerID.id),
-           let favoriteStatus = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
-           favoriteStatus.isMutual {
-            return .nostrAvailable
-        }
-        if chatViewModel.meshService.isPeerConnected(headerPeerID) || chatViewModel.connectedPeers.contains(headerPeerID) {
-            return .bluetoothConnected
-        }
-
-        return .offline
-    }
-}

bitchat/App/PublicChatModel.swift

@@ -1,41 +0,0 @@
-import BitFoundation
-import Combine
-import SwiftUI
-
-@MainActor
-final class PublicChatModel: ObservableObject {
-    @Published private(set) var activeChannel: ChannelID
-    @Published private(set) var messages: [BitchatMessage] = []
-
-    private let conversationStore: ConversationStore
-    private var cancellables = Set<AnyCancellable>()
-
-    init(conversationStore: ConversationStore) {
-        self.activeChannel = conversationStore.activeChannel
-        self.conversationStore = conversationStore
-
-        bind()
-        refreshMessages()
-    }
-
-    private func bind() {
-        conversationStore.$activeChannel
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] channel in
-                self?.activeChannel = channel
-                self?.refreshMessages()
-            }
-            .store(in: &cancellables)
-
-        conversationStore.$messagesByConversation
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.refreshMessages()
-            }
-            .store(in: &cancellables)
-    }
-
-    private func refreshMessages() {
-        messages = conversationStore.messages(for: ConversationID(channelID: activeChannel))
-    }
-}

bitchat/App/VerificationModel.swift

@@ -1,152 +0,0 @@
-import BitFoundation
-import Combine
-import Foundation
-
-struct FingerprintPresentationState: Equatable {
-    let statusPeerID: PeerID
-    let peerNickname: String
-    let encryptionStatus: EncryptionStatus
-    let theirFingerprint: String?
-    let myFingerprint: String
-    let isVerified: Bool
-
-    var canToggleVerification: Bool {
-        encryptionStatus == .noiseSecured || encryptionStatus == .noiseVerified
-    }
-}
-
-enum VerificationScanOutcome: Equatable {
-    case requested(String)
-    case notFound
-    case invalid
-}
-
-@MainActor
-final class VerificationModel: ObservableObject {
-    @Published private(set) var currentNickname: String
-    @Published private(set) var selectedPeerID: PeerID?
-
-    private let chatViewModel: ChatViewModel
-    private let peerIdentityStore: PeerIdentityStore
-    private var cancellables = Set<AnyCancellable>()
-
-    init(
-        chatViewModel: ChatViewModel,
-        privateConversationModel: PrivateConversationModel,
-        peerIdentityStore: PeerIdentityStore? = nil
-    ) {
-        self.chatViewModel = chatViewModel
-        self.peerIdentityStore = peerIdentityStore ?? chatViewModel.peerIdentityStore
-        self.currentNickname = chatViewModel.nickname
-        self.selectedPeerID = privateConversationModel.selectedPeerID
-
-        bind(privateConversationModel: privateConversationModel)
-    }
-
-    func myQRString() -> String {
-        let npub = try? chatViewModel.idBridge.getCurrentNostrIdentity()?.npub
-        return VerificationService.shared.buildMyQRString(nickname: currentNickname, npub: npub) ?? ""
-    }
-
-    func beginQRVerification(with qr: VerificationService.VerificationQR) -> Bool {
-        chatViewModel.beginQRVerification(with: qr)
-    }
-
-    func verifyScannedPayload(_ payload: String) -> VerificationScanOutcome {
-        guard let qr = VerificationService.shared.verifyScannedQR(payload) else {
-            return .invalid
-        }
-
-        guard chatViewModel.beginQRVerification(with: qr) else {
-            return .notFound
-        }
-
-        return .requested(qr.nickname)
-    }
-
-    func verifyFingerprint(for peerID: PeerID) {
-        chatViewModel.verifyFingerprint(for: peerID)
-    }
-
-    func unverifyFingerprint(for peerID: PeerID) {
-        chatViewModel.unverifyFingerprint(for: peerID)
-    }
-
-    func isVerified(peerID: PeerID) -> Bool {
-        guard let fingerprint = chatViewModel.getFingerprint(for: peerID) else { return false }
-        return peerIdentityStore.isVerified(fingerprint)
-    }
-
-    func fingerprintPresentation(for peerID: PeerID) -> FingerprintPresentationState {
-        let statusPeerID = chatViewModel.getShortIDForNoiseKey(peerID)
-        let encryptionStatus = chatViewModel.getEncryptionStatus(for: statusPeerID)
-        let theirFingerprint = chatViewModel.getFingerprint(for: statusPeerID)
-        let peerNickname = resolveDisplayName(for: peerID, statusPeerID: statusPeerID)
-
-        return FingerprintPresentationState(
-            statusPeerID: statusPeerID,
-            peerNickname: peerNickname,
-            encryptionStatus: encryptionStatus,
-            theirFingerprint: theirFingerprint,
-            myFingerprint: chatViewModel.getMyFingerprint(),
-            isVerified: theirFingerprint.map { peerIdentityStore.isVerified($0) } ?? false
-        )
-    }
-
-    private func bind(privateConversationModel: PrivateConversationModel) {
-        chatViewModel.$nickname
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$currentNickname)
-
-        privateConversationModel.$selectedPeerID
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$selectedPeerID)
-
-        peerIdentityStore.$encryptionStatuses
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.objectWillChange.send()
-            }
-            .store(in: &cancellables)
-
-        peerIdentityStore.$verifiedFingerprints
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.objectWillChange.send()
-            }
-            .store(in: &cancellables)
-
-        chatViewModel.$allPeers
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.objectWillChange.send()
-            }
-            .store(in: &cancellables)
-    }
-
-    private func resolveDisplayName(for peerID: PeerID, statusPeerID: PeerID) -> String {
-        if let peer = chatViewModel.getPeer(byID: statusPeerID) {
-            return peer.displayName
-        }
-        if let name = chatViewModel.meshService.peerNickname(peerID: statusPeerID) {
-            return name
-        }
-        if let data = peerID.noiseKey {
-            if let favorite = FavoritesPersistenceService.shared.getFavoriteStatus(for: data),
-               !favorite.peerNickname.isEmpty {
-                return favorite.peerNickname
-            }
-            let fingerprint = data.sha256Fingerprint()
-            if let social = chatViewModel.identityManager.getSocialIdentity(for: fingerprint) {
-                if let pet = social.localPetname, !pet.isEmpty {
-                    return pet
-                }
-                if !social.claimedNickname.isEmpty {
-                    return social.claimedNickname
-                }
-            }
-        }
-
-        return String(localized: "common.unknown", comment: "Label for an unknown peer")
-    }
-}

bitchat/BitchatApp.swift

@@ -6,6 +6,7 @@
 // For more information, see <https://unlicense.org>
 //
 
+import Tor
 import SwiftUI
 import UserNotifications
 
@@ -14,47 +15,118 @@ struct BitchatApp: App {
     static let bundleID = Bundle.main.bundleIdentifier ?? "chat.bitchat"
     static let groupID = "group.\(bundleID)"
     
-    @StateObject private var runtime: AppRuntime
+    @StateObject private var chatViewModel: ChatViewModel
     #if os(iOS)
     @Environment(\.scenePhase) var scenePhase
     @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
+    // Skip the very first .active-triggered Tor restart on cold launch
+    @State private var didHandleInitialActive: Bool = false
+    @State private var didEnterBackground: Bool = false
     #elseif os(macOS)
     @NSApplicationDelegateAdaptor(MacAppDelegate.self) var appDelegate
     #endif
     
+    private let idBridge = NostrIdentityBridge()
+    
     init() {
-        _runtime = StateObject(wrappedValue: AppRuntime())
+        let keychain = KeychainManager()
+        let idBridge = self.idBridge
+        _chatViewModel = StateObject(
+            wrappedValue: ChatViewModel(
+                keychain: keychain,
+                idBridge: idBridge,
+                identityManager: SecureIdentityStateManager(keychain)
+            )
+        )
+        
         UNUserNotificationCenter.current().delegate = NotificationDelegate.shared
+        // Warm up georelay directory and refresh if stale (once/day)
+        GeoRelayDirectory.shared.prefetchIfNeeded()
     }
     
     var body: some Scene {
         WindowGroup {
             ContentView()
-                .environmentObject(runtime.publicChatModel)
+                .environmentObject(chatViewModel)
-                .environmentObject(runtime.privateInboxModel)
-                .environmentObject(runtime.privateConversationModel)
-                .environmentObject(runtime.verificationModel)
-                .environmentObject(runtime.conversationUIModel)
-                .environmentObject(runtime.locationChannelsModel)
-                .environmentObject(runtime.peerListModel)
-                .environmentObject(runtime.appChromeModel)
                 .onAppear {
-                    appDelegate.runtime = runtime
+                    NotificationDelegate.shared.chatViewModel = chatViewModel
-                    runtime.start()
+                    // Inject live Noise service into VerificationService to avoid creating new BLE instances
+                    VerificationService.shared.configure(with: chatViewModel.meshService.getNoiseService())
+                    // Prewarm Nostr identity and QR to make first VERIFY sheet fast
+                    let nickname = chatViewModel.nickname
+                    DispatchQueue.global(qos: .utility).async {
+                        let npub = try? idBridge.getCurrentNostrIdentity()?.npub
+                        _ = VerificationService.shared.buildMyQRString(nickname: nickname, npub: npub)
+                    }
+
+                    appDelegate.chatViewModel = chatViewModel
+
+                    // Initialize network activation policy; will start Tor/Nostr only when allowed
+                    NetworkActivationService.shared.start()
+                    
+                    // Start presence service (will wait for Tor readiness)
+                    GeohashPresenceService.shared.start()
+
+                    // Check for shared content
+                    checkForSharedContent()
                 }
                 .onOpenURL { url in
-                    runtime.handleOpenURL(url)
+                    handleURL(url)
                 }
                 #if os(iOS)
                 .onChange(of: scenePhase) { newPhase in
-                    runtime.handleScenePhaseChange(newPhase)
+                    switch newPhase {
+                    case .background:
+                        // Keep BLE mesh running in background; BLEService adapts scanning automatically
+                        // Always send Tor to dormant on background for a clean restart later.
+                        TorManager.shared.setAppForeground(false)
+                        TorManager.shared.goDormantOnBackground()
+                        // Stop geohash sampling while backgrounded
+                        Task { @MainActor in
+                            chatViewModel.endGeohashSampling()
+                        }
+                        // Proactively disconnect Nostr to avoid spurious socket errors while Tor is down
+                        NostrRelayManager.shared.disconnect()
+                        didEnterBackground = true
+                    case .active:
+                        // Restart services when becoming active
+                        chatViewModel.meshService.startServices()
+                        TorManager.shared.setAppForeground(true)
+                        // On initial cold launch, Tor was just started in onAppear.
+                        // Skip the deterministic restart the first time we become active.
+                        if didHandleInitialActive && didEnterBackground {
+                            if TorManager.shared.isAutoStartAllowed() && !TorManager.shared.isReady {
+                                TorManager.shared.ensureRunningOnForeground()
+                            }
+                        } else {
+                            didHandleInitialActive = true
+                        }
+                        didEnterBackground = false
+                        if TorManager.shared.isAutoStartAllowed() {
+                            Task.detached {
+                                let _ = await TorManager.shared.awaitReady(timeout: 60)
+                                await MainActor.run {
+                                    // Rebuild proxied sessions to bind to the live Tor after readiness
+                                    TorURLSession.shared.rebuild()
+                                    // Reconnect Nostr via fresh sessions; will gate until Tor 100%
+                                    NostrRelayManager.shared.resetAllConnections()
+                                }
+                            }
+                        }
+                        checkForSharedContent()
+                    case .inactive:
+                        break
+                    @unknown default:
+                        break
+                    }
                 }
                 .onReceive(NotificationCenter.default.publisher(for: UIApplication.didBecomeActiveNotification)) { _ in
-                    runtime.handleDidBecomeActiveNotification()
+                    // Check for shared content when app becomes active
+                    checkForSharedContent()
                 }
                 #elseif os(macOS)
                 .onReceive(NotificationCenter.default.publisher(for: NSApplication.didBecomeActiveNotification)) { _ in
-                    runtime.handleMacDidBecomeActiveNotification()
+                    // App became active
                 }
                 #endif
         }
@@ -63,18 +135,66 @@ struct BitchatApp: App {
         .windowResizability(.contentSize)
         #endif
     }
+    
+    private func handleURL(_ url: URL) {
+        if url.scheme == "bitchat" && url.host == "share" {
+            // Handle shared content
+            checkForSharedContent()
+        }
+    }
+    
+    private func checkForSharedContent() {
+        // Check app group for shared content from extension
+        guard let userDefaults = UserDefaults(suiteName: BitchatApp.groupID) else {
+            return
+        }
+        
+        guard let sharedContent = userDefaults.string(forKey: "sharedContent"),
+              let sharedDate = userDefaults.object(forKey: "sharedContentDate") as? Date else {
+            return
+        }
+        
+        // Only process if shared within configured window
+        if Date().timeIntervalSince(sharedDate) < TransportConfig.uiShareAcceptWindowSeconds {
+            let contentType = userDefaults.string(forKey: "sharedContentType") ?? "text"
+            
+            // Clear the shared content
+            userDefaults.removeObject(forKey: "sharedContent")
+            userDefaults.removeObject(forKey: "sharedContentType")
+            userDefaults.removeObject(forKey: "sharedContentDate")
+            // No need to force synchronize here
+            
+            // Send the shared content immediately on the main queue
+            DispatchQueue.main.async {
+                if contentType == "url" {
+                    // Try to parse as JSON first
+                    if let data = sharedContent.data(using: .utf8),
+                       let urlData = try? JSONSerialization.jsonObject(with: data) as? [String: String],
+                       let url = urlData["url"] {
+                        // Send plain URL
+                        self.chatViewModel.sendMessage(url)
+                    } else {
+                        // Fallback to simple URL
+                        self.chatViewModel.sendMessage(sharedContent)
+                    }
+                } else {
+                    self.chatViewModel.sendMessage(sharedContent)
+                }
+            }
+        }
+    }
 }
 
 #if os(iOS)
 final class AppDelegate: NSObject, UIApplicationDelegate {
-    weak var runtime: AppRuntime?
+    weak var chatViewModel: ChatViewModel?
     
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
-        true
+        return true
     }
     
     func applicationWillTerminate(_ application: UIApplication) {
-        runtime?.applicationWillTerminate()
+        chatViewModel?.applicationWillTerminate()
     }
 }
 #endif
@@ -83,29 +203,44 @@ final class AppDelegate: NSObject, UIApplicationDelegate {
 import AppKit
 
 final class MacAppDelegate: NSObject, NSApplicationDelegate {
-    weak var runtime: AppRuntime?
+    weak var chatViewModel: ChatViewModel?
     
     func applicationWillTerminate(_ notification: Notification) {
-        runtime?.applicationWillTerminate()
+        chatViewModel?.applicationWillTerminate()
     }
     
     func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
-        true
+        return true
     }
 }
 #endif
 
 final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
     static let shared = NotificationDelegate()
-    weak var runtime: AppRuntime?
+    weak var chatViewModel: ChatViewModel?
     
     func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
         let identifier = response.notification.request.identifier
         let userInfo = response.notification.request.content.userInfo
         
-        Task { @MainActor in
+        // Check if this is a private message notification
-            self.runtime?.handleNotificationResponse(identifier: identifier, userInfo: userInfo)
+        if identifier.hasPrefix("private-") {
+            // Get peer ID from userInfo
+            if let peerID = userInfo["peerID"] as? String {
+                DispatchQueue.main.async {
+                    self.chatViewModel?.startPrivateChat(with: PeerID(str: peerID))
                 }
+            }
+        }
+        // Handle deeplink (e.g., geohash activity)
+        if let deep = userInfo["deeplink"] as? String, let url = URL(string: deep) {
+            #if os(iOS)
+            DispatchQueue.main.async { UIApplication.shared.open(url) }
+            #else
+            DispatchQueue.main.async { NSWorkspace.shared.open(url) }
+            #endif
+        }
+        
         completionHandler()
     }
     
@@ -113,12 +248,34 @@ final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
         let identifier = notification.request.identifier
         let userInfo = notification.request.content.userInfo
         
-        Task {
+        // Check if this is a private message notification
-            let options = await self.runtime?.presentationOptions(
+        if identifier.hasPrefix("private-") {
-                forNotificationIdentifier: identifier,
+            // Get peer ID from userInfo
-                userInfo: userInfo
+            if let peerID = userInfo["peerID"] as? String {
-            ) ?? [.banner, .sound]
+                // Don't show notification if the private chat is already open
-            completionHandler(options)
+                // Access main-actor-isolated property via Task
+                Task { @MainActor in
+                    if self.chatViewModel?.selectedPrivateChatPeer == PeerID(str: peerID) {
+                        completionHandler([])
+                    } else {
+                        completionHandler([.banner, .sound])
                     }
                 }
+                return
+            }
+        }
+        // Suppress geohash activity notification if we're already in that geohash channel
+        if identifier.hasPrefix("geo-activity-"),
+           let deep = userInfo["deeplink"] as? String,
+           let gh = deep.components(separatedBy: "/").last {
+            if case .location(let ch) = LocationChannelManager.shared.selectedChannel, ch.geohash == gh {
+                completionHandler([])
+                return
+            }
+        }
+        
+        // Show notification in all other cases
+        completionHandler([.banner, .sound])
+    }
 }
+

bitchat/Features/media/ImageUtils.swift

@@ -15,39 +15,30 @@ enum ImageUtilsError: Error {
 enum ImageUtils {
     private static let compressionQuality: CGFloat = 0.82
     private static let targetImageBytes: Int = 45_000
-    private static let maxSourceImageBytes: Int = 10 * 1024 * 1024
 
-    static func processImage(at url: URL, maxDimension: CGFloat = 448, outputDirectory: URL? = nil) throws -> URL {
+    static func processImage(at url: URL, maxDimension: CGFloat = 448) throws -> URL {
-        try validateImageSource(at: url)
+        // Security H1: Check file size BEFORE reading into memory
+        let attrs = try FileManager.default.attributesOfItem(atPath: url.path)
+        guard let fileSize = attrs[.size] as? Int else {
+            throw ImageUtilsError.invalidImage
+        }
+        // Allow up to 10MB source images (will be scaled down)
+        guard fileSize <= 10 * 1024 * 1024 else {
+            throw ImageUtilsError.invalidImage
+        }
 
         let data = try Data(contentsOf: url)
         #if os(iOS)
         guard let image = UIImage(data: data) else { throw ImageUtilsError.invalidImage }
-        return try processImage(image, maxDimension: maxDimension, outputDirectory: outputDirectory)
+        return try processImage(image, maxDimension: maxDimension)
         #else
         guard let image = NSImage(data: data) else { throw ImageUtilsError.invalidImage }
-        return try processImage(image, maxDimension: maxDimension, outputDirectory: outputDirectory)
+        return try processImage(image, maxDimension: maxDimension)
         #endif
     }
 
-    static func validateImageSource(at url: URL) throws {
-        // Security H1: Check file size BEFORE reading into memory.
-        let attrs = try FileManager.default.attributesOfItem(atPath: url.path)
-        guard let fileSize = attrs[.size] as? Int,
-              fileSize > 0,
-              fileSize <= maxSourceImageBytes else {
-            throw ImageUtilsError.invalidImage
-        }
-
-        let options = [kCGImageSourceShouldCache: false] as CFDictionary
-        guard let source = CGImageSourceCreateWithURL(url as CFURL, options),
-              CGImageSourceGetType(source) != nil else {
-            throw ImageUtilsError.invalidImage
-        }
-    }
-
     #if os(iOS)
-    static func processImage(_ image: UIImage, maxDimension: CGFloat = 448, outputDirectory: URL? = nil) throws -> URL {
+    static func processImage(_ image: UIImage, maxDimension: CGFloat = 448) throws -> URL {
         return try autoreleasepool {
             // Scale the image first
             let scaled = scaledImage(image, maxDimension: maxDimension)
@@ -73,7 +64,7 @@ enum ImageUtils {
                 }
             }
 
-            let outputURL = try makeOutputURL(outputDirectory: outputDirectory)
+            let outputURL = try makeOutputURL()
             try jpegData.write(to: outputURL, options: .atomic)
             return outputURL
         }
@@ -115,7 +106,7 @@ enum ImageUtils {
         return data as Data
     }
     #else
-    static func processImage(_ image: NSImage, maxDimension: CGFloat = 448, outputDirectory: URL? = nil) throws -> URL {
+    static func processImage(_ image: NSImage, maxDimension: CGFloat = 448) throws -> URL {
         return try autoreleasepool {
             let scaled = scaledImage(image, maxDimension: maxDimension)
             guard let inputCG = scaled.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
@@ -151,7 +142,7 @@ enum ImageUtils {
                     }
                 }
             }
-            let outputURL = try makeOutputURL(outputDirectory: outputDirectory)
+            let outputURL = try makeOutputURL()
             try jpegData.write(to: outputURL, options: .atomic)
             return outputURL
         }
@@ -195,17 +186,12 @@ enum ImageUtils {
     }
     #endif
 
-    private static func makeOutputURL(outputDirectory: URL? = nil) throws -> URL {
+    private static func makeOutputURL() throws -> URL {
         let formatter = DateFormatter()
         formatter.dateFormat = "yyyyMMdd_HHmmss"
-        let fileName = "img_\(formatter.string(from: Date()))_\(UUID().uuidString).jpg"
+        let fileName = "img_\(formatter.string(from: Date())).jpg"
 
-        let directory: URL
+        let directory = try applicationFilesDirectory().appendingPathComponent("images/outgoing", isDirectory: true)
-        if let outputDirectory {
-            directory = outputDirectory
-        } else {
-            directory = try applicationFilesDirectory().appendingPathComponent("images/outgoing", isDirectory: true)
-        }
         try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true, attributes: nil)
         return directory.appendingPathComponent(fileName)
     }

bitchat/Features/voice/VoiceNotePlaybackController.swift

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

bitchat/Features/voice/VoiceRecorder.swift

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

bitchat/Identity/IdentityModels.swift

@@ -81,7 +81,6 @@
 ///
 
 import Foundation
-import BitFoundation
 
 // MARK: - Three-Layer Identity Model
 

bitchat/Identity/SecureIdentityStateManager.swift

@@ -91,7 +91,6 @@
 ///
 
 import BitLogger
-import BitFoundation
 import Foundation
 import CryptoKit
 
@@ -202,12 +201,8 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
             let decryptedData = try AES.GCM.open(sealedBox, using: encryptionKey)
             cache = try JSONDecoder().decode(IdentityCache.self, from: decryptedData)
         } catch {
-            cache = IdentityCache()
+            // Log error but continue with empty cache
-            let deleted = keychain.deleteIdentityKey(forKey: cacheKey)
+            SecureLogger.error(error, context: "Failed to load identity cache", category: .security)
-            SecureLogger.warning(
-                "Discarded unreadable identity cache; starting fresh (deleted=\(deleted), error=\(error.localizedDescription))",
-                category: .security
-            )
         }
     }
     
@@ -336,15 +331,16 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     
     func updateSocialIdentity(_ identity: SocialIdentity) {
         queue.async(flags: .barrier) {
-            let previousClaimedNickname = self.cache.socialIdentities[identity.fingerprint]?.claimedNickname
             self.cache.socialIdentities[identity.fingerprint] = identity
             
             // Update nickname index
-            if let previousClaimedNickname,
+            if let existingIdentity = self.cache.socialIdentities[identity.fingerprint] {
-               previousClaimedNickname != identity.claimedNickname {
+                // Remove old nickname from index if changed
-                self.cache.nicknameIndex[previousClaimedNickname]?.remove(identity.fingerprint)
+                if existingIdentity.claimedNickname != identity.claimedNickname {
-                if self.cache.nicknameIndex[previousClaimedNickname]?.isEmpty == true {
+                    self.cache.nicknameIndex[existingIdentity.claimedNickname]?.remove(identity.fingerprint)
-                    self.cache.nicknameIndex.removeValue(forKey: previousClaimedNickname)
+                    if self.cache.nicknameIndex[existingIdentity.claimedNickname]?.isEmpty == true {
+                        self.cache.nicknameIndex.removeValue(forKey: existingIdentity.claimedNickname)
+                    }
                 }
             }
             
@@ -536,16 +532,4 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
             return cache.verifiedFingerprints
         }
     }
-
-    var debugNicknameIndex: [String: Set<String>] {
-        queue.sync { cache.nicknameIndex }
-    }
-
-    func debugEphemeralSession(for peerID: PeerID) -> EphemeralIdentity? {
-        queue.sync { ephemeralSessions[peerID] }
-    }
-
-    func debugLastInteraction(for fingerprint: String) -> Date? {
-        queue.sync { cache.lastInteractions[fingerprint] }
-    }
 }

bitchat/Info.plist

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

bitchat/Models/BitchatMessage+Media.swift

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

bitchat/Models/BitchatMessage.swift

@@ -6,39 +6,33 @@
 // For more information, see <https://unlicense.org>
 //
 
-import class Foundation.DateFormatter
+import Foundation
-
-import struct Foundation.AttributedString
-import struct Foundation.Data
-import struct Foundation.Date
-import struct Foundation.TimeInterval
-import struct Foundation.UUID
 
 /// Represents a user-visible message in the BitChat system.
 /// Handles both broadcast messages and private encrypted messages,
 /// with support for mentions, replies, and delivery tracking.
 /// - Note: This is the primary data model for chat messages
-public final class BitchatMessage: Codable {
+final class BitchatMessage: Codable {
-    public let id: String
+    let id: String
-    public let sender: String
+    let sender: String
-    public let content: String
+    let content: String
-    public let timestamp: Date
+    let timestamp: Date
-    public let isRelay: Bool
+    let isRelay: Bool
-    public let originalSender: String?
+    let originalSender: String?
-    public let isPrivate: Bool
+    let isPrivate: Bool
-    public let recipientNickname: String?
+    let recipientNickname: String?
-    public let senderPeerID: PeerID?
+    let senderPeerID: PeerID?
-    public let mentions: [String]?  // Array of mentioned nicknames
+    let mentions: [String]?  // Array of mentioned nicknames
-    public var deliveryStatus: DeliveryStatus? // Delivery tracking
+    var deliveryStatus: DeliveryStatus? // Delivery tracking
     
     // Cached formatted text (not included in Codable)
     private var _cachedFormattedText: [String: AttributedString] = [:]
     
-    public func getCachedFormattedText(isDark: Bool, isSelf: Bool) -> AttributedString? {
+    func getCachedFormattedText(isDark: Bool, isSelf: Bool) -> AttributedString? {
         return _cachedFormattedText["\(isDark)-\(isSelf)"]
     }
     
-    public func setCachedFormattedText(_ text: AttributedString, isDark: Bool, isSelf: Bool) {
+    func setCachedFormattedText(_ text: AttributedString, isDark: Bool, isSelf: Bool) {
         _cachedFormattedText["\(isDark)-\(isSelf)"] = text
     }
     
@@ -48,7 +42,7 @@ public final class BitchatMessage: Codable {
         case isPrivate, recipientNickname, senderPeerID, mentions, deliveryStatus
     }
     
-    public init(
+    init(
         id: String? = nil,
         sender: String,
         content: String,
@@ -78,7 +72,7 @@ public final class BitchatMessage: Codable {
 // MARK: - Equatable Conformance
 
 extension BitchatMessage: Equatable {
-    public static func == (lhs: BitchatMessage, rhs: BitchatMessage) -> Bool {
+    static func == (lhs: BitchatMessage, rhs: BitchatMessage) -> Bool {
         return lhs.id == rhs.id &&
                lhs.sender == rhs.sender &&
                lhs.content == rhs.content &&
@@ -336,15 +330,15 @@ extension BitchatMessage {
         return formatter
     }()
     
-    public var formattedTimestamp: String {
+    var formattedTimestamp: String {
         Self.timestampFormatter.string(from: timestamp)
     }
 }
 
 extension Array where Element == BitchatMessage {
     /// Filters out empty ones and deduplicate by ID while preserving order (from oldest to newest)
-    public func cleanedAndDeduped() -> [Element] {
+    func cleanedAndDeduped() -> [Element] {
-        let arr = filter { $0.content.trimmed.isEmpty == false }
+        let arr = filter { $0.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false }
         guard arr.count > 1 else {
             return arr
         }

bitchat/Models/BitchatPacket.swift

@@ -6,26 +6,25 @@
 // For more information, see <https://unlicense.org>
 //
 
-import struct Foundation.Data
+import Foundation
-import struct Foundation.Date
 
 /// The core packet structure for all BitChat protocol messages.
 /// Encapsulates all data needed for routing through the mesh network,
 /// including TTL for hop limiting and optional encryption.
 /// - Note: Packets larger than BLE MTU (512 bytes) are automatically fragmented
-public struct BitchatPacket: Codable {
+struct BitchatPacket: Codable {
     let version: UInt8
-    public let type: UInt8
+    let type: UInt8
-    public let senderID: Data
+    let senderID: Data
-    public let recipientID: Data?
+    let recipientID: Data?
-    public let timestamp: UInt64
+    let timestamp: UInt64
-    public let payload: Data
+    let payload: Data
-    public var signature: Data?
+    var signature: Data?
-    public var ttl: UInt8
+    var ttl: UInt8
-    public var route: [Data]?
+    var route: [Data]?
-    public var isRSR: Bool
+    var isRSR: Bool
     
-    public init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8, version: UInt8 = 1, route: [Data]? = nil, isRSR: Bool = false) {
+    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8, version: UInt8 = 1, route: [Data]? = nil, isRSR: Bool = false) {
         self.version = version
         self.type = type
         self.senderID = senderID
@@ -66,18 +65,18 @@ public struct BitchatPacket: Codable {
         BinaryProtocol.encode(self)
     }
     
-    public func toBinaryData(padding: Bool = true) -> Data? {
+    func toBinaryData(padding: Bool = true) -> Data? {
         BinaryProtocol.encode(self, padding: padding)
     }
 
     // Backward-compatible helper (defaults to padded encoding)
-    public func toBinaryData() -> Data? {
+    func toBinaryData() -> Data? {
         toBinaryData(padding: true)
     }
     
     /// Create binary representation for signing (without signature and TTL fields)
     /// TTL is excluded because it changes during packet relay operations
-    public func toBinaryDataForSigning() -> Data? {
+    func toBinaryDataForSigning() -> Data? {
         // Create a copy without signature and with fixed TTL for signing
         // TTL must be excluded because it changes during relay
         let unsignedPacket = BitchatPacket(
@@ -95,7 +94,7 @@ public struct BitchatPacket: Codable {
         return BinaryProtocol.encode(unsignedPacket)
     }
     
-    public static func from(_ data: Data) -> BitchatPacket? {
+    static func from(_ data: Data) -> BitchatPacket? {
         BinaryProtocol.decode(data)
     }
 }

bitchat/Models/BitchatPeer.swift

@@ -1,6 +1,5 @@
 import Foundation
 import CoreBluetooth
-import BitFoundation
 
 /// Represents a peer in the BitChat network with all associated metadata
 struct BitchatPeer: Equatable {

bitchat/Models/MessagePadding.swift

@@ -6,7 +6,7 @@
 // For more information, see <https://unlicense.org>
 //
 
-import struct Foundation.Data
+import Foundation
 
 /// Provides privacy-preserving message padding to obscure actual content length.
 /// Uses PKCS#7-style padding with random bytes to prevent traffic analysis.

bitchat/Models/PeerID.swift

@@ -1,27 +1,15 @@
 //
 // PeerID.swift
-// BitFoundation
+// bitchat
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
 //
 
-import struct Foundation.Data
+import Foundation
-import struct Foundation.CharacterSet
 
-public struct PeerID: Equatable, Hashable, Sendable {
+struct PeerID: Equatable, Hashable {
-    enum Constants {
+    enum Prefix: String, CaseIterable {
-        /// 16
-        static let nostrConvKeyPrefixLength = 16
-        /// 8
-        static let nostrShortKeyDisplayLength = 8
-        /// 64
-        fileprivate static let maxIDLength = 64
-        /// 16
-        fileprivate static let hexIDLength = 16 // 8 bytes = 16 hex chars
-    }
-
-    public enum Prefix: String, CaseIterable, Sendable {
         /// When no prefix is provided
         case empty = ""
         /// `"mesh:"`
@@ -36,13 +24,13 @@ public struct PeerID: Equatable, Hashable, Sendable {
         case geoChat = "nostr:"
     }
     
-    public let prefix: Prefix
+    let prefix: Prefix
     
     /// Returns the actual value without any prefix
-    public let bare: String
+    let bare: String
     
     /// Returns the full `id` value by combining `(prefix + bare)`
-    public var id: String { prefix.rawValue + bare }
+    var id: String { prefix.rawValue + bare }
     
     // Private so the callers have to go through a convenience init
     private init(prefix: Prefix, bare: any StringProtocol) {
@@ -53,15 +41,15 @@ public struct PeerID: Equatable, Hashable, Sendable {
 
 // MARK: - Convenience Inits
 
-public extension PeerID {
+extension PeerID {
     /// Convenience init to create GeoDM PeerID by appending `"nostr_"` to the first 16 characters of `pubKey`
     init(nostr_ pubKey: String) {
-        self.init(prefix: .geoDM, bare: pubKey.prefix(Constants.nostrConvKeyPrefixLength))
+        self.init(prefix: .geoDM, bare: pubKey.prefix(TransportConfig.nostrConvKeyPrefixLength))
     }
     
     /// Convenience init to create GeoChat PeerID by appending `"nostr:"` to the first 8 characters of `pubKey`
     init(nostr pubKey: String) {
-        self.init(prefix: .geoChat, bare: pubKey.prefix(Constants.nostrShortKeyDisplayLength))
+        self.init(prefix: .geoChat, bare: pubKey.prefix(TransportConfig.nostrShortKeyDisplayLength))
     }
     
     /// Convenience init to create PeerID from String/Substring by splitting it into prefix and bare parts
@@ -98,7 +86,7 @@ public extension PeerID {
 
 // MARK: - Noise Public Key Helpers
 
-public extension PeerID {
+extension PeerID {
     /// Derive the stable 16-hex peer ID from a Noise static public key
     init(publicKey: Data) {
         self.init(str: publicKey.sha256Fingerprint().prefix(16))
@@ -116,11 +104,11 @@ public extension PeerID {
 // MARK: - Codable
 
 extension PeerID: Codable {
-    public init(from decoder: any Decoder) throws {
+    init(from decoder: any Decoder) throws {
         self.init(str: try decoder.singleValueContainer().decode(String.self))
     }
     
-    public func encode(to encoder: any Encoder) throws {
+    func encode(to encoder: any Encoder) throws {
         var container = encoder.singleValueContainer()
         try container.encode(id)
     }
@@ -128,7 +116,7 @@ extension PeerID: Codable {
 
 // MARK: - Helpers
 
-public extension PeerID {
+extension PeerID {
     var isEmpty: Bool {
         id.isEmpty
     }
@@ -148,7 +136,7 @@ public extension PeerID {
     }
 }
 
-public extension PeerID {
+extension PeerID {
     var routingData: Data? {
         if let direct = Data(hexString: id), direct.count == 8 { return direct }
         if let bareData = Data(hexString: bare), bareData.count == 8 { return bareData }
@@ -164,7 +152,12 @@ public extension PeerID {
 
 // MARK: - Validation
 
-public extension PeerID {
+extension PeerID {
+    private enum Constants {
+        static let maxIDLength = 64
+        static let hexIDLength = 16 // 8 bytes = 16 hex chars
+    }
+    
     /// Validates a peer ID from any source (short 16-hex, full 64-hex, or internal alnum/-/_ up to 64)
     var isValid: Bool {
         if prefix != .empty {
@@ -213,7 +206,7 @@ public extension PeerID {
 // MARK: - Comparable
 
 extension PeerID: Comparable {
-    public static func < (lhs: PeerID, rhs: PeerID) -> Bool {
+    static func < (lhs: PeerID, rhs: PeerID) -> Bool {
         lhs.id < rhs.id
     }
 }
@@ -222,7 +215,7 @@ extension PeerID: Comparable {
 
 extension PeerID: CustomStringConvertible {
     /// So it returns the actual `id` like before even inside another String
-    public var description: String {
+    var description: String {
         id
     }
 }

bitchat/Models/ReadReceipt.swift

@@ -7,7 +7,6 @@
 //
 
 import Foundation
-import BitFoundation
 
 struct ReadReceipt: Codable {
     let originalMessageID: String

bitchat/Noise/NoiseProtocol.swift

@@ -78,7 +78,6 @@
 ///
 
 import BitLogger
-import BitFoundation
 import Foundation
 import CryptoKit
 
@@ -385,16 +384,6 @@ final class NoiseCipherState {
             replayWindow[i] = 0
         }
     }
-
-    #if DEBUG
-    func setNonceForTesting(_ nonce: UInt64) {
-        self.nonce = nonce
-    }
-
-    func extractNonceFromCiphertextPayloadForTesting(_ combinedPayload: Data) throws -> (nonce: UInt64, ciphertext: Data)? {
-        try extractNonceFromCiphertextPayload(combinedPayload)
-    }
-    #endif
 }
 
 // MARK: - Symmetric State
@@ -596,9 +585,8 @@ final class NoiseHandshakeState {
             break // No pre-message keys
         case .IK, .NK:
             if role == .initiator, let remoteStatic = remoteStaticPublic {
+                _ = symmetricState.getHandshakeHash()
                 symmetricState.mixHash(remoteStatic.rawRepresentation)
-            } else if role == .responder, let localStatic = localStaticPublic {
-                symmetricState.mixHash(localStatic.rawRepresentation)
             }
         }
     }
@@ -873,20 +861,6 @@ final class NoiseHandshakeState {
     func getHandshakeHash() -> Data {
         return symmetricState.getHandshakeHash()
     }
-
-    #if DEBUG
-    func performDHOperationForTesting(_ pattern: NoiseMessagePattern) throws {
-        try performDHOperation(pattern)
-    }
-
-    func setCurrentPatternForTesting(_ currentPattern: Int) {
-        self.currentPattern = currentPattern
-    }
-
-    func setRemoteEphemeralPublicKeyForTesting(_ key: Curve25519.KeyAgreement.PublicKey?) {
-        self.remoteEphemeralPublic = key
-    }
-    #endif
 }
 
 // MARK: - Pattern Extensions

bitchat/Noise/NoiseRateLimiter.swift

@@ -7,7 +7,6 @@
 //
 
 import BitLogger
-import BitFoundation
 import Foundation
 
 final class NoiseRateLimiter {

bitchat/Noise/NoiseSession.swift

@@ -9,7 +9,6 @@
 import BitLogger
 import Foundation
 import CryptoKit
-import BitFoundation
 
 class NoiseSession {
     let peerID: PeerID

bitchat/Noise/NoiseSessionManager.swift

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

bitchat/Noise/SecureNoiseSession.swift

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

bitchat/Nostr/Base64URLCoding.swift

@@ -1,22 +0,0 @@
-import Foundation
-
-enum Base64URLCoding {
-    static func encode(_ data: Data) -> String {
-        data.base64EncodedString()
-            .replacingOccurrences(of: "+", with: "-")
-            .replacingOccurrences(of: "/", with: "_")
-            .replacingOccurrences(of: "=", with: "")
-    }
-
-    static func decode(_ string: String) -> Data? {
-        var base64 = string
-        let padding = (4 - (base64.count % 4)) % 4
-        if padding > 0 {
-            base64 += String(repeating: "=", count: padding)
-        }
-        base64 = base64
-            .replacingOccurrences(of: "-", with: "+")
-            .replacingOccurrences(of: "_", with: "/")
-        return Data(base64Encoded: base64)
-    }
-}

bitchat/Nostr/GeoRelayDirectory.swift

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

bitchat/Nostr/NostrEmbeddedBitChat.swift

@@ -1,5 +1,4 @@
 import Foundation
-import BitFoundation
 
 // MARK: - BitChat-over-Nostr Adapter
 

bitchat/Nostr/NostrIdentityBridge.swift

@@ -1,4 +1,3 @@
-import BitFoundation
 import Foundation
 import CryptoKit
 

bitchat/Nostr/NostrProtocol.swift

@@ -109,7 +109,7 @@ struct NostrProtocol {
         teleported: Bool = false
     ) throws -> NostrEvent {
         var tags = [["g", geohash]]
-        if let nickname = nickname?.trimmedOrNilIfEmpty {
+        if let nickname = nickname?.trimmingCharacters(in: .whitespacesAndNewlines), !nickname.isEmpty {
             tags.append(["n", nickname])
         }
         if teleported {
@@ -152,7 +152,7 @@ struct NostrProtocol {
         nickname: String? = nil
     ) throws -> NostrEvent {
         var tags = [["g", geohash]]
-        if let nickname = nickname?.trimmedOrNilIfEmpty {
+        if let nickname = nickname?.trimmingCharacters(in: .whitespacesAndNewlines), !nickname.isEmpty {
             tags.append(["n", nickname])
         }
         let event = NostrEvent(
@@ -303,7 +303,7 @@ struct NostrProtocol {
         combined.append(nonce24)
         combined.append(sealed.ciphertext)
         combined.append(sealed.tag)
-        return "v2:" + Base64URLCoding.encode(combined)
+        return "v2:" + base64URLEncode(combined)
     }
     
     private static func decrypt(
@@ -314,7 +314,7 @@ struct NostrProtocol {
         // Expect NIP-44 v2 format
         guard ciphertext.hasPrefix("v2:") else { throw NostrError.invalidCiphertext }
         let encoded = String(ciphertext.dropFirst(3))
-        guard let data = Base64URLCoding.decode(encoded),
+        guard let data = base64URLDecode(encoded),
               data.count > (24 + 16),
               let senderPubkeyData = Data(hexString: senderPubkey) else {
             throw NostrError.invalidCiphertext
@@ -529,26 +529,6 @@ struct NostrEvent: Codable {
         return signed
     }
     
-    /// Validate that the event ID and Schnorr signature match the content and pubkey.
-    /// Returns false when the signature is missing, malformed, or does not verify.
-    func isValidSignature() -> Bool {
-        guard let sig = sig,
-              let sigData = Data(hexString: sig),
-              let pubData = Data(hexString: pubkey),
-              sigData.count == 64,
-              pubData.count == 32,
-              let signature = try? P256K.Schnorr.SchnorrSignature(dataRepresentation: sigData),
-              let (expectedId, eventHash) = try? calculateEventId(),
-              expectedId == id
-        else {
-            return false
-        }
-
-        var messageBytes = [UInt8](eventHash)
-        let xonly = P256K.Schnorr.XonlyKey(dataRepresentation: pubData)
-        return xonly.isValid(signature, for: &messageBytes)
-    }
-    
     private func calculateEventId() throws -> (String, Data) {
         let serialized = [
             0,
@@ -580,9 +560,24 @@ enum NostrError: Error {
     case encryptionFailed
 }
 
-// MARK: - NIP-44 v2 helpers (XChaCha20-Poly1305)
+// MARK: - NIP-44 v2 helpers (XChaCha20-Poly1305 + base64url)
 
 private extension NostrProtocol {
+    static func base64URLEncode(_ data: Data) -> String {
+        return data.base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+    }
+
+    static func base64URLDecode(_ s: String) -> Data? {
+        var str = s
+        let pad = (4 - (str.count % 4)) % 4
+        if pad > 0 { str += String(repeating: "=", count: pad) }
+        str = str.replacingOccurrences(of: "-", with: "+").replacingOccurrences(of: "_", with: "/")
+        return Data(base64Encoded: str)
+    }
+
     static func deriveNIP44V2Key(from sharedSecretData: Data) throws -> Data {
         let derivedKey = HKDF<CryptoKit.SHA256>.deriveKey(
             inputKeyMaterial: SymmetricKey(data: sharedSecretData),

bitchat/Nostr/NostrRelayManager.swift

@@ -4,100 +4,6 @@ import Network
 import Combine
 import Tor
 
-protocol NostrRelayConnectionProtocol: AnyObject {
-    func resume()
-    func cancel(with closeCode: URLSessionWebSocketTask.CloseCode, reason: Data?)
-    func send(_ message: URLSessionWebSocketTask.Message, completionHandler: @escaping (Error?) -> Void)
-    func receive(completionHandler: @escaping (Result<URLSessionWebSocketTask.Message, Error>) -> Void)
-    func sendPing(pongReceiveHandler: @escaping (Error?) -> Void)
-}
-
-protocol NostrRelaySessionProtocol {
-    func webSocketTask(with url: URL) -> NostrRelayConnectionProtocol
-}
-
-private final class URLSessionWebSocketTaskAdapter: NostrRelayConnectionProtocol {
-    private let base: URLSessionWebSocketTask
-
-    init(base: URLSessionWebSocketTask) {
-        self.base = base
-    }
-
-    func resume() {
-        base.resume()
-    }
-
-    func cancel(with closeCode: URLSessionWebSocketTask.CloseCode, reason: Data?) {
-        base.cancel(with: closeCode, reason: reason)
-    }
-
-    func send(_ message: URLSessionWebSocketTask.Message, completionHandler: @escaping (Error?) -> Void) {
-        base.send(message, completionHandler: completionHandler)
-    }
-
-    func receive(completionHandler: @escaping (Result<URLSessionWebSocketTask.Message, Error>) -> Void) {
-        base.receive(completionHandler: completionHandler)
-    }
-
-    func sendPing(pongReceiveHandler: @escaping (Error?) -> Void) {
-        base.sendPing(pongReceiveHandler: pongReceiveHandler)
-    }
-}
-
-private struct URLSessionAdapter: NostrRelaySessionProtocol {
-    let base: URLSession
-
-    func webSocketTask(with url: URL) -> NostrRelayConnectionProtocol {
-        URLSessionWebSocketTaskAdapter(base: base.webSocketTask(with: url))
-    }
-}
-
-struct NostrRelayManagerDependencies {
-    var activationAllowed: () -> Bool
-    var userTorEnabled: () -> Bool
-    var hasMutualFavorites: () -> Bool
-    var hasLocationPermission: () -> Bool
-    var mutualFavoritesPublisher: AnyPublisher<Set<Data>, Never>
-    var locationPermissionPublisher: AnyPublisher<LocationChannelManager.PermissionState, Never>
-    var torEnforced: () -> Bool
-    var torIsReady: () -> Bool
-    var torIsForeground: () -> Bool
-    var awaitTorReady: (@escaping (Bool) -> Void) -> Void
-    var makeSession: () -> NostrRelaySessionProtocol
-    var scheduleAfter: @Sendable (TimeInterval, @escaping @Sendable () -> Void) -> Void
-    var now: () -> Date
-}
-
-private extension NostrRelayManagerDependencies {
-    @MainActor
-    static func live() -> Self {
-        Self(
-            activationAllowed: { NetworkActivationService.shared.activationAllowed },
-            userTorEnabled: { NetworkActivationService.shared.userTorEnabled },
-            hasMutualFavorites: { !FavoritesPersistenceService.shared.mutualFavorites.isEmpty },
-            hasLocationPermission: { LocationChannelManager.shared.permissionState == .authorized },
-            mutualFavoritesPublisher: FavoritesPersistenceService.shared.$mutualFavorites.eraseToAnyPublisher(),
-            locationPermissionPublisher: LocationChannelManager.shared.$permissionState.eraseToAnyPublisher(),
-            torEnforced: { TorManager.shared.torEnforced },
-            torIsReady: { TorManager.shared.isReady },
-            torIsForeground: { TorManager.shared.isForeground() },
-            awaitTorReady: { completion in
-                Task.detached {
-                    let ready = await TorManager.shared.awaitReady()
-                    await MainActor.run {
-                        completion(ready)
-                    }
-                }
-            },
-            makeSession: { URLSessionAdapter(base: TorURLSession.shared.session) },
-            scheduleAfter: { delay, action in
-                DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: action)
-            },
-            now: Date.init
-        )
-    }
-}
-
 /// Manages WebSocket connections to Nostr relays
 @MainActor
 final class NostrRelayManager: ObservableObject {
@@ -121,40 +27,31 @@ final class NostrRelayManager: ObservableObject {
         var nextReconnectTime: Date?
     }
     
-    // Default relays carry NIP-17 gift wraps, so avoid relays known to reject kind 1059.
+    // Default relay list (can be customized)
     private static let defaultRelays = [
         "wss://relay.damus.io",
         "wss://nos.lol",
         "wss://relay.primal.net",
-        "wss://offchain.pub"
+        "wss://offchain.pub",
+        "wss://nostr21.com"
         // For local testing, you can add: "ws://localhost:8080"
     ]
-    private static let defaultRelaySet = Set(defaultRelays.compactMap { NostrRelayURL.normalized($0) })
+    private static let defaultRelaySet = Set(defaultRelays)
     
     @Published private(set) var relays: [Relay] = []
     @Published private(set) var isConnected = false
     
-    private let dependencies: NostrRelayManagerDependencies
     private var allowDefaultRelays: Bool = false
     private var hasMutualFavorites: Bool = false
     private var hasLocationPermission: Bool = false
-    private var connections: [String: NostrRelayConnectionProtocol] = [:]
+    private var connections: [String: URLSessionWebSocketTask] = [:]
     private var subscriptions: [String: Set<String>] = [:] // relay URL -> active subscription IDs
     private var pendingSubscriptions: [String: [String: String]] = [:] // relay URL -> (subscription id -> encoded REQ JSON)
     private var messageHandlers: [String: (NostrEvent) -> Void] = [:]
-    // Coalesce duplicate subscribe requests for the same id within a short window.
+    // Coalesce duplicate subscribe requests for the same id within a short window
-    private let subscribeCoalesceInterval: TimeInterval = 1.0
     private var subscribeCoalesce: [String: Date] = [:]
-    private var pendingTorConnectionURLs = Set<String>()
-    private var awaitingTorForConnections = false
     private var cancellables = Set<AnyCancellable>()
 
-    private struct SubscriptionRequestState: Equatable {
-        let messageString: String
-        let relayURLs: Set<String>
-    }
-    private var subscriptionRequestState: [String: SubscriptionRequestState] = [:]
-
     // Track EOSE per subscription to signal when initial stored events are done
     private struct EOSETracker {
         var pendingRelays: Set<String>
@@ -162,7 +59,6 @@ final class NostrRelayManager: ObservableObject {
         var timer: Timer?
     }
     private var eoseTrackers: [String: EOSETracker] = [:]
-    private var pendingEOSECallbacks: [String: () -> Void] = [:]
     
     // Message queue for reliability
     // Pending sends held only for relays that are not yet connected.
@@ -173,7 +69,8 @@ final class NostrRelayManager: ObservableObject {
     private var messageQueue: [PendingSend] = []
     private let messageQueueLock = NSLock()
     private let encoder = JSONEncoder()
-    private var shouldUseTor: Bool { dependencies.userTorEnabled() }
+    private var networkService: NetworkActivationService { NetworkActivationService.shared }
+    private var shouldUseTor: Bool { networkService.userTorEnabled }
     
     // Exponential backoff configuration
     private let initialBackoffInterval: TimeInterval = TransportConfig.nostrRelayInitialBackoffSeconds
@@ -185,13 +82,12 @@ final class NostrRelayManager: ObservableObject {
     private var connectionGeneration: Int = 0
     
     init() {
-        self.dependencies = .live()
+        hasMutualFavorites = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
-        hasMutualFavorites = dependencies.hasMutualFavorites()
+        hasLocationPermission = LocationChannelManager.shared.permissionState == .authorized
-        hasLocationPermission = dependencies.hasLocationPermission()
         applyDefaultRelayPolicy(force: true)
         // Deterministic JSON shape for outbound requests
         self.encoder.outputFormatting = .sortedKeys
-        dependencies.mutualFavoritesPublisher
+        FavoritesPersistenceService.shared.$mutualFavorites
             .receive(on: DispatchQueue.main)
             .sink { [weak self] favorites in
                 guard let self = self else { return }
@@ -199,34 +95,7 @@ final class NostrRelayManager: ObservableObject {
                 self.applyDefaultRelayPolicy()
             }
             .store(in: &cancellables)
-        dependencies.locationPermissionPublisher
+        LocationChannelManager.shared.$permissionState
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] state in
-                guard let self = self else { return }
-                let authorized = (state == .authorized)
-                if authorized == self.hasLocationPermission { return }
-                self.hasLocationPermission = authorized
-                self.applyDefaultRelayPolicy()
-            }
-            .store(in: &cancellables)
-    }
-
-    internal init(dependencies: NostrRelayManagerDependencies) {
-        self.dependencies = dependencies
-        hasMutualFavorites = dependencies.hasMutualFavorites()
-        hasLocationPermission = dependencies.hasLocationPermission()
-        applyDefaultRelayPolicy(force: true)
-        // Deterministic JSON shape for outbound requests
-        self.encoder.outputFormatting = .sortedKeys
-        dependencies.mutualFavoritesPublisher
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] favorites in
-                guard let self = self else { return }
-                self.hasMutualFavorites = !favorites.isEmpty
-                self.applyDefaultRelayPolicy()
-            }
-            .store(in: &cancellables)
-        dependencies.locationPermissionPublisher
             .receive(on: DispatchQueue.main)
             .sink { [weak self] state in
                 guard let self = self else { return }
@@ -241,8 +110,28 @@ final class NostrRelayManager: ObservableObject {
     /// Connect to all configured relays
     func connect() {
         // Global network policy gate
-        guard dependencies.activationAllowed() else { return }
+        guard networkService.activationAllowed else { return }
-        connectToRelays(relays.map(\.url), shouldLog: true)
+        if shouldUseTor {
+            // Ensure Tor is started early and wait for readiness off-main; then hop back to connect.
+            Task.detached {
+                let ready = await TorManager.shared.awaitReady()
+                await MainActor.run {
+                    if !ready {
+                        SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
+                        return
+                    }
+                    SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
+                    for relay in self.relays {
+                        self.connectToRelay(relay.url)
+                    }
+                }
+            }
+        } else {
+            SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (direct)", category: .session)
+            for relay in self.relays {
+                connectToRelay(relay.url)
+            }
+        }
     }
     
     /// Disconnect from all relays
@@ -255,40 +144,44 @@ final class NostrRelayManager: ObservableObject {
         // Clear known subscriptions and any queued subs since connections are gone
         subscriptions.removeAll()
         pendingSubscriptions.removeAll()
-        subscriptionRequestState.removeAll()
-        pendingEOSECallbacks.removeAll()
-        for (_, tracker) in eoseTrackers {
-            tracker.timer?.invalidate()
-        }
-        eoseTrackers.removeAll()
-        pendingTorConnectionURLs.removeAll()
-        awaitingTorForConnections = false
         updateConnectionStatus()
     }
     
     /// Ensure connections exist to the given relay URLs (idempotent).
     func ensureConnections(to relayUrls: [String]) {
         // Global network policy gate
-        guard dependencies.activationAllowed() else { return }
+        guard networkService.activationAllowed else { return }
         let targets = allowedRelayList(from: relayUrls)
         guard !targets.isEmpty else { return }
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
+            // Defer until Tor is fully ready; avoid queuing connection attempts early
+            Task.detached { [weak self] in
+                guard let self = self else { return }
+                let ready = await TorManager.shared.awaitReady()
+                await MainActor.run { if ready { self.ensureConnections(to: relayUrls) } }
+            }
+            return
+        }
         var existing = Set(relays.map { $0.url })
         for url in targets where !existing.contains(url) {
             relays.append(Relay(url: url))
             existing.insert(url)
         }
-        connectToRelays(targets)
+        for url in targets where connections[url] == nil {
+            connectToRelay(url)
+        }
     }
 
     /// Send an event to specified relays (or all if none specified)
     func sendEvent(_ event: NostrEvent, to relayUrls: [String]? = nil) {
         // Global network policy gate
-        guard dependencies.activationAllowed() else { return }
+        guard networkService.activationAllowed else { return }
-        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady() {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer sends until Tor is ready to avoid premature queueing
-            dependencies.awaitTorReady { [weak self] ready in
+            Task.detached { [weak self] in
                 guard let self = self else { return }
-                if ready { self.sendEvent(event, to: relayUrls) }
+                let ready = await TorManager.shared.awaitReady()
+                await MainActor.run { if ready { self.sendEvent(event, to: relayUrls) } }
             }
             return
         }
@@ -300,7 +193,7 @@ final class NostrRelayManager: ObservableObject {
         // Attempt immediate send to relays with active connections; queue the rest
         var stillPending = Set<String>()
         for relayUrl in targetRelays {
-            if let connection = connectedConnection(for: relayUrl) {
+            if let connection = connections[relayUrl] {
                 sendToRelay(event: event, connection: connection, relayUrl: relayUrl)
             } else {
                 stillPending.insert(relayUrl)
@@ -322,7 +215,7 @@ final class NostrRelayManager: ObservableObject {
             // Flush only for a specific relay
             for i in (0..<messageQueue.count).reversed() {
                 var item = messageQueue[i]
-                if item.pendingRelays.contains(target), let conn = connectedConnection(for: target) {
+                if item.pendingRelays.contains(target), let conn = connections[target] {
                     sendToRelay(event: item.event, connection: conn, relayUrl: target)
                     item.pendingRelays.remove(target)
                     if item.pendingRelays.isEmpty {
@@ -337,7 +230,7 @@ final class NostrRelayManager: ObservableObject {
             for i in (0..<messageQueue.count).reversed() {
                 var item = messageQueue[i]
                 for url in item.pendingRelays {
-                    if let conn = connectedConnection(for: url) {
+                    if let conn = connections[url] {
                         sendToRelay(event: item.event, connection: conn, relayUrl: url)
                         item.pendingRelays.remove(url)
                     }
@@ -351,14 +244,6 @@ final class NostrRelayManager: ObservableObject {
         }
     }
     
-    private func connectedConnection(for relayUrl: String) -> NostrRelayConnectionProtocol? {
-        guard let connection = connections[relayUrl],
-              relays.first(where: { $0.url == relayUrl })?.isConnected == true else {
-            return nil
-        }
-        return connection
-    }
-    
     /// Subscribe to events matching a filter. If `relayUrls` provided, targets only those relays.
     func subscribe(
         filter: NostrFilter,
@@ -368,13 +253,28 @@ final class NostrRelayManager: ObservableObject {
         onEOSE: (() -> Void)? = nil
     ) {
         // Global network policy gate
-        guard dependencies.activationAllowed() else { return }
+        guard networkService.activationAllowed else { return }
-        // Coalesce rapid duplicate subscribe requests even while Tor readiness is pending.
+        // Coalesce rapid duplicate subscribe requests only if a handler already exists
-        let now = dependencies.now()
+        let now = Date()
-        if let last = subscribeCoalesce[id], now.timeIntervalSince(last) < subscribeCoalesceInterval {
+        if messageHandlers[id] != nil {
+            if let last = subscribeCoalesce[id], now.timeIntervalSince(last) < 1.0 {
                 return
             }
+        }
         subscribeCoalesce[id] = now
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
+            // Defer subscription setup until Tor is ready; avoid queuing subs early
+            Task.detached { [weak self] in
+                guard let self = self else { return }
+                let ready = await TorManager.shared.awaitReady()
+                await MainActor.run {
+                    if ready {
+                        self.subscribe(filter: filter, id: id, relayUrls: relayUrls, handler: handler)
+                    }
+                }
+            }
+            return
+        }
         messageHandlers[id] = handler
         
         let req = NostrRequest.subscribe(id: id, filters: [filter])
@@ -390,20 +290,14 @@ final class NostrRelayManager: ObservableObject {
             
             // Target specific relays if provided; else default. Filter permanently failed relays.
             let baseUrls = relayUrls ?? Self.defaultRelays
-            let urls = allowedRelayList(from: baseUrls).filter { !isPermanentlyFailed($0) }
+            let candidateUrls = baseUrls.filter { !isPermanentlyFailed($0) }
-            let requestState = SubscriptionRequestState(messageString: messageString, relayURLs: Set(urls))
+            let urls = allowedRelayList(from: candidateUrls)
-            if subscriptionRequestState[id] == requestState, subscriptionStateExists(id: id, requestState: requestState) {
-                return
-            }
-            subscriptionRequestState[id] = requestState
-
             // Always queue subscriptions; sending happens when a relay reports connected
-            var existingSet = Set(relays.map { $0.url })
+            let existingSet = Set(relays.map { $0.url })
             for url in urls where !existingSet.contains(url) {
                 relays.append(Relay(url: url))
-                existingSet.insert(url)
             }
-            for url in urls {
+            for url in candidateUrls {
                 var map = self.pendingSubscriptions[url] ?? [:]
                 map[id] = messageString
                 self.pendingSubscriptions[url] = map
@@ -412,10 +306,20 @@ final class NostrRelayManager: ObservableObject {
             if let onEOSE = onEOSE {
                 if urls.isEmpty {
                     onEOSE()
-                } else if shouldWaitForTorBeforeConnecting {
-                    pendingEOSECallbacks[id] = onEOSE
                 } else {
-                    startEOSETracking(id: id, relayURLs: Set(urls), callback: onEOSE)
+                    var tracker = EOSETracker(pendingRelays: Set(urls), callback: onEOSE, timer: nil)
+                    // Fallback timeout to avoid hanging if a relay never sends EOSE
+                    tracker.timer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
+                        Task { @MainActor in
+                            guard let self = self else { return }
+                            if let t = self.eoseTrackers[id] {
+                                t.timer?.invalidate()
+                                self.eoseTrackers.removeValue(forKey: id)
+                                onEOSE()
+                            }
+                        }
+                    }
+                    eoseTrackers[id] = tracker
                 }
             }
             SecureLogger.debug("📋 Queued subscription id=\(id) for \(urls.count) relay(s)", category: .session)
@@ -442,7 +346,7 @@ final class NostrRelayManager: ObservableObject {
                 relays.append(Relay(url: url))
                 existing.insert(url)
             }
-            if dependencies.activationAllowed() {
+            if networkService.activationAllowed {
                 ensureConnections(to: Self.defaultRelays)
             }
         } else {
@@ -452,7 +356,6 @@ final class NostrRelayManager: ObservableObject {
                 }
                 connections.removeValue(forKey: url)
                 subscriptions.removeValue(forKey: url)
-                pendingSubscriptions.removeValue(forKey: url)
             }
             messageQueueLock.lock()
             for index in (0..<messageQueue.count).reversed() {
@@ -473,8 +376,7 @@ final class NostrRelayManager: ObservableObject {
     private func allowedRelayList(from urls: [String]) -> [String] {
         var seen = Set<String>()
         var result: [String] = []
-        for rawURL in urls {
+        for url in urls {
-            guard let url = NostrRelayURL.normalized(rawURL) else { continue }
             if !allowDefaultRelays && Self.defaultRelaySet.contains(url) { continue }
             if seen.insert(url).inserted {
                 result.append(url)
@@ -488,13 +390,6 @@ final class NostrRelayManager: ObservableObject {
         messageHandlers.removeValue(forKey: id)
         // Allow immediate re-subscription by clearing coalescer timestamp
         subscribeCoalesce.removeValue(forKey: id)
-        subscriptionRequestState.removeValue(forKey: id)
-        pendingEOSECallbacks.removeValue(forKey: id)
-        eoseTrackers[id]?.timer?.invalidate()
-        eoseTrackers.removeValue(forKey: id)
-        for url in Array(pendingSubscriptions.keys) {
-            pendingSubscriptions[url]?.removeValue(forKey: id)
-        }
         
         let req = NostrRequest.close(id: id)
         let message = try? encoder.encode(req)
@@ -505,9 +400,10 @@ final class NostrRelayManager: ObservableObject {
         // Send unsubscribe to all relays
         for (relayUrl, connection) in connections {
             if subscriptions[relayUrl]?.contains(id) == true {
-                subscriptions[relayUrl]?.remove(id)
                 connection.send(.string(messageString)) { _ in
-                    // Local state is cleared before sending so callers can re-subscribe immediately.
+                    Task { @MainActor in
+                        self.subscriptions[relayUrl]?.remove(id)
+                    }
                 }
             }
         }
@@ -515,110 +411,16 @@ final class NostrRelayManager: ObservableObject {
     
     // MARK: - Private Methods
     
-    private var shouldWaitForTorBeforeConnecting: Bool {
-        shouldUseTor && !dependencies.torIsReady()
-    }
-
-    private func connectToRelays(_ relayUrls: [String], shouldLog: Bool = false) {
-        guard dependencies.activationAllowed() else { return }
-        let targets = allowedRelayList(from: relayUrls).filter {
-            connections[$0] == nil && !isPermanentlyFailed($0)
-        }
-        guard !targets.isEmpty else { return }
-
-        if shouldWaitForTorBeforeConnecting {
-            queueConnectionsUntilTorReady(targets)
-            return
-        }
-
-        if shouldLog {
-            let route = shouldUseTor ? "via Tor" : "direct"
-            SecureLogger.debug("🌐 Connecting to \(targets.count) Nostr relay(s) (\(route))", category: .session)
-        }
-
-        for url in targets {
-            connectToRelay(url)
-        }
-    }
-
-    private func queueConnectionsUntilTorReady(_ relayUrls: [String]) {
-        let targets = allowedRelayList(from: relayUrls).filter {
-            connections[$0] == nil && !isPermanentlyFailed($0)
-        }
-        guard !targets.isEmpty else { return }
-
-        pendingTorConnectionURLs.formUnion(targets)
-        guard !awaitingTorForConnections else { return }
-
-        awaitingTorForConnections = true
-        let generation = connectionGeneration
-        dependencies.awaitTorReady { [weak self] ready in
-            guard let self else { return }
-            guard generation == self.connectionGeneration else { return }
-
-            let pending = Array(self.pendingTorConnectionURLs)
-            self.pendingTorConnectionURLs.removeAll()
-            self.awaitingTorForConnections = false
-
-            guard ready else {
-                SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
-                return
-            }
-
-            self.connectToRelays(pending, shouldLog: true)
-        }
-    }
-
-    private func subscriptionStateExists(id: String, requestState: SubscriptionRequestState) -> Bool {
-        guard !requestState.relayURLs.isEmpty else { return true }
-        return requestState.relayURLs.allSatisfy { url in
-            pendingSubscriptions[url]?[id] == requestState.messageString ||
-                subscriptions[url]?.contains(id) == true
-        }
-    }
-
-    private func startEOSETracking(id: String, relayURLs: Set<String>, callback: @escaping () -> Void) {
-        eoseTrackers[id]?.timer?.invalidate()
-        var tracker = EOSETracker(pendingRelays: relayURLs, callback: callback, timer: nil)
-        // Fallback timeout to avoid hanging if a relay never sends EOSE.
-        tracker.timer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
-            Task { @MainActor in
-                guard let self else { return }
-                if let tracker = self.eoseTrackers[id] {
-                    tracker.timer?.invalidate()
-                    self.eoseTrackers.removeValue(forKey: id)
-                    callback()
-                }
-            }
-        }
-        eoseTrackers[id] = tracker
-    }
-
-    private func startPendingEOSETrackingIfNeeded(id: String) {
-        guard eoseTrackers[id] == nil,
-              let callback = pendingEOSECallbacks.removeValue(forKey: id),
-              let requestState = subscriptionRequestState[id]
-        else {
-            return
-        }
-
-        if requestState.relayURLs.isEmpty {
-            callback()
-        } else {
-            startEOSETracking(id: id, relayURLs: requestState.relayURLs, callback: callback)
-        }
-    }
-    
     private func connectToRelay(_ urlString: String) {
         // Global network policy gate
-        guard dependencies.activationAllowed() else { return }
+        guard networkService.activationAllowed else { return }
         guard let url = URL(string: urlString) else { 
             SecureLogger.warning("Invalid relay URL: \(urlString)", category: .session)
             return 
         }
 
         // Avoid initiating connections while app is backgrounded; we'll reconnect on foreground
-        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsForeground() {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isForeground() {
             return
         }
         
@@ -633,12 +435,19 @@ final class NostrRelayManager: ObservableObject {
         // Attempting to connect to Nostr relay via the proxied session
         
         // If Tor is enforced but not ready, delay connection until it is.
-        if shouldWaitForTorBeforeConnecting {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
-            queueConnectionsUntilTorReady([urlString])
+            Task.detached { [weak self] in
+                guard let self = self else { return }
+                let ready = await TorManager.shared.awaitReady()
+                await MainActor.run {
+                    if ready { self.connectToRelay(urlString) }
+                    else { SecureLogger.error("❌ Tor not ready; skipping connection to \(urlString)", category: .session) }
+                }
+            }
             return
         }
         
-        let session = dependencies.makeSession()
+        let session = TorURLSession.shared.session
         let task = session.webSocketTask(with: url)
         
         connections[urlString] = task
@@ -671,7 +480,6 @@ final class NostrRelayManager: ObservableObject {
         guard let connection = connections[relayUrl] else { return }
         for (id, messageString) in map {
             if self.subscriptions[relayUrl]?.contains(id) == true { continue }
-            startPendingEOSETrackingIfNeeded(id: id)
             connection.send(.string(messageString)) { error in
                 if let error = error {
                     SecureLogger.error("❌ Failed to send pending subscription to \(relayUrl): \(error)", category: .session)
@@ -687,7 +495,7 @@ final class NostrRelayManager: ObservableObject {
         pendingSubscriptions[relayUrl] = nil
     }
     
-    private func receiveMessage(from task: NostrRelayConnectionProtocol, relayUrl: String) {
+    private func receiveMessage(from task: URLSessionWebSocketTask, relayUrl: String) {
         task.receive { [weak self] result in
             guard let self = self else { return }
             
@@ -697,7 +505,7 @@ final class NostrRelayManager: ObservableObject {
                 Task.detached(priority: .utility) {
                     guard let parsed = ParsedInbound(message) else { return }
                     await MainActor.run {
-                        self.handleParsedMessage(parsed, from: relayUrl)
+                        NostrRelayManager.shared.handleParsedMessage(parsed, from: relayUrl)
                     }
                 }
                 
@@ -751,9 +559,9 @@ final class NostrRelayManager: ObservableObject {
             } else {
                 let isGiftWrap = Self.pendingGiftWrapIDs.remove(eventId) != nil
                 if isGiftWrap {
-                    SecureLogger.warning("📮 Rejected id=\(eventId.prefix(16))… relay=\(relayUrl) reason=\(reason)", category: .session)
+                    SecureLogger.warning("📮 Rejected id=\(eventId.prefix(16))… reason=\(reason)", category: .session)
                 } else {
-                    SecureLogger.error("📮 Rejected id=\(eventId.prefix(16))… relay=\(relayUrl) reason=\(reason)", category: .session)
+                    SecureLogger.error("📮 Rejected id=\(eventId.prefix(16))… reason=\(reason)", category: .session)
                 }
             }
         case .notice:
@@ -761,7 +569,7 @@ final class NostrRelayManager: ObservableObject {
         }
     }
     
-    private func sendToRelay(event: NostrEvent, connection: NostrRelayConnectionProtocol, relayUrl: String) {
+    private func sendToRelay(event: NostrEvent, connection: URLSessionWebSocketTask, relayUrl: String) {
         let req = NostrRequest.event(event)
         
         do {
@@ -793,11 +601,11 @@ final class NostrRelayManager: ObservableObject {
             relays[index].isConnected = isConnected
             relays[index].lastError = error
             if isConnected {
-                relays[index].lastConnectedAt = dependencies.now()
+                relays[index].lastConnectedAt = Date()
                 relays[index].reconnectAttempts = 0  // Reset on successful connection
                 relays[index].nextReconnectTime = nil
             } else {
-                relays[index].lastDisconnectedAt = dependencies.now()
+                relays[index].lastDisconnectedAt = Date()
             }
         }
         updateConnectionStatus()
@@ -813,7 +621,7 @@ final class NostrRelayManager: ObservableObject {
     
     private func handleDisconnection(relayUrl: String, error: Error) {
         // If networking is disallowed, do not schedule reconnection
-        if !dependencies.activationAllowed() {
+        if !networkService.activationAllowed {
             connections.removeValue(forKey: relayUrl)
             subscriptions.removeValue(forKey: relayUrl)
             updateRelayStatus(relayUrl, isConnected: false, error: error)
@@ -858,14 +666,13 @@ final class NostrRelayManager: ObservableObject {
             maxBackoffInterval
         )
         
-        let nextReconnectTime = dependencies.now().addingTimeInterval(backoffInterval)
+        let nextReconnectTime = Date().addingTimeInterval(backoffInterval)
         relays[index].nextReconnectTime = nextReconnectTime
         
         
         // Schedule reconnection with exponential backoff
         let gen = connectionGeneration
-        dependencies.scheduleAfter(backoffInterval) { [weak self] in
+        DispatchQueue.main.asyncAfter(deadline: .now() + backoffInterval) { [weak self] in
-            Task { @MainActor [weak self] in
             guard let self = self else { return }
             // Ignore stale scheduled reconnects from a previous generation
             guard gen == self.connectionGeneration else { return }
@@ -875,28 +682,25 @@ final class NostrRelayManager: ObservableObject {
             }
         }
     }
-    }
     
     // MARK: - Public Utility Methods
     
     /// Manually retry connection to a specific relay
     func retryConnection(to relayUrl: String) {
-        let normalizedRelayUrl = NostrRelayURL.normalized(relayUrl) ?? relayUrl
+        guard let index = relays.firstIndex(where: { $0.url == relayUrl }) else { return }
-        guard let index = relays.firstIndex(where: { $0.url == normalizedRelayUrl }) else { return }
         
         // Reset reconnection attempts
         relays[index].reconnectAttempts = 0
         relays[index].nextReconnectTime = nil
-        relays[index].lastError = nil
         
         // Disconnect if connected
-        if let connection = connections[normalizedRelayUrl] {
+        if let connection = connections[relayUrl] {
             connection.cancel(with: .goingAway, reason: nil)
-            connections.removeValue(forKey: normalizedRelayUrl)
+            connections.removeValue(forKey: relayUrl)
         }
         
         // Attempt immediate reconnection
-        connectToRelay(normalizedRelayUrl)
+        connectToRelay(relayUrl)
     }
     
     /// Get detailed status for all relays
@@ -909,20 +713,6 @@ final class NostrRelayManager: ObservableObject {
         }
     }
     
-    var debugPendingMessageQueueCount: Int {
-        messageQueueLock.lock()
-        defer { messageQueueLock.unlock() }
-        return messageQueue.count
-    }
-
-    func debugPendingSubscriptionCount(for relayUrl: String) -> Int {
-        pendingSubscriptions[relayUrl]?.count ?? 0
-    }
-
-    func debugFlushMessageQueue() {
-        flushMessageQueue(for: nil)
-    }
-    
     /// Reset all relay connections
     func resetAllConnections() {
         disconnect()
@@ -974,8 +764,7 @@ private enum ParsedInbound {
             if array.count >= 3,
                let subId = array[1] as? String,
                let eventDict = array[2] as? [String: Any],
-               let event = try? NostrEvent(from: eventDict),
+               let event = try? NostrEvent(from: eventDict) {
-               event.isValidSignature() {
                 self = .event(subId: subId, event: event)
                 return
             }

bitchat/Nostr/NostrRelayURL.swift

@@ -1,51 +0,0 @@
-import Foundation
-
-enum NostrRelayURL {
-    static func normalized(_ rawValue: String, defaultScheme: String? = nil) -> String? {
-        var value = rawValue.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !value.isEmpty else { return nil }
-
-        if !value.contains("://"), let defaultScheme {
-            value = "\(defaultScheme)://\(value)"
-        }
-
-        guard var components = URLComponents(string: value),
-              let rawScheme = components.scheme?.lowercased(),
-              let rawHost = components.host?.lowercased(),
-              !rawHost.isEmpty else {
-            return nil
-        }
-
-        switch rawScheme {
-        case "wss", "https":
-            components.scheme = "wss"
-            if components.port == 443 {
-                components.port = nil
-            }
-        case "ws", "http":
-            components.scheme = "ws"
-            if components.port == 80 {
-                components.port = nil
-            }
-        default:
-            return nil
-        }
-
-        components.host = rawHost
-        if components.path == "/" {
-            components.path = ""
-        }
-        components.fragment = nil
-
-        return components.string
-    }
-
-    static func directoryAddress(_ rawValue: String) -> String? {
-        guard var normalized = normalized(rawValue, defaultScheme: "wss") else { return nil }
-        for prefix in ["wss://", "ws://"] where normalized.hasPrefix(prefix) {
-            normalized.removeFirst(prefix.count)
-            break
-        }
-        return normalized
-    }
-}

bitchat/Protocols/BinaryEncodingUtils.swift

@@ -5,15 +5,70 @@
 // Binary encoding utilities for efficient protocol messages
 //
 
-import struct Foundation.Data
+import Foundation
-import struct Foundation.Date
+import CryptoKit
+
+// MARK: - Hex Encoding/Decoding
+
+extension Data {
+    func hexEncodedString() -> String {
+        if self.isEmpty {
+            return ""
+        }
+        return self.map { String(format: "%02x", $0) }.joined()
+    }
+
+    func sha256Hex() -> String {
+        let digest = SHA256.hash(data: self)
+        return digest.map { String(format: "%02x", $0) }.joined()
+    }
+    
+    /// Initialize Data from a hex string.
+    /// - Parameter hexString: A hex string, optionally prefixed with "0x" or "0X".
+    ///   Whitespace is trimmed. Must have even length after prefix removal.
+    /// - Returns: nil if the string has odd length or contains invalid hex characters.
+    init?(hexString: String) {
+        var hex = hexString.trimmingCharacters(in: .whitespaces)
+
+        // Remove optional 0x prefix
+        if hex.hasPrefix("0x") || hex.hasPrefix("0X") {
+            hex = String(hex.dropFirst(2))
+        }
+
+        // Reject odd-length strings
+        guard hex.count % 2 == 0 else {
+            return nil
+        }
+
+        // Reject empty strings
+        guard !hex.isEmpty else {
+            self = Data()
+            return
+        }
+
+        let len = hex.count / 2
+        var data = Data(capacity: len)
+        var index = hex.startIndex
+
+        for _ in 0..<len {
+            let nextIndex = hex.index(index, offsetBy: 2)
+            guard let byte = UInt8(String(hex[index..<nextIndex]), radix: 16) else {
+                return nil
+            }
+            data.append(byte)
+            index = nextIndex
+        }
+
+        self = data
+    }
+}
 
 // MARK: - Binary Encoding Utilities
 
 extension Data {
     // MARK: Writing
     
-    @inlinable public mutating func appendUInt8(_ value: UInt8) {
+    @inlinable mutating func appendUInt8(_ value: UInt8) {
         self.append(value)
     }
     
@@ -35,7 +90,7 @@ extension Data {
         }
     }
     
-    public mutating func appendString(_ string: String, maxLength: Int = 255) {
+    mutating func appendString(_ string: String, maxLength: Int = 255) {
         guard let data = string.data(using: .utf8) else { return }
         let length = Swift.min(data.count, maxLength)
         
@@ -48,7 +103,7 @@ extension Data {
         self.append(data.prefix(length))
     }
     
-    public mutating func appendData(_ data: Data, maxLength: Int = 65535) {
+    mutating func appendData(_ data: Data, maxLength: Int = 65535) {
         let length = Swift.min(data.count, maxLength)
         
         if maxLength <= 255 {
@@ -60,12 +115,12 @@ extension Data {
         self.append(data.prefix(length))
     }
     
-    public mutating func appendDate(_ date: Date) {
+    mutating func appendDate(_ date: Date) {
         let timestamp = UInt64(date.timeIntervalSince1970 * 1000) // milliseconds
         self.appendUInt64(timestamp)
     }
     
-    public mutating func appendUUID(_ uuid: String) {
+    mutating func appendUUID(_ uuid: String) {
         // Convert UUID string to 16 bytes
         var uuidData = Data(count: 16)
         
@@ -86,7 +141,7 @@ extension Data {
     
     // MARK: Reading
     
-    @inlinable public func readUInt8(at offset: inout Int) -> UInt8? {
+    @inlinable func readUInt8(at offset: inout Int) -> UInt8? {
         guard offset >= 0 && offset < self.count else { return nil }
         let value = self[offset]
         offset += 1
@@ -120,7 +175,7 @@ extension Data {
         return value
     }
     
-    public func readString(at offset: inout Int, maxLength: Int = 255) -> String? {
+    func readString(at offset: inout Int, maxLength: Int = 255) -> String? {
         let length: Int
         
         if maxLength <= 255 {
@@ -139,7 +194,7 @@ extension Data {
         return String(data: stringData, encoding: .utf8)
     }
     
-    public func readData(at offset: inout Int, maxLength: Int = 65535) -> Data? {
+    func readData(at offset: inout Int, maxLength: Int = 65535) -> Data? {
         let length: Int
         
         if maxLength <= 255 {
@@ -158,12 +213,12 @@ extension Data {
         return data
     }
     
-    public func readDate(at offset: inout Int) -> Date? {
+    func readDate(at offset: inout Int) -> Date? {
         guard let timestamp = readUInt64(at: &offset) else { return nil }
         return Date(timeIntervalSince1970: Double(timestamp) / 1000.0)
     }
     
-    public func readUUID(at offset: inout Int) -> String? {
+    func readUUID(at offset: inout Int) -> String? {
         guard offset + 16 <= self.count else { return nil }
         
         let uuidData = self[offset..<offset + 16]
@@ -184,7 +239,7 @@ extension Data {
         return result.uppercased()
     }
     
-    public func readFixedBytes(at offset: inout Int, count: Int) -> Data? {
+    func readFixedBytes(at offset: inout Int, count: Int) -> Data? {
         guard offset + count <= self.count else { return nil }
         
         let data = self[offset..<offset + count]

bitchat/Protocols/BinaryProtocol.swift

@@ -88,31 +88,40 @@
 /// - Platform-optimized byte swapping
 ///
 
-import struct Foundation.Data
+import Foundation
-import class Foundation.NSData
+import BitLogger
-private import BitLogger
+
+extension Data {
+    func trimmingNullBytes() -> Data {
+        // Find the first null byte
+        if let nullIndex = self.firstIndex(of: 0) {
+            return self.prefix(nullIndex)
+        }
+        return self
+    }
+}
 
 /// Implements binary encoding and decoding for BitChat protocol messages.
 /// Provides static methods for converting between BitchatPacket objects and
 /// their binary wire format representation.
 /// - Note: All multi-byte values use network byte order (big-endian)
-public struct BinaryProtocol {
+struct BinaryProtocol {
-    public static let v1HeaderSize = 14
+    static let v1HeaderSize = 14
     static let v2HeaderSize = 16
-    public static let senderIDSize = 8
+    static let senderIDSize = 8
-    public static let recipientIDSize = 8
+    static let recipientIDSize = 8
-    public static let signatureSize = 64
+    static let signatureSize = 64
 
     // Field offsets within packet header
-    public struct Offsets {
+    struct Offsets {
         static let version = 0
         static let type = 1
         static let ttl = 2
         static let timestamp = 3
-        public static let flags = 11  // After version(1) + type(1) + ttl(1) + timestamp(8)
+        static let flags = 11  // After version(1) + type(1) + ttl(1) + timestamp(8)
     }
 
-    public static func headerSize(for version: UInt8) -> Int? {
+    static func headerSize(for version: UInt8) -> Int? {
         switch version {
         case 1: return v1HeaderSize
         case 2: return v2HeaderSize
@@ -124,11 +133,11 @@ public struct BinaryProtocol {
         return version == 2 ? 4 : 2
     }
     
-    public struct Flags {
+    struct Flags {
-        public static let hasRecipient: UInt8 = 0x01
+        static let hasRecipient: UInt8 = 0x01
-        public static let hasSignature: UInt8 = 0x02
+        static let hasSignature: UInt8 = 0x02
-        public static let isCompressed: UInt8 = 0x04
+        static let isCompressed: UInt8 = 0x04
-        public static let hasRoute: UInt8 = 0x08
+        static let hasRoute: UInt8 = 0x08
         static let isRSR: UInt8 = 0x10
     }
     
@@ -257,7 +266,7 @@ public struct BinaryProtocol {
     }
     
     // Decode binary data to BitchatPacket
-    public static func decode(_ data: Data) -> BitchatPacket? {
+    static func decode(_ data: Data) -> BitchatPacket? {
         // Try decode as-is first (robust when padding wasn't applied)
         if let pkt = decodeCore(data) { return pkt }
         // If that fails, try after removing padding
@@ -334,7 +343,6 @@ public struct BinaryProtocol {
             }
 
             guard payloadLength >= 0 else { return nil }
-            guard payloadLength <= FileTransferLimits.maxFramedFileBytes else { return nil }
 
             guard let senderID = readData(senderIDSize) else { return nil }
 

bitchat/Protocols/BitchatFilePacket.swift

@@ -7,7 +7,6 @@
 //
 
 import Foundation
-import BitFoundation
 import BitLogger
 
 /// TLV payload for Bluetooth mesh file transfers (voice notes, images, generic files).

bitchat/Protocols/BitchatProtocol.swift

@@ -60,7 +60,40 @@
 
 import Foundation
 import CoreBluetooth
-import BitFoundation
+
+// MARK: - Message Types
+
+/// Simplified BitChat protocol message types.
+/// Reduced from 24 types to just 6 essential ones.
+/// All private communication metadata (receipts, status) is embedded in noiseEncrypted payloads.
+enum MessageType: UInt8 {
+    // Public messages (unencrypted)
+    case announce = 0x01        // "I'm here" with nickname
+    case message = 0x02         // Public chat message  
+    case leave = 0x03           // "I'm leaving"
+    case requestSync = 0x21     // GCS filter-based sync request (local-only)
+    
+    // Noise encryption
+    case noiseHandshake = 0x10  // Handshake (init or response determined by payload)
+    case noiseEncrypted = 0x11  // All encrypted payloads (messages, receipts, etc.)
+    
+    // Fragmentation (simplified)
+    case fragment = 0x20        // Single fragment type for large messages
+    case fileTransfer = 0x22    // Binary file/audio/image payloads
+    
+    var description: String {
+        switch self {
+        case .announce: return "announce"
+        case .message: return "message"
+        case .leave: return "leave"
+        case .requestSync: return "requestSync"
+        case .noiseHandshake: return "noiseHandshake"
+        case .noiseEncrypted: return "noiseEncrypted"
+        case .fragment: return "fragment"
+        case .fileTransfer: return "fileTransfer"
+        }
+    }
+}
 
 // MARK: - Noise Payload Types
 
@@ -98,6 +131,35 @@ enum LazyHandshakeState {
     case failed(Error)         // Handshake failed
 }
 
+// MARK: - Delivery Status
+
+// Delivery status for messages
+enum DeliveryStatus: Codable, Equatable, Hashable {
+    case sending
+    case sent  // Left our device
+    case delivered(to: String, at: Date)  // Confirmed by recipient
+    case read(by: String, at: Date)  // Seen by recipient
+    case failed(reason: String)
+    case partiallyDelivered(reached: Int, total: Int)  // For rooms
+    
+    var displayText: String {
+        switch self {
+        case .sending:
+            return "Sending..."
+        case .sent:
+            return "Sent"
+        case .delivered(let nickname, _):
+            return "Delivered to \(nickname)"
+        case .read(let nickname, _):
+            return "Read by \(nickname)"
+        case .failed(let reason):
+            return "Failed: \(reason)"
+        case .partiallyDelivered(let reached, let total):
+            return "Delivered to \(reached)/\(total)"
+        }
+    }
+}
+
 // MARK: - Delegate Protocol
 
 protocol BitchatDelegate: AnyObject {

bitchat/Services/BLE/BLEAnnounceHandlingPolicy.swift

@@ -1,116 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEAnnouncePreflightAcceptance {
-    let announcement: AnnouncementPacket
-    let derivedPeerID: PeerID
-}
-
-enum BLEAnnouncePreflightRejection: Equatable {
-    case malformed
-    case senderMismatch(derivedPeerID: PeerID)
-    case selfAnnounce
-    case stale(ageSeconds: Double)
-}
-
-enum BLEAnnouncePreflightDecision {
-    case accept(BLEAnnouncePreflightAcceptance)
-    case reject(BLEAnnouncePreflightRejection)
-}
-
-enum BLEAnnouncePreflightPolicy {
-    static func evaluate(
-        packet: BitchatPacket,
-        from peerID: PeerID,
-        localPeerID: PeerID,
-        now: Date
-    ) -> BLEAnnouncePreflightDecision {
-        guard let announcement = AnnouncementPacket.decode(from: packet.payload) else {
-            return .reject(.malformed)
-        }
-
-        let derivedPeerID = PeerID(publicKey: announcement.noisePublicKey)
-        guard derivedPeerID == peerID else {
-            return .reject(.senderMismatch(derivedPeerID: derivedPeerID))
-        }
-
-        guard peerID != localPeerID else {
-            return .reject(.selfAnnounce)
-        }
-
-        guard !BLEPacketFreshnessPolicy.isStale(timestampMilliseconds: packet.timestamp, now: now) else {
-            return .reject(.stale(ageSeconds: BLEPacketFreshnessPolicy.ageSeconds(
-                timestampMilliseconds: packet.timestamp,
-                now: now
-            )))
-        }
-
-        return .accept(BLEAnnouncePreflightAcceptance(
-            announcement: announcement,
-            derivedPeerID: derivedPeerID
-        ))
-    }
-}
-
-enum BLEAnnounceTrustRejection: Equatable {
-    case missingSignature
-    case invalidSignature
-    case keyMismatch
-}
-
-enum BLEAnnounceTrustDecision: Equatable {
-    case verified
-    case reject(BLEAnnounceTrustRejection)
-
-    var isVerified: Bool {
-        self == .verified
-    }
-}
-
-enum BLEAnnounceTrustPolicy {
-    static func evaluate(
-        hasSignature: Bool,
-        signatureValid: Bool,
-        existingNoisePublicKey: Data?,
-        announcedNoisePublicKey: Data
-    ) -> BLEAnnounceTrustDecision {
-        if let existingNoisePublicKey, existingNoisePublicKey != announcedNoisePublicKey {
-            return .reject(.keyMismatch)
-        }
-
-        guard hasSignature else {
-            return .reject(.missingSignature)
-        }
-
-        guard signatureValid else {
-            return .reject(.invalidSignature)
-        }
-
-        return .verified
-    }
-}
-
-struct BLEAnnounceResponsePlan: Equatable {
-    let shouldNotifyPeerConnected: Bool
-    let shouldScheduleInitialSync: Bool
-    let shouldSendAnnounceBack: Bool
-    let shouldScheduleAfterglow: Bool
-}
-
-enum BLEAnnounceResponsePolicy {
-    static func plan(
-        isDirectAnnounce: Bool,
-        isNewPeer: Bool,
-        isReconnectedPeer: Bool,
-        shouldSendAnnounceBack: Bool
-    ) -> BLEAnnounceResponsePlan {
-        let shouldNotifyPeerConnected = isDirectAnnounce && (isNewPeer || isReconnectedPeer)
-
-        return BLEAnnounceResponsePlan(
-            shouldNotifyPeerConnected: shouldNotifyPeerConnected,
-            shouldScheduleInitialSync: shouldNotifyPeerConnected,
-            shouldSendAnnounceBack: shouldSendAnnounceBack,
-            shouldScheduleAfterglow: isNewPeer
-        )
-    }
-}

bitchat/Services/BLE/BLEAnnounceThrottle.swift

@@ -1,31 +0,0 @@
-import Foundation
-
-struct BLEAnnounceThrottle {
-    private var lastSent: Date
-    private let normalMinimumInterval: TimeInterval
-    private let forcedMinimumInterval: TimeInterval
-
-    init(
-        lastSent: Date = .distantPast,
-        normalMinimumInterval: TimeInterval = TransportConfig.bleAnnounceMinInterval,
-        forcedMinimumInterval: TimeInterval = TransportConfig.bleForceAnnounceMinIntervalSeconds
-    ) {
-        self.lastSent = lastSent
-        self.normalMinimumInterval = normalMinimumInterval
-        self.forcedMinimumInterval = forcedMinimumInterval
-    }
-
-    func elapsed(since now: Date) -> TimeInterval {
-        now.timeIntervalSince(lastSent)
-    }
-
-    mutating func shouldSend(force: Bool, now: Date) -> Bool {
-        let minimumInterval = force ? forcedMinimumInterval : normalMinimumInterval
-        guard elapsed(since: now) >= minimumInterval else {
-            return false
-        }
-
-        lastSent = now
-        return true
-    }
-}

bitchat/Services/BLE/BLEConnectionScheduler.swift

@@ -1,271 +0,0 @@
-import Foundation
-
-struct BLEConnectionCandidate<Peripheral> {
-    let peripheral: Peripheral
-    let peripheralID: String
-    let rssi: Int
-    let name: String
-    let isConnectable: Bool
-    let discoveredAt: Date
-}
-
-struct BLEExistingConnectionState {
-    let isConnecting: Bool
-    let isConnected: Bool
-    let lastConnectionAttempt: Date?
-}
-
-enum BLEPeripheralConnectionState {
-    case disconnected
-    case connecting
-    case connected
-}
-
-enum BLEDiscoveryDecision: Equatable {
-    case ignore
-    case queued
-    case scheduleRetry(after: TimeInterval)
-    case cancelStaleConnection
-    case connectNow
-}
-
-enum BLEConnectionQueueDecision<Peripheral> {
-    case none
-    case retryAfter(TimeInterval)
-    case connect(BLEConnectionCandidate<Peripheral>)
-}
-
-final class BLEConnectionScheduler<Peripheral> {
-    private let maxCentralLinks: Int
-    private let connectRateLimitInterval: TimeInterval
-    private let candidateCap: Int
-    private let weakLinkCooldownSeconds: TimeInterval
-    private let weakLinkRSSICutoff: Int
-    private let recentTimeoutWindowSeconds: TimeInterval
-    private let recentTimeoutCountThreshold: Int
-
-    private var lastGlobalConnectAttempt: Date = .distantPast
-    private var candidates: [BLEConnectionCandidate<Peripheral>] = []
-    private var failureCounts: [String: Int] = [:]
-    private var recentConnectTimeouts: [String: Date] = [:]
-    private var lastIsolatedAt: Date?
-
-    private let initialDynamicRSSIThreshold: Int
-    private(set) var dynamicRSSIThreshold: Int
-
-    var candidateCount: Int {
-        candidates.count
-    }
-
-    init(
-        maxCentralLinks: Int = TransportConfig.bleMaxCentralLinks,
-        connectRateLimitInterval: TimeInterval = TransportConfig.bleConnectRateLimitInterval,
-        candidateCap: Int = TransportConfig.bleConnectionCandidatesMax,
-        weakLinkCooldownSeconds: TimeInterval = TransportConfig.bleWeakLinkCooldownSeconds,
-        weakLinkRSSICutoff: Int = TransportConfig.bleWeakLinkRSSICutoff,
-        recentTimeoutWindowSeconds: TimeInterval = TransportConfig.bleRecentTimeoutWindowSeconds,
-        recentTimeoutCountThreshold: Int = TransportConfig.bleRecentTimeoutCountThreshold,
-        dynamicRSSIThreshold: Int = TransportConfig.bleDynamicRSSIThresholdDefault
-    ) {
-        self.maxCentralLinks = maxCentralLinks
-        self.connectRateLimitInterval = connectRateLimitInterval
-        self.candidateCap = candidateCap
-        self.weakLinkCooldownSeconds = weakLinkCooldownSeconds
-        self.weakLinkRSSICutoff = weakLinkRSSICutoff
-        self.recentTimeoutWindowSeconds = recentTimeoutWindowSeconds
-        self.recentTimeoutCountThreshold = recentTimeoutCountThreshold
-        self.initialDynamicRSSIThreshold = dynamicRSSIThreshold
-        self.dynamicRSSIThreshold = dynamicRSSIThreshold
-    }
-
-    func handleDiscovery(
-        _ candidate: BLEConnectionCandidate<Peripheral>,
-        connectedOrConnectingCount: Int,
-        existingState: BLEExistingConnectionState?,
-        peripheralState: BLEPeripheralConnectionState,
-        now: Date
-    ) -> BLEDiscoveryDecision {
-        guard candidate.isConnectable else { return .ignore }
-
-        if candidate.rssi <= dynamicRSSIThreshold {
-            enqueue(candidate)
-            return .queued
-        }
-
-        if connectedOrConnectingCount >= maxCentralLinks {
-            enqueue(candidate)
-            return .queued
-        }
-
-        if let retryDelay = rateLimitRetryDelay(now: now) {
-            enqueue(candidate)
-            return .scheduleRetry(after: retryDelay)
-        }
-
-        if let existingState {
-            if existingState.isConnected || existingState.isConnecting {
-                return .ignore
-            }
-
-            if let lastAttempt = existingState.lastConnectionAttempt,
-               now.timeIntervalSince(lastAttempt) < 2.0 {
-                return .ignore
-            }
-        }
-
-        if let lastTimeout = recentConnectTimeouts[candidate.peripheralID],
-           now.timeIntervalSince(lastTimeout) < 15 {
-            return .ignore
-        }
-
-        switch peripheralState {
-        case .disconnected:
-            return .connectNow
-        case .connecting, .connected:
-            return .cancelStaleConnection
-        }
-    }
-
-    func enqueue(_ candidate: BLEConnectionCandidate<Peripheral>) {
-        if let existingIndex = candidates.firstIndex(where: { $0.peripheralID == candidate.peripheralID }) {
-            candidates[existingIndex] = candidate
-        } else {
-            candidates.append(candidate)
-        }
-
-        candidates.sort {
-            if $0.rssi != $1.rssi { return $0.rssi > $1.rssi }
-            return $0.discoveredAt < $1.discoveredAt
-        }
-        if candidates.count > candidateCap {
-            candidates.removeLast(candidates.count - candidateCap)
-        }
-    }
-
-    func nextCandidate(
-        connectedOrConnectingCount: Int,
-        isAlreadyConnectingOrConnected: (String) -> Bool,
-        now: Date
-    ) -> BLEConnectionQueueDecision<Peripheral> {
-        guard connectedOrConnectingCount < maxCentralLinks else { return .none }
-
-        if let retryDelay = rateLimitRetryDelay(now: now) {
-            return .retryAfter(retryDelay)
-        }
-
-        while !candidates.isEmpty {
-            candidates.sort { score($0, now: now) > score($1, now: now) }
-            let candidate = candidates.removeFirst()
-            guard candidate.isConnectable else { continue }
-
-            if let delay = weakLinkRetryDelay(for: candidate, now: now) {
-                enqueue(candidate)
-                return .retryAfter(delay)
-            }
-
-            if isAlreadyConnectingOrConnected(candidate.peripheralID) {
-                continue
-            }
-
-            return .connect(candidate)
-        }
-
-        return .none
-    }
-
-    func recordConnectionAttempt(at now: Date) {
-        lastGlobalConnectAttempt = now
-    }
-
-    func recordConnectionSuccess(peripheralID: String) {
-        failureCounts[peripheralID] = 0
-        recentConnectTimeouts.removeValue(forKey: peripheralID)
-    }
-
-    func recordConnectionFailure(peripheralID: String) {
-        failureCounts[peripheralID, default: 0] += 1
-    }
-
-    func recordDisconnectError(peripheralID: String, at now: Date) {
-        recentConnectTimeouts[peripheralID] = now
-    }
-
-    func recordConnectionTimeout(peripheralID: String, at now: Date) {
-        recentConnectTimeouts[peripheralID] = now
-        recordConnectionFailure(peripheralID: peripheralID)
-    }
-
-    func pruneConnectionTimeouts(before cutoff: Date) {
-        recentConnectTimeouts = recentConnectTimeouts.filter { $0.value >= cutoff }
-    }
-
-    func reset() {
-        lastGlobalConnectAttempt = .distantPast
-        candidates.removeAll()
-        failureCounts.removeAll()
-        recentConnectTimeouts.removeAll()
-        lastIsolatedAt = nil
-        dynamicRSSIThreshold = initialDynamicRSSIThreshold
-    }
-
-    @discardableResult
-    func updateRSSIThreshold(
-        connectedCount: Int,
-        connectedOrConnectingLinkCount: Int,
-        now: Date
-    ) -> Int {
-        if connectedCount == 0 {
-            if lastIsolatedAt == nil { lastIsolatedAt = now }
-            let isolatedAt = lastIsolatedAt ?? now
-            let elapsed = now.timeIntervalSince(isolatedAt)
-            dynamicRSSIThreshold = elapsed > TransportConfig.bleIsolationRelaxThresholdSeconds
-                ? TransportConfig.bleRSSIIsolatedRelaxed
-                : TransportConfig.bleRSSIIsolatedBase
-            return dynamicRSSIThreshold
-        }
-
-        lastIsolatedAt = nil
-        var threshold = TransportConfig.bleDynamicRSSIThresholdDefault
-        if connectedOrConnectingLinkCount >= maxCentralLinks || candidates.count >= candidateCap {
-            threshold = TransportConfig.bleRSSIConnectedThreshold
-        }
-
-        let recentTimeouts = recentConnectTimeouts.filter {
-            now.timeIntervalSince($0.value) < recentTimeoutWindowSeconds
-        }.count
-        if recentTimeouts >= recentTimeoutCountThreshold {
-            threshold = max(threshold, TransportConfig.bleRSSIHighTimeoutThreshold)
-        }
-
-        dynamicRSSIThreshold = threshold
-        return threshold
-    }
-
-    private func rateLimitRetryDelay(now: Date) -> TimeInterval? {
-        let elapsed = now.timeIntervalSince(lastGlobalConnectAttempt)
-        guard elapsed < connectRateLimitInterval else { return nil }
-        return connectRateLimitInterval - elapsed + 0.05
-    }
-
-    private func weakLinkRetryDelay(
-        for candidate: BLEConnectionCandidate<Peripheral>,
-        now: Date
-    ) -> TimeInterval? {
-        guard let lastTimeout = recentConnectTimeouts[candidate.peripheralID] else { return nil }
-        let elapsed = now.timeIntervalSince(lastTimeout)
-        guard elapsed < weakLinkCooldownSeconds && candidate.rssi <= weakLinkRSSICutoff else { return nil }
-        let remaining = weakLinkCooldownSeconds - elapsed
-        return min(max(2.0, remaining), 15.0)
-    }
-
-    private func score(_ candidate: BLEConnectionCandidate<Peripheral>, now: Date) -> Int {
-        let failures = failureCounts[candidate.peripheralID] ?? 0
-        let penalty = min(20, 1 << min(4, failures))
-        let timeoutBias = recentConnectTimeouts[candidate.peripheralID].map {
-            now.timeIntervalSince($0) < 60 ? 10 : 0
-        } ?? 0
-        let base = (candidate.isConnectable ? 1000 : 0) + (candidate.rssi + 100) * 2
-        let recency = -Int(now.timeIntervalSince(candidate.discoveredAt) * 10)
-        return base + recency - penalty - timeoutBias
-    }
-}

bitchat/Services/BLE/BLEDirectedRelaySpool.swift

@@ -1,71 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEDirectedRelaySpoolEntry {
-    let recipient: PeerID
-    let packet: BitchatPacket
-}
-
-struct BLEDirectedRelaySpool {
-    private struct StoredPacket {
-        let packet: BitchatPacket
-        let enqueuedAt: Date
-    }
-
-    private var packetsByRecipient: [PeerID: [String: StoredPacket]] = [:]
-
-    var isEmpty: Bool {
-        packetsByRecipient.isEmpty
-    }
-
-    var count: Int {
-        packetsByRecipient.values.reduce(0) { $0 + $1.count }
-    }
-
-    @discardableResult
-    mutating func enqueue(
-        packet: BitchatPacket,
-        recipient: PeerID,
-        messageID: String,
-        enqueuedAt: Date
-    ) -> Bool {
-        var packets = packetsByRecipient[recipient] ?? [:]
-        guard packets[messageID] == nil else {
-            return false
-        }
-
-        packets[messageID] = StoredPacket(packet: packet, enqueuedAt: enqueuedAt)
-        packetsByRecipient[recipient] = packets
-        return true
-    }
-
-    mutating func drainUnexpired(now: Date, window: TimeInterval) -> [BLEDirectedRelaySpoolEntry] {
-        var entries: [BLEDirectedRelaySpoolEntry] = []
-
-        for (recipient, packets) in packetsByRecipient {
-            for stored in packets.values where now.timeIntervalSince(stored.enqueuedAt) <= window {
-                entries.append(BLEDirectedRelaySpoolEntry(recipient: recipient, packet: stored.packet))
-            }
-        }
-
-        packetsByRecipient.removeAll()
-        return entries
-    }
-
-    mutating func pruneExpired(now: Date, window: TimeInterval) {
-        guard !packetsByRecipient.isEmpty else { return }
-
-        var pruned: [PeerID: [String: StoredPacket]] = [:]
-        for (recipient, packets) in packetsByRecipient {
-            let freshPackets = packets.filter { now.timeIntervalSince($0.value.enqueuedAt) <= window }
-            if !freshPackets.isEmpty {
-                pruned[recipient] = freshPackets
-            }
-        }
-        packetsByRecipient = pruned
-    }
-
-    mutating func removeAll() {
-        packetsByRecipient.removeAll()
-    }
-}

bitchat/Services/BLE/BLEFanoutSelector.swift

@@ -1,109 +0,0 @@
-import BitFoundation
-import CryptoKit
-import Foundation
-
-struct BLEFanoutSelection: Equatable {
-    let peripheralIDs: Set<String>
-    let centralIDs: Set<String>
-}
-
-enum BLEFanoutSelector {
-    static func selectLinks(
-        peripheralIDs: [String],
-        centralIDs: [String],
-        ingressLink: BLEIngressLinkID?,
-        excludedLinks: Set<BLEIngressLinkID> = [],
-        directedPeerHint: PeerID?,
-        packetType: UInt8,
-        messageID: String
-    ) -> BLEFanoutSelection {
-        let allowed = allowedLinks(
-            peripheralIDs: peripheralIDs,
-            centralIDs: centralIDs,
-            ingressLink: ingressLink,
-            excludedLinks: excludedLinks
-        )
-
-        guard shouldSubset(packetType: packetType, directedPeerHint: directedPeerHint) else {
-            return BLEFanoutSelection(
-                peripheralIDs: Set(allowed.peripheralIDs),
-                centralIDs: Set(allowed.centralIDs)
-            )
-        }
-
-        return BLEFanoutSelection(
-            peripheralIDs: deterministicSubset(
-                ids: allowed.peripheralIDs,
-                k: subsetSize(for: allowed.peripheralIDs.count),
-                seed: messageID
-            ),
-            centralIDs: deterministicSubset(
-                ids: allowed.centralIDs,
-                k: subsetSize(for: allowed.centralIDs.count),
-                seed: messageID
-            )
-        )
-    }
-
-    private static func allowedLinks(
-        peripheralIDs: [String],
-        centralIDs: [String],
-        ingressLink: BLEIngressLinkID?,
-        excludedLinks: Set<BLEIngressLinkID>
-    ) -> (peripheralIDs: [String], centralIDs: [String]) {
-        var allowedPeripheralIDs = peripheralIDs
-        var allowedCentralIDs = centralIDs
-        var blockedLinks = excludedLinks
-
-        if let ingressLink {
-            blockedLinks.insert(ingressLink)
-        }
-
-        allowedPeripheralIDs.removeAll { blockedLinks.contains(.peripheral($0)) }
-        allowedCentralIDs.removeAll { blockedLinks.contains(.central($0)) }
-
-        return (allowedPeripheralIDs, allowedCentralIDs)
-    }
-
-    private static func shouldSubset(packetType: UInt8, directedPeerHint: PeerID?) -> Bool {
-        directedPeerHint == nil
-            && packetType != MessageType.fragment.rawValue
-            && packetType != MessageType.announce.rawValue
-            && packetType != MessageType.requestSync.rawValue
-    }
-
-    private static func subsetSize(for count: Int) -> Int {
-        guard count > 0 else { return 0 }
-        if count <= 2 { return count }
-
-        var value = count - 1
-        var bits = 0
-        while value > 0 {
-            value >>= 1
-            bits += 1
-        }
-        return min(count, max(1, bits + 1))
-    }
-
-    private static func deterministicSubset(ids: [String], k: Int, seed: String) -> Set<String> {
-        guard k > 0 && ids.count > k else { return Set(ids) }
-
-        var scored: [(score: [UInt8], id: String)] = []
-        for id in ids {
-            let data = (seed + "::" + id).data(using: .utf8) ?? Data()
-            let digest = Array(SHA256.hash(data: data))
-            scored.append((digest, id))
-        }
-
-        scored.sort { lhs, rhs in
-            for index in 0..<min(lhs.score.count, rhs.score.count) {
-                if lhs.score[index] != rhs.score[index] {
-                    return lhs.score[index] < rhs.score[index]
-                }
-            }
-            return lhs.id < rhs.id
-        }
-
-        return Set(scored.prefix(k).map(\.id))
-    }
-}

bitchat/Services/BLE/BLEFileTransferPolicy.swift

@@ -1,71 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEFileTransferDeliveryPlan: Equatable {
-    let isPrivateMessage: Bool
-    let shouldTrackForSync: Bool
-}
-
-enum BLEFileTransferPolicy {
-    static func isSelfEcho(packet: BitchatPacket, from peerID: PeerID, localPeerID: PeerID) -> Bool {
-        peerID == localPeerID && packet.ttl != 0
-    }
-
-    static func deliveryPlan(packet: BitchatPacket, localPeerID: PeerID) -> BLEFileTransferDeliveryPlan? {
-        guard let recipientID = packet.recipientID else {
-            return BLEFileTransferDeliveryPlan(isPrivateMessage: false, shouldTrackForSync: true)
-        }
-
-        let isBroadcast = recipientID.allSatisfy { $0 == 0xFF }
-        if isBroadcast {
-            return BLEFileTransferDeliveryPlan(isPrivateMessage: false, shouldTrackForSync: true)
-        }
-
-        guard PeerID(hexData: recipientID) == localPeerID else {
-            return nil
-        }
-
-        return BLEFileTransferDeliveryPlan(isPrivateMessage: true, shouldTrackForSync: false)
-    }
-}
-
-struct BLEIncomingFileAcceptance {
-    let filePacket: BitchatFilePacket
-    let mime: MimeType
-}
-
-enum BLEIncomingFileRejection: Error, Equatable {
-    case malformedPayload
-    case payloadTooLarge(bytes: Int)
-    case unsupportedMime(mimeType: String?, bytes: Int)
-    case magicMismatch(mime: MimeType, bytes: Int, prefixHex: String)
-}
-
-enum BLEIncomingFileValidator {
-    static func validate(payload: Data) -> Result<BLEIncomingFileAcceptance, BLEIncomingFileRejection> {
-        guard let filePacket = BitchatFilePacket.decode(payload) else {
-            return .failure(.malformedPayload)
-        }
-
-        guard FileTransferLimits.isValidPayload(filePacket.content.count) else {
-            return .failure(.payloadTooLarge(bytes: filePacket.content.count))
-        }
-
-        guard let mime = MimeType(filePacket.mimeType), mime.isAllowed else {
-            return .failure(.unsupportedMime(
-                mimeType: filePacket.mimeType,
-                bytes: filePacket.content.count
-            ))
-        }
-
-        guard mime.matches(data: filePacket.content) else {
-            return .failure(.magicMismatch(
-                mime: mime,
-                bytes: filePacket.content.count,
-                prefixHex: filePacket.content.prefix(20).map { String(format: "%02x", $0) }.joined(separator: " ")
-            ))
-        }
-
-        return .success(BLEIncomingFileAcceptance(filePacket: filePacket, mime: mime))
-    }
-}

bitchat/Services/BLE/BLEFragmentAssemblyBuffer.swift

@@ -1,153 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEFragmentKey: Hashable, Equatable {
-    let sender: UInt64
-    let id: UInt64
-}
-
-struct BLEFragmentHeader: Equatable {
-    let key: BLEFragmentKey
-    let index: Int
-    let total: Int
-    let originalType: UInt8
-    let fragmentData: Data
-    let isBroadcastFragment: Bool
-
-    var idLogString: String {
-        String(format: "%016llx", key.id)
-    }
-
-    init?(packet: BitchatPacket) {
-        // Minimum header: 8 bytes ID + 2 index + 2 total + 1 type.
-        guard packet.payload.count >= 13 else { return nil }
-
-        var senderU64: UInt64 = 0
-        for byte in packet.senderID.prefix(8) {
-            senderU64 = (senderU64 << 8) | UInt64(byte)
-        }
-
-        var fragmentU64: UInt64 = 0
-        for byte in packet.payload.prefix(8) {
-            fragmentU64 = (fragmentU64 << 8) | UInt64(byte)
-        }
-
-        let index = Int((UInt16(packet.payload[8]) << 8) | UInt16(packet.payload[9]))
-        let total = Int((UInt16(packet.payload[10]) << 8) | UInt16(packet.payload[11]))
-
-        guard total > 0 && total <= 10_000 && index >= 0 && index < total else {
-            return nil
-        }
-
-        let isBroadcastFragment: Bool = {
-            guard let recipient = packet.recipientID else { return true }
-            return recipient.count == 8 && recipient.allSatisfy { $0 == 0xFF }
-        }()
-
-        self.key = BLEFragmentKey(sender: senderU64, id: fragmentU64)
-        self.index = index
-        self.total = total
-        self.originalType = packet.payload[12]
-        self.fragmentData = Data(packet.payload.suffix(from: 13))
-        self.isBroadcastFragment = isBroadcastFragment
-    }
-}
-
-struct BLEFragmentAssemblyBuffer {
-    enum AppendResult: Equatable {
-        case stored(header: BLEFragmentHeader, started: Bool)
-        case complete(header: BLEFragmentHeader, reassembledData: Data, started: Bool)
-        case oversized(header: BLEFragmentHeader, projectedSize: Int, limit: Int, started: Bool)
-    }
-
-    private struct Metadata {
-        let type: UInt8
-        let total: Int
-        let timestamp: Date
-    }
-
-    private var fragmentsByKey: [BLEFragmentKey: [Int: Data]] = [:]
-    private var metadataByKey: [BLEFragmentKey: Metadata] = [:]
-
-    mutating func removeAll() {
-        fragmentsByKey.removeAll()
-        metadataByKey.removeAll()
-    }
-
-    @discardableResult
-    mutating func removeExpired(before cutoff: Date) -> Int {
-        let expiredKeys = metadataByKey
-            .filter { $0.value.timestamp < cutoff }
-            .map(\.key)
-
-        for key in expiredKeys {
-            fragmentsByKey.removeValue(forKey: key)
-            metadataByKey.removeValue(forKey: key)
-        }
-
-        return expiredKeys.count
-    }
-
-    mutating func append(
-        _ header: BLEFragmentHeader,
-        maxInFlightAssemblies: Int,
-        now: Date = Date()
-    ) -> AppendResult {
-        let started = startAssemblyIfNeeded(for: header, maxInFlightAssemblies: maxInFlightAssemblies, now: now)
-
-        let currentSize = fragmentsByKey[header.key]?.values.reduce(0) { $0 + $1.count } ?? 0
-        let limit = Self.assemblyLimit(for: header.originalType)
-        let projectedSize = currentSize + header.fragmentData.count
-
-        guard projectedSize <= limit else {
-            fragmentsByKey.removeValue(forKey: header.key)
-            metadataByKey.removeValue(forKey: header.key)
-            return .oversized(header: header, projectedSize: projectedSize, limit: limit, started: started)
-        }
-
-        fragmentsByKey[header.key]?[header.index] = header.fragmentData
-
-        guard let fragments = fragmentsByKey[header.key],
-              fragments.count == header.total else {
-            return .stored(header: header, started: started)
-        }
-
-        let reassembled = (0..<header.total).reduce(into: Data()) { data, index in
-            if let fragment = fragments[index] {
-                data.append(fragment)
-            }
-        }
-
-        fragmentsByKey.removeValue(forKey: header.key)
-        metadataByKey.removeValue(forKey: header.key)
-
-        return .complete(header: header, reassembledData: reassembled, started: started)
-    }
-
-    private mutating func startAssemblyIfNeeded(
-        for header: BLEFragmentHeader,
-        maxInFlightAssemblies: Int,
-        now: Date
-    ) -> Bool {
-        guard fragmentsByKey[header.key] == nil else { return false }
-
-        if fragmentsByKey.count >= maxInFlightAssemblies,
-           let oldest = metadataByKey.min(by: { $0.value.timestamp < $1.value.timestamp })?.key {
-            fragmentsByKey.removeValue(forKey: oldest)
-            metadataByKey.removeValue(forKey: oldest)
-        }
-
-        fragmentsByKey[header.key] = [:]
-        metadataByKey[header.key] = Metadata(type: header.originalType, total: header.total, timestamp: now)
-        return true
-    }
-
-    private static func assemblyLimit(for originalType: UInt8) -> Int {
-        if originalType == MessageType.fileTransfer.rawValue {
-            // Allow headroom for TLV metadata and binary framing overhead.
-            return FileTransferLimits.maxFramedFileBytes
-        }
-
-        return FileTransferLimits.maxPayloadBytes
-    }
-}

bitchat/Services/BLE/BLEInboundWriteBuffer.swift

@@ -1,70 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEInboundWriteChunk: Equatable {
-    let offset: Int
-    let data: Data
-}
-
-struct BLEInboundWriteAppendMetadata: Equatable {
-    let accumulatedBytes: Int
-    let appendedBytes: Int
-    let offsets: [Int]
-    let packetType: UInt8?
-}
-
-struct BLEInboundWriteBuffer {
-    enum AppendResult {
-        case decoded(packet: BitchatPacket, metadata: BLEInboundWriteAppendMetadata)
-        case waiting(metadata: BLEInboundWriteAppendMetadata)
-        case oversized(metadata: BLEInboundWriteAppendMetadata)
-    }
-
-    private var buffersByCentralID: [String: Data] = [:]
-
-    mutating func removeAll() {
-        buffersByCentralID.removeAll()
-    }
-
-    mutating func append(
-        chunks: [BLEInboundWriteChunk],
-        for centralID: String,
-        capBytes: Int
-    ) -> AppendResult {
-        var combined = buffersByCentralID[centralID] ?? Data()
-        var appendedBytes = 0
-        var offsets: [Int] = []
-
-        for chunk in chunks where !chunk.data.isEmpty {
-            offsets.append(chunk.offset)
-            let end = chunk.offset + chunk.data.count
-
-            if combined.count < end {
-                combined.append(Data(repeating: 0, count: end - combined.count))
-            }
-
-            combined.replaceSubrange(chunk.offset..<end, with: chunk.data)
-            appendedBytes += chunk.data.count
-        }
-
-        let metadata = BLEInboundWriteAppendMetadata(
-            accumulatedBytes: combined.count,
-            appendedBytes: appendedBytes,
-            offsets: offsets,
-            packetType: combined.count >= 2 ? combined[1] : nil
-        )
-
-        if let packet = BinaryProtocol.decode(combined) {
-            buffersByCentralID.removeValue(forKey: centralID)
-            return .decoded(packet: packet, metadata: metadata)
-        }
-
-        guard combined.count <= capBytes else {
-            buffersByCentralID.removeValue(forKey: centralID)
-            return .oversized(metadata: metadata)
-        }
-
-        buffersByCentralID[centralID] = combined
-        return .waiting(metadata: metadata)
-    }
-}

bitchat/Services/BLE/BLEIncomingFileStore.swift

@@ -1,168 +0,0 @@
-import BitLogger
-import BitFoundation
-import Foundation
-
-struct BLEIncomingFileStore {
-    private static let quotaBytes: Int64 = 100 * 1024 * 1024
-
-    private let fileManager: FileManager
-    private let baseDirectory: URL?
-    private let dateProvider: () -> Date
-
-    init(fileManager: FileManager = .default, baseDirectory: URL? = nil, dateProvider: @escaping () -> Date = Date.init) {
-        self.fileManager = fileManager
-        self.baseDirectory = baseDirectory
-        self.dateProvider = dateProvider
-    }
-
-    func save(
-        data: Data,
-        preferredName: String?,
-        subdirectory: String,
-        fallbackExtension: String?,
-        defaultPrefix: String
-    ) -> URL? {
-        do {
-            let base = try filesDirectory().appendingPathComponent(subdirectory, isDirectory: true)
-            try fileManager.createDirectory(at: base, withIntermediateDirectories: true, attributes: nil)
-            let sanitized = sanitizedFileName(
-                preferredName,
-                defaultName: "\(defaultPrefix)_\(Self.timestampString(from: dateProvider()))",
-                fallbackExtension: fallbackExtension
-            )
-            let destination = uniqueFileURL(in: base, fileName: sanitized)
-            try data.write(to: destination, options: .atomic)
-            return destination
-        } catch {
-            SecureLogger.error("❌ Failed to persist incoming media: \(error)", category: .session)
-            return nil
-        }
-    }
-
-    func enforceQuota(reservingBytes: Int) {
-        do {
-            let base = try filesDirectory()
-            let incomingDirs = [
-                base.appendingPathComponent("voicenotes/incoming", isDirectory: true),
-                base.appendingPathComponent("images/incoming", isDirectory: true),
-                base.appendingPathComponent("files/incoming", isDirectory: true)
-            ]
-            var allFiles: [(url: URL, size: Int64, modified: Date)] = []
-
-            for dir in incomingDirs where fileManager.fileExists(atPath: dir.path) {
-                guard let contents = try? fileManager.contentsOfDirectory(
-                    at: dir,
-                    includingPropertiesForKeys: [.fileSizeKey, .contentModificationDateKey],
-                    options: [.skipsHiddenFiles]
-                ) else { continue }
-
-                for fileURL in contents {
-                    guard let attrs = try? fileURL.resourceValues(forKeys: [.fileSizeKey, .contentModificationDateKey]),
-                          let size = attrs.fileSize,
-                          let modified = attrs.contentModificationDate else { continue }
-                    allFiles.append((url: fileURL, size: Int64(size), modified: modified))
-                }
-            }
-
-            let currentUsage = allFiles.reduce(0) { $0 + $1.size }
-            let targetUsage = Self.quotaBytes - Int64(reservingBytes)
-            guard currentUsage > targetUsage else { return }
-
-            let needToFree = currentUsage - targetUsage
-            var freedSpace: Int64 = 0
-            for file in allFiles.sorted(by: { $0.modified < $1.modified }) {
-                guard freedSpace < needToFree else { break }
-                do {
-                    try fileManager.removeItem(at: file.url)
-                    freedSpace += file.size
-                    SecureLogger.debug("🗑️ BCH-01-002: Deleted old incoming file to free space: \(file.url.lastPathComponent)", category: .security)
-                } catch {
-                    SecureLogger.warning("⚠️ Failed to delete old file for quota: \(error)", category: .security)
-                }
-            }
-
-            if freedSpace > 0 {
-                SecureLogger.info("📊 BCH-01-002: Freed \(ByteCountFormatter.string(fromByteCount: freedSpace, countStyle: .file)) to stay within incoming files quota", category: .security)
-            }
-        } catch {
-            SecureLogger.warning("⚠️ Could not enforce storage quota: \(error)", category: .security)
-        }
-    }
-
-    private func filesDirectory() throws -> URL {
-        let root = try baseDirectory ?? fileManager.url(
-            for: .applicationSupportDirectory,
-            in: .userDomainMask,
-            appropriateFor: nil,
-            create: true
-        )
-        let filesDir = root.appendingPathComponent("files", isDirectory: true)
-        try fileManager.createDirectory(at: filesDir, withIntermediateDirectories: true, attributes: nil)
-        return filesDir
-    }
-
-    private func sanitizedFileName(_ name: String?, defaultName: String, fallbackExtension: String?) -> String {
-        var candidate = (name ?? "")
-            .replacingOccurrences(of: "\0", with: "")
-            .precomposedStringWithCanonicalMapping
-            .replacingOccurrences(of: "/", with: "_")
-            .replacingOccurrences(of: "\\", with: "_")
-
-        let invalid = CharacterSet(charactersIn: "<>:\"|?*\0").union(.controlCharacters)
-        candidate = candidate.components(separatedBy: invalid).joined(separator: "_").trimmed
-        if candidate.isEmpty { candidate = defaultName }
-        if candidate.hasPrefix(".") { candidate = "_" + candidate }
-
-        if candidate.count > 120 {
-            let ext = (candidate as NSString).pathExtension
-            let base = (candidate as NSString).deletingPathExtension
-            candidate = ext.isEmpty
-                ? String(candidate.prefix(120))
-                : String(base.prefix(max(10, 120 - ext.count - 1))) + "." + ext
-        }
-
-        if let fallbackExtension, (candidate as NSString).pathExtension.isEmpty {
-            candidate += ".\(fallbackExtension)"
-        }
-
-        return candidate.isEmpty ? defaultName : candidate
-    }
-
-    private func uniqueFileURL(in directory: URL, fileName: String) -> URL {
-        let directoryPath = directory.standardizedFileURL.path
-        func isInsideDirectory(_ url: URL) -> Bool {
-            url.standardizedFileURL.path.hasPrefix(directoryPath + "/")
-        }
-
-        var candidate = directory.appendingPathComponent(fileName)
-        guard isInsideDirectory(candidate) else {
-            SecureLogger.warning("⚠️ Path traversal blocked: \(fileName)", category: .security)
-            return directory.appendingPathComponent("blocked_\(UUID().uuidString)")
-        }
-
-        if !fileManager.fileExists(atPath: candidate.path) {
-            return candidate
-        }
-
-        let baseName = (fileName as NSString).deletingPathExtension
-        let ext = (fileName as NSString).pathExtension
-        for counter in 1..<100 {
-            let newName = ext.isEmpty ? "\(baseName) (\(counter))" : "\(baseName) (\(counter)).\(ext)"
-            candidate = directory.appendingPathComponent(newName)
-            guard isInsideDirectory(candidate) else {
-                return directory.appendingPathComponent("blocked_\(UUID().uuidString)")
-            }
-            if !fileManager.fileExists(atPath: candidate.path) {
-                return candidate
-            }
-        }
-
-        return directory.appendingPathComponent("\(baseName)_\(UUID().uuidString).\(ext.isEmpty ? "dat" : ext)")
-    }
-
-    private static func timestampString(from date: Date) -> String {
-        let formatter = DateFormatter()
-        formatter.dateFormat = "yyyyMMdd_HHmmss"
-        return formatter.string(from: date)
-    }
-}

bitchat/Services/BLE/BLEIngressLinkRegistry.swift

@@ -1,108 +0,0 @@
-import BitFoundation
-import Foundation
-
-enum BLEIngressLinkID: Hashable, Equatable {
-    case peripheral(String)
-    case central(String)
-}
-
-struct BLEIngressPacketContext: Equatable {
-    let receivedFromPeerID: PeerID
-    let validationPeerID: PeerID
-}
-
-struct BLEIngressLinkRecord: Equatable {
-    let link: BLEIngressLinkID
-    let peerID: PeerID
-    let timestamp: Date
-}
-
-enum BLEIngressRejection: Error, Equatable {
-    case selfLoopback(packetType: UInt8)
-    case directSenderMismatch(boundPeerID: PeerID, claimedSenderID: PeerID)
-}
-
-struct BLEIngressLinkRegistry {
-    private var ingressByMessageID: [String: BLEIngressLinkRecord] = [:]
-
-    var isEmpty: Bool {
-        ingressByMessageID.isEmpty
-    }
-
-    mutating func removeAll() {
-        ingressByMessageID.removeAll()
-    }
-
-    func record(for packet: BitchatPacket) -> BLEIngressLinkRecord? {
-        ingressByMessageID[Self.messageID(for: packet)]
-    }
-
-    func link(for packet: BitchatPacket) -> BLEIngressLinkID? {
-        record(for: packet)?.link
-    }
-
-    func peerID(for packet: BitchatPacket) -> PeerID? {
-        record(for: packet)?.peerID
-    }
-
-    mutating func recordIfNew(
-        _ packet: BitchatPacket,
-        link: BLEIngressLinkID,
-        peerID: PeerID,
-        now: Date = Date(),
-        lifetime: TimeInterval
-    ) -> Bool {
-        let messageID = Self.messageID(for: packet)
-        if let existing = ingressByMessageID[messageID],
-           now.timeIntervalSince(existing.timestamp) <= lifetime {
-            return false
-        }
-
-        ingressByMessageID[messageID] = BLEIngressLinkRecord(link: link, peerID: peerID, timestamp: now)
-        return true
-    }
-
-    mutating func prune(before cutoff: Date) {
-        ingressByMessageID = ingressByMessageID.filter { $0.value.timestamp >= cutoff }
-    }
-
-    static func packetContext(
-        for packet: BitchatPacket,
-        claimedSenderID: PeerID,
-        boundPeerID: PeerID?,
-        localPeerID: PeerID,
-        directAnnounceTTL: UInt8
-    ) -> Result<BLEIngressPacketContext, BLEIngressRejection> {
-        if claimedSenderID == localPeerID,
-           !isSelfAuthoredSyncResponse(packet) {
-            return .failure(.selfLoopback(packetType: packet.type))
-        }
-
-        if let boundPeerID,
-           boundPeerID != claimedSenderID,
-           requiresDirectSenderBinding(packet, directAnnounceTTL: directAnnounceTTL) {
-            return .failure(.directSenderMismatch(boundPeerID: boundPeerID, claimedSenderID: claimedSenderID))
-        }
-
-        let receivedFromPeerID = boundPeerID ?? claimedSenderID
-        let validationPeerID = packet.isRSR ? receivedFromPeerID : claimedSenderID
-        return .success(BLEIngressPacketContext(
-            receivedFromPeerID: receivedFromPeerID,
-            validationPeerID: validationPeerID
-        ))
-    }
-
-    static func messageID(for packet: BitchatPacket) -> String {
-        let senderID = packet.senderID.hexEncodedString()
-        let digestPrefix = packet.payload.sha256Hash().prefix(4).hexEncodedString()
-        return "\(senderID)-\(packet.timestamp)-\(packet.type)-\(digestPrefix)"
-    }
-
-    private static func requiresDirectSenderBinding(_ packet: BitchatPacket, directAnnounceTTL: UInt8) -> Bool {
-        packet.type == MessageType.announce.rawValue && packet.ttl == directAnnounceTTL
-    }
-
-    private static func isSelfAuthoredSyncResponse(_ packet: BitchatPacket) -> Bool {
-        packet.isRSR && packet.ttl == 0
-    }
-}

bitchat/Services/BLE/BLEIngressPacketGuard.swift

@@ -1,76 +0,0 @@
-import BitFoundation
-import Foundation
-
-enum BLEIngressPacketGuard {
-    enum Rejection: Error, Equatable {
-        case selfLoopback(packetType: UInt8)
-        case directSenderMismatch(boundPeerID: PeerID, claimedSenderID: PeerID)
-        case invalidRSR(peerID: PeerID)
-        case timestampSkew(peerID: PeerID, skewMs: UInt64, maxSkewMs: UInt64)
-    }
-
-    static func evaluate(
-        packet: BitchatPacket,
-        claimedSenderID: PeerID,
-        boundPeerID: PeerID?,
-        localPeerID: PeerID,
-        directAnnounceTTL: UInt8,
-        nowMs: UInt64 = UInt64(Date().timeIntervalSince1970 * 1000),
-        maxTimestampSkewMs: UInt64 = 120_000,
-        isValidSyncResponse: (PeerID) -> Bool
-    ) -> Result<BLEIngressPacketContext, Rejection> {
-        let contextResult = BLEIngressLinkRegistry.packetContext(
-            for: packet,
-            claimedSenderID: claimedSenderID,
-            boundPeerID: boundPeerID,
-            localPeerID: localPeerID,
-            directAnnounceTTL: directAnnounceTTL
-        )
-
-        let context: BLEIngressPacketContext
-        switch contextResult {
-        case .success(let acceptedContext):
-            context = acceptedContext
-        case .failure(.selfLoopback(let packetType)):
-            return .failure(.selfLoopback(packetType: packetType))
-        case .failure(.directSenderMismatch(let boundPeerID, let claimedSenderID)):
-            return .failure(.directSenderMismatch(boundPeerID: boundPeerID, claimedSenderID: claimedSenderID))
-        }
-
-        switch validatePayload(
-            packet,
-            from: context.validationPeerID,
-            nowMs: nowMs,
-            maxTimestampSkewMs: maxTimestampSkewMs,
-            isValidSyncResponse: isValidSyncResponse
-        ) {
-        case .success:
-            return .success(context)
-        case .failure(let rejection):
-            return .failure(rejection)
-        }
-    }
-
-    static func validatePayload(
-        _ packet: BitchatPacket,
-        from peerID: PeerID,
-        nowMs: UInt64 = UInt64(Date().timeIntervalSince1970 * 1000),
-        maxTimestampSkewMs: UInt64 = 120_000,
-        isValidSyncResponse: (PeerID) -> Bool
-    ) -> Result<Void, Rejection> {
-        if packet.isRSR {
-            guard isValidSyncResponse(peerID) else {
-                return .failure(.invalidRSR(peerID: peerID))
-            }
-            return .success(())
-        }
-
-        let packetTime = packet.timestamp
-        let skew = packetTime > nowMs ? packetTime - nowMs : nowMs - packetTime
-        guard skew <= maxTimestampSkewMs else {
-            return .failure(.timestampSkew(peerID: peerID, skewMs: skew, maxSkewMs: maxTimestampSkewMs))
-        }
-
-        return .success(())
-    }
-}

bitchat/Services/BLE/BLELinkStateStore.swift

@@ -1,196 +0,0 @@
-import BitFoundation
-import CoreBluetooth
-import Foundation
-
-struct BLEPeripheralLinkState {
-    let peripheral: CBPeripheral
-    var characteristic: CBCharacteristic?
-    var peerID: PeerID?
-    var isConnecting: Bool
-    var isConnected: Bool
-    var lastConnectionAttempt: Date?
-    var assembler: NotificationStreamAssembler
-}
-
-struct BLEDirectLinkState: Equatable {
-    let hasPeripheral: Bool
-    let hasCentral: Bool
-}
-
-struct BLESubscribedCentralSnapshot {
-    let centrals: [CBCentral]
-    let peerIDsByCentralUUID: [String: PeerID]
-
-    func central(for peerID: PeerID) -> CBCentral? {
-        centrals.first { peerIDsByCentralUUID[$0.identifier.uuidString] == peerID }
-    }
-}
-
-final class BLELinkStateStore {
-    private(set) var peripherals: [String: BLEPeripheralLinkState] = [:]
-    private(set) var peerToPeripheralUUID: [PeerID: String] = [:]
-    private(set) var subscribedCentrals: [CBCentral] = []
-    private(set) var centralToPeerID: [String: PeerID] = [:]
-
-    var peripheralStates: [BLEPeripheralLinkState] {
-        Array(peripherals.values)
-    }
-
-    var subscribedCentralSnapshot: BLESubscribedCentralSnapshot {
-        BLESubscribedCentralSnapshot(
-            centrals: subscribedCentrals,
-            peerIDsByCentralUUID: centralToPeerID
-        )
-    }
-
-    var subscribedCentralCount: Int {
-        subscribedCentrals.count
-    }
-
-    var connectedOrConnectingPeripheralCount: Int {
-        peripherals.values.filter { $0.isConnected || $0.isConnecting }.count
-    }
-
-    func state(forPeripheralID peripheralID: String) -> BLEPeripheralLinkState? {
-        peripherals[peripheralID]
-    }
-
-    func setPeripheralState(_ state: BLEPeripheralLinkState, for peripheralID: String) {
-        peripherals[peripheralID] = state
-    }
-
-    @discardableResult
-    func updatePeripheral(
-        _ peripheralID: String,
-        _ update: (inout BLEPeripheralLinkState) -> Void
-    ) -> BLEPeripheralLinkState? {
-        guard var state = peripherals[peripheralID] else { return nil }
-        update(&state)
-        peripherals[peripheralID] = state
-        return state
-    }
-
-    func beginConnecting(to peripheral: CBPeripheral, at date: Date) {
-        setPeripheralState(
-            BLEPeripheralLinkState(
-                peripheral: peripheral,
-                characteristic: nil,
-                peerID: nil,
-                isConnecting: true,
-                isConnected: false,
-                lastConnectionAttempt: date,
-                assembler: NotificationStreamAssembler()
-            ),
-            for: peripheral.identifier.uuidString
-        )
-    }
-
-    func markConnected(_ peripheral: CBPeripheral) {
-        let peripheralID = peripheral.identifier.uuidString
-        if updatePeripheral(peripheralID, {
-            $0.isConnecting = false
-            $0.isConnected = true
-        }) == nil {
-            setPeripheralState(
-                BLEPeripheralLinkState(
-                    peripheral: peripheral,
-                    characteristic: nil,
-                    peerID: nil,
-                    isConnecting: false,
-                    isConnected: true,
-                    lastConnectionAttempt: nil,
-                    assembler: NotificationStreamAssembler()
-                ),
-                for: peripheralID
-            )
-        }
-    }
-
-    func updateCharacteristic(_ characteristic: CBCharacteristic, forPeripheralID peripheralID: String) {
-        updatePeripheral(peripheralID) {
-            $0.characteristic = characteristic
-        }
-    }
-
-    func directPeripheralState(for peerID: PeerID) -> BLEPeripheralLinkState? {
-        peerToPeripheralUUID[peerID].flatMap { peripherals[$0] }
-    }
-
-    func directLinkState(for peerID: PeerID) -> BLEDirectLinkState {
-        let peripheralUUID = peerToPeripheralUUID[peerID]
-        let hasPeripheral = peripheralUUID.flatMap { peripherals[$0]?.isConnected } ?? false
-        let hasCentral = centralToPeerID.values.contains(peerID)
-        return BLEDirectLinkState(hasPeripheral: hasPeripheral, hasCentral: hasCentral)
-    }
-
-    func links(to peerID: PeerID?) -> Set<BLEIngressLinkID> {
-        guard let peerID else { return [] }
-
-        var links: Set<BLEIngressLinkID> = []
-        if let peripheralUUID = peerToPeripheralUUID[peerID] {
-            links.insert(.peripheral(peripheralUUID))
-        }
-        for (centralUUID, mappedPeerID) in centralToPeerID where mappedPeerID == peerID {
-            links.insert(.central(centralUUID))
-        }
-        return links
-    }
-
-    func peerID(forPeripheralID peripheralID: String) -> PeerID? {
-        peripherals[peripheralID]?.peerID
-    }
-
-    func peerID(forCentralUUID centralUUID: String) -> PeerID? {
-        centralToPeerID[centralUUID]
-    }
-
-    func addSubscribedCentral(_ central: CBCentral) {
-        guard !subscribedCentrals.contains(central) else { return }
-        subscribedCentrals.append(central)
-    }
-
-    func removeSubscribedCentral(_ central: CBCentral) -> PeerID? {
-        let centralUUID = central.identifier.uuidString
-        subscribedCentrals.removeAll { $0.identifier == central.identifier }
-        return centralToPeerID.removeValue(forKey: centralUUID)
-    }
-
-    func bindCentral(_ centralUUID: String, to peerID: PeerID) {
-        centralToPeerID[centralUUID] = peerID
-    }
-
-    func bindPeripheral(_ peripheralUUID: String, to peerID: PeerID) {
-        if updatePeripheral(peripheralUUID, { $0.peerID = peerID }) != nil {
-            peerToPeripheralUUID[peerID] = peripheralUUID
-        }
-    }
-
-    func removePeripheral(_ peripheralID: String) -> PeerID? {
-        let peerID = peripherals.removeValue(forKey: peripheralID)?.peerID
-        if let peerID {
-            peerToPeripheralUUID.removeValue(forKey: peerID)
-        }
-        return peerID
-    }
-
-    func clearPeripherals() -> [PeerID] {
-        let peerIDs = peripherals.compactMap { $0.value.peerID }
-        peripherals.removeAll()
-        peerToPeripheralUUID.removeAll()
-        return peerIDs
-    }
-
-    func clearCentrals() -> [PeerID] {
-        let peerIDs = Array(centralToPeerID.values)
-        subscribedCentrals.removeAll()
-        centralToPeerID.removeAll()
-        return peerIDs
-    }
-
-    func clearAll() {
-        peripherals.removeAll()
-        peerToPeripheralUUID.removeAll()
-        subscribedCentrals.removeAll()
-        centralToPeerID.removeAll()
-    }
-}

bitchat/Services/BLE/BLELogRateLimiter.swift

@@ -1,33 +0,0 @@
-import Foundation
-
-final class BLELogRateLimiter {
-    private let defaultMinimumInterval: TimeInterval
-    private let queue = DispatchQueue(label: "chat.bitchat.ble.log-rate-limiter")
-    private var lastLogTimeByKey: [String: Date] = [:]
-
-    init(defaultMinimumInterval: TimeInterval) {
-        self.defaultMinimumInterval = defaultMinimumInterval
-    }
-
-    func shouldLog(
-        key: String,
-        now: Date = Date(),
-        minimumInterval: TimeInterval? = nil
-    ) -> Bool {
-        queue.sync {
-            let interval = minimumInterval ?? defaultMinimumInterval
-            if let lastLogTime = lastLogTimeByKey[key],
-               now.timeIntervalSince(lastLogTime) < interval {
-                return false
-            }
-            lastLogTimeByKey[key] = now
-            return true
-        }
-    }
-
-    func removeAll() {
-        queue.sync {
-            lastLogTimeByKey.removeAll()
-        }
-    }
-}

bitchat/Services/BLE/BLEMaintenancePolicy.swift

@@ -1,62 +0,0 @@
-import Foundation
-
-struct BLEMaintenancePlan: Equatable {
-    let shouldSendAnnounce: Bool
-    let shouldEnsureAdvertising: Bool
-    let shouldRunCleanup: Bool
-    let shouldFlushDirectedSpool: Bool
-    let shouldResetCounter: Bool
-}
-
-enum BLEMaintenancePolicy {
-    static func plan(
-        cycle: Int,
-        connectedCount: Int,
-        peerRegistryIsEmpty: Bool,
-        elapsedSinceLastAnnounce: TimeInterval,
-        hasRecentTraffic: Bool,
-        connectedAnnounceJitterOffset: TimeInterval? = nil,
-        highDegreeThreshold: Int = TransportConfig.bleHighDegreeThreshold
-    ) -> BLEMaintenancePlan {
-        BLEMaintenancePlan(
-            shouldSendAnnounce: shouldSendAnnounce(
-                connectedCount: connectedCount,
-                elapsedSinceLastAnnounce: elapsedSinceLastAnnounce,
-                hasRecentTraffic: hasRecentTraffic,
-                connectedAnnounceJitterOffset: connectedAnnounceJitterOffset,
-                highDegreeThreshold: highDegreeThreshold
-            ),
-            shouldEnsureAdvertising: peerRegistryIsEmpty,
-            shouldRunCleanup: cycle.isMultiple(of: 3),
-            shouldFlushDirectedSpool: !cycle.isMultiple(of: 2),
-            shouldResetCounter: cycle >= 6
-        )
-    }
-
-    static func shouldSendAnnounce(
-        connectedCount: Int,
-        elapsedSinceLastAnnounce: TimeInterval,
-        hasRecentTraffic: Bool,
-        connectedAnnounceJitterOffset: TimeInterval? = nil,
-        highDegreeThreshold: Int = TransportConfig.bleHighDegreeThreshold
-    ) -> Bool {
-        if hasRecentTraffic && elapsedSinceLastAnnounce >= 10.0 {
-            return true
-        }
-
-        guard connectedCount > 0 else {
-            return elapsedSinceLastAnnounce >= TransportConfig.bleAnnounceIntervalSeconds
-        }
-
-        let highDegree = connectedCount >= highDegreeThreshold
-        let base = highDegree ?
-            TransportConfig.bleConnectedAnnounceBaseSecondsDense :
-            TransportConfig.bleConnectedAnnounceBaseSecondsSparse
-        let jitter = highDegree ?
-            TransportConfig.bleConnectedAnnounceJitterDense :
-            TransportConfig.bleConnectedAnnounceJitterSparse
-        let jitterOffset = connectedAnnounceJitterOffset ?? Double.random(in: -jitter...jitter)
-
-        return elapsedSinceLastAnnounce >= base + jitterOffset
-    }
-}

bitchat/Services/BLE/BLENoisePayloadFactory.swift

@@ -1,25 +0,0 @@
-import Foundation
-
-enum BLENoisePayloadFactory {
-    static func privateMessage(content: String, messageID: String) -> Data? {
-        guard let payload = PrivateMessagePacket(messageID: messageID, content: content).encode() else {
-            return nil
-        }
-
-        return typedPayload(.privateMessage, payload: payload)
-    }
-
-    static func readReceipt(originalMessageID: String) -> Data {
-        typedPayload(.readReceipt, payload: Data(originalMessageID.utf8))
-    }
-
-    static func delivered(messageID: String) -> Data {
-        typedPayload(.delivered, payload: Data(messageID.utf8))
-    }
-
-    static func typedPayload(_ type: NoisePayloadType, payload: Data) -> Data {
-        var typed = Data([type.rawValue])
-        typed.append(payload)
-        return typed
-    }
-}

bitchat/Services/BLE/BLENoiseSessionQueues.swift

@@ -1,46 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEPendingPrivateMessage: Equatable {
-    let content: String
-    let messageID: String
-}
-
-struct BLENoiseSessionQueues {
-    private var privateMessagesByPeerID: [PeerID: [BLEPendingPrivateMessage]] = [:]
-    private var typedPayloadsByPeerID: [PeerID: [Data]] = [:]
-
-    var isEmpty: Bool {
-        privateMessagesByPeerID.isEmpty && typedPayloadsByPeerID.isEmpty
-    }
-
-    mutating func removeAll() {
-        privateMessagesByPeerID.removeAll()
-        typedPayloadsByPeerID.removeAll()
-    }
-
-    mutating func appendPrivateMessage(content: String, messageID: String, for peerID: PeerID) {
-        privateMessagesByPeerID[peerID, default: []].append(BLEPendingPrivateMessage(content: content, messageID: messageID))
-    }
-
-    mutating func takePrivateMessages(for peerID: PeerID) -> [BLEPendingPrivateMessage] {
-        let messages = privateMessagesByPeerID[peerID] ?? []
-        privateMessagesByPeerID.removeValue(forKey: peerID)
-        return messages
-    }
-
-    mutating func prependPrivateMessages(_ messages: [BLEPendingPrivateMessage], for peerID: PeerID) {
-        guard !messages.isEmpty else { return }
-        privateMessagesByPeerID[peerID, default: []].insert(contentsOf: messages, at: 0)
-    }
-
-    mutating func appendTypedPayload(_ payload: Data, for peerID: PeerID) {
-        typedPayloadsByPeerID[peerID, default: []].append(payload)
-    }
-
-    mutating func takeTypedPayloads(for peerID: PeerID) -> [Data] {
-        let payloads = typedPayloadsByPeerID[peerID] ?? []
-        typedPayloadsByPeerID.removeValue(forKey: peerID)
-        return payloads
-    }
-}

bitchat/Services/BLE/BLEOutboundFragmentPlanner.swift

@@ -1,137 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEOutboundFragmentPlan {
-    let fragmentPackets: [BitchatPacket]
-    let fragmentVersion: UInt8
-    let chunkSize: Int
-    let spacingMs: Int
-
-    var totalFragments: Int {
-        fragmentPackets.count
-    }
-
-    var shouldPauseScanning: Bool {
-        totalFragments > 4
-    }
-}
-
-enum BLEOutboundFragmentPlanner {
-    private static let minimumChunkSize = 64
-    private static let fragmentIDLength = 8
-
-    static func makePlan(
-        for request: BLEOutboundFragmentTransferRequest,
-        defaultChunkSize: Int,
-        bleMaxMTU: Int,
-        fragmentID: Data = randomFragmentID()
-    ) -> BLEOutboundFragmentPlan? {
-        guard fragmentID.count == fragmentIDLength,
-              let fullData = request.packet.toBinaryData(padding: request.pad) else {
-            return nil
-        }
-
-        let sizing = sizingPolicy(
-            for: request.packet,
-            requestedMaxChunk: request.maxChunk,
-            defaultChunkSize: defaultChunkSize,
-            bleMaxMTU: bleMaxMTU
-        )
-
-        let chunks = stride(from: 0, to: fullData.count, by: sizing.chunkSize).map { offset in
-            Data(fullData[offset..<min(offset + sizing.chunkSize, fullData.count)])
-        }
-
-        guard !chunks.isEmpty else { return nil }
-
-        let fragmentRecipient: Data? = {
-            if let directedPeer = request.directedPeer {
-                return Data(hexString: directedPeer.id)
-            }
-            return request.packet.recipientID
-        }()
-
-        let fragmentPackets = chunks.enumerated().map { index, chunk in
-            makeFragmentPacket(
-                original: request.packet,
-                fragmentID: fragmentID,
-                index: index,
-                total: chunks.count,
-                fragmentData: chunk,
-                fragmentRecipient: fragmentRecipient,
-                fragmentVersion: sizing.fragmentVersion
-            )
-        }
-
-        return BLEOutboundFragmentPlan(
-            fragmentPackets: fragmentPackets,
-            fragmentVersion: sizing.fragmentVersion,
-            chunkSize: sizing.chunkSize,
-            spacingMs: spacingMs(for: request)
-        )
-    }
-
-    private static func sizingPolicy(
-        for packet: BitchatPacket,
-        requestedMaxChunk: Int?,
-        defaultChunkSize: Int,
-        bleMaxMTU: Int
-    ) -> (fragmentVersion: UInt8, chunkSize: Int) {
-        var fragmentVersion: UInt8 = 1
-        var calculatedChunk = defaultChunkSize
-
-        if let route = packet.route, !route.isEmpty {
-            fragmentVersion = 2
-            let routeSize = 1 + (route.count * 8)
-            let overhead = 16 + 8 + 8 + routeSize + 13 + 16
-            calculatedChunk = max(minimumChunkSize, bleMaxMTU - overhead)
-        }
-
-        return (
-            fragmentVersion: fragmentVersion,
-            chunkSize: max(minimumChunkSize, requestedMaxChunk ?? calculatedChunk)
-        )
-    }
-
-    private static func makeFragmentPacket(
-        original packet: BitchatPacket,
-        fragmentID: Data,
-        index: Int,
-        total: Int,
-        fragmentData: Data,
-        fragmentRecipient: Data?,
-        fragmentVersion: UInt8
-    ) -> BitchatPacket {
-        var payload = Data()
-        payload.append(fragmentID)
-        payload.append(contentsOf: withUnsafeBytes(of: UInt16(index).bigEndian) { Data($0) })
-        payload.append(contentsOf: withUnsafeBytes(of: UInt16(total).bigEndian) { Data($0) })
-        payload.append(packet.type)
-        payload.append(fragmentData)
-
-        return BitchatPacket(
-            type: MessageType.fragment.rawValue,
-            senderID: packet.senderID,
-            recipientID: fragmentRecipient,
-            timestamp: packet.timestamp,
-            payload: payload,
-            signature: nil,
-            ttl: packet.ttl,
-            version: fragmentVersion,
-            route: packet.route,
-            isRSR: packet.isRSR
-        )
-    }
-
-    private static func spacingMs(for request: BLEOutboundFragmentTransferRequest) -> Int {
-        if request.directedPeer != nil || request.packet.recipientID != nil {
-            return TransportConfig.bleFragmentSpacingDirectedMs
-        }
-
-        return TransportConfig.bleFragmentSpacingMs
-    }
-
-    private static func randomFragmentID() -> Data {
-        Data((0..<fragmentIDLength).map { _ in UInt8.random(in: 0...255) })
-    }
-}

bitchat/Services/BLE/BLEOutboundFragmentTransferScheduler.swift

@@ -1,181 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEOutboundFragmentTransferRequest {
-    let packet: BitchatPacket
-    let pad: Bool
-    let maxChunk: Int?
-    let directedPeer: PeerID?
-    let transferId: String?
-
-    var resolvedTransferId: String? {
-        guard packet.type == MessageType.fileTransfer.rawValue else { return nil }
-        return transferId ?? packet.payload.sha256Hex()
-    }
-}
-
-struct BLEOutboundFragmentTransferScheduler {
-    enum QueuePosition {
-        case front
-        case back
-    }
-
-    enum SubmitResult {
-        case start(request: BLEOutboundFragmentTransferRequest, reservedTransferId: String?)
-        case queued(request: BLEOutboundFragmentTransferRequest, transferId: String?, position: QueuePosition)
-    }
-
-    enum CancelResult {
-        case active(transferId: String, workItems: [DispatchWorkItem])
-        case pending(transferId: String)
-        case missing
-    }
-
-    enum SentResult: Equatable {
-        case progress(sentFragments: Int, totalFragments: Int)
-        case complete(sentFragments: Int, totalFragments: Int)
-        case missing
-    }
-
-    private struct ActiveTransferState {
-        let totalFragments: Int
-        var sentFragments: Int
-        var workItems: [DispatchWorkItem]
-    }
-
-    private var activeTransfers: [String: ActiveTransferState] = [:]
-    private var pendingTransfers: [BLEOutboundFragmentTransferRequest] = []
-
-    var activeCount: Int {
-        activeTransfers.count
-    }
-
-    var pendingCount: Int {
-        pendingTransfers.count
-    }
-
-    mutating func removeAll() -> [(id: String, workItems: [DispatchWorkItem])] {
-        let active = activeTransfers.map { ($0.key, $0.value.workItems) }
-        activeTransfers.removeAll()
-        pendingTransfers.removeAll()
-        return active
-    }
-
-    mutating func submit(
-        _ request: BLEOutboundFragmentTransferRequest,
-        maxConcurrentTransfers: Int
-    ) -> SubmitResult {
-        guard let transferId = request.resolvedTransferId else {
-            return .start(request: request, reservedTransferId: nil)
-        }
-
-        guard activeTransfers.count < maxConcurrentTransfers else {
-            pendingTransfers.append(request)
-            return .queued(request: request, transferId: transferId, position: .back)
-        }
-
-        guard activeTransfers[transferId] == nil else {
-            pendingTransfers.insert(request, at: 0)
-            return .queued(request: request, transferId: transferId, position: .front)
-        }
-
-        activeTransfers[transferId] = ActiveTransferState(totalFragments: 0, sentFragments: 0, workItems: [])
-        return .start(request: request, reservedTransferId: transferId)
-    }
-
-    mutating func activateReservedTransfer(
-        id transferId: String,
-        totalFragments: Int,
-        workItems: [DispatchWorkItem]
-    ) -> Bool {
-        guard activeTransfers[transferId] != nil else { return false }
-        activeTransfers[transferId] = ActiveTransferState(
-            totalFragments: totalFragments,
-            sentFragments: 0,
-            workItems: workItems
-        )
-        return true
-    }
-
-    mutating func updateWorkItems(_ workItems: [DispatchWorkItem], for transferId: String) -> Bool {
-        guard var state = activeTransfers[transferId] else { return false }
-        state.workItems = workItems
-        activeTransfers[transferId] = state
-        return true
-    }
-
-    mutating func releaseReservation(_ transferId: String) -> [DispatchWorkItem]? {
-        activeTransfers.removeValue(forKey: transferId)?.workItems
-    }
-
-    func isActive(_ transferId: String) -> Bool {
-        activeTransfers[transferId] != nil
-    }
-
-    mutating func cancelTransfer(_ transferId: String) -> CancelResult {
-        if let active = activeTransfers.removeValue(forKey: transferId) {
-            return .active(transferId: transferId, workItems: active.workItems)
-        }
-
-        if let pendingIndex = pendingTransfers.firstIndex(where: { $0.resolvedTransferId == transferId || $0.transferId == transferId }) {
-            pendingTransfers.remove(at: pendingIndex)
-            return .pending(transferId: transferId)
-        }
-
-        return .missing
-    }
-
-    mutating func markFragmentSent(transferId: String) -> SentResult {
-        guard var state = activeTransfers[transferId] else { return .missing }
-
-        state.sentFragments = min(state.sentFragments + 1, state.totalFragments)
-        let isComplete = state.sentFragments >= state.totalFragments
-
-        if isComplete {
-            activeTransfers.removeValue(forKey: transferId)
-            return .complete(sentFragments: state.sentFragments, totalFragments: state.totalFragments)
-        }
-
-        activeTransfers[transferId] = state
-        return .progress(sentFragments: state.sentFragments, totalFragments: state.totalFragments)
-    }
-
-    mutating func reservePendingStarts(maxConcurrentTransfers: Int) -> [SubmitResult] {
-        var availableSlots = max(0, maxConcurrentTransfers - activeTransfers.count)
-        guard availableSlots > 0, !pendingTransfers.isEmpty else { return [] }
-
-        var results: [SubmitResult] = []
-        var blockedFront: [BLEOutboundFragmentTransferRequest] = []
-
-        while availableSlots > 0, !pendingTransfers.isEmpty {
-            let request = pendingTransfers.removeFirst()
-            availableSlots -= 1
-
-            guard let transferId = request.resolvedTransferId else {
-                results.append(.start(request: request, reservedTransferId: nil))
-                continue
-            }
-
-            guard activeTransfers.count < maxConcurrentTransfers else {
-                pendingTransfers.insert(request, at: 0)
-                results.append(.queued(request: request, transferId: transferId, position: .front))
-                break
-            }
-
-            guard activeTransfers[transferId] == nil else {
-                blockedFront.append(request)
-                results.append(.queued(request: request, transferId: transferId, position: .front))
-                continue
-            }
-
-            activeTransfers[transferId] = ActiveTransferState(totalFragments: 0, sentFragments: 0, workItems: [])
-            results.append(.start(request: request, reservedTransferId: transferId))
-        }
-
-        if !blockedFront.isEmpty {
-            pendingTransfers.insert(contentsOf: blockedFront, at: 0)
-        }
-
-        return results
-    }
-}

bitchat/Services/BLE/BLEOutboundLinkPlanner.swift

@@ -1,87 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEOutboundLinkPlan: Equatable {
-    let directedPeerHint: PeerID?
-    let fragmentChunkSize: Int?
-    let selectedLinks: BLEFanoutSelection
-    let shouldSpoolDirectedPacket: Bool
-}
-
-enum BLEOutboundLinkPlanner {
-    static func plan(
-        packet: BitchatPacket,
-        dataCount: Int,
-        peripheralIDs: [String],
-        peripheralWriteLimits: [Int],
-        centralIDs: [String],
-        centralNotifyLimits: [Int],
-        ingressRecord: BLEIngressLinkRecord?,
-        excludedLinks: Set<BLEIngressLinkID>,
-        directedOnlyPeer: PeerID?
-    ) -> BLEOutboundLinkPlan {
-        if let minLimit = minimumLinkLimit(
-            peripheralWriteLimits: peripheralWriteLimits,
-            centralNotifyLimits: centralNotifyLimits
-        ), packet.type != MessageType.fragment.rawValue,
-           dataCount > minLimit {
-            return BLEOutboundLinkPlan(
-                directedPeerHint: directedPeerHint(for: packet, explicitPeer: directedOnlyPeer),
-                fragmentChunkSize: BLEOutboundPacketPolicy.fragmentChunkSize(forLinkLimit: minLimit),
-                selectedLinks: BLEFanoutSelection(peripheralIDs: [], centralIDs: []),
-                shouldSpoolDirectedPacket: false
-            )
-        }
-
-        let directedPeerHint = directedPeerHint(for: packet, explicitPeer: directedOnlyPeer)
-        let selectedLinks = BLEFanoutSelector.selectLinks(
-            peripheralIDs: peripheralIDs,
-            centralIDs: centralIDs,
-            ingressLink: ingressRecord?.link,
-            excludedLinks: excludedLinks,
-            directedPeerHint: directedPeerHint,
-            packetType: packet.type,
-            messageID: BLEOutboundPacketPolicy.messageID(for: packet)
-        )
-
-        return BLEOutboundLinkPlan(
-            directedPeerHint: directedPeerHint,
-            fragmentChunkSize: nil,
-            selectedLinks: selectedLinks,
-            shouldSpoolDirectedPacket: shouldSpoolDirectedPacket(
-                directedPeerHint: directedPeerHint,
-                selectedLinks: selectedLinks,
-                packetType: packet.type
-            )
-        )
-    }
-
-    static func directedPeerHint(for packet: BitchatPacket, explicitPeer: PeerID?) -> PeerID? {
-        if let explicitPeer { return explicitPeer }
-        if let recipient = PeerID(str: packet.recipientID?.hexEncodedString()), !recipient.isEmpty {
-            return recipient
-        }
-        return nil
-    }
-
-    static func minimumLinkLimit(peripheralWriteLimits: [Int], centralNotifyLimits: [Int]) -> Int? {
-        [peripheralWriteLimits.min(), centralNotifyLimits.min()]
-            .compactMap { $0 }
-            .min()
-    }
-
-    static func shouldSpoolDirectedPacket(
-        directedPeerHint: PeerID?,
-        selectedLinks: BLEFanoutSelection,
-        packetType: UInt8
-    ) -> Bool {
-        guard directedPeerHint != nil,
-              selectedLinks.peripheralIDs.isEmpty,
-              selectedLinks.centralIDs.isEmpty else {
-            return false
-        }
-
-        return packetType == MessageType.noiseEncrypted.rawValue ||
-            packetType == MessageType.noiseHandshake.rawValue
-    }
-}

bitchat/Services/BLE/BLEOutboundNotificationBuffer.swift

@@ -1,47 +0,0 @@
-import Foundation
-
-struct BLEPendingNotification<Target> {
-    let data: Data
-    let targets: [Target]?
-}
-
-struct BLEOutboundNotificationBuffer<Target> {
-    enum EnqueueResult {
-        case enqueued(count: Int)
-        case full(count: Int)
-    }
-
-    private var notifications: [BLEPendingNotification<Target>] = []
-
-    var count: Int {
-        notifications.count
-    }
-
-    var isEmpty: Bool {
-        notifications.isEmpty
-    }
-
-    mutating func removeAll() {
-        notifications.removeAll()
-    }
-
-    mutating func enqueue(data: Data, targets: [Target]?, capCount: Int) -> EnqueueResult {
-        guard notifications.count < capCount else {
-            return .full(count: notifications.count)
-        }
-
-        notifications.append(BLEPendingNotification(data: data, targets: targets))
-        return .enqueued(count: notifications.count)
-    }
-
-    mutating func takeAll() -> [BLEPendingNotification<Target>] {
-        let pending = notifications
-        notifications.removeAll()
-        return pending
-    }
-
-    mutating func prepend(_ pending: [BLEPendingNotification<Target>]) {
-        guard !pending.isEmpty else { return }
-        notifications.insert(contentsOf: pending, at: 0)
-    }
-}

bitchat/Services/BLE/BLEOutboundPacketPolicy.swift

@@ -1,43 +0,0 @@
-import BitFoundation
-import Foundation
-
-enum BLEOutboundPacketPolicy {
-    private static let fragmentFrameOverhead = 13 + 8 + 8 + 13
-
-    static func messageID(for packet: BitchatPacket) -> String {
-        BLEIngressLinkRegistry.messageID(for: packet)
-    }
-
-    static func padsBLEFrame(for packetType: UInt8) -> Bool {
-        switch MessageType(rawValue: packetType) {
-        case .noiseEncrypted, .noiseHandshake:
-            return true
-        case .none, .announce, .message, .leave, .requestSync, .fragment, .fileTransfer:
-            return false
-        }
-    }
-
-    static func priority(for packet: BitchatPacket, data: Data) -> BLEOutboundWritePriority {
-        guard let messageType = MessageType(rawValue: packet.type) else { return .low }
-        switch messageType {
-        case .fragment:
-            return .fragment(totalFragments: fragmentTotalCount(from: packet.payload))
-        case .fileTransfer:
-            return .fileTransfer
-        default:
-            return .high
-        }
-    }
-
-    static func fragmentChunkSize(forLinkLimit limit: Int) -> Int {
-        max(64, limit - fragmentFrameOverhead)
-    }
-
-    private static func fragmentTotalCount(from payload: Data) -> Int {
-        guard payload.count >= 12 else { return Int(UInt16.max) }
-        let totalHigh = Int(payload[10])
-        let totalLow = Int(payload[11])
-        let total = (totalHigh << 8) | totalLow
-        return max(total, 1)
-    }
-}

bitchat/Services/BLE/BLEOutboundWriteBuffer.swift

@@ -1,83 +0,0 @@
-import Foundation
-
-struct BLEOutboundWritePriority: Comparable {
-    let level: Int
-    let suborder: Int
-
-    static let high = BLEOutboundWritePriority(level: 0, suborder: 0)
-
-    static func fragment(totalFragments: Int) -> BLEOutboundWritePriority {
-        BLEOutboundWritePriority(level: 1, suborder: max(1, min(totalFragments, Int(UInt16.max))))
-    }
-
-    static let fileTransfer = BLEOutboundWritePriority(level: 2, suborder: Int.max - 1)
-    static let low = BLEOutboundWritePriority(level: 2, suborder: Int.max)
-
-    static func < (lhs: BLEOutboundWritePriority, rhs: BLEOutboundWritePriority) -> Bool {
-        if lhs.level != rhs.level { return lhs.level < rhs.level }
-        return lhs.suborder < rhs.suborder
-    }
-}
-
-struct BLEPendingWrite {
-    let priority: BLEOutboundWritePriority
-    let data: Data
-}
-
-struct BLEOutboundWriteBuffer {
-    enum EnqueueResult {
-        case enqueued(trimmedBytes: Int, remainingBytes: Int)
-        case oversized(bytes: Int)
-    }
-
-    private var writesByPeripheralID: [String: [BLEPendingWrite]] = [:]
-
-    var peripheralIDs: [String] {
-        Array(writesByPeripheralID.keys)
-    }
-
-    mutating func removeAll() {
-        writesByPeripheralID.removeAll()
-    }
-
-    mutating func enqueue(
-        data: Data,
-        for peripheralID: String,
-        priority: BLEOutboundWritePriority,
-        capBytes: Int
-    ) -> EnqueueResult {
-        guard data.count <= capBytes else {
-            return .oversized(bytes: data.count)
-        }
-
-        var queue = writesByPeripheralID[peripheralID] ?? []
-        let item = BLEPendingWrite(priority: priority, data: data)
-        let insertIndex = queue.firstIndex { item.priority < $0.priority } ?? queue.count
-        queue.insert(item, at: insertIndex)
-
-        var total = queue.reduce(0) { $0 + $1.data.count }
-        var trimmedBytes = 0
-
-        while total > capBytes && !queue.isEmpty {
-            let removed = queue.removeLast()
-            trimmedBytes += removed.data.count
-            total -= removed.data.count
-        }
-
-        writesByPeripheralID[peripheralID] = queue.isEmpty ? nil : queue
-        return .enqueued(trimmedBytes: trimmedBytes, remainingBytes: total)
-    }
-
-    mutating func takeAll(for peripheralID: String) -> [BLEPendingWrite] {
-        let items = writesByPeripheralID[peripheralID] ?? []
-        writesByPeripheralID[peripheralID] = nil
-        return items
-    }
-
-    mutating func prepend(_ items: [BLEPendingWrite], for peripheralID: String) {
-        guard !items.isEmpty else { return }
-        var existing = writesByPeripheralID[peripheralID] ?? []
-        existing.insert(contentsOf: items, at: 0)
-        writesByPeripheralID[peripheralID] = existing
-    }
-}

bitchat/Services/BLE/BLEPacketFreshnessPolicy.swift

@@ -1,27 +0,0 @@
-import Foundation
-
-enum BLEPacketFreshnessPolicy {
-    static let defaultMaxAgeSeconds: TimeInterval = 900
-
-    static func isBroadcastRecipient(_ recipientID: Data?) -> Bool {
-        guard let recipientID else { return true }
-        return recipientID.count == 8 && recipientID.allSatisfy { $0 == 0xFF }
-    }
-
-    static func isStale(
-        timestampMilliseconds: UInt64,
-        now: Date,
-        maxAgeSeconds: TimeInterval = defaultMaxAgeSeconds
-    ) -> Bool {
-        let nowMilliseconds = UInt64(now.timeIntervalSince1970 * 1000)
-        let maxAgeMilliseconds = UInt64(maxAgeSeconds * 1000)
-        guard nowMilliseconds >= maxAgeMilliseconds else { return false }
-        return timestampMilliseconds < nowMilliseconds - maxAgeMilliseconds
-    }
-
-    static func ageSeconds(timestampMilliseconds: UInt64, now: Date) -> Double {
-        let nowMilliseconds = UInt64(now.timeIntervalSince1970 * 1000)
-        guard nowMilliseconds >= timestampMilliseconds else { return 0 }
-        return Double(nowMilliseconds - timestampMilliseconds) / 1000.0
-    }
-}

bitchat/Services/BLE/BLEPeerEventDebouncer.swift

@@ -1,25 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEPeerEventDebouncer {
-    private var lastEmitByPeer: [PeerID: Date] = [:]
-
-    var count: Int {
-        lastEmitByPeer.count
-    }
-
-    @discardableResult
-    mutating func shouldEmit(peerID: PeerID, now: Date, minimumInterval: TimeInterval) -> Bool {
-        if let lastEmit = lastEmitByPeer[peerID],
-           now.timeIntervalSince(lastEmit) < minimumInterval {
-            return false
-        }
-
-        lastEmitByPeer[peerID] = now
-        return true
-    }
-
-    mutating func removeAll() {
-        lastEmitByPeer.removeAll()
-    }
-}

bitchat/Services/BLE/BLEPeerPublishCoalescer.swift

@@ -1,43 +0,0 @@
-import Foundation
-
-enum BLEPeerPublishDecision: Equatable {
-    case publishNow
-    case schedule(delay: TimeInterval)
-    case skip
-}
-
-struct BLEPeerPublishCoalescer {
-    private var lastPublishAt: Date
-    private var publishPending: Bool
-    private let minimumInterval: TimeInterval
-
-    init(
-        lastPublishAt: Date = .distantPast,
-        publishPending: Bool = false,
-        minimumInterval: TimeInterval = 0.1
-    ) {
-        self.lastPublishAt = lastPublishAt
-        self.publishPending = publishPending
-        self.minimumInterval = minimumInterval
-    }
-
-    mutating func requestPublish(now: Date) -> BLEPeerPublishDecision {
-        let elapsed = now.timeIntervalSince(lastPublishAt)
-        if elapsed >= minimumInterval {
-            lastPublishAt = now
-            return .publishNow
-        }
-
-        guard !publishPending else {
-            return .skip
-        }
-
-        publishPending = true
-        return .schedule(delay: minimumInterval - elapsed)
-    }
-
-    mutating func scheduledPublishFired(now: Date) {
-        lastPublishAt = now
-        publishPending = false
-    }
-}

bitchat/Services/BLE/BLEPeerRegistry.swift

@@ -1,211 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEPeerInfo: Equatable {
-    let peerID: PeerID
-    var nickname: String
-    var isConnected: Bool
-    var noisePublicKey: Data?
-    var signingPublicKey: Data?
-    var isVerifiedNickname: Bool
-    var lastSeen: Date
-}
-
-struct BLEPeerAnnounceUpdate: Equatable {
-    let isNewPeer: Bool
-    let wasDisconnected: Bool
-    let previousNickname: String?
-}
-
-struct BLEPeerLinkPresence: Equatable {
-    var hasPeripheral: Bool
-    var hasCentral: Bool
-}
-
-struct BLERemovedPeer: Equatable {
-    let peerID: PeerID
-    let nickname: String
-}
-
-struct BLEPeerConnectivityChanges: Equatable {
-    var disconnectedPeerIDs: [PeerID] = []
-    var removedPeers: [BLERemovedPeer] = []
-}
-
-struct BLEPeerRegistry {
-    private var peers: [PeerID: BLEPeerInfo] = [:]
-
-    var isEmpty: Bool {
-        peers.isEmpty
-    }
-
-    var count: Int {
-        peers.count
-    }
-
-    var peerIDs: [PeerID] {
-        Array(peers.keys)
-    }
-
-    var connectedCount: Int {
-        peers.values.filter(\.isConnected).count
-    }
-
-    var connectedPeerIDs: [PeerID] {
-        peers.values.compactMap { $0.isConnected ? $0.peerID : nil }
-    }
-
-    var connectedRoutingData: [Data] {
-        peers.values.filter(\.isConnected).compactMap { $0.peerID.routingData }
-    }
-
-    var snapshotByID: [PeerID: BLEPeerInfo] {
-        peers
-    }
-
-    mutating func removeAll() {
-        peers.removeAll()
-    }
-
-    func info(for peerID: PeerID) -> BLEPeerInfo? {
-        peers[peerID]
-    }
-
-    mutating func upsert(_ info: BLEPeerInfo) {
-        peers[info.peerID] = info
-    }
-
-    @discardableResult
-    mutating func remove(_ peerID: PeerID) -> BLEPeerInfo? {
-        peers.removeValue(forKey: peerID)
-    }
-
-    func isConnected(_ peerID: PeerID) -> Bool {
-        peers[peerID.toShort()]?.isConnected ?? false
-    }
-
-    func isReachable(_ peerID: PeerID, now: Date) -> Bool {
-        let shortID = peerID.toShort()
-        let meshAttached = connectedCount > 0
-        guard let info = peers[shortID] else { return false }
-        if info.isConnected { return true }
-        guard meshAttached else { return false }
-
-        let retention: TimeInterval = info.isVerifiedNickname
-            ? TransportConfig.bleReachabilityRetentionVerifiedSeconds
-            : TransportConfig.bleReachabilityRetentionUnverifiedSeconds
-        return now.timeIntervalSince(info.lastSeen) <= retention
-    }
-
-    func nickname(for peerID: PeerID, connectedOnly: Bool) -> String? {
-        guard let peer = peers[peerID] else { return nil }
-        if connectedOnly && !peer.isConnected { return nil }
-        return peer.nickname
-    }
-
-    func fingerprint(for peerID: PeerID) -> String? {
-        peers[peerID]?.noisePublicKey?.sha256Fingerprint()
-    }
-
-    func displayNicknames(selfNickname: String) -> [PeerID: String] {
-        let connected = peers.filter { $0.value.isConnected }
-        let tuples = connected.map { ($0.key, $0.value.nickname, true) }
-        return PeerDisplayNameResolver.resolve(tuples, selfNickname: selfNickname)
-    }
-
-    func transportSnapshots(selfNickname: String) -> [TransportPeerSnapshot] {
-        let snapshot = Array(peers.values)
-        let resolvedNames = PeerDisplayNameResolver.resolve(
-            snapshot.map { ($0.peerID, $0.nickname, $0.isConnected) },
-            selfNickname: selfNickname
-        )
-        return snapshot.map { info in
-            TransportPeerSnapshot(
-                peerID: info.peerID,
-                nickname: resolvedNames[info.peerID] ?? info.nickname,
-                isConnected: info.isConnected,
-                noisePublicKey: info.noisePublicKey,
-                lastSeen: info.lastSeen
-            )
-        }
-    }
-
-    func collisionResolvedNickname(for peerID: PeerID, selfNickname: String) -> String? {
-        guard let info = peers[peerID], info.isVerifiedNickname else { return nil }
-        let hasCollision = peers.values.contains {
-            $0.isConnected && $0.nickname == info.nickname && $0.peerID != peerID
-        } || selfNickname == info.nickname
-        return hasCollision ? info.nickname + "#" + String(peerID.id.prefix(4)) : info.nickname
-    }
-
-    mutating func markDisconnected(_ peerID: PeerID) {
-        guard var info = peers[peerID] else { return }
-        info.isConnected = false
-        peers[peerID] = info
-    }
-
-    mutating func updateLastSeen(_ peerID: PeerID, at date: Date) {
-        guard var peer = peers[peerID] else { return }
-        peer.lastSeen = date
-        peers[peerID] = peer
-    }
-
-    mutating func upsertVerifiedAnnounce(
-        peerID: PeerID,
-        nickname: String,
-        noisePublicKey: Data,
-        signingPublicKey: Data?,
-        isConnected: Bool,
-        now: Date
-    ) -> BLEPeerAnnounceUpdate {
-        let existing = peers[peerID]
-        let update = BLEPeerAnnounceUpdate(
-            isNewPeer: existing == nil,
-            wasDisconnected: existing?.isConnected == false,
-            previousNickname: existing?.nickname
-        )
-
-        peers[peerID] = BLEPeerInfo(
-            peerID: existing?.peerID ?? peerID,
-            nickname: nickname,
-            isConnected: isConnected,
-            noisePublicKey: noisePublicKey,
-            signingPublicKey: signingPublicKey,
-            isVerifiedNickname: true,
-            lastSeen: now
-        )
-
-        return update
-    }
-
-    mutating func reconcileConnectivity(
-        now: Date,
-        linkStates: [PeerID: BLEPeerLinkPresence]
-    ) -> BLEPeerConnectivityChanges {
-        var changes = BLEPeerConnectivityChanges()
-
-        for (peerID, peer) in Array(peers) {
-            let age = now.timeIntervalSince(peer.lastSeen)
-            let retention: TimeInterval = peer.isVerifiedNickname
-                ? TransportConfig.bleReachabilityRetentionVerifiedSeconds
-                : TransportConfig.bleReachabilityRetentionUnverifiedSeconds
-
-            if peer.isConnected && age > TransportConfig.blePeerInactivityTimeoutSeconds {
-                let state = linkStates[peerID] ?? BLEPeerLinkPresence(hasPeripheral: false, hasCentral: false)
-                if !state.hasPeripheral && !state.hasCentral {
-                    var updated = peer
-                    updated.isConnected = false
-                    peers[peerID] = updated
-                    changes.disconnectedPeerIDs.append(peerID)
-                }
-            }
-
-            if !peer.isConnected && age > retention {
-                peers.removeValue(forKey: peerID)
-                changes.removedPeers.append(BLERemovedPeer(peerID: peerID, nickname: peer.nickname))
-            }
-        }
-
-        return changes
-    }
-}

bitchat/Services/BLE/BLEPeerSenderDisplayName.swift

@@ -1,60 +0,0 @@
-import BitFoundation
-import Foundation
-
-enum BLEPeerSenderDisplayName {
-    static func resolveKnownPeer(
-        peerID: PeerID,
-        localPeerID: PeerID,
-        localNickname: String,
-        peers: [PeerID: BLEPeerInfo],
-        allowConnectedUnverified: Bool
-    ) -> String? {
-        if peerID == localPeerID {
-            return localNickname
-        }
-
-        guard let info = peers[peerID] else { return nil }
-
-        if info.isVerifiedNickname {
-            return collisionResolvedName(
-                displayName: info.nickname,
-                collisionNickname: info.nickname,
-                peerID: peerID,
-                localNickname: localNickname,
-                peers: peers
-            )
-        }
-
-        if allowConnectedUnverified, info.isConnected {
-            let displayName = info.nickname.isEmpty ? anonymousNickname(for: peerID) : info.nickname
-            return collisionResolvedName(
-                displayName: displayName,
-                collisionNickname: info.nickname,
-                peerID: peerID,
-                localNickname: localNickname,
-                peers: peers
-            )
-        }
-
-        return nil
-    }
-
-    static func anonymousNickname(for peerID: PeerID) -> String {
-        "anon" + String(peerID.id.prefix(4))
-    }
-
-    private static func collisionResolvedName(
-        displayName: String,
-        collisionNickname: String,
-        peerID: PeerID,
-        localNickname: String,
-        peers: [PeerID: BLEPeerInfo]
-    ) -> String {
-        let hasCollision = peers.values.contains {
-            $0.isConnected && $0.nickname == collisionNickname && $0.peerID != peerID
-        } || localNickname == collisionNickname
-
-        guard hasCollision else { return displayName }
-        return displayName + "#" + String(peerID.id.prefix(4))
-    }
-}

bitchat/Services/BLE/BLEPublicMessagePolicy.swift

@@ -1,42 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEPublicMessageAcceptance: Equatable {
-    let shouldTrackForSync: Bool
-}
-
-enum BLEPublicMessageRejection: Equatable {
-    case selfEcho
-    case staleBroadcast(ageSeconds: Double)
-}
-
-enum BLEPublicMessageDecision: Equatable {
-    case accept(BLEPublicMessageAcceptance)
-    case reject(BLEPublicMessageRejection)
-}
-
-enum BLEPublicMessagePolicy {
-    static func evaluate(
-        packet: BitchatPacket,
-        from peerID: PeerID,
-        localPeerID: PeerID,
-        now: Date
-    ) -> BLEPublicMessageDecision {
-        if peerID == localPeerID && packet.ttl != 0 {
-            return .reject(.selfEcho)
-        }
-
-        let isBroadcast = BLEPacketFreshnessPolicy.isBroadcastRecipient(packet.recipientID)
-        if isBroadcast,
-           BLEPacketFreshnessPolicy.isStale(timestampMilliseconds: packet.timestamp, now: now) {
-            return .reject(.staleBroadcast(ageSeconds: BLEPacketFreshnessPolicy.ageSeconds(
-                timestampMilliseconds: packet.timestamp,
-                now: now
-            )))
-        }
-
-        return .accept(BLEPublicMessageAcceptance(
-            shouldTrackForSync: isBroadcast && packet.type == MessageType.message.rawValue
-        ))
-    }
-}

bitchat/Services/BLE/BLEReceivePipeline.swift

@@ -1,84 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLEReceivedPacketContext: Equatable {
-    let senderID: PeerID
-    let messageID: String
-    let messageType: MessageType?
-    let shouldDeduplicate: Bool
-    let logsHandlingDetails: Bool
-}
-
-struct BLEReceivePipeline {
-    static func context(for packet: BitchatPacket, localPeerID: PeerID) -> BLEReceivedPacketContext {
-        let senderID = PeerID(hexData: packet.senderID)
-        let messageID = "\(senderID)-\(packet.timestamp)-\(packet.type)"
-        let messageType = MessageType(rawValue: packet.type)
-        let allowSelfSyncReplay = packet.ttl == 0 && senderID == localPeerID
-        let shouldDeduplicate = messageType != .fragment && !allowSelfSyncReplay
-
-        return BLEReceivedPacketContext(
-            senderID: senderID,
-            messageID: messageID,
-            messageType: messageType,
-            shouldDeduplicate: shouldDeduplicate,
-            logsHandlingDetails: messageType != .announce
-        )
-    }
-
-    static func shouldCancelScheduledRelayForDuplicate(connectedPeerCount: Int) -> Bool {
-        connectedPeerCount > 2
-    }
-
-    static func relayDecision(
-        for packet: BitchatPacket,
-        senderID: PeerID,
-        localPeerID: PeerID,
-        degree: Int,
-        highDegreeThreshold: Int
-    ) -> RelayDecision {
-        RelayController.decide(
-            ttl: packet.ttl,
-            senderIsSelf: senderID == localPeerID,
-            recipientIsSelf: PeerID(hexData: packet.recipientID) == localPeerID,
-            isEncrypted: packet.type == MessageType.noiseEncrypted.rawValue,
-            isDirectedEncrypted: packet.type == MessageType.noiseEncrypted.rawValue && packet.recipientID != nil,
-            isFragment: packet.type == MessageType.fragment.rawValue,
-            isDirectedFragment: packet.type == MessageType.fragment.rawValue && packet.recipientID != nil,
-            isHandshake: packet.type == MessageType.noiseHandshake.rawValue,
-            isAnnounce: packet.type == MessageType.announce.rawValue,
-            degree: degree,
-            highDegreeThreshold: highDegreeThreshold
-        )
-    }
-}
-
-struct BLERecentTrafficTracker: Equatable {
-    private var packetTimestamps: [Date] = []
-
-    var count: Int {
-        packetTimestamps.count
-    }
-
-    mutating func removeAll() {
-        packetTimestamps.removeAll()
-    }
-
-    mutating func recordPacket(at now: Date) {
-        packetTimestamps.append(now)
-        prune(at: now)
-    }
-
-    func hasTraffic(within seconds: TimeInterval, now: Date) -> Bool {
-        let cutoff = now.addingTimeInterval(-seconds)
-        return packetTimestamps.contains { $0 >= cutoff }
-    }
-
-    private mutating func prune(at now: Date) {
-        let cutoff = now.addingTimeInterval(-TransportConfig.bleRecentPacketWindowSeconds)
-        if packetTimestamps.count > TransportConfig.bleRecentPacketWindowMaxCount {
-            packetTimestamps.removeFirst(packetTimestamps.count - TransportConfig.bleRecentPacketWindowMaxCount)
-        }
-        packetTimestamps.removeAll { $0 < cutoff }
-    }
-}

bitchat/Services/BLE/BLERouteForwardingPolicy.swift

@@ -1,93 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLERouteForwardingPlan {
-    let shouldSuppressFloodRelay: Bool
-    let forwardPacket: BitchatPacket?
-    let nextHop: PeerID?
-
-    static let allowFloodRelay = BLERouteForwardingPlan(
-        shouldSuppressFloodRelay: false,
-        forwardPacket: nil,
-        nextHop: nil
-    )
-
-    static let suppressFloodRelay = BLERouteForwardingPlan(
-        shouldSuppressFloodRelay: true,
-        forwardPacket: nil,
-        nextHop: nil
-    )
-
-    static func forward(_ packet: BitchatPacket, to nextHop: PeerID) -> BLERouteForwardingPlan {
-        BLERouteForwardingPlan(
-            shouldSuppressFloodRelay: true,
-            forwardPacket: packet,
-            nextHop: nextHop
-        )
-    }
-}
-
-struct BLERouteForwardingPolicy {
-    static func plan(
-        for packet: BitchatPacket,
-        localPeerID: PeerID,
-        localRoutingData: Data?,
-        routingPeer: (Data) -> PeerID?,
-        isPeerConnected: (PeerID) -> Bool
-    ) -> BLERouteForwardingPlan {
-        if PeerID(hexData: packet.recipientID) == localPeerID {
-            return .suppressFloodRelay
-        }
-
-        guard let route = packet.route, !route.isEmpty else {
-            return .allowFloodRelay
-        }
-
-        guard packet.ttl > 1 else {
-            return .suppressFloodRelay
-        }
-
-        guard let localRoutingData else {
-            return .allowFloodRelay
-        }
-
-        guard let localIndex = route.firstIndex(of: localRoutingData) else {
-            return forward(packet, toRouteData: route[0], routingPeer: routingPeer, isPeerConnected: isPeerConnected)
-        }
-
-        if localIndex == route.count - 1 {
-            guard let destinationPeer = PeerID(hexData: packet.recipientID),
-                  isPeerConnected(destinationPeer) else {
-                return .allowFloodRelay
-            }
-            return .forward(relayed(packet), to: destinationPeer)
-        }
-
-        return forward(
-            packet,
-            toRouteData: route[localIndex + 1],
-            routingPeer: routingPeer,
-            isPeerConnected: isPeerConnected
-        )
-    }
-
-    private static func forward(
-        _ packet: BitchatPacket,
-        toRouteData routeData: Data,
-        routingPeer: (Data) -> PeerID?,
-        isPeerConnected: (PeerID) -> Bool
-    ) -> BLERouteForwardingPlan {
-        guard let nextPeer = routingPeer(routeData),
-              isPeerConnected(nextPeer) else {
-            return .allowFloodRelay
-        }
-
-        return .forward(relayed(packet), to: nextPeer)
-    }
-
-    private static func relayed(_ packet: BitchatPacket) -> BitchatPacket {
-        var relayPacket = packet
-        relayPacket.ttl = packet.ttl - 1
-        return relayPacket
-    }
-}

bitchat/Services/BLE/BLEScanDutyPolicy.swift

@@ -1,35 +0,0 @@
-import Foundation
-
-enum BLEScanDutyPlan: Equatable {
-    case continuous
-    case dutyCycle(onDuration: TimeInterval, offDuration: TimeInterval)
-}
-
-enum BLEScanDutyPolicy {
-    static func plan(
-        dutyEnabled: Bool,
-        appIsActive: Bool,
-        connectedCount: Int,
-        hasRecentTraffic: Bool,
-        highDegreeThreshold: Int = TransportConfig.bleHighDegreeThreshold
-    ) -> BLEScanDutyPlan {
-        let forceContinuousScan = connectedCount <= 2 || hasRecentTraffic
-        let shouldDutyCycle = dutyEnabled && appIsActive && connectedCount > 0 && !forceContinuousScan
-
-        guard shouldDutyCycle else {
-            return .continuous
-        }
-
-        if connectedCount >= highDegreeThreshold {
-            return .dutyCycle(
-                onDuration: TransportConfig.bleDutyOnDurationDense,
-                offDuration: TransportConfig.bleDutyOffDurationDense
-            )
-        }
-
-        return .dutyCycle(
-            onDuration: TransportConfig.bleDutyOnDuration,
-            offDuration: TransportConfig.bleDutyOffDuration
-        )
-    }
-}

bitchat/Services/BLE/BLEScheduledRelayStore.swift

@@ -1,43 +0,0 @@
-import Foundation
-
-struct BLEScheduledRelayStore {
-    private var relays: [String: DispatchWorkItem] = [:]
-
-    var count: Int {
-        relays.count
-    }
-
-    var isEmpty: Bool {
-        relays.isEmpty
-    }
-
-    mutating func schedule(_ workItem: DispatchWorkItem, messageID: String) {
-        relays[messageID] = workItem
-    }
-
-    @discardableResult
-    mutating func remove(messageID: String) -> DispatchWorkItem? {
-        relays.removeValue(forKey: messageID)
-    }
-
-    @discardableResult
-    mutating func cancel(messageID: String) -> Bool {
-        guard let workItem = relays.removeValue(forKey: messageID) else {
-            return false
-        }
-
-        workItem.cancel()
-        return true
-    }
-
-    mutating func cancelAll() {
-        relays.values.forEach { $0.cancel() }
-        relays.removeAll()
-    }
-
-    mutating func removeAllIfOverCapacity(_ maxCount: Int) {
-        if relays.count > maxCount {
-            relays.removeAll()
-        }
-    }
-}

bitchat/Services/BLE/BLESelfBroadcastTracker.swift

@@ -1,40 +0,0 @@
-import BitFoundation
-import Foundation
-
-struct BLESelfBroadcastTracker {
-    private struct Entry {
-        let messageID: String
-        let sentAt: Date
-    }
-
-    private var entriesByDedupID: [String: Entry] = [:]
-
-    var isEmpty: Bool {
-        entriesByDedupID.isEmpty
-    }
-
-    var count: Int {
-        entriesByDedupID.count
-    }
-
-    mutating func record(messageID: String, packet: BitchatPacket, sentAt: Date) {
-        entriesByDedupID[Self.dedupID(for: packet)] = Entry(messageID: messageID, sentAt: sentAt)
-    }
-
-    mutating func takeMessageID(for packet: BitchatPacket) -> String? {
-        entriesByDedupID.removeValue(forKey: Self.dedupID(for: packet))?.messageID
-    }
-
-    mutating func prune(before cutoff: Date) {
-        guard !entriesByDedupID.isEmpty else { return }
-        entriesByDedupID = entriesByDedupID.filter { cutoff <= $0.value.sentAt }
-    }
-
-    mutating func removeAll() {
-        entriesByDedupID.removeAll()
-    }
-
-    static func dedupID(for packet: BitchatPacket) -> String {
-        "\(packet.senderID.hexEncodedString())-\(packet.timestamp)-\(packet.type)"
-    }
-}

bitchat/Services/BLE/BLESubscriptionAnnounceLimiter.swift

@@ -1,71 +0,0 @@
-import Foundation
-
-enum BLESubscriptionAnnounceDecision: Equatable {
-    case allowed
-    case rateLimited(backoffSeconds: TimeInterval, attemptCount: Int, suppressAnnounce: Bool)
-}
-
-struct BLESubscriptionAnnounceLimiter {
-    private struct State {
-        var lastAnnounceTime: Date
-        var attemptCount: Int
-        var currentBackoffSeconds: TimeInterval
-    }
-
-    private var states: [String: State] = [:]
-
-    var trackedCentralCount: Int {
-        states.count
-    }
-
-    mutating func removeAll() {
-        states.removeAll()
-    }
-
-    mutating func decision(for centralID: String, now: Date) -> BLESubscriptionAnnounceDecision {
-        pruneStaleEntries(now: now)
-
-        guard let existing = states[centralID] else {
-            recordAllowedAttempt(for: centralID, now: now)
-            return .allowed
-        }
-
-        let timeSinceLastAnnounce = now.timeIntervalSince(existing.lastAnnounceTime)
-        guard timeSinceLastAnnounce < existing.currentBackoffSeconds else {
-            recordAllowedAttempt(for: centralID, now: now)
-            return .allowed
-        }
-
-        let newAttemptCount = existing.attemptCount + 1
-        let newBackoff = min(
-            existing.currentBackoffSeconds * TransportConfig.bleSubscriptionRateLimitBackoffFactor,
-            TransportConfig.bleSubscriptionRateLimitMaxBackoffSeconds
-        )
-        states[centralID] = State(
-            lastAnnounceTime: now,
-            attemptCount: newAttemptCount,
-            currentBackoffSeconds: newBackoff
-        )
-
-        return .rateLimited(
-            backoffSeconds: existing.currentBackoffSeconds,
-            attemptCount: existing.attemptCount,
-            suppressAnnounce: newAttemptCount >= TransportConfig.bleSubscriptionRateLimitMaxAttempts
-        )
-    }
-
-    private mutating func recordAllowedAttempt(for centralID: String, now: Date) {
-        states[centralID] = State(
-            lastAnnounceTime: now,
-            attemptCount: 1,
-            currentBackoffSeconds: TransportConfig.bleSubscriptionRateLimitMinSeconds
-        )
-    }
-
-    private mutating func pruneStaleEntries(now: Date) {
-        let windowSeconds = TransportConfig.bleSubscriptionRateLimitWindowSeconds
-        states = states.filter { _, state in
-            now.timeIntervalSince(state.lastAnnounceTime) < windowSeconds
-        }
-    }
-}

bitchat/Services/BLE/MimeType.swift

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

bitchat/Services/CommandProcessor.swift

@@ -7,7 +7,6 @@
 //
 
 import Foundation
-import BitFoundation
 
 /// Result of command processing
 enum CommandResult {
@@ -28,7 +27,6 @@ struct CommandGeoParticipant {
 protocol CommandContextProvider: AnyObject {
     // MARK: - State Properties
     var nickname: String { get }
-    var activeChannel: ChannelID { get }
     var selectedPrivateChatPeer: PeerID? { get }
     var blockedUsers: Set<String> { get }
     var privateChats: [PeerID: [BitchatMessage]] { get set }
@@ -76,7 +74,7 @@ final class CommandProcessor {
         
         // Geohash context: disable favoriting in public geohash or GeoDM
         let inGeoPublic: Bool = {
-            switch contextProvider?.activeChannel ?? .mesh {
+            switch LocationChannelManager.shared.selectedChannel {
             case .mesh: return false
             case .location: return true
             }
@@ -136,7 +134,7 @@ final class CommandProcessor {
     
     private func handleWho() -> CommandResult {
         // Show geohash participants when in a geohash channel; otherwise mesh peers
-        switch contextProvider?.activeChannel ?? .mesh {
+        switch LocationChannelManager.shared.selectedChannel {
         case .location(let ch):
             // Geohash context: show visible geohash participants (exclude self)
             guard let vm = contextProvider else { return .success(message: "nobody around") }
@@ -168,7 +166,7 @@ final class CommandProcessor {
     }
     
     private func handleEmote(_ args: String, command: String, action: String, emoji: String, suffix: String = "") -> CommandResult {
-        let targetName = args.trimmed
+        let targetName = args.trimmingCharacters(in: .whitespaces)
         guard !targetName.isEmpty else {
             return .error(message: "usage: /\(command) <nickname>")
         }
@@ -211,7 +209,7 @@ final class CommandProcessor {
     }
     
     private func handleBlock(_ args: String) -> CommandResult {
-        let targetName = args.trimmed
+        let targetName = args.trimmingCharacters(in: .whitespaces)
         
         if targetName.isEmpty {
             // List blocked users (mesh) and geohash (Nostr) blocks
@@ -286,7 +284,7 @@ final class CommandProcessor {
     }
     
     private func handleUnblock(_ args: String) -> CommandResult {
-        let targetName = args.trimmed
+        let targetName = args.trimmingCharacters(in: .whitespaces)
         guard !targetName.isEmpty else {
             return .error(message: "usage: /unblock <nickname>")
         }
@@ -313,7 +311,7 @@ final class CommandProcessor {
     }
     
     private func handleFavorite(_ args: String, add: Bool) -> CommandResult {
-        let targetName = args.trimmed
+        let targetName = args.trimmingCharacters(in: .whitespaces)
         guard !targetName.isEmpty else {
             return .error(message: "usage: /\(add ? "fav" : "unfav") <nickname>")
         }

bitchat/Services/FavoritesPersistenceService.swift

@@ -1,5 +1,4 @@
 import BitLogger
-import BitFoundation
 import Foundation
 import Combine
 

bitchat/Services/GeohashPresenceService.swift

@@ -13,25 +13,6 @@ import Combine
 import BitLogger
 import Tor
 
-protocol GeohashPresenceTimerProtocol: AnyObject {
-    var isValid: Bool { get }
-    func invalidate()
-}
-
-private final class GeohashPresenceTimerAdapter: GeohashPresenceTimerProtocol {
-    private let base: Timer
-
-    init(base: Timer) {
-        self.base = base
-    }
-
-    var isValid: Bool { base.isValid }
-
-    func invalidate() {
-        base.invalidate()
-    }
-}
-
 /// Service that coordinates the broadcasting of presence heartbeats.
 ///
 /// Behavior:
@@ -44,27 +25,18 @@ final class GeohashPresenceService: ObservableObject {
     static let shared = GeohashPresenceService()
 
     private var subscriptions = Set<AnyCancellable>()
-    private var heartbeatTimer: GeohashPresenceTimerProtocol?
+    private var heartbeatTimer: Timer?
-    private let availableChannelsProvider: () -> [GeohashChannel]
+    private let idBridge = NostrIdentityBridge()
-    private let locationChanges: AnyPublisher<[GeohashChannel], Never>
-    private let torReadyPublisher: AnyPublisher<Void, Never>
-    private let torIsReady: () -> Bool
-    private let torIsForeground: () -> Bool
-    private let deriveIdentity: (String) throws -> NostrIdentity
-    private let relayLookup: (String, Int) -> [String]
-    private let relaySender: (NostrEvent, [String]) -> Void
-    private let sleeper: (UInt64) async -> Void
-    private let scheduleTimer: (TimeInterval, @escaping () -> Void) -> GeohashPresenceTimerProtocol
     
     // MARK: - Constants
 
     // Loop interval range in seconds
-    private let loopMinInterval: TimeInterval
+    private let loopMinInterval: TimeInterval = 40.0
-    private let loopMaxInterval: TimeInterval
+    private let loopMaxInterval: TimeInterval = 80.0
     
     // Per-broadcast decorrelation delay range in seconds
-    private let burstMinDelay: TimeInterval
+    private let burstMinDelay: TimeInterval = 2.0
-    private let burstMaxDelay: TimeInterval
+    private let burstMaxDelay: TimeInterval = 5.0
 
     // Privacy: Only broadcast to these levels
     private let allowedPrecisions: Set<Int> = [
@@ -74,74 +46,6 @@ final class GeohashPresenceService: ObservableObject {
     ]
 
     private init() {
-        let idBridge = NostrIdentityBridge()
-        self.availableChannelsProvider = { LocationStateManager.shared.availableChannels }
-        self.locationChanges = LocationStateManager.shared.$availableChannels.eraseToAnyPublisher()
-        self.torReadyPublisher = NotificationCenter.default.publisher(for: .TorDidBecomeReady)
-            .map { _ in () }
-            .eraseToAnyPublisher()
-        self.torIsReady = { TorManager.shared.isReady }
-        self.torIsForeground = { TorManager.shared.isForeground() }
-        self.deriveIdentity = { try idBridge.deriveIdentity(forGeohash: $0) }
-        self.relayLookup = { geohash, count in
-            GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: count)
-        }
-        self.relaySender = { event, relays in
-            NostrRelayManager.shared.sendEvent(event, to: relays)
-        }
-        self.sleeper = { nanoseconds in
-            try? await Task.sleep(nanoseconds: nanoseconds)
-        }
-        self.scheduleTimer = { interval, action in
-            GeohashPresenceTimerAdapter(
-                base: Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { _ in
-                    action()
-                }
-            )
-        }
-        self.loopMinInterval = 40.0
-        self.loopMaxInterval = 80.0
-        self.burstMinDelay = 2.0
-        self.burstMaxDelay = 5.0
-        setupObservers()
-    }
-
-    internal init(
-        availableChannelsProvider: @escaping () -> [GeohashChannel],
-        locationChanges: AnyPublisher<[GeohashChannel], Never>,
-        torReadyPublisher: AnyPublisher<Void, Never>,
-        torIsReady: @escaping () -> Bool,
-        torIsForeground: @escaping () -> Bool,
-        deriveIdentity: @escaping (String) throws -> NostrIdentity,
-        relayLookup: @escaping (String, Int) -> [String],
-        relaySender: @escaping (NostrEvent, [String]) -> Void,
-        sleeper: @escaping (UInt64) async -> Void = { nanoseconds in try? await Task.sleep(nanoseconds: nanoseconds) },
-        scheduleTimer: @escaping (TimeInterval, @escaping () -> Void) -> GeohashPresenceTimerProtocol = { interval, action in
-            GeohashPresenceTimerAdapter(
-                base: Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { _ in
-                    action()
-                }
-            )
-        },
-        loopMinInterval: TimeInterval = 40.0,
-        loopMaxInterval: TimeInterval = 80.0,
-        burstMinDelay: TimeInterval = 2.0,
-        burstMaxDelay: TimeInterval = 5.0
-    ) {
-        self.availableChannelsProvider = availableChannelsProvider
-        self.locationChanges = locationChanges
-        self.torReadyPublisher = torReadyPublisher
-        self.torIsReady = torIsReady
-        self.torIsForeground = torIsForeground
-        self.deriveIdentity = deriveIdentity
-        self.relayLookup = relayLookup
-        self.relaySender = relaySender
-        self.sleeper = sleeper
-        self.scheduleTimer = scheduleTimer
-        self.loopMinInterval = loopMinInterval
-        self.loopMaxInterval = loopMaxInterval
-        self.burstMinDelay = burstMinDelay
-        self.burstMaxDelay = burstMaxDelay
         setupObservers()
     }
     
@@ -153,7 +57,7 @@ final class GeohashPresenceService: ObservableObject {
 
     private func setupObservers() {
         // Monitor location channel changes
-        locationChanges
+        LocationStateManager.shared.$availableChannels
             .dropFirst()
             .sink { [weak self] _ in
                 self?.handleLocationChange()
@@ -161,28 +65,28 @@ final class GeohashPresenceService: ObservableObject {
             .store(in: &subscriptions)
 
         // Monitor Tor readiness to kick off heartbeat if it was stalled
-        torReadyPublisher
+        NotificationCenter.default.publisher(for: .TorDidBecomeReady)
             .sink { [weak self] _ in
                 self?.handleConnectivityChange()
             }
             .store(in: &subscriptions)
     }
 
-    func handleLocationChange() {
+    private func handleLocationChange() {
         // When location changes, we trigger an immediate (but slightly delayed) heartbeat
         // to announce presence in the new zone, then reset the loop.
         SecureLogger.debug("Presence: location changed, scheduling update", category: .session)
         heartbeatTimer?.invalidate()
         
         // Small delay to allow location state to settle
-        heartbeatTimer = scheduleTimer(5.0) { [weak self] in
+        heartbeatTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: false) { [weak self] _ in
             Task { @MainActor [weak self] in
                 self?.performHeartbeat()
             }
         }
     }
     
-    func handleConnectivityChange() {
+    private func handleConnectivityChange() {
         SecureLogger.debug("Presence: connectivity restored, triggering heartbeat", category: .session)
         // If we were waiting for network, do it now
         if heartbeatTimer == nil || !heartbeatTimer!.isValid {
@@ -190,33 +94,33 @@ final class GeohashPresenceService: ObservableObject {
         }
     }
 
-    func scheduleNextHeartbeat() {
+    private func scheduleNextHeartbeat() {
         heartbeatTimer?.invalidate()
         let interval = TimeInterval.random(in: loopMinInterval...loopMaxInterval)
-        heartbeatTimer = scheduleTimer(interval) { [weak self] in
+        heartbeatTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { [weak self] _ in
             Task { @MainActor [weak self] in
                 self?.performHeartbeat()
             }
         }
     }
 
-    func performHeartbeat() {
+    private func performHeartbeat() {
         // Always schedule next loop first ensures continuity even if this one fails/skips
         defer { scheduleNextHeartbeat() }
 
         // 1. Check preconditions
-        guard torIsReady() else {
+        guard TorManager.shared.isReady else {
             SecureLogger.debug("Presence: skipping heartbeat (Tor not ready)", category: .session)
             return
         }
         
         // App must be active (or at least we shouldn't broadcast if in background, usually)
-        if !torIsForeground() {
+        if !TorManager.shared.isForeground() {
             return
         }
 
         // 2. Get channels
-        let channels = availableChannelsProvider()
+        let channels = LocationStateManager.shared.availableChannels
         guard !channels.isEmpty else { return }
 
         // 3. Filter and broadcast
@@ -232,16 +136,16 @@ final class GeohashPresenceService: ObservableObject {
                 // Random delay for decorrelation
                 let delay = TimeInterval.random(in: self.burstMinDelay...self.burstMaxDelay)
                 let nanoseconds = UInt64(delay * 1_000_000_000)
-                await self.sleeper(nanoseconds)
+                try? await Task.sleep(nanoseconds: nanoseconds)
                 
                 self.broadcastPresence(for: channel.geohash)
             }
         }
     }
 
-    func broadcastPresence(for geohash: String) {
+    private func broadcastPresence(for geohash: String) {
         do {
-            guard let identity = try? deriveIdentity(geohash) else {
+            guard let identity = try? idBridge.deriveIdentity(forGeohash: geohash) else {
                 return
             }
             
@@ -251,10 +155,13 @@ final class GeohashPresenceService: ObservableObject {
             )
             
             // Send via RelayManager
-            let targetRelays = relayLookup(geohash, TransportConfig.nostrGeoRelayCount)
+            let targetRelays = GeoRelayDirectory.shared.closestRelays(
+                toGeohash: geohash,
+                count: TransportConfig.nostrGeoRelayCount
+            )
             
             if !targetRelays.isEmpty {
-                relaySender(event, targetRelays)
+                NostrRelayManager.shared.sendEvent(event, to: targetRelays)
                 SecureLogger.debug("Presence: sent heartbeat for \(geohash) (pub=\(identity.publicKeyHex.prefix(6))...)", category: .session)
             }
         } catch {

bitchat/Services/KeychainManager.swift

@@ -7,10 +7,76 @@
 //
 
 import BitLogger
-import BitFoundation
 import Foundation
 import Security
 
+// MARK: - Keychain Error Types
+// BCH-01-009: Proper error classification to distinguish expected states from critical failures
+
+/// Result of a keychain read operation with proper error classification
+enum KeychainReadResult {
+    case success(Data)
+    case itemNotFound        // Expected: key doesn't exist yet
+    case accessDenied        // Critical: app lacks keychain access
+    case deviceLocked        // Recoverable: device is locked
+    case authenticationFailed // Recoverable: biometric/passcode failed
+    case otherError(OSStatus) // Unexpected error
+
+    var isRecoverableError: Bool {
+        switch self {
+        case .deviceLocked, .authenticationFailed:
+            return true
+        default:
+            return false
+        }
+    }
+}
+
+/// Result of a keychain save operation with proper error classification
+enum KeychainSaveResult {
+    case success
+    case duplicateItem       // Can retry with update
+    case accessDenied        // Critical: app lacks keychain access
+    case deviceLocked        // Recoverable: device is locked
+    case storageFull         // Critical: no space available
+    case otherError(OSStatus)
+
+    var isRecoverableError: Bool {
+        switch self {
+        case .duplicateItem, .deviceLocked:
+            return true
+        default:
+            return false
+        }
+    }
+}
+
+protocol KeychainManagerProtocol {
+    func saveIdentityKey(_ keyData: Data, forKey key: String) -> Bool
+    func getIdentityKey(forKey key: String) -> Data?
+    func deleteIdentityKey(forKey key: String) -> Bool
+    func deleteAllKeychainData() -> Bool
+
+    func secureClear(_ data: inout Data)
+    func secureClear(_ string: inout String)
+
+    func verifyIdentityKeyExists() -> Bool
+
+    // BCH-01-009: Methods with proper error classification
+    /// Get identity key with detailed result for error handling
+    func getIdentityKeyWithResult(forKey key: String) -> KeychainReadResult
+    /// Save identity key with detailed result for error handling
+    func saveIdentityKeyWithResult(_ keyData: Data, forKey key: String) -> KeychainSaveResult
+
+    // MARK: - Generic Data Storage (consolidated from KeychainHelper)
+    /// Save data with a custom service name
+    func save(key: String, data: Data, service: String, accessible: CFString?)
+    /// Load data from a custom service
+    func load(key: String, service: String) -> Data?
+    /// Delete data from a custom service
+    func delete(key: String, service: String)
+}
+
 final class KeychainManager: KeychainManagerProtocol {
     // Use consistent service name for all keychain items
     private let service = BitchatApp.bundleID

bitchat/Services/LocationNotesManager.swift

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

bitchat/Services/LocationStateManager.swift

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

bitchat/Services/MessageDeduplicationService.swift

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

bitchat/Services/MessageFormattingEngine.swift

@@ -6,7 +6,6 @@
 // This is free and unencumbered software released into the public domain.
 //
 
-import BitFoundation
 import Foundation
 import SwiftUI
 

bitchat/Services/MessageRouter.swift

@@ -1,5 +1,4 @@
 import BitLogger
-import BitFoundation
 import Foundation
 
 /// Routes messages using available transports (Mesh, Nostr, etc.)

bitchat/Services/NetworkActivationService.swift

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

bitchat/Services/NoiseEncryptionService.swift

@@ -83,7 +83,6 @@
 ///
 
 import BitLogger
-import BitFoundation
 import Foundation
 import CryptoKit
 

bitchat/Services/NostrTransport.swift

@@ -1,36 +1,9 @@
 import BitLogger
-import BitFoundation
 import Foundation
 import Combine
 
 // Minimal Nostr transport conforming to Transport for offline sending
 final class NostrTransport: Transport, @unchecked Sendable {
-    struct Dependencies {
-        let notificationCenter: NotificationCenter
-        let loadFavorites: @MainActor () -> [Data: FavoritesPersistenceService.FavoriteRelationship]
-        let favoriteStatusForNoiseKey: @MainActor (Data) -> FavoritesPersistenceService.FavoriteRelationship?
-        let favoriteStatusForPeerID: @MainActor (PeerID) -> FavoritesPersistenceService.FavoriteRelationship?
-        let currentIdentity: @MainActor () throws -> NostrIdentity?
-        let registerPendingGiftWrap: @MainActor (String) -> Void
-        let sendEvent: @MainActor (NostrEvent) -> Void
-        let scheduleAfter: @Sendable (TimeInterval, @escaping @Sendable () -> Void) -> Void
-
-        static func live(idBridge: NostrIdentityBridge) -> Dependencies {
-            Dependencies(
-                notificationCenter: .default,
-                loadFavorites: { FavoritesPersistenceService.shared.favorites },
-                favoriteStatusForNoiseKey: { FavoritesPersistenceService.shared.getFavoriteStatus(for: $0) },
-                favoriteStatusForPeerID: { FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: $0) },
-                currentIdentity: { try idBridge.getCurrentNostrIdentity() },
-                registerPendingGiftWrap: { NostrRelayManager.registerPendingGiftWrap(id: $0) },
-                sendEvent: { NostrRelayManager.shared.sendEvent($0) },
-                scheduleAfter: { delay, action in
-                    DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: action)
-                }
-            )
-        }
-    }
-
     // Provide BLE short peer ID for BitChat embedding
     var senderPeerID = PeerID(str: "")
 
@@ -44,27 +17,20 @@ final class NostrTransport: Transport, @unchecked Sendable {
     private let readAckInterval: TimeInterval = TransportConfig.nostrReadAckInterval
     private let keychain: KeychainManagerProtocol
     private let idBridge: NostrIdentityBridge
-    private let dependencies: Dependencies
-    private var favoriteStatusObserver: NSObjectProtocol?
 
     // Reachability Cache (thread-safe)
     private var reachablePeers: Set<PeerID> = []
     private let queue = DispatchQueue(label: "nostr.transport.state", attributes: .concurrent)
 
     @MainActor
-    init(
+    init(keychain: KeychainManagerProtocol, idBridge: NostrIdentityBridge) {
-        keychain: KeychainManagerProtocol,
-        idBridge: NostrIdentityBridge,
-        dependencies: Dependencies? = nil
-    ) {
         self.keychain = keychain
         self.idBridge = idBridge
-        self.dependencies = dependencies ?? .live(idBridge: idBridge)
         
         setupObservers()
         
         // Synchronously warm the cache to avoid startup race
-        let favorites = self.dependencies.loadFavorites()
+        let favorites = FavoritesPersistenceService.shared.favorites
         let reachable = favorites.values
             .filter { $0.peerNostrPublicKey != nil }
             .map { PeerID(publicKey: $0.peerNoisePublicKey) }
@@ -74,14 +40,8 @@ final class NostrTransport: Transport, @unchecked Sendable {
         }
     }
 
-    deinit {
-        if let favoriteStatusObserver {
-            dependencies.notificationCenter.removeObserver(favoriteStatusObserver)
-        }
-    }
-
     private func setupObservers() {
-        favoriteStatusObserver = dependencies.notificationCenter.addObserver(
+        NotificationCenter.default.addObserver(
             forName: .favoriteStatusChanged,
             object: nil,
             queue: nil
@@ -92,7 +52,7 @@ final class NostrTransport: Transport, @unchecked Sendable {
 
     private func refreshReachablePeers() {
         Task { @MainActor in
-            let favorites = dependencies.loadFavorites()
+            let favorites = FavoritesPersistenceService.shared.favorites
             let reachable = favorites.values
                 .filter { $0.peerNostrPublicKey != nil }
                 .map { PeerID(publicKey: $0.peerNoisePublicKey) }
@@ -106,7 +66,6 @@ final class NostrTransport: Transport, @unchecked Sendable {
     // MARK: - Transport Protocol Conformance
 
     weak var delegate: BitchatDelegate?
-    weak var eventDelegate: TransportEventDelegate?
     weak var peerEventsDelegate: TransportPeerEventsDelegate?
 
     var peerSnapshotPublisher: AnyPublisher<[TransportPeerSnapshot], Never> {
@@ -161,7 +120,7 @@ final class NostrTransport: Transport, @unchecked Sendable {
         Task { @MainActor in
             guard let recipientNpub = resolveRecipientNpub(for: peerID),
                   let recipientHex = npubToHex(recipientNpub),
-                  let senderIdentity = try? dependencies.currentIdentity() else { return }
+                  let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
             SecureLogger.debug("NostrTransport: preparing PM to \(recipientNpub.prefix(16))… id=\(messageID.prefix(8))…", category: .session)
             guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed PM packet", category: .session)
@@ -174,9 +133,9 @@ final class NostrTransport: Transport, @unchecked Sendable {
     func sendReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID) {
         // Enqueue and process with throttling to avoid relay rate limits
         // Use barrier to synchronize access to readQueue
-        queue.async(flags: .barrier) {
+        queue.async(flags: .barrier) { [weak self] in
-            self.readQueue.append(QueuedRead(receipt: receipt, peerID: peerID))
+            self?.readQueue.append(QueuedRead(receipt: receipt, peerID: peerID))
-            self.processReadQueueIfNeeded()
+            self?.processReadQueueIfNeeded()
         }
     }
 
@@ -184,7 +143,7 @@ final class NostrTransport: Transport, @unchecked Sendable {
         Task { @MainActor in
             guard let recipientNpub = resolveRecipientNpub(for: peerID),
                   let recipientHex = npubToHex(recipientNpub),
-                  let senderIdentity = try? dependencies.currentIdentity() else { return }
+                  let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
             let content = isFavorite ? "[FAVORITED]:\(senderIdentity.npub)" : "[UNFAVORITED]:\(senderIdentity.npub)"
             SecureLogger.debug("NostrTransport: preparing FAVORITE(\(isFavorite)) to \(recipientNpub.prefix(16))…", category: .session)
             guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: UUID().uuidString, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
@@ -200,7 +159,7 @@ final class NostrTransport: Transport, @unchecked Sendable {
         Task { @MainActor in
             guard let recipientNpub = resolveRecipientNpub(for: peerID),
                   let recipientHex = npubToHex(recipientNpub),
-                  let senderIdentity = try? dependencies.currentIdentity() else { return }
+                  let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
             SecureLogger.debug("NostrTransport: preparing DELIVERED ack id=\(messageID.prefix(8))…", category: .session)
             guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .delivered, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed DELIVERED ack", category: .session)
@@ -270,9 +229,9 @@ extension NostrTransport {
             return
         }
         if registerPending {
-            dependencies.registerPendingGiftWrap(event.id)
+            NostrRelayManager.registerPendingGiftWrap(id: event.id)
         }
-        dependencies.sendEvent(event)
+        NostrRelayManager.shared.sendEvent(event)
     }
 
     /// Must be called within a barrier on `queue`
@@ -290,7 +249,7 @@ extension NostrTransport {
             defer { scheduleNextReadAck() }
             guard let recipientNpub = resolveRecipientNpub(for: item.peerID),
                   let recipientHex = npubToHex(recipientNpub),
-                  let senderIdentity = try? dependencies.currentIdentity() else { return }
+                  let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { return }
             SecureLogger.debug("NostrTransport: preparing READ ack id=\(item.receipt.originalMessageID.prefix(8))…", category: .session)
             guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .readReceipt, messageID: item.receipt.originalMessageID, recipientPeerID: item.peerID, senderPeerID: senderPeerID) else {
                 SecureLogger.error("NostrTransport: failed to embed READ ack", category: .session)
@@ -301,7 +260,7 @@ extension NostrTransport {
     }
 
     private func scheduleNextReadAck() {
-        dependencies.scheduleAfter(readAckInterval) { [weak self] in
+        DispatchQueue.main.asyncAfter(deadline: .now() + readAckInterval) { [weak self] in
             self?.queue.async(flags: .barrier) { [weak self] in
                 self?.isSendingReadAcks = false
                 self?.processReadQueueIfNeeded()
@@ -312,12 +271,12 @@ extension NostrTransport {
     @MainActor
     private func resolveRecipientNpub(for peerID: PeerID) -> String? {
         if let noiseKey = Data(hexString: peerID.id),
-           let fav = dependencies.favoriteStatusForNoiseKey(noiseKey),
+           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
            let npub = fav.peerNostrPublicKey {
             return npub
         }
         if peerID.id.count == 16,
-           let fav = dependencies.favoriteStatusForPeerID(peerID),
+           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID),
            let npub = fav.peerNostrPublicKey {
             return npub
         }

bitchat/Services/NotificationService.swift

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

bitchat/Services/NotificationStreamAssembler.swift

@@ -7,7 +7,6 @@
 //
 
 import BitLogger
-import BitFoundation
 import Foundation
 
 struct NotificationStreamAssembler {
@@ -21,19 +20,6 @@ struct NotificationStreamAssembler {
         pendingFrameExpectedLength = 0
     }
 
-    private mutating func discardLeadingPaddingIfPresent() -> Bool {
-        guard let first = buffer.first else { return false }
-        guard first != 1 && first != 2 else { return false }
-        let paddingLength = Int(first)
-        guard paddingLength > 0, paddingLength <= buffer.count else { return false }
-        guard buffer.prefix(paddingLength).allSatisfy({ $0 == first }) else { return false }
-
-        buffer.removeFirst(paddingLength)
-        pendingFrameStartedAt = nil
-        pendingFrameExpectedLength = 0
-        return true
-    }
-
     mutating func append(_ chunk: Data) -> (frames: [Data], droppedPrefixes: [UInt8], reset: Bool) {
         guard !chunk.isEmpty else { return ([], [], false) }
 
@@ -55,9 +41,6 @@ struct NotificationStreamAssembler {
         while buffer.count >= minimumFramePrefix {
             guard let version = buffer.first else { break }
             guard version == 1 || version == 2 else {
-                if discardLeadingPaddingIfPresent() {
-                    continue
-                }
                 dropped.append(buffer.removeFirst())
                 pendingFrameStartedAt = nil
                 pendingFrameExpectedLength = 0
@@ -149,11 +132,6 @@ struct NotificationStreamAssembler {
             let frame = Data(buffer.prefix(frameLength))
             frames.append(frame)
             buffer.removeFirst(frameLength)
-            _ = discardLeadingPaddingIfPresent()
-        }
-
-        if discardLeadingPaddingIfPresent() {
-            return (frames, dropped, didReset)
         }
 
         if !buffer.isEmpty, buffer.allSatisfy({ $0 == 0 }) {

bitchat/Services/PrivateChatManager.swift

@@ -7,7 +7,6 @@
 //
 
 import BitLogger
-import BitFoundation
 import Foundation
 import SwiftUI
 

bitchat/Services/RelayController.swift

@@ -11,7 +11,6 @@ struct RelayDecision {
 struct RelayController {
     static func decide(ttl: UInt8,
                        senderIsSelf: Bool,
-                       recipientIsSelf: Bool = false,
                        isEncrypted: Bool,
                        isDirectedEncrypted: Bool,
                        isFragment: Bool,
@@ -23,7 +22,7 @@ struct RelayController {
         let ttlCap = min(ttl, TransportConfig.messageTTLDefault)
 
         // Suppress obvious non-relays
-        if ttlCap <= 1 || senderIsSelf || recipientIsSelf {
+        if ttlCap <= 1 || senderIsSelf {
             return RelayDecision(shouldRelay: false, newTTL: ttlCap, delayMs: 0)
         }
 

bitchat/Services/Transport.swift

@@ -1,7 +1,5 @@
-import BitFoundation
 import Foundation
 import Combine
-import CoreBluetooth
 
 /// Abstract transport interface used by ChatViewModel and services.
 /// BLEService implements this protocol; a future Nostr transport can too.
@@ -13,27 +11,9 @@ struct TransportPeerSnapshot: Equatable, Hashable {
     let lastSeen: Date
 }
 
-enum TransportEvent: @unchecked Sendable {
-    case messageReceived(BitchatMessage)
-    case publicMessageReceived(peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?)
-    case noisePayloadReceived(peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date)
-    case peerConnected(PeerID)
-    case peerDisconnected(PeerID)
-    case peerListUpdated([PeerID])
-    case peerSnapshotsUpdated([TransportPeerSnapshot])
-    case messageDeliveryStatusUpdated(messageID: String, status: DeliveryStatus)
-    case bluetoothStateUpdated(CBManagerState)
-}
-
-protocol TransportEventDelegate: AnyObject {
-    @MainActor func didReceiveTransportEvent(_ event: TransportEvent)
-}
-
 protocol Transport: AnyObject {
     // Event sink
     var delegate: BitchatDelegate? { get set }
-    // Typed event sink for transport-domain events. Prefer this over BitchatDelegate for new code.
-    var eventDelegate: TransportEventDelegate? { get set }
     // Peer events (preferred over publishers for UI)
     var peerEventsDelegate: TransportPeerEventsDelegate? { get set }
     
@@ -103,36 +83,4 @@ protocol TransportPeerEventsDelegate: AnyObject {
     @MainActor func didUpdatePeerSnapshots(_ peers: [TransportPeerSnapshot])
 }
 
-extension BitchatDelegate {
-    @MainActor
-    func receiveTransportEvent(_ event: TransportEvent) {
-        switch event {
-        case .messageReceived(let message):
-            didReceiveMessage(message)
-        case let .publicMessageReceived(peerID, nickname, content, timestamp, messageID):
-            didReceivePublicMessage(
-                from: peerID,
-                nickname: nickname,
-                content: content,
-                timestamp: timestamp,
-                messageID: messageID
-            )
-        case let .noisePayloadReceived(peerID, type, payload, timestamp):
-            didReceiveNoisePayload(from: peerID, type: type, payload: payload, timestamp: timestamp)
-        case .peerConnected(let peerID):
-            didConnectToPeer(peerID)
-        case .peerDisconnected(let peerID):
-            didDisconnectFromPeer(peerID)
-        case .peerListUpdated(let peers):
-            didUpdatePeerList(peers)
-        case .peerSnapshotsUpdated:
-            break
-        case let .messageDeliveryStatusUpdated(messageID, status):
-            didUpdateMessageDeliveryStatus(messageID, status: status)
-        case .bluetoothStateUpdated(let state):
-            didUpdateBluetoothState(state)
-        }
-    }
-}
-
 extension BLEService: Transport {}

bitchat/Services/TransportConfig.swift

@@ -21,7 +21,6 @@ enum TransportConfig {
 
     // Timers
     static let networkResetGraceSeconds: TimeInterval = 600 // 10 minutes
-    static let networkNotificationCooldownSeconds: TimeInterval = 300 // 5 minutes
     static let basePublicFlushInterval: TimeInterval = 0.08  // ~12.5 fps batching
 
     // BLE duty/announce/connect
@@ -56,9 +55,6 @@ enum TransportConfig {
     static let uiSenderRateBucketRefillPerSec: Double = 1.0
     static let uiContentRateBucketCapacity: Double = 3
     static let uiContentRateBucketRefillPerSec: Double = 0.5
-    static let uiSenderRateBucketMaxEntries: Int = 2000
-    static let uiContentRateBucketMaxEntries: Int = 2000
-    static let uiRateBucketIdleTTL: TimeInterval = 10 * 60
 
     // UI sleeps/delays
     static let uiStartupInitialDelaySeconds: TimeInterval = 1.0
@@ -136,6 +132,9 @@ enum TransportConfig {
     static let nostrShortKeyDisplayLength: Int = 8
     static let nostrConvKeyPrefixLength: Int = 16
 
+    // Compression
+    static let compressionThresholdBytes: Int = 100
+
     // Message deduplication
     static let messageDedupMaxAgeSeconds: TimeInterval = 300
     static let messageDedupMaxCount: Int = 1000