Serialize iOS tests in CI

.github/workflows/swift-tests.yml

@@ -94,6 +94,24 @@ jobs:
           kill "$watchdog_pid" 2>/dev/null || true
           exit "$status"
 
+      # Read coverage before the serial benchmark command below rebuilds the
+      # test binary without instrumentation. Reporting against that newer
+      # binary makes llvm-cov reject the profile as out of date.
+      # Informational only: there is deliberately no percentage threshold, but
+      # a broken/missing report is a CI configuration error and must be visible.
+      - name: Coverage summary
+        run: |
+          BIN_PATH=$(swift build --show-bin-path --package-path ${{ matrix.path }})
+          PROF="$BIN_PATH/codecov/default.profdata"
+          XCTEST=$(find "$BIN_PATH" -maxdepth 1 -name '*.xctest' | head -1)
+          BINARY="$XCTEST/Contents/MacOS/$(basename "$XCTEST" .xctest)"
+          if [ ! -f "$PROF" ] || [ ! -f "$BINARY" ]; then
+            echo "::error::Coverage profile or test binary is missing"
+            exit 1
+          fi
+          xcrun llvm-cov report "$BINARY" -instr-profile "$PROF" \
+            -ignore-filename-regex='(Tests|\.build|checkouts|Mocks|_PreviewHelpers)'
+
       # Benchmarks run serially on an otherwise idle runner for stable
       # numbers; BITCHAT_PERF_LOG captures the PERF[...] lines for the gate.
       - name: Run performance benchmarks (serial)
@@ -115,22 +133,6 @@ jobs:
         timeout-minutes: 10
         run: ./scripts/check-perf-floors.sh perf-output.log
 
-      # Informational only: surfaces per-file and total line coverage in the
-      # job log so coverage trends are visible on every PR. No thresholds —
-      # this must never be the reason a build goes red.
-      - name: Coverage summary
-        run: |
-          BIN_PATH=$(swift build --show-bin-path --package-path ${{ matrix.path }})
-          PROF="$BIN_PATH/codecov/default.profdata"
-          XCTEST=$(find "$BIN_PATH" -maxdepth 1 -name '*.xctest' | head -1)
-          BINARY="$XCTEST/Contents/MacOS/$(basename "$XCTEST" .xctest)"
-          if [ -f "$PROF" ] && [ -f "$BINARY" ]; then
-            xcrun llvm-cov report "$BINARY" -instr-profile "$PROF" \
-              -ignore-filename-regex='(Tests|\.build|checkouts|Mocks|_PreviewHelpers)' || true
-          else
-            echo "No coverage data found; skipping summary."
-          fi
-
   # SPM tests do not link the shipping app targets. This job covers the
   # iOS-conditional paths and both universal Release link configurations.
   ios-build:
@@ -169,6 +171,52 @@ jobs:
             CODE_SIGNING_ALLOWED=NO \
             build
 
+  # The SwiftPM matrix runs on macOS and cannot execute UIKit/CoreBluetooth
+  # conditional tests. Build the shared iOS test target and run it on the first
+  # available iPhone simulator from the runner image instead of hard-coding a
+  # model that changes when GitHub updates Xcode. The suite intentionally runs
+  # in one test runner: a number of integration tests exercise process-global
+  # stores and notification centers, so overlapping workers can corrupt each
+  # other's fixtures and turn sub-second tests into multi-minute timeouts.
+  ios-tests:
+    name: Run iOS simulator tests
+    runs-on: macos-latest
+    timeout-minutes: 20
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Select available iPhone simulator
+        id: destination
+        run: |
+          destinations=$(xcodebuild -project bitchat.xcodeproj -scheme "bitchat (iOS)" -showdestinations)
+          destination_id=$(awk -F'id:' '
+            /platform:iOS Simulator/ && /name:iPhone/ && !found {
+              value=$2
+              sub(/,.*/, "", value)
+              gsub(/^[[:space:]]+|[[:space:]]+$/, "", value)
+              print value
+              found=1
+            }
+          ' <<< "$destinations")
+          if [ -z "$destination_id" ]; then
+            echo "::error::No available iPhone simulator destination found"
+            exit 1
+          fi
+          echo "id=$destination_id" >> "$GITHUB_OUTPUT"
+
+      - name: Run iOS tests
+        run: |
+          set -o pipefail
+          xcodebuild -project bitchat.xcodeproj \
+            -scheme "bitchat (iOS)" \
+            -sdk iphonesimulator \
+            -destination "platform=iOS Simulator,id=${{ steps.destination.outputs.id }}" \
+            -parallel-testing-enabled NO \
+            CODE_SIGNING_ALLOWED=NO \
+            test
+
   # Advisory only: SwiftLint reports style violations without ever failing the
   # build. Runs in a pinned container (no Xcode plugin, no pbxproj changes) so
   # it can never break the documented xcodebuild path or block a merge.

PRIVACY_POLICY.md

@@ -17,8 +17,8 @@ bitchat is designed for private, account-free communication. This policy describ
 
 1. **Identity and cryptographic keys**
    - Noise, signing, group, prekey, and optional Nostr identity material is generated locally.
-   - Secret keys are stored in the system keychain as device-only items. Public keys are shared when required for messaging, verification, groups, or Nostr events.
+   - Secret keys are stored in the system keychain. Public keys are shared when required for messaging, verification, groups, or Nostr events.
-   - Keys remain until they are rotated, removed by the relevant feature, or erased with panic wipe. Because operating-system keychains can outlive an uninstall, bitchat records a non-secret install marker and deletes surviving app keys before use after a later reinstall.
+   - Keys remain until they are rotated, removed by the relevant feature, erased with panic wipe, or removed with the app.
 
 2. **Nickname, preferences, and relationships**
    - Your nickname, settings, favorites, petnames, read-receipt identifiers, and bounded operational metadata are stored locally.
@@ -121,7 +121,7 @@ No cryptographic system can protect content after a recipient reads, copies, scr
 
 ## Your Controls
 
-- **Panic wipe:** Triple-tap the logo to synchronously cancel in-flight media work and clear local keys, sessions, preferences, groups, queues, carried mail, public archives, board data, and media managed by the app.
+- **Panic wipe:** Triple-tap the logo to clear local keys, sessions, preferences, groups, queues, carried mail, public archives, board data, and media managed by the app.
 - **Feature controls:** Location channels, mesh bridge, internet gateway, and related internet behaviors can be disabled in the app. Some already-published relay data cannot be recalled.
 - **System permissions:** Bluetooth, location, microphone, camera, and photo-library access can be revoked in system settings.
 - **No account:** The project operates no account record for you to request or export.

bitchat.xcodeproj/project.pbxproj

@@ -337,7 +337,6 @@
 				es,
 				ar,
 				de,
-				fa,
 				fr,
 				he,
 				id,

bitchat/App/AppChromeModel.swift

@@ -21,9 +21,6 @@ final class AppChromeModel: ObservableObject {
 
     private let chatViewModel: ChatViewModel
     private var cancellables = Set<AnyCancellable>()
-    /// The composer owns capture state above ChatViewModel. ContentView
-    /// installs this hook so both panic entry points synchronously stop it.
-    private var prepareForPanic: (@MainActor () -> Void)?
 
     /// Bulletin-board coordinator, created on first use of the board sheet.
     private(set) lazy var boardManager = BoardManager(transport: chatViewModel.meshService)
@@ -100,12 +97,7 @@ final class AppChromeModel: ObservableObject {
         showScreenshotPrivacyWarning = true
     }
 
-    func setPanicPreparation(_ preparation: (@MainActor () -> Void)?) {
-        prepareForPanic = preparation
-    }
-
     func panicClearAllData() {
-        prepareForPanic?()
         chatViewModel.panicClearAllData()
     }
 

bitchat/App/AppRuntime.swift

@@ -107,15 +107,12 @@ final class AppRuntime: ObservableObject {
             )
         )
 
-        if chatViewModel.networkActivationAllowed {
+        GeoRelayDirectory.shared.prefetchIfNeeded()
-            GeoRelayDirectory.shared.prefetchIfNeeded()
-        }
         bindRuntimeObservers()
         NotificationDelegate.shared.runtime = self
     }
 
     func start() {
-        guard chatViewModel.networkActivationAllowed else { return }
         guard !started else {
             checkForSharedContent()
             return
@@ -154,14 +151,12 @@ final class AppRuntime: ObservableObject {
     }
 
     func handleDidBecomeActiveNotification() {
-        guard chatViewModel.networkActivationAllowed else { return }
         chatViewModel.handleDidBecomeActive()
         checkForSharedContent()
     }
 
     #if os(macOS)
     func handleMacDidBecomeActiveNotification() {
-        guard chatViewModel.networkActivationAllowed else { return }
         record(.scenePhaseChanged(.active))
         chatViewModel.handleDidBecomeActive()
         checkForSharedContent()
@@ -180,7 +175,6 @@ final class AppRuntime: ObservableObject {
             didEnterBackground = true
 
         case .active:
-            guard chatViewModel.networkActivationAllowed else { return }
             record(.scenePhaseChanged(.active))
             chatViewModel.meshService.startServices()
             TorManager.shared.setAppForeground(true)
@@ -228,7 +222,6 @@ final class AppRuntime: ObservableObject {
         actionIdentifier: String = UNNotificationDefaultActionIdentifier,
         userInfo: [AnyHashable: Any]
     ) {
-        guard chatViewModel.networkActivationAllowed else { return }
         if actionIdentifier == NotificationService.waveActionID {
             chatViewModel.sendMeshWave()
             return
@@ -280,8 +273,6 @@ private extension AppRuntime {
         NotificationCenter.default.publisher(for: .TorWillRestart)
             .receive(on: DispatchQueue.main)
             .sink { [weak self] _ in
-                guard self?.chatViewModel.networkActivationAllowed == true
-                else { return }
                 self?.record(.torLifecycleChanged(.willRestart))
                 self?.chatViewModel.handleTorWillRestart()
             }
@@ -290,8 +281,6 @@ private extension AppRuntime {
         NotificationCenter.default.publisher(for: .TorDidBecomeReady)
             .receive(on: DispatchQueue.main)
             .sink { [weak self] _ in
-                guard self?.chatViewModel.networkActivationAllowed == true
-                else { return }
                 self?.record(.torLifecycleChanged(.didBecomeReady))
                 self?.chatViewModel.handleTorDidBecomeReady()
             }
@@ -300,8 +289,6 @@ private extension AppRuntime {
         NotificationCenter.default.publisher(for: .TorWillStart)
             .receive(on: DispatchQueue.main)
             .sink { [weak self] _ in
-                guard self?.chatViewModel.networkActivationAllowed == true
-                else { return }
                 self?.record(.torLifecycleChanged(.willStart))
                 self?.chatViewModel.handleTorWillStart()
             }
@@ -310,8 +297,6 @@ private extension AppRuntime {
         NotificationCenter.default.publisher(for: .TorUserPreferenceChanged)
             .receive(on: DispatchQueue.main)
             .sink { [weak self] notification in
-                guard self?.chatViewModel.networkActivationAllowed == true
-                else { return }
                 self?.record(.torLifecycleChanged(.preferenceChanged))
                 self?.chatViewModel.handleTorPreferenceChanged(notification)
             }
@@ -328,7 +313,6 @@ private extension AppRuntime {
     }
 
     func checkForSharedContent() {
-        guard chatViewModel.networkActivationAllowed else { return }
         guard let userDefaults = UserDefaults(suiteName: BitchatApp.groupID) else { return }
         let clearSharedContent = {
             userDefaults.removeObject(forKey: "sharedContent")
@@ -375,9 +359,7 @@ private extension AppRuntime {
         let becameConnected = isConnected && !lastNostrRelayConnectedState
         lastNostrRelayConnectedState = isConnected
 
-        guard chatViewModel.networkActivationAllowed,
+        guard started, becameConnected else { return }
-              started,
-              becameConnected else { return }
 
         let isInitialConnection = !didHandleInitialNostrConnection
         didHandleInitialNostrConnection = true

bitchat/App/ConversationUIModel.swift

@@ -12,7 +12,6 @@ final class ConversationUIModel: ObservableObject {
     @Published private(set) var currentNickname: String
     @Published private(set) var isBatchingPublic = false
     @Published private(set) var canSendMediaInCurrentContext = true
-    @Published private(set) var legacyPrivateMediaConsentRequest: LegacyPrivateMediaConsentRequest?
     /// Who is talking live in the public mesh channel right now (floor
     /// courtesy: the composer mic tints "busy" while someone holds the floor).
     @Published private(set) var activeLiveVoiceTalker: String?
@@ -154,13 +153,6 @@ final class ConversationUIModel: ObservableObject {
         chatViewModel.sendVoiceNote(at: url)
     }
 
-    func resolveLegacyPrivateMediaConsent(requestID: UUID, approved: Bool) {
-        chatViewModel.resolveLegacyPrivateMediaConsent(
-            requestID: requestID,
-            approved: approved
-        )
-    }
-
     /// Capture backend for the mic gesture: live PTT when the current DM
     /// peer can hear it now, classic voice note otherwise.
     func makeVoiceCaptureSession() -> VoiceCaptureSession {
@@ -201,10 +193,6 @@ final class ConversationUIModel: ObservableObject {
             .receive(on: DispatchQueue.main)
             .assign(to: &$activeLiveVoiceTalker)
 
-        chatViewModel.$legacyPrivateMediaConsentRequest
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$legacyPrivateMediaConsentRequest)
-
         conversations.$activeChannel
             .receive(on: DispatchQueue.main)
             .sink { [weak self] channel in

bitchat/App/LocationPresenceStore.swift

@@ -7,146 +7,45 @@ final class LocationPresenceStore: ObservableObject {
     @Published private(set) var geoNicknames: [String: String] = [:]
     @Published private(set) var teleportedGeo: Set<String> = []
 
-    private let teleportedGeoCapacity: Int
-    private var teleportedGeoOrder: [String] = []
-    private let geoNicknameCapacity: Int
-    private var geoNicknameOrder: [String] = []
-
-    init(
-        teleportedGeoCapacity: Int = TransportConfig.geoTeleportedParticipantsCap,
-        geoNicknameCapacity: Int = TransportConfig.geoNicknameParticipantsCap
-    ) {
-        self.teleportedGeoCapacity = max(0, teleportedGeoCapacity)
-        self.geoNicknameCapacity = max(0, geoNicknameCapacity)
-    }
-
     func setCurrentGeohash(_ geohash: String?) {
-        let normalized = geohash?.lowercased()
+        currentGeohash = geohash?.lowercased()
-        if currentGeohash != normalized {
-            // Presence markers are scoped to the active geohash channel.
-            clearTeleportedGeo()
-            clearGeoNicknames()
-        }
-        currentGeohash = normalized
     }
 
     func setNickname(_ nickname: String, for pubkeyHex: String) {
-        guard geoNicknameCapacity > 0 else {
+        geoNicknames[pubkeyHex.lowercased()] = nickname
-            clearGeoNicknames()
-            return
-        }
-
-        let key = pubkeyHex.lowercased()
-        if geoNicknames[key] != nil {
-            geoNicknames[key] = nickname
-            return
-        }
-
-        while geoNicknameOrder.count >= geoNicknameCapacity, let oldest = geoNicknameOrder.first {
-            geoNicknameOrder.removeFirst()
-            geoNicknames.removeValue(forKey: oldest)
-        }
-
-        geoNicknames[key] = nickname
-        geoNicknameOrder.append(key)
     }
 
     func replaceGeoNicknames(_ nicknames: [String: String]) {
-        guard geoNicknameCapacity > 0 else {
+        geoNicknames = Dictionary(
-            clearGeoNicknames()
+            uniqueKeysWithValues: nicknames.map { key, value in
-            return
+                (key.lowercased(), value)
-        }
+            }
-
+        )
-        var seen: Set<String> = []
-        var ordered: [String] = []
-        var normalized: [String: String] = [:]
-        for (key, value) in nicknames {
-            let lower = key.lowercased()
-            guard seen.insert(lower).inserted else { continue }
-            ordered.append(lower)
-            normalized[lower] = value
-        }
-        if ordered.count > geoNicknameCapacity {
-            let kept = Array(ordered.suffix(geoNicknameCapacity))
-            ordered = kept
-            normalized = Dictionary(uniqueKeysWithValues: kept.compactMap { key in
-                normalized[key].map { (key, $0) }
-            })
-        }
-        geoNicknameOrder = ordered
-        geoNicknames = normalized
     }
 
     func clearGeoNicknames() {
         geoNicknames.removeAll()
-        geoNicknameOrder.removeAll()
-    }
-
-    func retainGeoNicknames(keeping pubkeys: Set<String>) {
-        let allowed = Set(pubkeys.map { $0.lowercased() })
-        geoNicknameOrder = geoNicknameOrder.filter { allowed.contains($0) }
-        geoNicknames = geoNicknames.filter { allowed.contains($0.key) }
     }
 
     func markTeleported(_ pubkeyHex: String) {
-        guard teleportedGeoCapacity > 0 else {
+        teleportedGeo.insert(pubkeyHex.lowercased())
-            clearTeleportedGeo()
-            return
-        }
-
-        let key = pubkeyHex.lowercased()
-        guard !teleportedGeo.contains(key) else { return }
-
-        while teleportedGeoOrder.count >= teleportedGeoCapacity, let oldest = teleportedGeoOrder.first {
-            teleportedGeoOrder.removeFirst()
-            teleportedGeo.remove(oldest)
-        }
-
-        teleportedGeo.insert(key)
-        teleportedGeoOrder.append(key)
     }
 
     func clearTeleported(_ pubkeyHex: String) {
-        let key = pubkeyHex.lowercased()
+        teleportedGeo.remove(pubkeyHex.lowercased())
-        teleportedGeo.remove(key)
-        teleportedGeoOrder.removeAll { $0 == key }
     }
 
     func replaceTeleportedGeo(_ pubkeys: Set<String>) {
-        guard teleportedGeoCapacity > 0 else {
+        teleportedGeo = Set(pubkeys.map { $0.lowercased() })
-            clearTeleportedGeo()
-            return
-        }
-
-        var seen: Set<String> = []
-        var ordered: [String] = []
-        for key in pubkeys.map({ $0.lowercased() }) where !seen.contains(key) {
-            seen.insert(key)
-            ordered.append(key)
-        }
-        if ordered.count > teleportedGeoCapacity {
-            ordered = Array(ordered.suffix(teleportedGeoCapacity))
-        }
-        teleportedGeoOrder = ordered
-        teleportedGeo = Set(ordered)
-    }
-
-    func retainTeleportedGeo(keeping pubkeys: Set<String>) {
-        let allowed = Set(pubkeys.map { $0.lowercased() })
-        teleportedGeoOrder = teleportedGeoOrder.filter { allowed.contains($0) }
-        teleportedGeo = teleportedGeo.intersection(allowed)
     }
 
     func clearTeleportedGeo() {
         teleportedGeo.removeAll()
-        teleportedGeoOrder.removeAll()
     }
 
     func reset() {
         currentGeohash = nil
         geoNicknames.removeAll()
-        geoNicknameOrder.removeAll()
         teleportedGeo.removeAll()
-        teleportedGeoOrder.removeAll()
     }
 }

bitchat/Features/voice/VoiceCaptureSession.swift

@@ -26,8 +26,6 @@ protocol VoiceCaptureSession: AnyObject {
     /// nothing valid was captured.
     func finish() async -> URL?
     func cancel() async
-    /// Stops capture and suppresses every later send before returning.
-    func panicCancelSynchronously()
 }
 
 /// The classic record-then-send backend, wrapping the shared `VoiceRecorder`.
@@ -57,10 +55,6 @@ final class VoiceNoteCaptureSession: VoiceCaptureSession {
     func cancel() async {
         await recorder.cancelRecording(owner: owner)
     }
-
-    func panicCancelSynchronously() {
-        recorder.panicCancelSynchronously(owner: owner)
-    }
 }
 
 /// Testable surface of the live capture engine. Production uses
@@ -222,13 +216,6 @@ final class PTTLiveVoiceSession: VoiceCaptureSession {
         }
     }
 
-    func panicCancelSynchronously() {
-        // Do not emit a canceled packet: it would itself be pre-panic
-        // conversation data racing the emergency transport reset.
-        completed = true
-        capture.cancel()
-    }
-
     private func sendControlPacket(_ kind: VoiceBurstPacket.Kind) {
         guard let packet = VoiceBurstPacket(burstID: burstID, seq: stream.packetizer.nextSeq, kind: kind) else { return }
         sendPacket(packet.encode())

bitchat/Features/voice/VoiceRecorder.swift

@@ -246,21 +246,6 @@ actor VoiceRecorder {
         currentURL = nil
     }
 
-    /// Panic is a synchronous security boundary: the caller must know the
-    /// microphone, audio-session lease, and partial file are gone before it
-    /// rotates identities or deletes the media tree. VoiceRecorder is an
-    /// independent actor and this cleanup path never hops to MainActor, so a
-    /// short semaphore join is safe even when invoked by the UI actor.
-    nonisolated
-    func panicCancelSynchronously(owner: RecordingOwner) {
-        let finished = DispatchSemaphore(value: 0)
-        Task {
-            await cancelRecording(owner: owner)
-            finished.signal()
-        }
-        finished.wait()
-    }
-
     /// The audio session was interrupted (call, Siri) or reconfigured: stop
     /// the recorder but keep `recorder`/`currentURL` so the caller's pending
     /// `stopRecording()` still returns the partial note.

bitchat/Identity/IdentityModels.swift

@@ -189,18 +189,6 @@ struct IdentityCache: Codable {
     // Fingerprint -> when we verified it (orders outgoing vouch batches;
     // entries verified before this field exists sort as oldest)
     var verifiedAt: [String: Date]? = nil
-
-    // Stable Noise fingerprints that proved encrypted private-media support
-    // inside an authenticated Noise session. Optional for decoding caches
-    // written before this migration. Entries are monotonic until a panic wipe
-    // so an old/replayed announce cannot silently downgrade a peer.
-    var privateMediaCapableFingerprints: Set<String>? = nil
-
-    // Noise-fingerprint -> Ed25519 announcement key, learned only from the
-    // authenticated peer-state payload. This prevents a self-signed announce
-    // containing a copied public Noise key from replacing a previously bound
-    // public-message signing identity. Optional for old cache compatibility.
-    var authenticatedSigningKeysByFingerprint: [String: Data]? = nil
 }
 
 //

bitchat/Identity/SecureIdentityStateManager.swift

@@ -140,14 +140,6 @@ protocol SecureIdentityStateManagerProtocol {
     func markVouchBatchSent(to fingerprint: String, at date: Date)
     func signingPublicKey(forFingerprint fingerprint: String) -> Data?
     func mostRecentlyVerifiedFingerprints(limit: Int, excluding fingerprint: String) -> [String]
-
-    // MARK: Noise-authenticated announcement identity
-    func bindAuthenticatedSigningPublicKey(_ signingPublicKey: Data, fingerprint: String)
-    func authenticatedSigningPublicKey(forFingerprint fingerprint: String) -> Data?
-
-    // MARK: Private-media downgrade protection
-    func markPrivateMediaCapable(fingerprint: String)
-    func hasObservedPrivateMediaCapability(fingerprint: String) -> Bool
 }
 
 /// Singleton manager for secure identity state persistence and retrieval.
@@ -165,7 +157,6 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     
     // Thread safety
     private let queue = DispatchQueue(label: "bitchat.identity.state", attributes: .concurrent)
-    private let queueSpecificKey = DispatchSpecificKey<UInt8>()
     
     // Pending-save coalescing flag. Reads/writes are serialized on `queue`.
     // Persistence is done with a fire-and-forget `queue.async(.barrier)` rather
@@ -223,7 +214,6 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
 
         self.encryptionKey = loadedKey
         self.encryptionKeyIsEphemeral = keyIsEphemeral
-        queue.setSpecific(key: queueSpecificKey, value: 1)
 
         // Only read the persisted cache when we hold the real key; with an
         // ephemeral key the decrypt would fail and discard the real cache.
@@ -380,66 +370,6 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
             return cryptographicIdentities.values.filter { $0.fingerprint.hasPrefix(peerID.id) }
         }
     }
-
-    // MARK: - Private-media downgrade protection
-
-    func markPrivateMediaCapable(fingerprint: String) {
-        guard !fingerprint.isEmpty else { return }
-        let insertAndPersist = {
-            var pinned = self.cache.privateMediaCapableFingerprints ?? []
-            guard pinned.insert(fingerprint).inserted else { return }
-            self.cache.privateMediaCapableFingerprints = pinned
-            self.saveIdentityCache()
-        }
-        // Downgrade decisions can run immediately after an authenticated
-        // announce. Make the pin visible before returning; merely enqueueing a
-        // barrier leaves a cross-queue window where a replay can look legacy.
-        // The queue-specific fast path prevents self-deadlock if a future
-        // identity-state mutation records the capability from inside `queue`.
-        if DispatchQueue.getSpecific(key: queueSpecificKey) != nil {
-            insertAndPersist()
-        } else {
-            queue.sync(flags: .barrier, execute: insertAndPersist)
-        }
-    }
-
-    func hasObservedPrivateMediaCapability(fingerprint: String) -> Bool {
-        guard !fingerprint.isEmpty else { return false }
-        return queue.sync {
-            cache.privateMediaCapableFingerprints?.contains(fingerprint) == true
-        }
-    }
-
-    // MARK: - Noise-authenticated announcement identity
-
-    func bindAuthenticatedSigningPublicKey(_ signingPublicKey: Data, fingerprint: String) {
-        guard signingPublicKey.count == AuthenticatedPeerStatePacket.signingPublicKeyLength,
-              !fingerprint.isEmpty else { return }
-        let bindAndPersist = {
-            var bindings = self.cache.authenticatedSigningKeysByFingerprint ?? [:]
-            let bindingChanged = bindings[fingerprint] != signingPublicKey
-            bindings[fingerprint] = signingPublicKey
-            self.cache.authenticatedSigningKeysByFingerprint = bindings
-            if var cryptoIdentity = self.cryptographicIdentities[fingerprint] {
-                cryptoIdentity.signingPublicKey = signingPublicKey
-                self.cryptographicIdentities[fingerprint] = cryptoIdentity
-            }
-            guard bindingChanged else { return }
-            self.saveIdentityCache()
-        }
-        if DispatchQueue.getSpecific(key: queueSpecificKey) != nil {
-            bindAndPersist()
-        } else {
-            queue.sync(flags: .barrier, execute: bindAndPersist)
-        }
-    }
-
-    func authenticatedSigningPublicKey(forFingerprint fingerprint: String) -> Data? {
-        guard !fingerprint.isEmpty else { return nil }
-        return queue.sync {
-            cache.authenticatedSigningKeysByFingerprint?[fingerprint]
-        }
-    }
     
     func updateSocialIdentity(_ identity: SocialIdentity) {
         queue.async(flags: .barrier) {

bitchat/Models/NoisePayload.swift

@@ -30,7 +30,7 @@ struct NoisePayload {
         
         // Safely get the first byte
         let firstByte = data[data.startIndex]
-        guard let type = NoisePayloadType.decoded(rawValue: firstByte) else {
+        guard let type = NoisePayloadType(rawValue: firstByte) else {
             return nil
         }
         

bitchat/Noise/NoiseSecurityConstants.swift

@@ -6,60 +6,14 @@
 // For more information, see <https://unlicense.org>
 //
 
-import BitFoundation
 import Foundation
 
 enum NoiseSecurityConstants {
     // Maximum message size to prevent memory exhaustion
     static let maxMessageSize = 65535 // 64KB as per Noise spec
-
-    /// The extracted transport nonce (4 bytes) and Poly1305 tag (16 bytes)
-    /// added by `NoiseCipherState` around every transport plaintext.
-    static let transportCiphertextOverhead = 20
-
-    /// Private files are an explicit BitChat extension to the ordinary Noise
-    /// message-size ceiling. They remain bounded by the same framed-file cap
-    /// used by the binary and fragment decoders. Only the `.privateFile`
-    /// typed-payload path is allowed to use this larger budget.
-    private static let privateFileOuterPacketOverhead =
-        (BinaryProtocol.v1HeaderSize + 2) // v2 adds two length bytes
-        + BinaryProtocol.senderIDSize
-        + BinaryProtocol.recipientIDSize
-    static let maxPrivateFilePlaintextSize = FileTransferLimits.maxFramedFileBytes
-        - privateFileOuterPacketOverhead
-        - transportCiphertextOverhead
-    static let maxPrivateFileCiphertextSize =
-        maxPrivateFilePlaintextSize + transportCiphertextOverhead
     
     // Maximum handshake message size
     static let maxHandshakeMessageSize = 2048 // 2KB to accommodate XX pattern
-
-    // Noise XX message 1 contains only the initiator's 32-byte ephemeral key.
-    static let xxInitialMessageSize = 32
-
-    // Bounds an ordinary initiator whose message 1 or 2 is lost.
-    static let ordinaryHandshakeTimeout: TimeInterval = 10
-
-    // Bounds the receive-only rollback quarantine created by an unauthenticated
-    // inbound message 1. A lost message 3 must not strand outbound traffic.
-    static let ordinaryResponderHandshakeTimeout: TimeInterval = 20
-
-    // A released client may immediately retry after both crossed initiators
-    // yielded. Give that unilateral retry a brief head start before the
-    // patched side spends its one bounded recovery.
-    static let handshakeCollisionRecoveryDelay: TimeInterval = 0.2
-
-    // Rate-limited recovery remains actionable without spinning.
-    static let handshakeRateLimitRecoveryDelay: TimeInterval = 60
-
-    // Covers only reordering between a winning message 3 and the losing
-    // crossed message 1.
-    static let recentInitiatorCompletionGracePeriod: TimeInterval = 1
-
-    // After unauthenticated responder rollback, reject another attempt long
-    // enough that paced message 1 traffic cannot keep outbound paused. A
-    // legitimate peer converges through the one manager-owned local retry.
-    static let ordinaryReconnectRollbackCooldown: TimeInterval = 60
     
     // Session timeout - sessions older than this should be renegotiated
     static let sessionTimeout: TimeInterval = 86400 // 24 hours

bitchat/Noise/NoiseSecurityValidator.swift

@@ -14,19 +14,6 @@ struct NoiseSecurityValidator {
     static func validateMessageSize(_ data: Data) -> Bool {
         return data.count <= NoiseSecurityConstants.maxMessageSize
     }
-
-    static func validateCiphertextSize(_ data: Data) -> Bool {
-        data.count <= NoiseSecurityConstants.maxMessageSize
-            + NoiseSecurityConstants.transportCiphertextOverhead
-    }
-
-    static func validatePrivateFileMessageSize(_ data: Data) -> Bool {
-        data.count <= NoiseSecurityConstants.maxPrivateFilePlaintextSize
-    }
-
-    static func validatePrivateFileCiphertextSize(_ data: Data) -> Bool {
-        data.count <= NoiseSecurityConstants.maxPrivateFileCiphertextSize
-    }
     
     /// Validate handshake message size
     static func validateHandshakeMessageSize(_ data: Data) -> Bool {

bitchat/Noise/NoiseSession.swift

@@ -66,10 +66,7 @@ class NoiseSession {
             
             // Only initiator writes the first message
             if role == .initiator {
-                guard let handshake = handshakeState else {
+                let message = try handshakeState!.writeMessage()
-                    throw NoiseSessionError.invalidState
-                }
-                let message = try handshake.writeMessage()
                 sentHandshakeMessages.append(message)
                 return message
             } else {

bitchat/Noise/NoiseSessionError.swift

@@ -11,11 +11,4 @@ enum NoiseSessionError: Error, Equatable {
     case notEstablished
     case sessionNotFound
     case alreadyEstablished
-    case peerIdentityMismatch
-}
-
-/// The manager owns the exact attempt's one bounded recovery. Packet handling
-/// must not launch its historical second, immediate restart for this failure.
-struct NoiseManagedHandshakeFailure: Error {
-    let underlying: Error
 }

bitchat/Noise/SecureNoiseSession.swift

@@ -24,12 +24,8 @@ final class SecureNoiseSession: NoiseSession {
             throw NoiseSecurityError.sessionExhausted
         }
         
-        // Ordinary Noise messages keep the protocol ceiling. Finalized media
+        // Validate message size
-        // is the sole typed-payload extension and remains under the framed-file
+        guard NoiseSecurityValidator.validateMessageSize(plaintext) else {
-        // cap enforced again at the service and file-decoder layers.
-        let isPrivateFile = NoisePayloadType.isPrivateFile(rawValue: plaintext.first)
-            && NoiseSecurityValidator.validatePrivateFileMessageSize(plaintext)
-        guard NoiseSecurityValidator.validateMessageSize(plaintext) || isPrivateFile else {
             throw NoiseSecurityError.messageTooLarge
         }
         
@@ -46,11 +42,8 @@ final class SecureNoiseSession: NoiseSession {
             throw NoiseSecurityError.sessionExpired
         }
         
-        // The payload type is encrypted, so a large candidate can only be
+        // Validate message size
-        // bounded here; `NoiseEncryptionService.decrypt` authenticates it and
+        guard NoiseSecurityValidator.validateMessageSize(ciphertext) else {
-        // then requires the resulting type to be `.privateFile`.
-        guard NoiseSecurityValidator.validateCiphertextSize(ciphertext)
-                || NoiseSecurityValidator.validatePrivateFileCiphertextSize(ciphertext) else {
             throw NoiseSecurityError.messageTooLarge
         }
         

bitchat/Nostr/NostrProtocol.swift

@@ -700,10 +700,6 @@ struct NostrEvent: Codable {
               let content = dict["content"] as? String else {
             throw NostrError.invalidEvent
         }
-
-        guard Self.isWithinInboundTagLimits(tags) else {
-            throw NostrError.invalidEvent
-        }
         
         self.id = dict["id"] as? String ?? ""
         self.pubkey = pubkey
@@ -713,21 +709,6 @@ struct NostrEvent: Codable {
         self.content = content
         self.sig = dict["sig"] as? String
     }
-
-    /// Bounds untrusted relay tag arrays so attackers cannot force large
-    /// allocations or expensive joins on the inbound hot path.
-    static func isWithinInboundTagLimits(_ tags: [[String]]) -> Bool {
-        guard tags.count <= TransportConfig.nostrMaxEventTags else { return false }
-
-        for tag in tags {
-            guard tag.count <= TransportConfig.nostrMaxEventTagValues else { return false }
-            guard tag.allSatisfy({ $0.utf8.count <= TransportConfig.nostrMaxEventTagValueBytes }) else {
-                return false
-            }
-        }
-
-        return true
-    }
     
     func sign(with key: P256K.Schnorr.PrivateKey) throws -> NostrEvent {
         let (eventId, eventIdHash) = try calculateEventId()

bitchat/Nostr/NostrRelayManager.swift

@@ -1480,7 +1480,7 @@ private enum ParsedInbound {
     case notice(String)
     
     init?(_ message: URLSessionWebSocketTask.Message) {
-        guard let data = message.dataWithinInboundLimit,
+        guard let data = message.data,
               let array = try? JSONSerialization.jsonObject(with: data) as? [Any],
               array.count >= 2,
               let type = array[0] as? String else {
@@ -1525,19 +1525,11 @@ private enum ParsedInbound {
 }
 
 private extension URLSessionWebSocketTask.Message {
-    /// Prefer rejecting oversized frames before UTF-8/Data materialization
+    var data: Data? {
-    /// where we can (string length), and always before JSON parse.
-    var dataWithinInboundLimit: Data? {
-        let maxBytes = TransportConfig.nostrMaxInboundMessageBytes
         switch self {
-        case .string(let text):
+        case .string(let text): text.data(using: .utf8)
-            guard text.utf8.count <= maxBytes else { return nil }
+        case .data(let data):   data
-            return text.data(using: .utf8)
+        @unknown default:       nil
-        case .data(let data):
-            guard data.count <= maxBytes else { return nil }
-            return data
-        @unknown default:
-            return nil
         }
     }
 }

bitchat/Protocols/BitchatProtocol.swift

@@ -79,35 +79,12 @@ enum NoisePayloadType: UInt8 {
     case groupKeyUpdate = 0x07      // Creator-signed group state (key rotation / roster update)
     // Live voice (push-to-talk)
     case voiceFrame = 0x08          // One live voice-burst packet (see VoiceBurstPacket)
-    // Finalized private media. `0x20` is the value already deployed by the
-    // Android client. The complete BitchatFilePacket is encrypted inside
-    // Noise before the outer noiseEncrypted packet is fragmented.
-    case privateFile = 0x20
-    // Versioned peer state authenticated by the surrounding Noise session.
-    // This is intentionally distinct from the public announce: announce
-    // capabilities are discovery hints, while this payload proves possession
-    // of the advertised Noise static key before downgrade state is pinned.
-    case authenticatedPeerState = 0x21
     // Verification (QR-based OOB binding)
     case verifyChallenge = 0x10     // Verification challenge
     case verifyResponse  = 0x11     // Verification response
     // Transitive verification (web of trust)
     case vouch = 0x12               // Batch of vouch attestations
 
-    /// #1434 briefly used 0x09 before release. Accept it while prerelease
-    /// builds age out, but never emit it. Decoders canonicalize both values to
-    /// `.privateFile` so the compatibility alias cannot leak into app logic.
-    static let prereleasePrivateFileRawValue: UInt8 = 0x09
-
-    static func decoded(rawValue: UInt8) -> NoisePayloadType? {
-        rawValue == prereleasePrivateFileRawValue ? .privateFile : Self(rawValue: rawValue)
-    }
-
-    static func isPrivateFile(rawValue: UInt8?) -> Bool {
-        guard let rawValue else { return false }
-        return rawValue == privateFile.rawValue || rawValue == prereleasePrivateFileRawValue
-    }
-
     var description: String {
         switch self {
         case .privateMessage: return "privateMessage"
@@ -116,8 +93,6 @@ enum NoisePayloadType: UInt8 {
         case .groupInvite: return "groupInvite"
         case .groupKeyUpdate: return "groupKeyUpdate"
         case .voiceFrame: return "voiceFrame"
-        case .privateFile: return "privateFile"
-        case .authenticatedPeerState: return "authenticatedPeerState"
         case .verifyChallenge: return "verifyChallenge"
         case .verifyResponse: return "verifyResponse"
         case .vouch: return "vouch"

bitchat/Protocols/Packets.swift

@@ -156,89 +156,6 @@ struct AnnouncementPacket {
     }
 }
 
-/// State that is authoritative only because it is carried inside an
-/// established Noise session. The public announce remains useful for
-/// discovery, but its self-signature cannot prove possession of the copied
-/// Noise public key it contains.
-///
-/// Wire format (v1):
-/// `[version=0x01][type][length][value]...`
-/// - TLV `0x01`: canonical minimal little-endian `PeerCapabilities`
-/// - TLV `0x02`: 32-byte Ed25519 signing public key
-///
-/// Unknown TLVs are skipped for forward compatibility. Unknown versions,
-/// duplicates, non-canonical capability fields, and malformed lengths are
-/// rejected without changing authenticated state.
-struct AuthenticatedPeerStatePacket: Equatable {
-    static let currentVersion: UInt8 = 1
-    static let signingPublicKeyLength = 32
-
-    let capabilities: PeerCapabilities
-    let signingPublicKey: Data
-
-    private enum TLVType: UInt8 {
-        case capabilities = 0x01
-        case signingPublicKey = 0x02
-    }
-
-    func encode() -> Data? {
-        guard signingPublicKey.count == Self.signingPublicKeyLength else { return nil }
-        let capabilityBytes = capabilities.encoded()
-        guard !capabilityBytes.isEmpty, capabilityBytes.count <= 8 else { return nil }
-
-        var data = Data([Self.currentVersion])
-        data.append(TLVType.capabilities.rawValue)
-        data.append(UInt8(capabilityBytes.count))
-        data.append(capabilityBytes)
-        data.append(TLVType.signingPublicKey.rawValue)
-        data.append(UInt8(signingPublicKey.count))
-        data.append(signingPublicKey)
-        return data
-    }
-
-    static func decode(from data: Data) -> AuthenticatedPeerStatePacket? {
-        guard data.first == Self.currentVersion else { return nil }
-
-        var offset = 1
-        var capabilities: PeerCapabilities?
-        var signingPublicKey: Data?
-
-        while offset < data.count {
-            guard offset + 2 <= data.count else { return nil }
-            let typeRaw = data[offset]
-            let length = Int(data[offset + 1])
-            offset += 2
-            guard offset + length <= data.count else { return nil }
-            let value = Data(data[offset..<(offset + length)])
-            offset += length
-
-            guard let type = TLVType(rawValue: typeRaw) else {
-                continue
-            }
-            switch type {
-            case .capabilities:
-                guard capabilities == nil,
-                      !value.isEmpty,
-                      value.count <= 8 else { return nil }
-                let decoded = PeerCapabilities(encoded: value)
-                guard decoded.encoded() == value else { return nil }
-                capabilities = decoded
-
-            case .signingPublicKey:
-                guard signingPublicKey == nil,
-                      value.count == Self.signingPublicKeyLength else { return nil }
-                signingPublicKey = value
-            }
-        }
-
-        guard let capabilities, let signingPublicKey else { return nil }
-        return AuthenticatedPeerStatePacket(
-            capabilities: capabilities,
-            signingPublicKey: signingPublicKey
-        )
-    }
-}
-
 struct PrivateMessagePacket {
     let messageID: String
     let content: String

bitchat/Protocols/PeerCapabilities+Local.swift

@@ -3,5 +3,5 @@ import BitFoundation
 extension PeerCapabilities {
     /// Capabilities this build advertises in its announce packets.
     /// Each feature adds its bit here when it ships.
-    static let localSupported: PeerCapabilities = [.vouch, .prekeys, .groups, .privateMedia]
+    static let localSupported: PeerCapabilities = [.vouch, .prekeys, .groups]
 }

bitchat/Services/BLE/BLEAnnounceHandler.swift

@@ -16,9 +16,6 @@ struct BLEAnnounceHandlerEnvironment {
     let now: () -> Date
     /// Noise public key already recorded for the peer, if any (registry read).
     let existingNoisePublicKey: (PeerID) -> Data?
-    /// Ed25519 key previously bound to this Noise identity by an authenticated
-    /// peer-state payload, if any (persistent identity-state read).
-    let authenticatedSigningPublicKey: (_ noisePublicKey: Data) -> Data?
     /// Verifies the packet signature against the announced signing key.
     let verifySignature: (_ packet: BitchatPacket, _ signingPublicKey: Data) -> Bool
     /// Direct link state for the peer (BLE-queue read).
@@ -133,21 +130,11 @@ final class BLEAnnounceHandler {
             hasSignature: hasSignature,
             signatureValid: signatureValid,
             existingNoisePublicKey: existingNoisePublicKey,
-            announcedNoisePublicKey: announcement.noisePublicKey,
+            announcedNoisePublicKey: announcement.noisePublicKey
-            authenticatedSigningPublicKey: env.authenticatedSigningPublicKey(
-                announcement.noisePublicKey
-            ),
-            announcedSigningPublicKey: announcement.signingPublicKey
         )
         if case .reject(.keyMismatch) = trustDecision {
             SecureLogger.warning("⚠️ Announce key mismatch for \(peerID.id.prefix(8))… — keeping unverified", category: .security)
         }
-        if case .reject(.authenticatedSigningKeyMismatch) = trustDecision {
-            SecureLogger.warning(
-                "⚠️ Announce signing-key replacement rejected for Noise-authenticated peer \(peerID.id.prefix(8))…",
-                category: .security
-            )
-        }
         let verifiedAnnounce = trustDecision.isVerified
 
         var isNewPeer = false

bitchat/Services/BLE/BLEAnnounceHandlingPolicy.swift

@@ -56,7 +56,6 @@ enum BLEAnnounceTrustRejection: Equatable {
     case missingSignature
     case invalidSignature
     case keyMismatch
-    case authenticatedSigningKeyMismatch
 }
 
 enum BLEAnnounceTrustDecision: Equatable {
@@ -73,19 +72,12 @@ enum BLEAnnounceTrustPolicy {
         hasSignature: Bool,
         signatureValid: Bool,
         existingNoisePublicKey: Data?,
-        announcedNoisePublicKey: Data,
+        announcedNoisePublicKey: Data
-        authenticatedSigningPublicKey: Data? = nil,
-        announcedSigningPublicKey: Data? = nil
     ) -> BLEAnnounceTrustDecision {
         if let existingNoisePublicKey, existingNoisePublicKey != announcedNoisePublicKey {
             return .reject(.keyMismatch)
         }
 
-        if let authenticatedSigningPublicKey,
-           announcedSigningPublicKey != authenticatedSigningPublicKey {
-            return .reject(.authenticatedSigningKeyMismatch)
-        }
-
         guard hasSignature else {
             return .reject(.missingSignature)
         }

bitchat/Services/BLE/BLEFileTransferHandler.swift

@@ -16,8 +16,6 @@ struct BLEFileTransferHandlerEnvironment {
     let peersSnapshot: () -> [PeerID: BLEPeerInfo]
     /// Verifies a packet's signature against a candidate signing key (registry path).
     let verifyPacketSignature: (_ packet: BitchatPacket, _ signingPublicKey: Data) -> Bool
-    /// Local signing key used to authenticate our own gossip-sync replays.
-    let localSigningPublicKey: () -> Data
     /// Resolves a display name from a verified packet signature for peers missing from the registry.
     let signedSenderDisplayName: (_ packet: BitchatPacket, _ peerID: PeerID) -> String?
     /// Tracks the broadcast file packet for gossip sync.
@@ -48,105 +46,54 @@ final class BLEFileTransferHandler {
         self.environment = environment
     }
 
-    /// Returns `false` when the raw packet fails sender authentication (or is
+    /// Returns `false` when the packet fails sender authentication and must
-    /// a live self-echo) and must not be relayed onward. Authentication runs
+    /// not be relayed onward. Every other outcome returns `true`: files
-    /// before the routing decision, so a forged directed packet cannot use a
+    /// directed to another peer are forwarded untouched, and local-only drops
-    /// node that is not its recipient as an unsigned forwarding hop.
+    /// (malformed payload, quota, save failure) don't affect multi-hop
+    /// delivery to nodes that may handle them fine.
     @discardableResult
     func handle(_ packet: BitchatPacket, from peerID: PeerID) -> Bool {
         let env = environment
-        let localPeerID = env.localPeerID()
+        if BLEFileTransferPolicy.isSelfEcho(packet: packet, from: peerID, localPeerID: env.localPeerID()) { return true }
-        let peersSnapshot = env.peersSnapshot()
 
-        guard let senderNickname = authenticatedRawSenderNickname(
+        guard let deliveryPlan = BLEFileTransferPolicy.deliveryPlan(packet: packet, localPeerID: env.localPeerID()) else {
+            return true
+        }
+
+        let peersSnapshot = env.peersSnapshot()
+        guard let senderNickname = resolveSenderNickname(
             packet: packet,
             from: peerID,
+            isBroadcast: !deliveryPlan.isPrivateMessage,
             peers: peersSnapshot,
             env: env
         ) else {
-            SecureLogger.warning("🚫 Dropping raw file transfer with missing/invalid signature from \(peerID.id.prefix(8))…", category: .security)
+            SecureLogger.warning("🚫 Dropping file transfer from unverified or unknown peer \(peerID.id.prefix(8))…", category: .security)
             return false
         }
 
-        if BLEFileTransferPolicy.isSelfEcho(packet: packet, from: peerID, localPeerID: localPeerID) {
-            return false
-        }
-
-        guard let deliveryPlan = BLEFileTransferPolicy.deliveryPlan(packet: packet, localPeerID: localPeerID) else {
-            return true
-        }
-
         if deliveryPlan.shouldTrackForSync {
             env.trackPacketSeen(packet)
         }
 
-        _ = storeIncomingPayload(
-            packet.payload,
-            from: peerID,
-            senderNickname: senderNickname,
-            timestamp: Date(timeIntervalSince1970: Double(packet.timestamp) / 1000),
-            isPrivate: deliveryPlan.isPrivateMessage,
-            env: env
-        )
-        // Once authenticated, a local decode/quota/save failure is not proof
-        // that downstream nodes should be denied the valid signed packet.
-        return true
-    }
-
-    /// Accepts a file packet only after it has been authenticated and
-    /// decrypted by the peer's Noise session. The inner packet deliberately
-    /// has no redundant signature: Noise supplies sender authentication and
-    /// confidentiality, while this handler retains the same validation,
-    /// quota, persistence, and UI-delivery behavior as public files.
-    @discardableResult
-    func handlePrivatePayload(_ payload: Data, from peerID: PeerID, timestamp: Date) -> Bool {
-        let env = environment
-        let peers = env.peersSnapshot()
-        let senderNickname = BLEPeerSenderDisplayName.resolveKnownPeer(
-            peerID: peerID,
-            localPeerID: env.localPeerID(),
-            localNickname: env.localNickname(),
-            peers: peers,
-            allowConnectedUnverified: true
-        ) ?? BLEPeerSenderDisplayName.anonymousNickname(for: peerID)
-
-        return storeIncomingPayload(
-            payload,
-            from: peerID,
-            senderNickname: senderNickname,
-            timestamp: timestamp,
-            isPrivate: true,
-            env: env
-        )
-    }
-
-    private func storeIncomingPayload(
-        _ payload: Data,
-        from peerID: PeerID,
-        senderNickname: String,
-        timestamp: Date,
-        isPrivate: Bool,
-        env: BLEFileTransferHandlerEnvironment
-    ) -> Bool {
-
         let filePacket: BitchatFilePacket
         let mime: MimeType
-        switch BLEIncomingFileValidator.validate(payload: payload) {
+        switch BLEIncomingFileValidator.validate(payload: packet.payload) {
         case .success(let acceptance):
             filePacket = acceptance.filePacket
             mime = acceptance.mime
         case .failure(.malformedPayload):
             SecureLogger.error("❌ Failed to decode file transfer payload", category: .session)
-            return false
+            return true
         case .failure(.payloadTooLarge(let bytes)):
             SecureLogger.warning("🚫 Dropping file transfer exceeding size cap (\(bytes) bytes)", category: .security)
-            return false
+            return true
         case .failure(.unsupportedMime(let mimeType, let bytes)):
             SecureLogger.warning("🚫 MIME REJECT: '\(mimeType ?? "<empty>")' not supported. Size=\(bytes)b from \(peerID.id.prefix(8))...", category: .security)
-            return false
+            return true
         case .failure(.magicMismatch(let mime, let bytes, let prefixHex)):
             SecureLogger.warning("🚫 MAGIC REJECT: MIME='\(mime)' size=\(bytes)b prefix=[\(prefixHex)] from \(peerID.id.prefix(8))...", category: .security)
-            return false
+            return true
         }
 
         // BCH-01-002: Enforce storage quota before saving
@@ -159,27 +106,28 @@ final class BLEFileTransferHandler {
             mime.defaultExtension,
             mime.category.rawValue
         ) else {
-            return false
+            return true
         }
 
-        if isPrivate {
+        if deliveryPlan.isPrivateMessage {
             env.updatePeerLastSeen(peerID)
         }
 
+        let ts = Date(timeIntervalSince1970: Double(packet.timestamp) / 1000)
         let message = BitchatMessage(
             sender: senderNickname,
             content: "\(mime.category.messagePrefix)\(destination.lastPathComponent)",
-            timestamp: timestamp,
+            timestamp: ts,
             isRelay: false,
             originalSender: nil,
-            isPrivate: isPrivate,
+            isPrivate: deliveryPlan.isPrivateMessage,
             recipientNickname: nil,
             senderPeerID: peerID,
             // Received messages need an explicit status: BitchatMessage
             // defaults private messages to .sending, which the media views
             // render as an in-flight send (empty reveal mask, disabled tap).
-            deliveryStatus: isPrivate
+            deliveryStatus: deliveryPlan.isPrivateMessage
-                ? .delivered(to: env.localNickname(), at: timestamp)
+                ? .delivered(to: env.localNickname(), at: ts)
                 : nil
         )
 
@@ -189,38 +137,51 @@ final class BLEFileTransferHandler {
         return true
     }
 
-    /// Every remaining raw file transfer is signed, regardless of whether it
+    /// Resolves the authenticated display name for a file transfer's sender.
-    /// is broadcast, addressed to us, or merely passing through. Registry
+    ///
-    /// signing keys are preferred; persisted identities cover peers that have
+    /// Directed (private) transfers are addressed to us specifically and keep
-    /// rotated or are not currently present in the registry.
+    /// the lenient connected-peer path. Broadcast transfers carry an
-    private func authenticatedRawSenderNickname(
+    /// attacker-controllable `senderID` exactly like public messages and public
+    /// voice frames — registry membership alone is NOT proof of identity, so a
+    /// valid packet signature from the claimed sender is required before we
+    /// trust it. Without this, a peer that observed a public voice burst could
+    /// spoof a broadcast `voice_<burstID>.m4a` note under the talker's ID and
+    /// overwrite the signature-verified live bubble with attacker audio.
+    private func resolveSenderNickname(
         packet: BitchatPacket,
         from peerID: PeerID,
+        isBroadcast: Bool,
         peers: [PeerID: BLEPeerInfo],
         env: BLEFileTransferHandlerEnvironment
     ) -> String? {
-        guard packet.signature != nil else { return nil }
+        guard isBroadcast else {
+            return BLEPeerSenderDisplayName.resolveKnownPeer(
+                peerID: peerID,
+                localPeerID: env.localPeerID(),
+                localNickname: env.localNickname(),
+                peers: peers,
+                allowConnectedUnverified: true
+            ) ?? env.signedSenderDisplayName(packet, peerID)
+        }
 
-        let localPeerID = env.localPeerID()
+        // Our own broadcasts replayed back via gossip sync (ttl==0) are
-        let candidateKey = peerID == localPeerID
+        // trivially authentic and cannot be verified against the peer registry
-            ? env.localSigningPublicKey()
+        // or identity cache, so exempt self exactly as `BLEPublicMessageHandler`
-            : peers[peerID]?.signingPublicKey
+        // does. Verify against the signing key already in the
-        let verifiedWithKnownKey = candidateKey.map {
+        // (synchronously-updated) registry first, then fall back to the
-            env.verifyPacketSignature(packet, $0)
+        // persisted-identity signature lookup for peers not yet cached there.
-        } ?? false
+        let isSelf = peerID == env.localPeerID()
-        let signedDisplayName = verifiedWithKnownKey
+        let registrySigningKey = peers[peerID]?.signingPublicKey
-            ? nil
+        let verifiedViaRegistry = !isSelf && (registrySigningKey.map { env.verifyPacketSignature(packet, $0) } ?? false)
-            : env.signedSenderDisplayName(packet, peerID)
+        let signedDisplayName = (isSelf || verifiedViaRegistry) ? nil : env.signedSenderDisplayName(packet, peerID)
-        guard verifiedWithKnownKey || signedDisplayName != nil else { return nil }
+        guard isSelf || verifiedViaRegistry || signedDisplayName != nil else { return nil }
 
         return BLEPeerSenderDisplayName.resolveKnownPeer(
             peerID: peerID,
-            localPeerID: localPeerID,
+            localPeerID: env.localPeerID(),
             localNickname: env.localNickname(),
             peers: peers,
-            // The packet signature authenticates the announced peer; the old
+            allowConnectedUnverified: false
-            // connected-but-unsigned leniency is not involved.
+        ) ?? signedDisplayName
-            allowConnectedUnverified: true
-        ) ?? signedDisplayName ?? BLEPeerSenderDisplayName.anonymousNickname(for: peerID)
     }
 }

bitchat/Services/BLE/BLEFragmentAssemblyBuffer.swift

@@ -201,11 +201,8 @@ struct BLEFragmentAssemblyBuffer {
     }
 
     private static func assemblyLimit(for originalType: UInt8) -> Int {
-        if originalType == MessageType.fileTransfer.rawValue
+        if originalType == MessageType.fileTransfer.rawValue {
-            || originalType == MessageType.noiseEncrypted.rawValue {
             // Allow headroom for TLV metadata and binary framing overhead.
-            // A large noiseEncrypted packet can be an E2E-encrypted private
-            // file; its authenticated plaintext is validated after decrypt.
             return FileTransferLimits.maxFramedFileBytes
         }
 

bitchat/Services/BLE/BLEIncomingFileStore.swift

@@ -2,124 +2,8 @@ import BitLogger
 import BitFoundation
 import Foundation
 
-struct PanicRecoveryIntent {
-    let fileMarkerEstablished: Bool
-    let externalMarkerEstablished: Bool
-
-    var hasDurableMarker: Bool {
-        fileMarkerEstablished || externalMarkerEstablished
-    }
-}
-
-/// Small, dependency-injectable transaction surface used by ChatViewModel.
-/// Production persists the same intent in two independent locations before
-/// any application state is erased. Tests can inject an ephemeral operation
-/// set without touching the developer's Application Support directory.
-struct PanicRecoveryOperations {
-    let isPending: () throws -> Bool
-    let begin: () -> PanicRecoveryIntent
-    let wipeMedia: (PanicRecoveryIntent) throws -> Void
-    let complete: () throws -> Void
-
-    static func ephemeral(
-        wipeMedia: @escaping () throws -> Void = {}
-    ) -> PanicRecoveryOperations {
-        PanicRecoveryOperations(
-            isPending: { false },
-            begin: {
-                PanicRecoveryIntent(
-                    fileMarkerEstablished: false,
-                    externalMarkerEstablished: false
-                )
-            },
-            wipeMedia: { _ in try wipeMedia() },
-            complete: {}
-        )
-    }
-
-    static func live(
-        fileStore: BLEIncomingFileStore = BLEIncomingFileStore(),
-        defaults: UserDefaults = .standard
-    ) -> PanicRecoveryOperations {
-        let defaultsKey = "bitchat.panicResetPending"
-        return PanicRecoveryOperations(
-            isPending: {
-                if defaults.bool(forKey: defaultsKey) {
-                    return true
-                }
-                return try fileStore.isPanicRecoveryPending()
-            },
-            begin: {
-                defaults.set(true, forKey: defaultsKey)
-                let externalMarkerEstablished =
-                    defaults.synchronize()
-                    && defaults.bool(forKey: defaultsKey)
-
-                let fileMarkerEstablished: Bool
-                do {
-                    try fileStore.markPanicRecoveryPending()
-                    fileMarkerEstablished = true
-                } catch {
-                    fileMarkerEstablished = false
-                    SecureLogger.error(
-                        "Failed to persist file panic-recovery marker: \(error)",
-                        category: .security
-                    )
-                }
-
-                return PanicRecoveryIntent(
-                    fileMarkerEstablished: fileMarkerEstablished,
-                    externalMarkerEstablished: externalMarkerEstablished
-                )
-            },
-            wipeMedia: { intent in
-                try fileStore.panicWipe(
-                    hasDurablePendingMarker: intent.hasDurableMarker
-                )
-            },
-            complete: {
-                // Keep the independent defaults latch until the file marker
-                // has definitely cleared. Any failure therefore remains
-                // visible to the next launch.
-                try fileStore.completePanicRecovery()
-                defaults.removeObject(forKey: defaultsKey)
-                guard defaults.synchronize(),
-                      !defaults.bool(forKey: defaultsKey) else {
-                    throw BLEIncomingFileStore.PanicRecoveryError
-                        .externalMarkerCommitFailed
-                }
-            }
-        )
-    }
-}
-
 struct BLEIncomingFileStore {
-    enum PanicRecoveryError: Error {
-        case externalMarkerCommitFailed
-        case markerWriteFailed(Error)
-        case markerWriteAndMediaWipeFailed(
-            markerError: Error,
-            mediaError: Error
-        )
-    }
-
     private static let quotaBytes: Int64 = 100 * 1024 * 1024
-    /// Kept outside `files/` so deleting the media tree cannot erase the
-    /// fail-closed startup decision before the full panic has committed.
-    private static let panicRecoveryPendingMarkerFileName =
-        ".panic-recovery-pending"
-    /// Compatibility with a short-lived development build that used the
-    /// media-specific name for the same full-transaction latch.
-    private static let legacyPanicRecoveryPendingMarkerFileName =
-        ".panic-media-wipe-pending"
-    private static let mediaSubdirectories = [
-        "voicenotes/incoming",
-        "voicenotes/outgoing",
-        "images/incoming",
-        "images/outgoing",
-        "files/incoming",
-        "files/outgoing"
-    ]
 
     /// Name prefix of in-flight live voice captures (progressively written by
     /// `ChatLiveVoiceCoordinator`). Quota eviction skips them by pattern —
@@ -133,96 +17,11 @@ struct BLEIncomingFileStore {
     let fileManager: FileManager
     private let baseDirectory: URL?
     private let dateProvider: () -> Date
-    private let panicMarkerWriter: (Data, URL) throws -> Void
 
-    init(
+    init(fileManager: FileManager = .default, baseDirectory: URL? = nil, dateProvider: @escaping () -> Date = Date.init) {
-        fileManager: FileManager = .default,
-        baseDirectory: URL? = nil,
-        dateProvider: @escaping () -> Date = Date.init,
-        panicMarkerWriter: @escaping (Data, URL) throws -> Void = {
-            try $0.write(to: $1, options: .atomic)
-        }
-    ) {
         self.fileManager = fileManager
         self.baseDirectory = baseDirectory
         self.dateProvider = dateProvider
-        self.panicMarkerWriter = panicMarkerWriter
-    }
-
-    /// Panic-wipe every managed incoming and outgoing media artifact before
-    /// returning. Recreating the directory tree keeps later capture/receive
-    /// paths usable without allowing a detached cleanup task to race them.
-    ///
-    /// Marker persistence and deletion are deliberately separate error
-    /// domains: even when both durable marker channels fail, deletion is
-    /// still attempted before this method reports the marker failure.
-    func panicWipe(
-        hasDurablePendingMarker: Bool = false
-    ) throws {
-        let markerError: Error?
-        do {
-            try markPanicRecoveryPending()
-            markerError = nil
-        } catch {
-            markerError = error
-            SecureLogger.error(
-                "Could not persist file panic-recovery marker; attempting media deletion anyway: \(error)",
-                category: .security
-            )
-        }
-
-        do {
-            let filesDirectory = try rootDirectory()
-                .appendingPathComponent("files", isDirectory: true)
-            if fileManager.fileExists(atPath: filesDirectory.path) {
-                try fileManager.removeItem(at: filesDirectory)
-            }
-            for subdirectory in Self.mediaSubdirectories {
-                try fileManager.createDirectory(
-                    at: filesDirectory.appendingPathComponent(
-                        subdirectory,
-                        isDirectory: true
-                    ),
-                    withIntermediateDirectories: true,
-                    attributes: nil
-                )
-            }
-        } catch {
-            if let markerError {
-                throw PanicRecoveryError.markerWriteAndMediaWipeFailed(
-                    markerError: markerError,
-                    mediaError: error
-                )
-            }
-            throw error
-        }
-
-        if let markerError, !hasDurablePendingMarker {
-            throw PanicRecoveryError.markerWriteFailed(markerError)
-        }
-    }
-
-    func markPanicRecoveryPending() throws {
-        let markerURL = try panicRecoveryPendingMarkerURL()
-        try fileManager.createDirectory(
-            at: markerURL.deletingLastPathComponent(),
-            withIntermediateDirectories: true,
-            attributes: nil
-        )
-        try panicMarkerWriter(Data([1]), markerURL)
-    }
-
-    func isPanicRecoveryPending() throws -> Bool {
-        try panicRecoveryMarkerURLs().contains {
-            fileManager.fileExists(atPath: $0.path)
-        }
-    }
-
-    func completePanicRecovery() throws {
-        for markerURL in try panicRecoveryMarkerURLs()
-        where fileManager.fileExists(atPath: markerURL.path) {
-            try fileManager.removeItem(at: markerURL)
-        }
     }
 
     /// Resolves (and creates) an incoming-media directory for callers that
@@ -314,39 +113,15 @@ struct BLEIncomingFileStore {
     }
 
     private func filesDirectory() throws -> URL {
-        let filesDir = try rootDirectory().appendingPathComponent("files", isDirectory: true)
+        let root = try baseDirectory ?? fileManager.url(
-        try fileManager.createDirectory(at: filesDir, withIntermediateDirectories: true, attributes: nil)
-        return filesDir
-    }
-
-    private func rootDirectory() throws -> URL {
-        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)
-    private func panicRecoveryPendingMarkerURL() throws -> URL {
+        return filesDir
-        try rootDirectory().appendingPathComponent(
-            Self.panicRecoveryPendingMarkerFileName,
-            isDirectory: false
-        )
-    }
-
-    private func panicRecoveryMarkerURLs() throws -> [URL] {
-        let root = try rootDirectory()
-        return [
-            root.appendingPathComponent(
-                Self.panicRecoveryPendingMarkerFileName,
-                isDirectory: false
-            ),
-            root.appendingPathComponent(
-                Self.legacyPanicRecoveryPendingMarkerFileName,
-                isDirectory: false
-            )
-        ]
     }
 
     private func sanitizedFileName(_ name: String?, defaultName: String, fallbackExtension: String?) -> String {

bitchat/Services/BLE/BLENoisePacketHandler.swift

@@ -2,11 +2,6 @@ import BitFoundation
 import BitLogger
 import Foundation
 
-struct BLENoiseDecryptionResult {
-    let plaintext: Data
-    let sessionGeneration: UUID
-}
-
 /// Narrow environment for `BLENoisePacketHandler`.
 ///
 /// All queue hops (collections barrier writes, main-actor UI notification)
@@ -32,16 +27,9 @@ struct BLENoisePacketHandlerEnvironment {
     /// Updates the registry last-seen timestamp for the peer (async barrier write).
     let updatePeerLastSeen: (PeerID) -> Void
     /// Decrypts an encrypted payload from the peer (crypto).
-    let decrypt: (_ payload: Data, _ peerID: PeerID) throws -> BLENoiseDecryptionResult
+    let decrypt: (_ payload: Data, _ peerID: PeerID) throws -> Data
     /// Clears the peer's Noise session after an unrecoverable decrypt failure (crypto).
     let clearSession: (PeerID) -> Void
-    /// Consumes session-authenticated protocol state inside the transport. It
-    /// must never escape to UI or Nostr payload dispatch.
-    let handleAuthenticatedPeerState: (
-        _ peerID: PeerID,
-        _ payload: Data,
-        _ sessionGeneration: UUID
-    ) -> Void
     /// Delivers `.noisePayloadReceived` to the UI as one main-actor hop.
     let deliverNoisePayload: (
         _ peerID: PeerID,
@@ -61,11 +49,7 @@ final class BLENoisePacketHandler {
         self.environment = environment
     }
 
-    /// Returns true when the handshake message was processed successfully.
+    func handleHandshake(_ packet: BitchatPacket, from peerID: PeerID) {
-    /// Callers use this to distinguish an authenticated reconnect completion
-    /// from a rejected ordinary responder while rollback state is restored.
-    @discardableResult
-    func handleHandshake(_ packet: BitchatPacket, from peerID: PeerID) -> Bool {
         let env = environment
         // Use NoiseEncryptionService for handshake processing
         if PeerID(hexData: packet.recipientID) == env.localPeerID() {
@@ -88,31 +72,14 @@ final class BLENoisePacketHandler {
 
                 // Session establishment will trigger onPeerAuthenticated callback
                 // which will send any pending messages at the right time
-                return true
-            } catch let managedFailure as NoiseManagedHandshakeFailure {
-                SecureLogger.error(
-                    "Failed to process handshake; manager owns recovery: \(managedFailure.underlying)"
-                )
-                return false
-            } catch NoiseSessionError.peerIdentityMismatch {
-                // The responder was already discarded by the session manager.
-                // Do not let a spoofed claimed ID trigger a fresh outbound
-                // handshake or recreate state for the attacker-selected ID.
-                SecureLogger.warning(
-                    "Rejected Noise handshake whose static key does not match \(peerID.id.prefix(8))…",
-                    category: .security
-                )
-                return false
             } catch {
                 SecureLogger.error("Failed to process handshake: \(error)")
                 // Try initiating a new handshake
                 if !env.hasNoiseSession(peerID) {
                     env.initiateHandshake(peerID)
                 }
-                return false
             }
         }
-        return false
     }
 
     func handleEncrypted(_ packet: BitchatPacket, from peerID: PeerID) {
@@ -131,30 +98,20 @@ final class BLENoisePacketHandler {
         env.updatePeerLastSeen(peerID)
 
         do {
-            let decryption = try env.decrypt(packet.payload, peerID)
+            let decrypted = try env.decrypt(packet.payload, peerID)
-            let decrypted = decryption.plaintext
             guard decrypted.count > 0 else { return }
 
             // First byte indicates the payload type
             let payloadType = decrypted[0]
             let payloadData = decrypted.dropFirst()
 
-            guard let noisePayloadType = NoisePayloadType.decoded(rawValue: payloadType) else {
+            guard let noisePayloadType = NoisePayloadType(rawValue: payloadType) else {
                 SecureLogger.warning("⚠️ Unknown noise payload type: \(payloadType)")
                 return
             }
 
             SecureLogger.debug("🔐 Decrypted noise payload type \(noisePayloadType.description) from \(peerID.id.prefix(8))…", category: .session)
 
-            if noisePayloadType == .authenticatedPeerState {
-                env.handleAuthenticatedPeerState(
-                    peerID,
-                    Data(payloadData),
-                    decryption.sessionGeneration
-                )
-                return
-            }
-
             let ts = Date(timeIntervalSince1970: Double(packet.timestamp) / 1000)
             env.deliverNoisePayload(peerID, noisePayloadType, Data(payloadData), ts)
         } catch NoiseEncryptionError.sessionNotEstablished {

bitchat/Services/BLE/BLENoisePayloadFactory.swift

@@ -17,16 +17,6 @@ enum BLENoisePayloadFactory {
         typedPayload(.delivered, payload: Data(messageID.utf8))
     }
 
-    static func privateFile(_ filePacket: BitchatFilePacket) -> Data? {
-        guard let payload = filePacket.encode() else { return nil }
-        return typedPayload(.privateFile, payload: payload)
-    }
-
-    static func authenticatedPeerState(_ state: AuthenticatedPeerStatePacket) -> Data? {
-        guard let payload = state.encode() else { return nil }
-        return typedPayload(.authenticatedPeerState, payload: payload)
-    }
-
     static func typedPayload(_ type: NoisePayloadType, payload: Data) -> Data {
         var typed = Data([type.rawValue])
         typed.append(payload)

bitchat/Services/BLE/BLENoiseReconnectPolicy.swift

@@ -1,40 +0,0 @@
-import Foundation
-
-/// Bounds ordinary Noise revalidation to one attempt per physical-link epoch.
-/// A live epoch may retry after the cooldown so a lost handshake cannot leave
-/// the link permanently unauthenticated.
-struct BLENoiseReconnectPolicy {
-    static let minimumRetryInterval: TimeInterval = 60
-
-    private var lastAttemptAt: [BLEIngressLinkID: Date] = [:]
-
-    mutating func shouldRevalidate(
-        on link: BLEIngressLinkID,
-        hasEstablishedSession: Bool,
-        isNoiseAuthenticatedLink: Bool,
-        hasAuthenticatedPeerLink: Bool,
-        now: Date
-    ) -> Bool {
-        guard hasEstablishedSession,
-              !isNoiseAuthenticatedLink,
-              !hasAuthenticatedPeerLink else {
-            return false
-        }
-        if let previous = lastAttemptAt[link],
-           now.timeIntervalSince(previous) < Self.minimumRetryInterval {
-            return false
-        }
-        lastAttemptAt[link] = now
-        return true
-    }
-
-    /// Link identifiers can be stable across CoreBluetooth reconnects, so a
-    /// disconnect explicitly starts a new epoch and permits one fresh attempt.
-    mutating func endLinkEpoch(_ link: BLEIngressLinkID) {
-        lastAttemptAt.removeValue(forKey: link)
-    }
-
-    mutating func removeAll() {
-        lastAttemptAt.removeAll()
-    }
-}

bitchat/Services/BLE/BLENoiseSessionQueues.swift

@@ -6,16 +6,9 @@ struct BLEPendingPrivateMessage: Equatable {
     let messageID: String
 }
 
-struct BLEPendingTypedPayload: Equatable {
-    let payload: Data
-    /// Present for app-initiated media so handshake queuing preserves the
-    /// fragment scheduler's progress/cancellation identity.
-    let transferId: String?
-}
-
 struct BLENoiseSessionQueues {
     private var privateMessagesByPeerID: [PeerID: [BLEPendingPrivateMessage]] = [:]
-    private var typedPayloadsByPeerID: [PeerID: [BLEPendingTypedPayload]] = [:]
+    private var typedPayloadsByPeerID: [PeerID: [Data]] = [:]
 
     var isEmpty: Bool {
         privateMessagesByPeerID.isEmpty && typedPayloadsByPeerID.isEmpty
@@ -41,35 +34,13 @@ struct BLENoiseSessionQueues {
         privateMessagesByPeerID[peerID, default: []].insert(contentsOf: messages, at: 0)
     }
 
-    mutating func appendTypedPayload(_ payload: Data, transferId: String? = nil, for peerID: PeerID) {
+    mutating func appendTypedPayload(_ payload: Data, for peerID: PeerID) {
-        typedPayloadsByPeerID[peerID, default: []].append(
+        typedPayloadsByPeerID[peerID, default: []].append(payload)
-            BLEPendingTypedPayload(payload: payload, transferId: transferId)
-        )
     }
 
-    mutating func takeTypedPayloads(for peerID: PeerID) -> [BLEPendingTypedPayload] {
+    mutating func takeTypedPayloads(for peerID: PeerID) -> [Data] {
         let payloads = typedPayloadsByPeerID[peerID] ?? []
         typedPayloadsByPeerID.removeValue(forKey: peerID)
         return payloads
     }
-
-    func containsTypedPayload(transferId: String) -> Bool {
-        typedPayloadsByPeerID.values.contains { payloads in
-            payloads.contains { $0.transferId == transferId }
-        }
-    }
-
-    @discardableResult
-    mutating func removeTypedPayload(transferId: String) -> Bool {
-        for peerID in Array(typedPayloadsByPeerID.keys) {
-            guard var payloads = typedPayloadsByPeerID[peerID],
-                  let index = payloads.firstIndex(where: { $0.transferId == transferId }) else {
-                continue
-            }
-            payloads.remove(at: index)
-            typedPayloadsByPeerID[peerID] = payloads.isEmpty ? nil : payloads
-            return true
-        }
-        return false
-    }
 }

bitchat/Services/BLE/BLEOutboundFragmentPlanner.swift

@@ -17,9 +17,6 @@ struct BLEOutboundFragmentPlan {
 }
 
 enum BLEOutboundFragmentPlanner {
-    /// Current Android receivers reject fragment sets above 256. Private
-    /// media v1 treats that deployed ceiling as a cross-platform contract.
-    static let privateMediaV1MaxFragments = 256
     private static let minimumChunkSize = 64
     private static let fragmentIDLength = 8
 
@@ -74,10 +71,6 @@ enum BLEOutboundFragmentPlanner {
         )
     }
 
-    static func isPrivateMediaV1Compatible(_ plan: BLEOutboundFragmentPlan) -> Bool {
-        plan.totalFragments <= privateMediaV1MaxFragments
-    }
-
     private static func sizingPolicy(
         for packet: BitchatPacket,
         requestedMaxChunk: Int?,

bitchat/Services/BLE/BLEOutboundFragmentTransferScheduler.swift

@@ -29,9 +29,8 @@ struct BLEOutboundFragmentTransferRequest {
     }
 
     var resolvedTransferId: String? {
-        if let transferId { return transferId }
         guard packet.type == MessageType.fileTransfer.rawValue else { return nil }
-        return packet.payload.sha256Hex()
+        return transferId ?? packet.payload.sha256Hex()
     }
 
     /// Content identity independent of the caller-chosen transfer ID: the

bitchat/Services/BLE/BLEPeerRegistry.swift

@@ -10,9 +10,6 @@ struct BLEPeerInfo: Equatable {
     var isVerifiedNickname: Bool
     var lastSeen: Date
     var capabilities: PeerCapabilities = []
-    /// Distinguishes an old client that omitted the capabilities TLV from a
-    /// modern client that explicitly advertised a set without a given bit.
-    var capabilitiesWereExplicitlyAdvertised: Bool = false
     /// Rendezvous cell from the peer's announce when it advertises `.bridge`.
     var bridgeGeohash: String?
 }
@@ -117,10 +114,6 @@ struct BLEPeerRegistry {
         peers[peerID.toShort()]?.capabilities ?? []
     }
 
-    func capabilitiesWereExplicitlyAdvertised(for peerID: PeerID) -> Bool {
-        peers[peerID.toShort()]?.capabilitiesWereExplicitlyAdvertised == true
-    }
-
     /// Peers whose last verified announce advertised the given capability.
     func peers(advertising capability: PeerCapabilities) -> [PeerID] {
         peers.values.filter { $0.capabilities.contains(capability) }.map(\.peerID)
@@ -181,14 +174,6 @@ struct BLEPeerRegistry {
         peers[peerID] = peer
     }
 
-    /// Replaces the announcement signing key only after the surrounding Noise
-    /// session proved possession of this peer's static key.
-    mutating func bindAuthenticatedSigningPublicKey(_ key: Data, for peerID: PeerID) {
-        guard var peer = peers[peerID.toShort()] else { return }
-        peer.signingPublicKey = key
-        peers[peer.peerID] = peer
-    }
-
     mutating func upsertVerifiedAnnounce(
         peerID: PeerID,
         nickname: String,
@@ -196,7 +181,7 @@ struct BLEPeerRegistry {
         signingPublicKey: Data?,
         isConnected: Bool,
         now: Date,
-        capabilities: PeerCapabilities? = nil,
+        capabilities: PeerCapabilities = [],
         bridgeGeohash: String? = nil
     ) -> BLEPeerAnnounceUpdate {
         let existing = peers[peerID]
@@ -214,8 +199,7 @@ struct BLEPeerRegistry {
             signingPublicKey: signingPublicKey,
             isVerifiedNickname: true,
             lastSeen: now,
-            capabilities: capabilities ?? [],
+            capabilities: capabilities,
-            capabilitiesWereExplicitlyAdvertised: capabilities != nil,
             bridgeGeohash: bridgeGeohash
         )
 

bitchat/Services/GeohashPresenceService.swift

@@ -45,9 +45,6 @@ final class GeohashPresenceService: ObservableObject {
 
     private var subscriptions = Set<AnyCancellable>()
     private var heartbeatTimer: GeohashPresenceTimerProtocol?
-    private var pendingBroadcastTasks: [UUID: Task<Void, Never>] = [:]
-    private var heartbeatGeneration: UInt64 = 0
-    private var started = false
     private let availableChannelsProvider: () -> [GeohashChannel]
     private let locationChanges: AnyPublisher<[GeohashChannel], Never>
     private let torReadyPublisher: AnyPublisher<Void, Never>
@@ -150,25 +147,10 @@ final class GeohashPresenceService: ObservableObject {
     
     /// Start the service (safe to call multiple times)
     func start() {
-        guard !started else { return }
-        started = true
-        heartbeatGeneration &+= 1
         SecureLogger.info("Presence: service starting...", category: .session)
         scheduleNextHeartbeat()
     }
 
-    /// Stops the timer and every decorrelation task synchronously at the panic
-    /// boundary. Generation checks also protect against custom sleepers that
-    /// ignore task cancellation and return later.
-    func stopForPanic() {
-        started = false
-        heartbeatGeneration &+= 1
-        heartbeatTimer?.invalidate()
-        heartbeatTimer = nil
-        pendingBroadcastTasks.values.forEach { $0.cancel() }
-        pendingBroadcastTasks.removeAll(keepingCapacity: false)
-    }
-
     private func setupObservers() {
         // Monitor location channel changes
         locationChanges
@@ -187,26 +169,20 @@ final class GeohashPresenceService: ObservableObject {
     }
 
     func handleLocationChange() {
-        guard started else { return }
         // 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
-        let generation = heartbeatGeneration
         heartbeatTimer = scheduleTimer(5.0) { [weak self] in
             Task { @MainActor [weak self] in
-                guard let self,
+                self?.performHeartbeat()
-                      self.started,
-                      self.heartbeatGeneration == generation else { return }
-                self.performHeartbeat()
             }
         }
     }
     
     func handleConnectivityChange() {
-        guard started else { return }
         SecureLogger.debug("Presence: connectivity restored, triggering heartbeat", category: .session)
         // If we were waiting for network, do it now
         if heartbeatTimer == nil || !heartbeatTimer!.isValid {
@@ -215,29 +191,18 @@ final class GeohashPresenceService: ObservableObject {
     }
 
     func scheduleNextHeartbeat() {
-        guard started else { return }
         heartbeatTimer?.invalidate()
         let interval = TimeInterval.random(in: loopMinInterval...loopMaxInterval)
-        let generation = heartbeatGeneration
         heartbeatTimer = scheduleTimer(interval) { [weak self] in
             Task { @MainActor [weak self] in
-                guard let self,
+                self?.performHeartbeat()
-                      self.started,
-                      self.heartbeatGeneration == generation else { return }
-                self.performHeartbeat()
             }
         }
     }
 
     func performHeartbeat() {
-        guard started else { return }
-        let generation = heartbeatGeneration
         // Always schedule next loop first ensures continuity even if this one fails/skips
-        defer {
+        defer { scheduleNextHeartbeat() }
-            if started, heartbeatGeneration == generation {
-                scheduleNextHeartbeat()
-            }
-        }
 
         // 1. Check preconditions
         guard torIsReady() else {
@@ -263,27 +228,14 @@ final class GeohashPresenceService: ObservableObject {
             }
             
             // Launch independent task for each channel's delay
-            let taskID = UUID()
+            Task { @MainActor in
-            let sleeper = self.sleeper
-            let delay = TimeInterval.random(
-                in: burstMinDelay...burstMaxDelay
-            )
-            let nanoseconds = UInt64(delay * 1_000_000_000)
-            let task = Task { @MainActor [weak self] in
                 // Random delay for decorrelation
-                await sleeper(nanoseconds)
+                let delay = TimeInterval.random(in: self.burstMinDelay...self.burstMaxDelay)
-
+                let nanoseconds = UInt64(delay * 1_000_000_000)
-                guard let self else { return }
+                await self.sleeper(nanoseconds)
-                guard !Task.isCancelled,
+                
-                      self.started,
-                      self.heartbeatGeneration == generation else {
-                    self.pendingBroadcastTasks.removeValue(forKey: taskID)
-                    return
-                }
-                self.pendingBroadcastTasks.removeValue(forKey: taskID)
                 self.broadcastPresence(for: channel.geohash)
             }
-            pendingBroadcastTasks[taskID] = task
         }
     }
 

bitchat/Services/KeychainManager.swift

@@ -11,13 +11,6 @@ import BitFoundation
 import Foundation
 import Security
 
-enum KeychainInstallLifecycleAction: Equatable {
-    case markerPresent
-    case bootstrapMarker
-    case clearStaleKeys
-    case retryLater
-}
-
 final class KeychainManager: KeychainManagerProtocol {
     /// Default keychain for components that construct their own rather than
     /// having one injected. Under test this is an in-memory keychain: the
@@ -48,80 +41,27 @@ final class KeychainManager: KeychainManagerProtocol {
     // Use consistent service name for all keychain items
     private let service = BitchatApp.bundleID
     private let appGroup = "group.\(BitchatApp.bundleID)"
+
     // AfterFirstUnlock, not WhenUnlocked: the mesh keeps running with the
     // device locked (identity-cache saves failed with -25308 throughout
     // locked-phone testing), and a wake-on-proximity relaunch via BLE state
     // restoration must be able to read the noise keys before the user
-    // unlocks. ThisDeviceOnly prevents private identities and group keys from
+    // unlocks. Backup/sync semantics are unchanged (not ThisDeviceOnly).
-    // migrating through device backups onto a second device.
+    private static let itemAccessibility = kSecAttrAccessibleAfterFirstUnlock
-    private static let itemAccessibility = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
 
     init() {
         #if os(iOS)
-        reconcileInstallLifecycle()
         migrateAccessibilityIfNeeded()
         #endif
     }
 
-    static func installLifecycleAction(
-        containerKnowsMarker: Bool,
-        markerRead: KeychainReadResult
-    ) -> KeychainInstallLifecycleAction {
-        switch markerRead {
-        case .success:
-            return containerKnowsMarker ? .markerPresent : .clearStaleKeys
-        case .itemNotFound:
-            return .bootstrapMarker
-        case .accessDenied, .deviceLocked, .authenticationFailed, .otherError:
-            return .retryLater
-        }
-    }
-
     #if os(iOS)
-
-    private static let installMarkerAccount = "install_lifecycle_marker"
-    private static let installMarkerDefaultsKey = "keychain.installLifecycleMarker.present"
-
-    /// Keychain items can survive app removal while the app container and its
-    /// UserDefaults do not. The first version carrying this marker bootstraps
-    /// without deleting existing users' identities. On a later reinstall, a
-    /// surviving keychain marker plus a missing defaults marker proves the app
-    /// container was replaced, so stale secrets are removed before use.
-    private func reconcileInstallLifecycle() {
-        let defaults = UserDefaults.standard
-        let containerKnowsMarker = defaults.bool(forKey: Self.installMarkerDefaultsKey)
-
-        let markerRead = retrieveDataWithResult(forKey: Self.installMarkerAccount)
-        switch Self.installLifecycleAction(
-            containerKnowsMarker: containerKnowsMarker,
-            markerRead: markerRead
-        ) {
-        case .markerPresent:
-            defaults.set(true, forKey: Self.installMarkerDefaultsKey)
-
-        case .bootstrapMarker:
-            if case .success = saveDataWithResult(Data([1]), forKey: Self.installMarkerAccount) {
-                defaults.set(true, forKey: Self.installMarkerDefaultsKey)
-            }
-
-        case .clearStaleKeys:
-            _ = deleteAllKeychainData()
-            defaults.set(true, forKey: Self.installMarkerDefaultsKey)
-
-        case .retryLater:
-            // Do not guess that a temporarily unreadable marker is absent.
-            // Leaving the defaults flag unchanged lets a later construction
-            // retry once protected keychain data is available.
-            break
-        }
-    }
-
     /// One-time upgrade of items created under WhenUnlocked. New saves get
     /// the right class on their own (saves are delete-then-add), but the
     /// long-lived identity keys are written once and would otherwise stay
     /// unreadable while the device is locked.
     private func migrateAccessibilityIfNeeded() {
-        let flag = "keychain.accessibility.afterFirstUnlockThisDeviceOnly.migrated"
+        let flag = "keychain.accessibility.afterFirstUnlock.migrated"
         guard !UserDefaults.standard.bool(forKey: flag) else { return }
 
         let query: [String: Any] = [
@@ -136,7 +76,7 @@ final class KeychainManager: KeychainManagerProtocol {
         case errSecSuccess, errSecItemNotFound:
             // Nothing to migrate on a fresh install; both are terminal.
             UserDefaults.standard.set(true, forKey: flag)
-            SecureLogger.info("Keychain accessibility migrated to AfterFirstUnlockThisDeviceOnly (status \(status))", category: .keychain)
+            SecureLogger.info("Keychain accessibility migrated to AfterFirstUnlock (status \(status))", category: .keychain)
         default:
             // Likely errSecInteractionNotAllowed (relaunched while locked) —
             // leave the flag unset so the next launch retries.
@@ -551,15 +491,6 @@ final class KeychainManager: KeychainManagerProtocol {
         }
         
         SecureLogger.warning("Panic mode cleanup completed. Total items deleted: \(totalDeleted)", category: .keychain)
-
-        #if os(iOS)
-        // The non-secret marker is intentionally recreated after a panic so a
-        // later uninstall/reinstall can still be distinguished from an in-place
-        // upgrade. It never restores any wiped identity or relationship data.
-        if case .success = saveDataWithResult(Data([1]), forKey: Self.installMarkerAccount) {
-            UserDefaults.standard.set(true, forKey: Self.installMarkerDefaultsKey)
-        }
-        #endif
         
         return totalDeleted > 0
     }
@@ -595,39 +526,18 @@ final class KeychainManager: KeychainManagerProtocol {
 
     /// Save data with a custom service name
     func save(key: String, data: Data, service customService: String, accessible: CFString?) {
-        let primaryKeyQuery: [String: Any] = [
+        var query: [String: Any] = [
             kSecClass as String: kSecClassGenericPassword,
             kSecAttrService as String: customService,
-            kSecAttrAccount as String: key
+            kSecAttrAccount as String: key,
+            kSecValueData as String: data
         ]
-        var addQuery = primaryKeyQuery
+        if let accessible = accessible {
-        addQuery.merge([
+            query[kSecAttrAccessible as String] = accessible
-            kSecValueData as String: data,
+        }
-            kSecAttrAccessible as String: accessible ?? Self.itemAccessibility,
-            kSecAttrSynchronizable as String: false
-        ]) { _, new in new }
 
-        // Delete by the item's primary key only. Value/accessibility fields
+        SecItemDelete(query as CFDictionary)
-        // are add attributes, not valid selectors for replacing an existing
+        SecItemAdd(query as CFDictionary, nil)
-        // item; including them can leave the old item in place and make the
-        // subsequent add fail as a duplicate.
-        let deleteStatus = SecItemDelete(primaryKeyQuery as CFDictionary)
-        guard deleteStatus == errSecSuccess || deleteStatus == errSecItemNotFound else {
-            SecureLogger.error(
-                NSError(domain: "Keychain", code: Int(deleteStatus)),
-                context: "Unable to replace custom-service keychain item",
-                category: .keychain
-            )
-            return
-        }
-        let addStatus = SecItemAdd(addQuery as CFDictionary, nil)
-        if addStatus != errSecSuccess {
-            SecureLogger.error(
-                NSError(domain: "Keychain", code: Int(addStatus)),
-                context: "Unable to save custom-service keychain item",
-                category: .keychain
-            )
-        }
     }
 
     /// Load data from a custom service

bitchat/Services/MessageFormattingEngine.swift

@@ -251,9 +251,9 @@ final class MessageFormattingEngine {
         isSelf: Bool,
         isMentioned: Bool
     ) -> AttributedString {
-        // For very long content, use plain formatting to avoid expensive
+        // For very long content without special tokens, use plain formatting
-        // regex/detector work. Cashu presence must not disable this guard.
+        let containsCashu = containsCashuToken(content)
-        if content.isOversizedForRichFormatting() {
+        if (content.count > 4000 || content.hasVeryLongToken(threshold: 1024)) && !containsCashu {
             return formatPlainContent(content, baseColor: baseColor, isSelf: isSelf)
         }
 

bitchat/Services/NetworkActivationService.swift

@@ -154,19 +154,6 @@ final class NetworkActivationService: ObservableObject {
             .store(in: &cancellables)
     }
 
-    /// Stops all internet-facing work at the synchronous panic boundary.
-    /// `start()` may be called again only after the full wipe commits.
-    func stopForPanic() {
-        cancellables.removeAll()
-        started = false
-        reachabilityMonitor.stop()
-        activationAllowed = false
-        torAutoStartDesired = false
-        relayController.disconnect()
-        torController.setAutoStartAllowed(false)
-        applyTorState(torDesired: false)
-    }
-
     func setUserTorEnabled(_ enabled: Bool) {
         guard enabled != userTorEnabled else { return }
         userTorEnabled = enabled
@@ -180,7 +167,6 @@ final class NetworkActivationService: ObservableObject {
     }
 
     private func reevaluate() {
-        guard started else { return }
         let allowed = effectiveAllowed()
         let torDesired = allowed && userTorEnabled
         let statusChanged = allowed != activationAllowed

bitchat/Services/NetworkReachabilityMonitor.swift

@@ -27,8 +27,6 @@ protocol NetworkReachabilityMonitoring: AnyObject {
     var reachabilityPublisher: AnyPublisher<Bool, Never> { get }
     /// Begin monitoring. Idempotent.
     func start()
-    /// Stop monitoring and discard pending debounce work. Idempotent.
-    func stop()
 }
 
 /// Pure debounce/decision logic for reachability, split out so it can be
@@ -100,7 +98,6 @@ final class AlwaysReachableMonitor: NetworkReachabilityMonitoring {
         Empty(completeImmediately: false).eraseToAnyPublisher()
     }
     func start() {}
-    func stop() {}
 }
 
 /// `NWPathMonitor`-backed reachability. All state lives on the main actor; the
@@ -149,18 +146,6 @@ final class NWPathReachabilityMonitor: NetworkReachabilityMonitoring {
         #endif
     }
 
-    func stop() {
-        guard started else { return }
-        started = false
-        flushWorkItem?.cancel()
-        flushWorkItem = nil
-        #if canImport(Network)
-        monitor?.pathUpdateHandler = nil
-        monitor?.cancel()
-        monitor = nil
-        #endif
-    }
-
     /// Feed an observation into the debounce and publish committed changes.
     /// Exposed internally so higher layers/tests could drive it if needed.
     func ingest(reachable: Bool) {

bitchat/Services/NoiseEncryptionService.swift

@@ -165,6 +165,7 @@ final class NoiseEncryptionService {
     // Peer fingerprints (SHA256 hash of static public key)
     private var peerFingerprints: [PeerID: String] = [:]
     private var fingerprintToPeerID: [String: PeerID] = [:]
+    
     // Thread safety
     private let serviceQueue = DispatchQueue(label: "chat.bitchat.noise.service", attributes: .concurrent)
     
@@ -182,24 +183,12 @@ final class NoiseEncryptionService {
     
     // Callbacks
     private var onPeerAuthenticatedHandlers: [((PeerID, String) -> Void)] = [] // Array of handlers for peer authentication
-    private var onPeerAuthenticatedWithGenerationHandlers: [((PeerID, String, UUID) -> Void)] = []
     var onHandshakeRequired: ((PeerID) -> Void)? // peerID needs handshake
-    /// Automatic rekey prepared XX message 1. The transport must claim the
-    /// exact attempt at its actual BLE handoff; a crossed inbound initiation
-    /// can invalidate the token before that point.
-    var onRekeyHandshakeReady:
-        ((_ peerID: PeerID, _ initiation: NoiseHandshakeInitiation) -> Void)?
-    var onHandshakeRecoveryRequired:
-        ((_ request: NoiseHandshakeRecoveryRequest) -> Void)?
-    /// An unauthenticated reconnect attempt failed or timed out and the
-    /// receive-only rollback session became the active transport again.
-    /// Transport queues must be drained for this exact restored generation.
-    var onSessionRestoredWithGeneration: ((_ peerID: PeerID, _ generation: UUID) -> Void)?
     
     // Add a handler for peer authentication
     func addOnPeerAuthenticatedHandler(_ handler: @escaping (PeerID, String) -> Void) {
-        serviceQueue.sync(flags: .barrier) {
+        serviceQueue.async(flags: .barrier) { [weak self] in
-            onPeerAuthenticatedHandlers.append(handler)
+            self?.onPeerAuthenticatedHandlers.append(handler)
         }
     }
     
@@ -212,30 +201,8 @@ final class NoiseEncryptionService {
             }
         }
     }
-
-    /// Generation-aware authentication notifications are used by protocols
-    /// whose state must be bound to one exact Noise transport session.
-    var onPeerAuthenticatedWithGeneration: ((PeerID, String, UUID) -> Void)? {
-        get { nil }
-        set {
-            guard let handler = newValue else { return }
-            serviceQueue.sync(flags: .barrier) {
-                onPeerAuthenticatedWithGenerationHandlers.append(handler)
-            }
-        }
-    }
     
-    init(
+    init(keychain: KeychainManagerProtocol) {
-        keychain: KeychainManagerProtocol,
-        ordinaryHandshakeTimeout: TimeInterval =
-            NoiseSecurityConstants.ordinaryHandshakeTimeout,
-        ordinaryResponderHandshakeTimeout: TimeInterval =
-            NoiseSecurityConstants.ordinaryResponderHandshakeTimeout,
-        recentInitiatorCompletionGracePeriod: TimeInterval =
-            NoiseSecurityConstants.recentInitiatorCompletionGracePeriod,
-        ordinaryReconnectRollbackCooldown: TimeInterval =
-            NoiseSecurityConstants.ordinaryReconnectRollbackCooldown
-    ) {
         self.keychain = keychain
         self.localPrekeys = LocalPrekeyStore(keychain: keychain)
 
@@ -325,31 +292,11 @@ final class NoiseEncryptionService {
         self.signingPublicKey = signingKey.publicKey
 
         // Initialize session manager
-        self.sessionManager = NoiseSessionManager(
+        self.sessionManager = NoiseSessionManager(localStaticKey: staticIdentityKey, keychain: keychain)
-            localStaticKey: staticIdentityKey,
-            keychain: keychain,
-            ordinaryHandshakeTimeout: ordinaryHandshakeTimeout,
-            ordinaryResponderHandshakeTimeout:
-                ordinaryResponderHandshakeTimeout,
-            recentInitiatorCompletionGracePeriod:
-                recentInitiatorCompletionGracePeriod,
-            ordinaryReconnectRollbackCooldown:
-                ordinaryReconnectRollbackCooldown
-        )
 
         // Set up session callbacks
-        sessionManager.onSessionEstablished = { [weak self] peerID, remoteStaticKey, generation in
+        sessionManager.onSessionEstablished = { [weak self] peerID, remoteStaticKey in
-            self?.handleSessionEstablished(
+            self?.handleSessionEstablished(peerID: peerID, remoteStaticKey: remoteStaticKey)
-                peerID: peerID,
-                remoteStaticKey: remoteStaticKey,
-                sessionGeneration: generation
-            )
-        }
-        sessionManager.onSessionRestored = { [weak self] peerID, generation in
-            self?.onSessionRestoredWithGeneration?(peerID, generation)
-        }
-        sessionManager.onHandshakeRecoveryRequired = { [weak self] request in
-            self?.onHandshakeRecoveryRequired?(request)
         }
 
         // Start session maintenance timer
@@ -714,90 +661,6 @@ final class NoiseEncryptionService {
         let handshakeData = try sessionManager.initiateHandshake(with: peerID)
         return handshakeData
     }
-
-    /// Atomically admits and prepares one initial ordinary handshake. Returns
-    /// nil when another discovery callback already created a session.
-    func initiateHandshakeIfNeeded(
-        with peerID: PeerID,
-        retryOnTimeout: Bool = false
-    ) throws -> NoiseHandshakeInitiation? {
-        guard peerID.isValid else {
-            SecureLogger.warning(.authenticationFailed(peerID: peerID.id))
-            throw NoiseSecurityError.invalidPeerID
-        }
-
-        guard let initiation = try sessionManager.initiateHandshakeIfAbsent(
-            with: peerID,
-            notifyOnTimeout: retryOnTimeout,
-            authorize: { [rateLimiter] in
-                guard rateLimiter.allowHandshake(from: peerID) else {
-                    SecureLogger.warning(
-                        .authenticationFailed(peerID: "Rate limited: \(peerID)")
-                    )
-                    throw NoiseSecurityError.rateLimitExceeded
-                }
-            }
-        ) else {
-            return nil
-        }
-        SecureLogger.info(.handshakeStarted(peerID: peerID.id))
-        return initiation
-    }
-
-    /// Atomically prepares an ordinary reconnect for a peer whose cached
-    /// transport belongs to an earlier physical link. Failed authorization or
-    /// handshake setup preserves the established session.
-    func initiateReconnectHandshake(
-        with peerID: PeerID,
-        retryOnTimeout: Bool = false
-    ) throws -> NoiseHandshakeInitiation {
-        guard peerID.isValid else {
-            SecureLogger.warning(.authenticationFailed(peerID: peerID.id))
-            throw NoiseSecurityError.invalidPeerID
-        }
-
-        return try sessionManager.initiateReconnectHandshake(
-            with: peerID,
-            notifyOnTimeout: retryOnTimeout,
-            authorize: { [rateLimiter] in
-                guard rateLimiter.allowHandshake(from: peerID) else {
-                    SecureLogger.warning(
-                        .authenticationFailed(peerID: "Rate limited: \(peerID)")
-                    )
-                    throw NoiseSecurityError.rateLimitExceeded
-                }
-            }
-        )
-    }
-
-    func prepareHandshakeRecovery(
-        _ request: NoiseHandshakeRecoveryRequest
-    ) throws -> NoiseHandshakeRecoveryPreparation? {
-        try sessionManager.prepareHandshakeRecovery(
-            request,
-            authorizeAttempt: { [rateLimiter] in
-                guard rateLimiter.allowHandshake(from: request.peerID) else {
-                    SecureLogger.warning(
-                        .authenticationFailed(
-                            peerID: "Rate limited: \(request.peerID)"
-                        )
-                    )
-                    throw NoiseSecurityError.rateLimitExceeded
-                }
-            }
-        )
-    }
-
-    func cancelHandshakeRecovery(_ request: NoiseHandshakeRecoveryRequest) {
-        sessionManager.cancelHandshakeRecovery(request)
-    }
-
-    func claimHandshakeInitiation(
-        _ initiation: NoiseHandshakeInitiation,
-        for peerID: PeerID
-    ) -> Data? {
-        sessionManager.claimHandshakeInitiation(initiation, for: peerID)
-    }
     
     /// Process an incoming handshake message
     func processHandshakeMessage(from peerID: PeerID, message: Data) throws -> Data? {
@@ -822,10 +685,7 @@ final class NoiseEncryptionService {
         
         // For handshakes, we process the raw data directly without NoiseMessage wrapper
         // The Noise protocol handles its own message format
-        let responsePayload = try sessionManager.handleIncomingHandshake(
+        let responsePayload = try sessionManager.handleIncomingHandshake(from: peerID, message: message)
-            from: peerID,
-            message: message
-        )
         
         
         // Return raw response without wrapper
@@ -865,56 +725,11 @@ final class NoiseEncryptionService {
         
         return try sessionManager.encrypt(data, for: peerID)
     }
-
-    /// Encrypts a finalized private-media packet. Ordinary Noise application
-    /// messages retain the 64 KiB ceiling; this purpose-specific path permits
-    /// the bounded `BitchatFilePacket` envelope and refuses every other typed
-    /// payload so the larger allocation budget cannot become a generic bypass.
-    func encryptPrivateFilePayload(
-        _ data: Data,
-        for peerID: PeerID,
-        sessionGeneration: UUID? = nil
-    ) throws -> Data {
-        guard NoisePayloadType.isPrivateFile(rawValue: data.first),
-              NoiseSecurityValidator.validatePrivateFileMessageSize(data) else {
-            throw NoiseSecurityError.messageTooLarge
-        }
-
-        guard rateLimiter.allowMessage(from: peerID) else {
-            throw NoiseSecurityError.rateLimitExceeded
-        }
-
-        guard hasEstablishedSession(with: peerID) else {
-            onHandshakeRequired?(peerID)
-            throw NoiseEncryptionError.handshakeRequired
-        }
-
-        // `maxPrivateFilePlaintextSize` already subtracts the cipher's fixed
-        // nonce/tag overhead, so the result is bounded without a second copy.
-        if let sessionGeneration {
-            return try sessionManager.encrypt(
-                data,
-                for: peerID,
-                expectedSessionGeneration: sessionGeneration
-            )
-        }
-        return try sessionManager.encrypt(data, for: peerID)
-    }
     
     /// Decrypt data from a specific peer
     func decrypt(_ data: Data, from peerID: PeerID) throws -> Data {
-        try decryptWithSessionGeneration(data, from: peerID).plaintext
+        // Validate message size
-    }
+        guard NoiseSecurityValidator.validateMessageSize(data) else {
-
-    func decryptWithSessionGeneration(
-        _ data: Data,
-        from peerID: PeerID
-    ) throws -> (plaintext: Data, sessionGeneration: UUID) {
-        // Standard transport ciphertext has 20 bytes of nonce/tag overhead.
-        // A larger candidate is admitted only up to the framed-file ceiling;
-        // after authenticated decryption it must prove it is `.privateFile`.
-        let isStandardCiphertext = NoiseSecurityValidator.validateCiphertextSize(data)
-        guard isStandardCiphertext || NoiseSecurityValidator.validatePrivateFileCiphertextSize(data) else {
             throw NoiseSecurityError.messageTooLarge
         }
         
@@ -923,21 +738,12 @@ final class NoiseEncryptionService {
             throw NoiseSecurityError.rateLimitExceeded
         }
         
-        // A quarantined transport is deliberately unavailable for outbound
+        // Check if we have an established session
-        // state, but remains receive-only until the responder proves identity
+        guard hasEstablishedSession(with: peerID) else {
-        // or the bounded rollback restores it.
-        guard sessionManager.hasReceiveSession(for: peerID) else {
             throw NoiseEncryptionError.sessionNotEstablished
         }
         
-        let result = try sessionManager.decryptWithSessionGeneration(data, from: peerID)
+        return try sessionManager.decrypt(data, from: peerID)
-        if !isStandardCiphertext {
-            guard NoisePayloadType.isPrivateFile(rawValue: result.plaintext.first),
-                  NoiseSecurityValidator.validatePrivateFileMessageSize(result.plaintext) else {
-                throw NoiseSecurityError.messageTooLarge
-            }
-        }
-        return result
     }
     
     // MARK: - Peer Management
@@ -949,25 +755,6 @@ final class NoiseEncryptionService {
         }
     }
 
-    func sessionGeneration(for peerID: PeerID) -> UUID? {
-        sessionManager.sessionGeneration(for: peerID)
-    }
-
-    /// Runs `body` while holding a read lease on the exact session generation.
-    /// Session insertion, replacement, and removal use the same manager
-    /// barrier, so they cannot interleave with an authenticated-state commit.
-    func withCurrentSessionGeneration<Result>(
-        for peerID: PeerID,
-        expected: UUID,
-        _ body: () -> Result
-    ) -> Result? {
-        sessionManager.withCurrentSessionGeneration(
-            for: peerID,
-            expected: expected,
-            body
-        )
-    }
-
     func clearEphemeralStateForPanic() {
         sessionManager.removeAllSessions()
         serviceQueue.sync(flags: .barrier) {
@@ -990,36 +777,24 @@ final class NoiseEncryptionService {
     
     // MARK: - Private Helpers
     
-    private func handleSessionEstablished(
+    private func handleSessionEstablished(peerID: PeerID, remoteStaticKey: Curve25519.KeyAgreement.PublicKey) {
-        peerID: PeerID,
-        remoteStaticKey: Curve25519.KeyAgreement.PublicKey,
-        sessionGeneration: UUID
-    ) {
         // Calculate fingerprint
         let fingerprint = remoteStaticKey.rawRepresentation.sha256Fingerprint()
         
-        // Registering handlers is synchronous, and this barrier snapshots them
+        // Store fingerprint mapping
-        // with the fingerprint update. Invoke the snapshot outside the queue:
+        serviceQueue.sync(flags: .barrier) {
-        // parallel Swift Testing workers must not block behind queued callback
-        // registration or allow a handler to re-enter serviceQueue.
-        let handlers: (
-            generationAware: [(PeerID, String, UUID) -> Void],
-            legacy: [(PeerID, String) -> Void]
-        ) = serviceQueue.sync(flags: .barrier) {
             peerFingerprints[peerID] = fingerprint
             fingerprintToPeerID[fingerprint] = peerID
-            return (onPeerAuthenticatedWithGenerationHandlers, onPeerAuthenticatedHandlers)
         }
         
         // Log security event
         SecureLogger.info(.handshakeCompleted(peerID: peerID.id))
         
-        // Notify all handlers about authentication.
+        // Notify all handlers about authentication
-        handlers.generationAware.forEach { handler in
+        serviceQueue.async { [weak self] in
-            handler(peerID, fingerprint, sessionGeneration)
+            self?.onPeerAuthenticatedHandlers.forEach { handler in
-        }
+                handler(peerID, fingerprint)
-        handlers.legacy.forEach { handler in
+            }
-            handler(peerID, fingerprint)
         }
     }
         
@@ -1040,26 +815,19 @@ final class NoiseEncryptionService {
         let sessionsNeedingRekey = sessionManager.getSessionsNeedingRekey()
         
         for (peerID, needsRekey) in sessionsNeedingRekey where needsRekey {
+            
+            // Attempt to rekey the session
             do {
-                try initiateAutomaticRekey(for: peerID)
+                try sessionManager.initiateRekey(for: peerID)
+                SecureLogger.debug("Key rotation initiated for peer: \(peerID)", category: .security)
+                
+                // Signal that handshake is needed
+                onHandshakeRequired?(peerID)
             } catch {
                 SecureLogger.error(error, context: "Failed to initiate rekey for peer: \(peerID)", category: .session)
             }
         }
     }
-
-    private func initiateAutomaticRekey(for peerID: PeerID) throws {
-        let initiation = try sessionManager.initiateRekey(for: peerID)
-        SecureLogger.debug("Key rotation initiated for peer: \(peerID)", category: .security)
-        onRekeyHandshakeReady?(peerID, initiation)
-        onHandshakeRequired?(peerID)
-    }
-
-    #if DEBUG
-    func _test_initiateAutomaticRekey(for peerID: PeerID) throws {
-        try initiateAutomaticRekey(for: peerID)
-    }
-    #endif
     
     deinit {
         stopRekeyTimer()

bitchat/Services/TransferProgressManager.swift

@@ -11,7 +11,6 @@ final class TransferProgressManager {
         case updated(id: String, sentFragments: Int, totalFragments: Int)
         case completed(id: String, totalFragments: Int)
         case cancelled(id: String, sentFragments: Int, totalFragments: Int)
-        case rejected(id: String, reason: String)
     }
 
     private let subject = PassthroughSubject<Event, Never>()
@@ -50,17 +49,6 @@ final class TransferProgressManager {
         }
     }
 
-    /// Fails a preflight check while keeping the outgoing placeholder visible
-    /// with an actionable reason instead of treating policy/size rejection as
-    /// a user cancellation.
-    func rejectBeforeStart(id: String, reason: String) {
-        queue.async(flags: .barrier) { [weak self] in
-            guard let self = self else { return }
-            self.states.removeValue(forKey: id)
-            self.subject.send(.rejected(id: id, reason: reason))
-        }
-    }
-
     func snapshot(id: String) -> (sent: Int, total: Int)? {
         var result: (sent: Int, total: Int)?
         queue.sync {

bitchat/Services/Transport.swift

@@ -83,20 +83,6 @@ enum TransportEvent: @unchecked Sendable {
     case bluetoothStateUpdated(CBManagerState)
 }
 
-/// Downgrade-safe decision for a private-media recipient. Callers ask before
-/// prompting, and BLEService checks again when it consumes any one-shot
-/// legacy consent.
-enum PrivateMediaSendPolicy: Equatable {
-    case encrypted
-    /// A public announce hinted at encrypted media (or a prior authenticated
-    /// pin exists), but this exact Noise session has not yet supplied its
-    /// authenticated peer-state proof. Callers wait boundedly; they must not
-    /// pre-queue encrypted bytes or silently select the legacy path.
-    case awaitingCapabilityProof
-    case legacyRequiresConsent
-    case blockedDowngrade
-}
-
 protocol TransportEventDelegate: AnyObject {
     @MainActor func didReceiveTransportEvent(_ event: TransportEvent)
 }
@@ -177,12 +163,6 @@ protocol Transport: AnyObject {
     func sendDeliveryAck(for messageID: String, to peerID: PeerID)
     func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String)
     func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String)
-    func sendFilePrivate(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        allowLegacyFallback: Bool
-    )
     func cancelTransfer(_ transferId: String)
 
     // Live voice / push-to-talk (mesh transports only): one encoded
@@ -228,11 +208,6 @@ protocol Transport: AnyObject {
     /// Capabilities the peer advertised in its last verified announce;
     /// empty for peers that predate the capabilities TLV.
     func peerCapabilities(_ peerID: PeerID) -> PeerCapabilities
-    func privateMediaSendPolicy(to peerID: PeerID) -> PrivateMediaSendPolicy
-    func resolvePrivateMediaSendPolicy(
-        to peerID: PeerID,
-        completion: @escaping @MainActor (PrivateMediaSendPolicy) -> Void
-    )
     /// Sends an encoded vouch-attestation batch inside the Noise session.
     func sendVouchAttestations(_ payload: Data, to peerID: PeerID)
     /// Appends a peer-authenticated observer. Unlike
@@ -303,16 +278,6 @@ extension Transport {
     func sendGroupKeyUpdate(_ statePayload: Data, to peerID: PeerID) {}
     func broadcastGroupMessage(_ envelope: Data) {}
     func peerCapabilities(_ peerID: PeerID) -> PeerCapabilities { [] }
-    func privateMediaSendPolicy(to peerID: PeerID) -> PrivateMediaSendPolicy { .blockedDowngrade }
-    func resolvePrivateMediaSendPolicy(
-        to peerID: PeerID,
-        completion: @escaping @MainActor (PrivateMediaSendPolicy) -> Void
-    ) {
-        let policy = privateMediaSendPolicy(to: peerID)
-        Task { @MainActor in
-            completion(policy == .awaitingCapabilityProof ? .blockedDowngrade : policy)
-        }
-    }
     func sendVouchAttestations(_ payload: Data, to peerID: PeerID) {}
     func addPeerAuthenticatedObserver(_ handler: @escaping (PeerID, String) -> Void) {}
     func sendCourierMessage(_ content: String, messageID: String, recipientNoiseKey: Data, via couriers: [PeerID]) -> Bool { false }
@@ -329,15 +294,6 @@ extension Transport {
     func currentMeshTopology() -> MeshTopologySnapshot? { nil }
     func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String) {}
     func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {}
-    func sendFilePrivate(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        allowLegacyFallback: Bool
-    ) {
-        guard !allowLegacyFallback else { return }
-        sendFilePrivate(packet, to: peerID, transferId: transferId)
-    }
     func cancelTransfer(_ transferId: String) {}
 
     func sendMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date) {

bitchat/Services/TransportConfig.swift

@@ -9,12 +9,6 @@ enum TransportConfig {
     static let bleMaxInFlightAssemblies: Int = 128          // Cap concurrent fragment assemblies
     static let bleHighDegreeThreshold: Int = 6              // For adaptive TTL/probabilistic relays
     static let bleMaxConcurrentTransfers: Int = 2           // Limit simultaneous large media sends
-    // Bounded wait for the session-authenticated capability proof used by
-    // private-media migration. Expiry never auto-sends clear bytes; it only
-    // resolves to the existing one-shot consent or downgrade-blocked path.
-    static let privateMediaCapabilityProofTimeoutSeconds: TimeInterval = 5
-    static let privateMediaCapabilityProofPendingPeerCap: Int = 64
-    static let privateMediaCapabilityProofWaitersPerPeerCap: Int = 16
     static let bleFragmentRelayMinDelayMs: Int = 8          // Faster forwarding for media fragments
     static let bleFragmentRelayMaxDelayMs: Int = 25         // Upper jitter bound for fragment relays
     // Fragment relay TTL in sparse graphs; matches messageTTLDefault so media
@@ -52,7 +46,6 @@ enum TransportConfig {
     static let privateChatCap: Int = 1337
     static let meshTimelineCap: Int = 1337
     static let geoTimelineCap: Int = 1337
-    static let geoNicknameParticipantsCap: Int = 1337
     static let contentLRUCap: Int = 2000
     static let geoSamplingEventLRUCap: Int = 2000
 
@@ -88,11 +81,6 @@ enum TransportConfig {
     static let nostrDuplicateEventLogInterval: Int = 50
     // Sample interval for per-event debug logs on the inbound hot path.
     static let nostrInboundEventLogInterval: Int = 100
-    // Reject oversized/untrusted relay frames before JSON parse / store.
-    static let nostrMaxInboundMessageBytes: Int = 256 * 1024
-    static let nostrMaxEventTags: Int = 64
-    static let nostrMaxEventTagValues: Int = 16
-    static let nostrMaxEventTagValueBytes: Int = 1024
 
     // Conversation store diagnostics (field observability)
     // Sample interval for the periodic store-audit "OK" heartbeat line
@@ -110,12 +98,6 @@ enum TransportConfig {
     static let uiSenderRateBucketRefillPerSec: Double = 1.0
     static let uiContentRateBucketCapacity: Double = 3
     static let uiContentRateBucketRefillPerSec: Double = 0.5
-    // Bound attacker-keyed bucket maps (sender IDs / content digests).
-    static let uiSenderRateBucketMaxEntries: Int = 2000
-    static let uiContentRateBucketMaxEntries: Int = 2000
-    static let uiRateBucketIdleTTL: TimeInterval = 10 * 60
-    // Cap teleported-participant markers so remote events cannot grow the set.
-    static let geoTeleportedParticipantsCap: Int = 1337
 
     // UI sleeps/delays
     static let uiStartupInitialDelaySeconds: TimeInterval = 1.0

bitchat/Utils/AppLanguageSettings.swift

@@ -1,40 +0,0 @@
-import Foundation
-
-/// In-app override for the UI language, on top of the system per-app
-/// language. Apple resolves localization from the AppleLanguages default at
-/// process start, so a new choice takes effect on the next launch — callers
-/// surface a "restart to apply" note after changing it.
-enum AppLanguageSettings {
-    /// "" means no override: follow the device (or per-app system) language.
-    static let overrideKey = "app.languageOverride"
-    private static let appleLanguagesKey = "AppleLanguages"
-
-    /// Language codes the app ships translations for, straight from the
-    /// built bundle so this never drifts from the string catalog.
-    static var availableLanguages: [String] {
-        Bundle.main.localizations
-            .filter { $0 != "Base" }
-            .sorted { endonym(for: $0).localizedCaseInsensitiveCompare(endonym(for: $1)) == .orderedAscending }
-    }
-
-    /// The language's name in that language ("فارسی", "한국어") so every user
-    /// can find their own entry regardless of the current UI language.
-    static func endonym(for code: String) -> String {
-        let locale = Locale(identifier: code)
-        let name = locale.localizedString(forIdentifier: code) ?? code
-        return name.lowercased(with: locale)
-    }
-
-    /// Persists the override (nil clears it). AppleLanguages drives the
-    /// actual localization lookup on next launch.
-    static func setOverride(_ code: String?) {
-        let defaults = UserDefaults.standard
-        if let code, !code.isEmpty {
-            defaults.set(code, forKey: overrideKey)
-            defaults.set([code], forKey: appleLanguagesKey)
-        } else {
-            defaults.removeObject(forKey: overrideKey)
-            defaults.removeObject(forKey: appleLanguagesKey)
-        }
-    }
-}

bitchat/ViewModels/ChatLiveVoiceCoordinator.swift

@@ -226,21 +226,6 @@ final class ChatLiveVoiceCoordinator {
         assemblies.values.contains { $0.messageID == message.id }
     }
 
-    /// Stop every live file handle/player before the panic media directory is
-    /// removed. This prevents an in-flight assembly from continuing to write
-    /// through an unlinked file after the wipe returns.
-    func resetForPanic() {
-        for assembly in Array(assemblies.values) {
-            cancelAssembly(assembly)
-        }
-        for player in drainingPlayers.values {
-            player.stop()
-        }
-        drainingPlayers.removeAll(keepingCapacity: false)
-        finishedBursts.removeAll(keepingCapacity: false)
-        updatePublicTalkerIndicator()
-    }
-
     /// Called for every inbound private message: when it is the finalized
     /// voice note of a burst we assembled (matched by burst ID in the file
     /// name), swap it into the existing live bubble and report `true` so the

bitchat/ViewModels/ChatMediaTransferCoordinator.swift

@@ -6,19 +6,6 @@ import Foundation
 import UIKit
 #endif
 
-struct LegacyPrivateMediaConsentRequest: Identifiable, Equatable {
-    let id: UUID
-    let peerID: PeerID
-    let peerName: String
-    let transferId: String
-    let messageID: String
-}
-
-struct PendingLegacyPrivateMediaConsent {
-    let request: LegacyPrivateMediaConsentRequest
-    let completion: @MainActor (Bool) -> Void
-}
-
 /// The narrow surface `ChatMediaTransferCoordinator` needs from its owner.
 ///
 /// Follows the `ChatDeliveryContext` exemplar: the coordinator depends on the
@@ -56,24 +43,7 @@ protocol ChatMediaTransferContext: AnyObject {
     func recordContentKey(_ key: String, timestamp: Date)
 
     // MARK: Mesh file transfer
-    func privateMediaSendPolicy(to peerID: PeerID) -> PrivateMediaSendPolicy
+    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String)
-    func resolvePrivateMediaSendPolicy(
-        to peerID: PeerID,
-        completion: @escaping @MainActor (PrivateMediaSendPolicy) -> Void
-    )
-    func requestLegacyPrivateMediaConsent(
-        for peerID: PeerID,
-        transferId: String,
-        messageID: String,
-        completion: @escaping @MainActor (Bool) -> Void
-    )
-    func cancelLegacyPrivateMediaConsent(transferId: String, messageID: String)
-    func sendFilePrivate(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        allowLegacyFallback: Bool
-    )
     func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String)
     func cancelTransfer(_ transferId: String)
 }
@@ -89,50 +59,8 @@ extension ChatViewModel: ChatMediaTransferContext {
     // other contexts or satisfied by existing `ChatViewModel` members. The
     // members below flatten mesh service accesses.
 
-    func privateMediaSendPolicy(to peerID: PeerID) -> PrivateMediaSendPolicy {
+    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {
-        meshService.privateMediaSendPolicy(to: peerID)
+        meshService.sendFilePrivate(packet, to: peerID, transferId: transferId)
-    }
-
-    func resolvePrivateMediaSendPolicy(
-        to peerID: PeerID,
-        completion: @escaping @MainActor (PrivateMediaSendPolicy) -> Void
-    ) {
-        meshService.resolvePrivateMediaSendPolicy(to: peerID, completion: completion)
-    }
-
-    func requestLegacyPrivateMediaConsent(
-        for peerID: PeerID,
-        transferId: String,
-        messageID: String,
-        completion: @escaping @MainActor (Bool) -> Void
-    ) {
-        enqueueLegacyPrivateMediaConsent(
-            for: peerID,
-            transferId: transferId,
-            messageID: messageID,
-            completion: completion
-        )
-    }
-
-    func cancelLegacyPrivateMediaConsent(transferId: String, messageID: String) {
-        invalidateLegacyPrivateMediaConsent(
-            transferId: transferId,
-            messageID: messageID
-        )
-    }
-
-    func sendFilePrivate(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        allowLegacyFallback: Bool
-    ) {
-        meshService.sendFilePrivate(
-            packet,
-            to: peerID,
-            transferId: transferId,
-            allowLegacyFallback: allowLegacyFallback
-        )
     }
 
     func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String) {
@@ -147,20 +75,12 @@ extension ChatViewModel: ChatMediaTransferContext {
 @MainActor
 final class ChatMediaTransferCoordinator {
     private unowned let context: any ChatMediaTransferContext
-    private let prepareVoiceNotePacket: @Sendable (URL) throws -> BitchatFilePacket
 
     private(set) var transferIdToMessageIDs: [String: [String]] = [:]
     private(set) var messageIDToTransferId: [String: String] = [:]
-    private var preparationGeneration: UInt64 = 0
 
-    init(
+    init(context: any ChatMediaTransferContext) {
-        context: any ChatMediaTransferContext,
-        prepareVoiceNotePacket: @escaping @Sendable (URL) throws -> BitchatFilePacket = {
-            try ChatMediaPreparation.prepareVoiceNotePacket(at: $0)
-        }
-    ) {
         self.context = context
-        self.prepareVoiceNotePacket = prepareVoiceNotePacket
     }
 
     func sendVoiceNote(at url: URL) {
@@ -178,30 +98,16 @@ final class ChatMediaTransferCoordinator {
         )
         let messageID = message.id
         let transferId = makeTransferID(messageID: messageID)
-        // Own the transfer before detached preparation begins. Cancel/delete
-        // must be able to invalidate this exact invocation even while file I/O
-        // is still running off the main actor.
-        registerTransfer(transferId: transferId, messageID: messageID)
-        let prepareVoiceNotePacket = self.prepareVoiceNotePacket
-        let generation = preparationGeneration
 
         Task.detached(priority: .userInitiated) { [weak self] in
             do {
-                let packet = try prepareVoiceNotePacket(url)
+                let packet = try ChatMediaPreparation.prepareVoiceNotePacket(at: url)
 
                 await MainActor.run { [weak self] in
-                    guard let self,
+                    guard let self else { return }
-                          self.preparationGeneration == generation,
+                    self.registerTransfer(transferId: transferId, messageID: messageID)
-                          self.isRegisteredTransfer(transferId, messageID: messageID) else {
-                        return
-                    }
                     if let peerID = targetPeer {
-                        self.beginPrivateMediaSend(
+                        self.context.sendFilePrivate(packet, to: peerID, transferId: transferId)
-                            packet,
-                            to: peerID,
-                            transferId: transferId,
-                            messageID: messageID
-                        )
                     } else {
                         self.context.sendFileBroadcast(packet, transferId: transferId)
                     }
@@ -210,21 +116,13 @@ final class ChatMediaTransferCoordinator {
                 SecureLogger.warning("Voice note exceeds size limit (\(size) bytes)", category: .session)
                 try? FileManager.default.removeItem(at: url)
                 await MainActor.run { [weak self] in
-                    guard let self,
+                    guard let self else { return }
-                          self.preparationGeneration == generation,
-                          self.isRegisteredTransfer(transferId, messageID: messageID) else {
-                        return
-                    }
                     self.handleMediaSendFailure(messageID: messageID, reason: String(localized: "content.delivery.reason.voice_too_large", comment: "Failure reason shown when a voice note exceeds the size limit"))
                 }
             } catch {
                 SecureLogger.error("Voice note send failed: \(error)", category: .session)
                 await MainActor.run { [weak self] in
-                    guard let self,
+                    guard let self else { return }
-                          self.preparationGeneration == generation,
-                          self.isRegisteredTransfer(transferId, messageID: messageID) else {
-                        return
-                    }
                     self.handleMediaSendFailure(messageID: messageID, reason: String(localized: "content.delivery.reason.voice_send_failed", comment: "Failure reason shown when a voice note could not be sent"))
                 }
             }
@@ -234,15 +132,11 @@ final class ChatMediaTransferCoordinator {
     #if os(iOS)
     func processThenSendImage(_ image: UIImage?) {
         guard let image else { return }
-        let generation = preparationGeneration
         Task.detached { [weak self] in
             do {
                 let processedURL = try ImageUtils.processImage(image)
                 await MainActor.run { [weak self] in
-                    guard let self, self.preparationGeneration == generation else {
+                    guard let self else { return }
-                        try? FileManager.default.removeItem(at: processedURL)
-                        return
-                    }
                     self.sendImage(from: processedURL)
                 }
             } catch {
@@ -253,15 +147,11 @@ final class ChatMediaTransferCoordinator {
     #elseif os(macOS)
     func processThenSendImage(from url: URL?) {
         guard let url else { return }
-        let generation = preparationGeneration
         Task.detached { [weak self] in
             do {
                 let processedURL = try ImageUtils.processImage(at: url)
                 await MainActor.run { [weak self] in
-                    guard let self, self.preparationGeneration == generation else {
+                    guard let self else { return }
-                        try? FileManager.default.removeItem(at: processedURL)
-                        return
-                    }
                     self.sendImage(from: processedURL)
                 }
             } catch {
@@ -280,7 +170,6 @@ final class ChatMediaTransferCoordinator {
         }
 
         let targetPeer = context.selectedPrivateChatPeer
-        let generation = preparationGeneration
 
         do {
             try ImageUtils.validateImageSource(at: sourceURL)
@@ -295,10 +184,7 @@ final class ChatMediaTransferCoordinator {
                 let prepared = try ChatMediaPreparation.prepareImagePacket(from: sourceURL)
 
                 await MainActor.run { [weak self] in
-                    guard let self, self.preparationGeneration == generation else {
+                    guard let self else { return }
-                        try? FileManager.default.removeItem(at: prepared.outputURL)
-                        return
-                    }
                     let message = self.enqueueMediaMessage(
                         content: "\(MimeType.Category.image.messagePrefix)\(prepared.outputURL.lastPathComponent)",
                         targetPeer: targetPeer
@@ -307,12 +193,7 @@ final class ChatMediaTransferCoordinator {
                     let transferId = self.makeTransferID(messageID: messageID)
                     self.registerTransfer(transferId: transferId, messageID: messageID)
                     if let peerID = targetPeer {
-                        self.beginPrivateMediaSend(
+                        self.context.sendFilePrivate(prepared.packet, to: peerID, transferId: transferId)
-                            prepared.packet,
-                            to: peerID,
-                            transferId: transferId,
-                            messageID: messageID
-                        )
                     } else {
                         self.context.sendFileBroadcast(prepared.packet, transferId: transferId)
                     }
@@ -320,13 +201,13 @@ final class ChatMediaTransferCoordinator {
             } catch ChatMediaPreparationError.imageTooLarge(let size) {
                 SecureLogger.warning("Processed image exceeds size limit (\(size) bytes)", category: .session)
                 await MainActor.run { [weak self] in
-                    guard let self, self.preparationGeneration == generation else { return }
+                    guard let self else { return }
                     self.context.addSystemMessage("Image is too large to send.")
                 }
             } catch {
                 SecureLogger.error("Image send preparation failed: \(error)", category: .session)
                 await MainActor.run { [weak self] in
-                    guard let self, self.preparationGeneration == generation else { return }
+                    guard let self else { return }
                     self.context.addSystemMessage("Failed to prepare image for sending.")
                 }
             }
@@ -372,127 +253,17 @@ final class ChatMediaTransferCoordinator {
         return message
     }
 
-    private func beginPrivateMediaSend(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        messageID: String
-    ) {
-        continuePrivateMediaSend(
-            packet,
-            to: peerID,
-            transferId: transferId,
-            messageID: messageID,
-            policy: context.privateMediaSendPolicy(to: peerID)
-        )
-    }
-
-    private func continuePrivateMediaSend(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        messageID: String,
-        policy: PrivateMediaSendPolicy
-    ) {
-        switch policy {
-        case .encrypted:
-            context.sendFilePrivate(
-                packet,
-                to: peerID,
-                transferId: transferId,
-                allowLegacyFallback: false
-            )
-
-        case .awaitingCapabilityProof:
-            context.resolvePrivateMediaSendPolicy(to: peerID) { [weak self] resolvedPolicy in
-                guard let self,
-                      self.isRegisteredTransfer(transferId, messageID: messageID) else {
-                    return
-                }
-                guard resolvedPolicy != .awaitingCapabilityProof else {
-                    self.handleMediaSendFailure(
-                        messageID: messageID,
-                        reason: String(
-                            localized: "content.delivery.reason.private_media_capability_unresolved",
-                            defaultValue: "Could not confirm encrypted media support",
-                            comment: "Failure reason when private-media capability negotiation did not resolve"
-                        )
-                    )
-                    return
-                }
-                self.continuePrivateMediaSend(
-                    packet,
-                    to: peerID,
-                    transferId: transferId,
-                    messageID: messageID,
-                    policy: resolvedPolicy
-                )
-            }
-
-        case .legacyRequiresConsent:
-            context.requestLegacyPrivateMediaConsent(
-                for: peerID,
-                transferId: transferId,
-                messageID: messageID
-            ) { [weak self] approved in
-                guard let self else { return }
-                // Consent belongs to this exact placeholder/transfer. A late
-                // dialog callback after cancel/delete must never resurrect it.
-                guard self.messageIDToTransferId[messageID] == transferId,
-                      self.transferIdToMessageIDs[transferId]?.contains(messageID) == true else {
-                    return
-                }
-                guard approved else {
-                    self.handleMediaSendFailure(
-                        messageID: messageID,
-                        reason: String(
-                            localized: "content.delivery.reason.legacy_media_declined",
-                            defaultValue: "Not sent without end-to-end encryption",
-                            comment: "Failure reason after declining the warning for a legacy clear private-media send"
-                        )
-                    )
-                    return
-                }
-                self.context.sendFilePrivate(
-                    packet,
-                    to: peerID,
-                    transferId: transferId,
-                    allowLegacyFallback: true
-                )
-            }
-
-        case .blockedDowngrade:
-            handleMediaSendFailure(
-                messageID: messageID,
-                reason: String(
-                    localized: "content.delivery.reason.private_media_downgrade_blocked",
-                    defaultValue: "Encrypted media required; ask this contact to upgrade",
-                    comment: "Failure reason when a peer that previously supported encrypted media appears to downgrade"
-                )
-            )
-        }
-    }
-
     func registerTransfer(transferId: String, messageID: String) {
         transferIdToMessageIDs[transferId, default: []].append(messageID)
         messageIDToTransferId[messageID] = transferId
     }
 
-    private func isRegisteredTransfer(_ transferId: String, messageID: String) -> Bool {
-        messageIDToTransferId[messageID] == transferId
-            && transferIdToMessageIDs[transferId]?.contains(messageID) == true
-    }
-
     func makeTransferID(messageID: String) -> String {
         "\(messageID)-\(UUID().uuidString)"
     }
 
     func clearTransferMapping(for messageID: String) {
         guard let transferId = messageIDToTransferId.removeValue(forKey: messageID) else { return }
-        context.cancelLegacyPrivateMediaConsent(
-            transferId: transferId,
-            messageID: messageID
-        )
         guard var queue = transferIdToMessageIDs[transferId] else { return }
 
         if !queue.isEmpty {
@@ -527,9 +298,6 @@ final class ChatMediaTransferCoordinator {
             guard let messageID = transferIdToMessageIDs[id]?.first else { return }
             clearTransferMapping(for: messageID)
             context.removeMessage(withID: messageID, cleanupFile: true)
-        case .rejected(let id, let reason):
-            guard let messageID = transferIdToMessageIDs[id]?.first else { return }
-            handleMediaSendFailure(messageID: messageID, reason: reason)
         }
     }
 
@@ -570,29 +338,9 @@ final class ChatMediaTransferCoordinator {
     }
 
     func deleteMediaMessage(messageID: String) {
-        // Delete is also a send cancellation. In particular, an approved
-        // legacy-clear send may still be waiting on BLEService.messageQueue;
-        // removing only the UI mapping would let that deferred work transmit.
-        if let transferId = messageIDToTransferId[messageID],
-           transferIdToMessageIDs[transferId]?.first == messageID {
-            context.cancelTransfer(transferId)
-        }
         clearTransferMapping(for: messageID)
         context.removeMessage(withID: messageID, cleanupFile: true)
     }
-
-    /// Invalidates detached preparation work and cancels every transfer that
-    /// reached the transport. Stale tasks check the generation before they
-    /// can recreate a message or send after a panic wipe.
-    func resetForPanic() {
-        preparationGeneration &+= 1
-        let transferIDs = Set(transferIdToMessageIDs.keys)
-        transferIdToMessageIDs.removeAll(keepingCapacity: false)
-        messageIDToTransferId.removeAll(keepingCapacity: false)
-        for transferID in transferIDs {
-            context.cancelTransfer(transferID)
-        }
-    }
 }
 
 private extension ChatMediaTransferCoordinator {

bitchat/ViewModels/ChatMessageFormatter.swift

@@ -71,8 +71,12 @@ final class ChatMessageFormatter {
             let content = message.content
             let nsContent = content as NSString
             let nsLen = nsContent.length
+            let containsCashuEarly: Bool = {
+                let regex = Patterns.quickCashuPresence
+                return regex.numberOfMatches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) > 0
+            }()
 
-            if content.isOversizedForRichFormatting() {
+            if (content.count > 4000 || content.hasVeryLongToken(threshold: 1024)) && !containsCashuEarly {
                 var plainStyle = AttributeContainer()
                 plainStyle.foregroundColor = baseColor
                 plainStyle.font = isSelf

bitchat/ViewModels/ChatTransportEventCoordinator.swift

@@ -407,13 +407,6 @@ private extension ChatTransportEventCoordinator {
 
         case .voiceFrame:
             context.handleVoiceFramePayload(from: peerID, payload: payload, timestamp: timestamp)
-
-        case .privateFile, .authenticatedPeerState:
-            // BLEService validates and persists decrypted private files before
-            // emitting a normal `.messageReceived` event, and consumes peer
-            // state inside the transport. Neither payload crosses this
-            // UI-facing typed-payload fallback.
-            break
         }
     }
 

bitchat/ViewModels/ChatViewModel.swift

@@ -89,26 +89,6 @@ import UIKit
 #endif
 import UniformTypeIdentifiers
 
-struct PanicNetworkLifecycle {
-    let stop: @MainActor () -> Void
-    let restart: @MainActor () -> Void
-
-    static let noop = PanicNetworkLifecycle(stop: {}, restart: {})
-
-    static var live: PanicNetworkLifecycle {
-        PanicNetworkLifecycle(
-            stop: {
-                GeohashPresenceService.shared.stopForPanic()
-                NetworkActivationService.shared.stopForPanic()
-            },
-            restart: {
-                NetworkActivationService.shared.start()
-                GeohashPresenceService.shared.start()
-            }
-        )
-    }
-}
-
 /// Manages the application state and business logic for BitChat.
 /// Acts as the primary coordinator between UI components and backend services,
 /// implementing the BitchatDelegate protocol to handle network events.
@@ -162,8 +142,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
     @Published var currentColorScheme: ColorScheme = .light
     @Published var currentTheme: AppTheme = .matrix
     @Published var isConnected = false
-    @Published private(set) var panicRecoveryBlocked = false
-    var networkActivationAllowed: Bool { !panicRecoveryBlocked }
     @Published var nickname: String = "" {
         didSet {
             // Trim whitespace whenever nickname is set; whitespace-only becomes ""
@@ -173,7 +151,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
                 return
             }
             // Update mesh service nickname if it's initialized
-            if !isPanicResetting, !meshService.myPeerID.isEmpty {
+            if !meshService.myPeerID.isEmpty {
                 meshService.setNickname(nickname)
             }
         }
@@ -199,10 +177,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
     lazy var privateConversationCoordinator = ChatPrivateConversationCoordinator(context: self)
     lazy var nostrCoordinator = ChatNostrCoordinator(context: self)
     lazy var mediaTransferCoordinator = ChatMediaTransferCoordinator(context: self)
-    lazy var liveVoiceCoordinator = ChatLiveVoiceCoordinator(
+    lazy var liveVoiceCoordinator = ChatLiveVoiceCoordinator(context: self)
-        context: self,
-        sweepsOnInit: !TestEnvironment.isRunningTests
-    )
     lazy var verificationCoordinator = ChatVerificationCoordinator(context: self)
     lazy var groupCoordinator = ChatGroupCoordinator(context: self)
     lazy var vouchCoordinator = ChatVouchCoordinator(context: self)
@@ -317,9 +292,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
     var nostrRelayManager: NostrRelayManager?
     private let userDefaults = UserDefaults.standard
     let keychain: KeychainManagerProtocol
-    private let panicRecoveryOperations: PanicRecoveryOperations
-    private let panicNetworkLifecycle: PanicNetworkLifecycle
-    private var isPanicResetting = false
     /// Private group membership: keys in the keychain, metadata on disk.
     let groupStore: GroupStore
     private let nicknameKey = "bitchat.nickname"
@@ -375,8 +347,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
     @Published var showBluetoothAlert = false
     @Published var bluetoothAlertMessage = ""
     @Published var bluetoothState: CBManagerState = .unknown
-    @Published private(set) var legacyPrivateMediaConsentRequest: LegacyPrivateMediaConsentRequest?
-    private var pendingLegacyPrivateMediaConsents: [PendingLegacyPrivateMediaConsent] = []
 
     private func performDeliveryUpdate(_ update: @escaping @MainActor (ChatDeliveryCoordinator) -> Void) {
         if Thread.isMainThread {
@@ -799,34 +769,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
         locationPresenceStore: LocationPresenceStore? = nil,
         locationManager: LocationChannelManager = .shared
     ) {
-        let livePanicRecoveryOperations = PanicRecoveryOperations.live()
+        let meshService = BLEService(keychain: keychain, idBridge: idBridge, identityManager: identityManager)
-        let startSuspendedForRecovery: Bool
-        do {
-            startSuspendedForRecovery =
-                try livePanicRecoveryOperations.isPending()
-        } catch {
-            startSuspendedForRecovery = true
-        }
-        // Preserve the preflight decision used to defer CoreBluetooth. A
-        // transiently successful second read must not skip recovery and leave
-        // the service permanently suspended without running the wipe.
-        let panicRecoveryOperations = PanicRecoveryOperations(
-            isPending: {
-                if startSuspendedForRecovery {
-                    return true
-                }
-                return try livePanicRecoveryOperations.isPending()
-            },
-            begin: livePanicRecoveryOperations.begin,
-            wipeMedia: livePanicRecoveryOperations.wipeMedia,
-            complete: livePanicRecoveryOperations.complete
-        )
-        let meshService = BLEService(
-            keychain: keychain,
-            idBridge: idBridge,
-            identityManager: identityManager,
-            startSuspendedForPanicRecovery: startSuspendedForRecovery
-        )
         meshService.sfMetrics = .shared
         self.init(
             keychain: keychain,
@@ -838,9 +781,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
             locationPresenceStore: locationPresenceStore ?? LocationPresenceStore(),
             locationManager: locationManager,
             outboxStore: MessageOutboxStore(keychain: keychain),
-            sfMetrics: .shared,
+            sfMetrics: .shared
-            panicRecoveryOperations: panicRecoveryOperations,
-            panicNetworkLifecycle: .live
         )
     }
 
@@ -858,10 +799,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
         locationManager: LocationChannelManager = .shared,
         readReceiptsDefaults: UserDefaults? = nil,
         outboxStore: MessageOutboxStore? = nil,
-        sfMetrics: StoreAndForwardMetrics? = nil,
+        sfMetrics: StoreAndForwardMetrics? = nil
-        panicMediaWipe: (() throws -> Void)? = nil,
-        panicRecoveryOperations: PanicRecoveryOperations? = nil,
-        panicNetworkLifecycle: PanicNetworkLifecycle = .noop
     ) {
         let conversations = conversations ?? ConversationStore()
         let peerIdentityStore = peerIdentityStore ?? PeerIdentityStore()
@@ -876,9 +814,6 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
         )
 
         self.keychain = keychain
-        self.panicRecoveryOperations = panicRecoveryOperations
-            ?? .ephemeral(wipeMedia: panicMediaWipe ?? {})
-        self.panicNetworkLifecycle = panicNetworkLifecycle
         self.groupStore = GroupStore(keychain: keychain)
         self.idBridge = idBridge
         self.identityManager = identityManager
@@ -914,31 +849,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
             }
             .store(in: &cancellables)
 
-        let recoveryRequired: Bool
+        ChatViewModelBootstrapper(viewModel: self).configure()
-        do {
-            recoveryRequired = try self.panicRecoveryOperations.isPending()
-        } catch {
-            // Failure to read the latch cannot fail open. Re-run the complete
-            // transaction; a persistent storage failure leaves services
-            // blocked below.
-            recoveryRequired = true
-            SecureLogger.error(
-                "Could not read panic-recovery state; retrying the full wipe before startup: \(error)",
-                category: .security
-            )
-        }
-
-        if recoveryRequired {
-            SecureLogger.warning(
-                "Pending panic recovery detected; wiping before runtime services start",
-                category: .security
-            )
-            _ = panicClearAllData(restartServices: false)
-        }
-
-        if networkActivationAllowed {
-            ChatViewModelBootstrapper(viewModel: self).configure()
-        }
     }
 
     // MARK: - Deinitialization
@@ -1242,37 +1153,8 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
 
     // PANIC: Emergency data clearing for activist safety
     @MainActor
-    @discardableResult
+    func panicClearAllData() {
-    func panicClearAllData(restartServices: Bool = true) -> Bool {
+        // Messages are processed immediately - nothing to flush
-        panicRecoveryBlocked = true
-        isPanicResetting = true
-        defer { isPanicResetting = false }
-
-        // Stop internet and location-presence work before clearing identity or
-        // state. These services cancel their subscriptions and delayed tasks,
-        // so old callbacks cannot reconnect during the transaction.
-        panicNetworkLifecycle.stop()
-
-        // Establish both independent durable intents before erasing anything.
-        // `wipeMedia` will still attempt deletion if neither write succeeds.
-        let recoveryIntent = panicRecoveryOperations.begin()
-
-        // Quiesce the mesh before clearing stores. Identity replacement below
-        // deliberately stays stopped until media deletion and marker commit.
-        if let bleService = meshService as? BLEService {
-            bleService.suspendForPanicReset()
-        } else {
-            meshService.emergencyDisconnectAll()
-        }
-
-        // Invalidate detached media preparation and close live capture file
-        // handles before clearing state or removing the media directory.
-        mediaTransferCoordinator.resetForPanic()
-        liveVoiceCoordinator.resetForPanic()
-
-        // Deny and release any clear-media confirmations before identities,
-        // message state, and local files are wiped.
-        cancelAllLegacyPrivateMediaConsents()
 
         // Clear all messages (public timelines and private chats live in the
         // single-writer ConversationStore; the derived `messages` view and
@@ -1294,14 +1176,13 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
 
         // Reset nickname to anonymous
         nickname = "anon\(Int.random(in: 1000...9999))"
-        userDefaults.set(nickname, forKey: nicknameKey)
+        saveNickname()
 
         // Clear favorites and peer mappings
         // Clear through SecureIdentityStateManager instead of directly
         identityManager.clearAllIdentityData()
         peerIdentityStore.clearAll()
         locationPresenceStore.reset()
-        publicRateLimiter.reset()
 
         // Clear persistent favorites from keychain
         FavoritesPersistenceService.shared.clearAllFavorites()
@@ -1366,68 +1247,78 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
         // Clear Nostr identity associations
         idBridge.clearAllAssociations()
 
-        // Replace the BLE identity while keeping the radio stopped. It may
+        // Disconnect from all peers and clear persistent identity
-        // reopen only after the durable panic transaction commits.
+        // This will force creation of a new identity (new fingerprint) on next launch
+        meshService.emergencyDisconnectAll()
         if let bleService = meshService as? BLEService {
-            bleService.resetIdentityForPanic(
+            bleService.resetIdentityForPanic(currentNickname: nickname)
-                currentNickname: nickname,
-                restartServices: false
-            )
-        } else {
-            meshService.setNickname(nickname)
         }
 
-        // The wipe must finish before this security action returns. A detached
+        // No need to force UserDefaults synchronization
-        // task could otherwise lose a race with a new capture or app exit and
-        // leave pre-panic media behind.
-        let panicCompleted: Bool
-        do {
-            try panicRecoveryOperations.wipeMedia(recoveryIntent)
-            try panicRecoveryOperations.complete()
-            panicCompleted = true
-            SecureLogger.info("🗑️ Deleted all media files during panic clear", category: .session)
-        } catch {
-            panicCompleted = false
-            SecureLogger.error(
-                "Panic transaction did not commit; services remain stopped: \(error)",
-                category: .security
-            )
-        }
-        panicRecoveryBlocked = !panicCompleted
 
-        // BCH-01-013: Clear iOS app switcher snapshots. Keep tests away from
+        // Reinitialize Nostr with new identity
-        // the host user's real cache tree just as the default media wipe does.
+        // This will generate new Nostr keys derived from new Noise keys.
-        #if os(iOS)
+        // Skipped under tests: connecting the shared relay singleton starts
+        // real network/reconnect work that never completes and would keep the
+        // test process alive (the singleton, unlike a discardable instance, is
+        // never deallocated to cancel it).
         if !TestEnvironment.isRunningTests {
-            Self.clearAppSwitcherSnapshots()
+            Task { @MainActor in
-        }
+                // Small delay to ensure cleanup completes
-        #endif
+                try? await Task.sleep(nanoseconds: TransportConfig.uiAsyncShortSleepNs) // 0.1 seconds
 
-        guard panicCompleted else { return false }
+                // Reinitialize Nostr relay manager with new identity. Reuse the
-
+                // shared singleton — every other component (NostrTransport, geohash
-        if let bleService = meshService as? BLEService {
+                // subscriptions, AppRuntime observers) is bound to `.shared`, so
-            // Startup recovery reopens admission but leaves actual service
+                // creating a fresh instance here would split relay state and leave
-            // start to the bootstrapper immediately after this method.
+                // sends running against a disconnected manager.
-            bleService.completePanicReset(
-                restartServices: restartServices
-            )
-        }
-
-        if restartServices {
-            // All persistent state and media are gone. Bring each service back
-            // only now, under the new identity.
-            if !(meshService is BLEService) {
-                meshService.startServices()
-            }
-
-            if !TestEnvironment.isRunningTests {
                 nostrRelayManager = NostrRelayManager.shared
                 setupNostrMessageHandling()
+                nostrRelayManager?.connect()
             }
-            panicNetworkLifecycle.restart()
         }
 
-        return true
+        // Delete ALL media files (incoming and outgoing) in background
+        Task.detached(priority: .utility) {
+            // Skipped under tests: the test process shares the user's real
+            // ~/Library/Application Support/files tree, and this detached
+            // utility-priority wipe fires at a nondeterministic time —
+            // deleting media that concurrently running tests (e.g. the
+            // sendImage flow) just wrote there, and the developer's real
+            // app data with it.
+            guard !TestEnvironment.isRunningTests else { return }
+            do {
+                let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+                let filesDir = base.appendingPathComponent("files", isDirectory: true)
+
+                // Delete the entire files directory and recreate it
+                if FileManager.default.fileExists(atPath: filesDir.path) {
+                    try FileManager.default.removeItem(at: filesDir)
+                    SecureLogger.info("🗑️ Deleted all media files during panic clear", category: .session)
+                }
+
+                // Recreate empty directory structure
+                try FileManager.default.createDirectory(at: filesDir, withIntermediateDirectories: true, attributes: nil)
+                try FileManager.default.createDirectory(at: filesDir.appendingPathComponent("voicenotes/incoming", isDirectory: true), withIntermediateDirectories: true, attributes: nil)
+                try FileManager.default.createDirectory(at: filesDir.appendingPathComponent("voicenotes/outgoing", isDirectory: true), withIntermediateDirectories: true, attributes: nil)
+                try FileManager.default.createDirectory(at: filesDir.appendingPathComponent("images/incoming", isDirectory: true), withIntermediateDirectories: true, attributes: nil)
+                try FileManager.default.createDirectory(at: filesDir.appendingPathComponent("images/outgoing", isDirectory: true), withIntermediateDirectories: true, attributes: nil)
+                try FileManager.default.createDirectory(at: filesDir.appendingPathComponent("files/incoming", isDirectory: true), withIntermediateDirectories: true, attributes: nil)
+                try FileManager.default.createDirectory(at: filesDir.appendingPathComponent("files/outgoing", isDirectory: true), withIntermediateDirectories: true, attributes: nil)
+            } catch {
+                SecureLogger.error("Failed to clear media files during panic: \(error)", category: .session)
+            }
+
+            // BCH-01-013: Clear iOS app switcher snapshots
+            // These are stored in Library/Caches/Snapshots/<bundle_id>/
+            #if os(iOS)
+            Self.clearAppSwitcherSnapshots()
+            #endif
+        }
+
+        // Force immediate UI update for panic mode
+        // UI updates immediately - no flushing needed
+
     }
 
     /// BCH-01-013: Clear iOS app switcher snapshots during panic mode
@@ -1913,91 +1804,4 @@ final class ChatViewModel: ObservableObject, BitchatDelegate, TransportEventDele
         publicConversationCoordinator.sendHapticFeedback(for: message)
     }
 }
-
-@MainActor
-extension ChatViewModel {
-    func enqueueLegacyPrivateMediaConsent(
-        for peerID: PeerID,
-        transferId: String,
-        messageID: String,
-        completion: @escaping @MainActor (Bool) -> Void
-    ) {
-        let request = LegacyPrivateMediaConsentRequest(
-            id: UUID(),
-            peerID: peerID,
-            peerName: nicknameForPeer(peerID),
-            transferId: transferId,
-            messageID: messageID
-        )
-        pendingLegacyPrivateMediaConsents.append(PendingLegacyPrivateMediaConsent(
-            request: request,
-            completion: completion
-        ))
-        if legacyPrivateMediaConsentRequest == nil {
-            legacyPrivateMediaConsentRequest = request
-        }
-    }
-
-    func resolveLegacyPrivateMediaConsent(requestID: UUID, approved: Bool) {
-        // SwiftUI may report both the selected button and the presentation
-        // binding's dismissal. Resolve only the exact request that was shown;
-        // a duplicate callback for it must not consume the next queued send.
-        guard legacyPrivateMediaConsentRequest?.id == requestID,
-              pendingLegacyPrivateMediaConsents.first?.request.id == requestID else {
-            return
-        }
-        let resolved = pendingLegacyPrivateMediaConsents.removeFirst()
-        // Drive the boolean presentation state through false before showing
-        // the next queued per-send warning. Otherwise SwiftUI sees true→true,
-        // closes the first dialog, and never presents the second.
-        legacyPrivateMediaConsentRequest = nil
-        resolved.completion(approved)
-        presentNextLegacyPrivateMediaConsentDeferred()
-    }
-
-    func invalidateLegacyPrivateMediaConsent(transferId: String, messageID: String) {
-        let invalidatedIDs = Set(
-            pendingLegacyPrivateMediaConsents.compactMap { pending -> UUID? in
-                let request = pending.request
-                return request.transferId == transferId && request.messageID == messageID
-                    ? request.id
-                    : nil
-            }
-        )
-        guard !invalidatedIDs.isEmpty else { return }
-
-        pendingLegacyPrivateMediaConsents.removeAll {
-            invalidatedIDs.contains($0.request.id)
-        }
-        if let currentID = legacyPrivateMediaConsentRequest?.id,
-           invalidatedIDs.contains(currentID) {
-            legacyPrivateMediaConsentRequest = nil
-            presentNextLegacyPrivateMediaConsentDeferred()
-        }
-    }
-
-    func cancelAllLegacyPrivateMediaConsents() {
-        let pending = pendingLegacyPrivateMediaConsents
-        pendingLegacyPrivateMediaConsents.removeAll()
-        legacyPrivateMediaConsentRequest = nil
-        for item in pending {
-            item.completion(false)
-        }
-    }
-
-    private func presentNextLegacyPrivateMediaConsentDeferred() {
-        guard legacyPrivateMediaConsentRequest == nil,
-              let nextRequestID = pendingLegacyPrivateMediaConsents.first?.request.id else {
-            return
-        }
-        DispatchQueue.main.async { [weak self] in
-            guard let self,
-                  self.legacyPrivateMediaConsentRequest == nil,
-                  self.pendingLegacyPrivateMediaConsents.first?.request.id == nextRequestID else {
-                return
-            }
-            self.legacyPrivateMediaConsentRequest = self.pendingLegacyPrivateMediaConsents[0].request
-        }
-    }
-}
 // End of ChatViewModel class

bitchat/ViewModels/ChatViewModelBootstrapper.swift

@@ -156,17 +156,6 @@ private extension ChatViewModelBootstrapper {
                 viewModel?.objectWillChange.send()
             }
             .store(in: &viewModel.cancellables)
-
-        viewModel.participantTracker.$visiblePeople
-            .receive(on: DispatchQueue.main)
-            .sink { [weak viewModel] people in
-                Task { @MainActor [weak viewModel] in
-                    let visible = Set(people.map { $0.id })
-                    viewModel?.locationPresenceStore.retainTeleportedGeo(keeping: visible)
-                    viewModel?.locationPresenceStore.retainGeoNicknames(keeping: visible)
-                }
-            }
-            .store(in: &viewModel.cancellables)
     }
 
     func loadPersistedViewState() {

bitchat/ViewModels/MessageRateLimiter.swift

@@ -26,10 +26,6 @@ struct MessageRateLimiter {
             }
             return false
         }
-
-        func isIdle(since now: Date, idleTTL: TimeInterval) -> Bool {
-            now.timeIntervalSince(lastRefill) >= idleTTL
-        }
     }
 
     private var senderBuckets: [String: TokenBucket] = [:]
@@ -39,26 +35,17 @@ struct MessageRateLimiter {
     private let senderRefill: Double
     private let contentCapacity: Double
     private let contentRefill: Double
-    private let maxSenderBuckets: Int
-    private let maxContentBuckets: Int
-    private let bucketIdleTTL: TimeInterval
 
     init(
         senderCapacity: Double,
         senderRefillPerSec: Double,
         contentCapacity: Double,
-        contentRefillPerSec: Double,
+        contentRefillPerSec: Double
-        maxSenderBuckets: Int = TransportConfig.uiSenderRateBucketMaxEntries,
-        maxContentBuckets: Int = TransportConfig.uiContentRateBucketMaxEntries,
-        bucketIdleTTL: TimeInterval = TransportConfig.uiRateBucketIdleTTL
     ) {
         self.senderCapacity = senderCapacity
         self.senderRefill = senderRefillPerSec
         self.contentCapacity = contentCapacity
         self.contentRefill = contentRefillPerSec
-        self.maxSenderBuckets = max(1, maxSenderBuckets)
-        self.maxContentBuckets = max(1, maxContentBuckets)
-        self.bucketIdleTTL = bucketIdleTTL
     }
 
     /// - Parameter powBits: validated NIP-13 difficulty of the event
@@ -71,83 +58,25 @@ struct MessageRateLimiter {
         if powBits >= NostrPoW.rateLimitBypassBits {
             senderAllowed = true
         } else {
-            var senderBucket = Self.bucket(
+            var senderBucket = senderBuckets[senderKey] ?? TokenBucket(
-                for: senderKey,
-                in: &senderBuckets,
                 capacity: senderCapacity,
+                tokens: senderCapacity,
                 refillPerSec: senderRefill,
-                maxBuckets: maxSenderBuckets,
+                lastRefill: now
-                idleTTL: bucketIdleTTL,
-                now: now
             )
             senderAllowed = senderBucket.allow(now: now)
             senderBuckets[senderKey] = senderBucket
         }
 
-        // Rejected senders must not mint attacker-keyed content entries.
+        var contentBucket = contentBuckets[contentKey] ?? TokenBucket(
-        guard senderAllowed else { return false }
-
-        var contentBucket = Self.bucket(
-            for: contentKey,
-            in: &contentBuckets,
             capacity: contentCapacity,
+            tokens: contentCapacity,
             refillPerSec: contentRefill,
-            maxBuckets: maxContentBuckets,
+            lastRefill: now
-            idleTTL: bucketIdleTTL,
-            now: now
         )
         let contentAllowed = contentBucket.allow(now: now)
         contentBuckets[contentKey] = contentBucket
 
-        return contentAllowed
+        return senderAllowed && contentAllowed
-    }
-
-    mutating func reset() {
-        senderBuckets.removeAll()
-        contentBuckets.removeAll()
-    }
-
-    var bucketCountsForTesting: (sender: Int, content: Int) {
-        (senderBuckets.count, contentBuckets.count)
-    }
-
-    // Static so we can take `inout` on a stored dictionary without overlapping
-    // exclusive access through a mutating method on `self`.
-    private static func bucket(
-        for key: String,
-        in buckets: inout [String: TokenBucket],
-        capacity: Double,
-        refillPerSec: Double,
-        maxBuckets: Int,
-        idleTTL: TimeInterval,
-        now: Date
-    ) -> TokenBucket {
-        if let existing = buckets[key] {
-            return existing
-        }
-
-        evictIfNeeded(from: &buckets, maxBuckets: maxBuckets, idleTTL: idleTTL, now: now)
-        return TokenBucket(
-            capacity: capacity,
-            tokens: capacity,
-            refillPerSec: refillPerSec,
-            lastRefill: now
-        )
-    }
-
-    private static func evictIfNeeded(
-        from buckets: inout [String: TokenBucket],
-        maxBuckets: Int,
-        idleTTL: TimeInterval,
-        now: Date
-    ) {
-        guard buckets.count >= maxBuckets else { return }
-
-        buckets = buckets.filter { !$0.value.isIdle(since: now, idleTTL: idleTTL) }
-        guard buckets.count >= maxBuckets else { return }
-
-        if let oldestKey = buckets.min(by: { $0.value.lastRefill < $1.value.lastRefill })?.key {
-            buckets.removeValue(forKey: oldestKey)
-        }
     }
 }

bitchat/ViewModels/NostrInboundPipeline.swift

@@ -196,10 +196,7 @@ final class NostrInboundPipeline {
         // Sampled: fires for every geo event and floods dev logs in busy geohashes.
         geoEventLogCount += 1
         if geoEventLogCount == 1 || geoEventLogCount.isMultiple(of: TransportConfig.nostrInboundEventLogInterval) {
-            SecureLogger.debug(
+            SecureLogger.debug("GeoTeleport: recv #\(geoEventLogCount) pub=\(event.pubkey.prefix(8))… pow=\(powBits) tags=\(event.tags.map { "[" + $0.joined(separator: ",") + "]" }.joined(separator: ","))", category: .session)
-                "GeoTeleport: recv #\(geoEventLogCount) pub=\(event.pubkey.prefix(8))… pow=\(powBits) tagCount=\(event.tags.count)",
-                category: .session
-            )
         }
 
         if context.isNostrBlocked(pubkeyHexLowercased: event.pubkey) {
@@ -310,7 +307,7 @@ final class NostrInboundPipeline {
         // claiming to be group traffic over Nostr is ignored.
         // Live voice is mesh-only: latency and relay cost make it
         // meaningless over Nostr.
-        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame, .privateFile, .authenticatedPeerState:
+        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame:
             break
         }
     }
@@ -366,7 +363,7 @@ final class NostrInboundPipeline {
         // claiming to be group traffic over Nostr is ignored.
         // Live voice is mesh-only: latency and relay cost make it
         // meaningless over Nostr.
-        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame, .privateFile, .authenticatedPeerState:
+        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame:
             break
         }
     }
@@ -449,7 +446,7 @@ final class NostrInboundPipeline {
                         // in v1; group traffic over Nostr is ignored.
                         // Live voice is mesh-only: latency and relay cost make it
                         // meaningless over Nostr.
-                        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame, .privateFile, .authenticatedPeerState:
+                        case .verifyChallenge, .verifyResponse, .groupInvite, .groupKeyUpdate, .vouch, .voiceFrame:
                             break
                         }
                     }

bitchat/ViewModels/VoiceRecordingViewModel.swift

@@ -188,25 +188,8 @@ final class VoiceRecordingViewModel: ObservableObject {
 
         Task {
             let finalDuration = Date().timeIntervalSince(startDate)
-            if let url = await session.finish() {
+            if let url = await session.finish(),
-                // Panic and a newer hold both invalidate this completion.
+               isValidRecording(at: url, duration: finalDuration) {
-                // Never route an old recording using a post-panic target.
-                guard generation == holdGeneration else {
-                    try? FileManager.default.removeItem(at: url)
-                    return
-                }
-                guard isValidRecording(
-                    at: url,
-                    duration: finalDuration
-                ) else {
-                    guard state == .idle else { return }
-                    state = .error(
-                        message: finalDuration < VoiceRecorder.minRecordingDuration
-                        ? "Recording is too short."
-                        : "Recording failed to save."
-                    )
-                    return
-                }
                 completion(url)
             } else {
                 guard generation == holdGeneration, state == .idle else { return }
@@ -223,17 +206,6 @@ final class VoiceRecordingViewModel: ObservableObject {
         finish(completion: nil)
     }
 
-    /// Invalidates in-flight permission/start/finalize callbacks and tears
-    /// down an active microphone before the panic transaction continues.
-    func panicWipe() {
-        holdGeneration &+= 1
-        let session = activeSession
-        activeSession = nil
-        state = .idle
-        isLiveStreaming = false
-        session?.panicCancelSynchronously()
-    }
-
     private func isValidRecording(at url: URL, duration: TimeInterval) -> Bool {
         if let attributes = try? FileManager.default.attributesOfItem(atPath: url.path),
            let fileSize = attributes[.size] as? NSNumber,

bitchat/Views/AppInfoView.swift

@@ -26,10 +26,6 @@ struct AppInfoView: View {
     /// introduction), and afterwards the sheet reopens wherever it was left.
     @AppStorage("appInfo.selectedPane") private var selectedPane: Pane = .info
     @State private var showPanicConfirmation = false
-    @AppStorage(AppLanguageSettings.overrideKey) private var languageOverride = ""
-    /// The override changed this session; localization resolves at process
-    /// start, so surface the restart hint.
-    @State private var showLanguageRestartNote = false
 
     private enum Pane: String {
         case settings
@@ -59,11 +55,6 @@ struct AppInfoView: View {
 
             static let connectivityTitle = String(localized: "app_info.settings.connectivity.title", defaultValue: "CONNECTIVITY", comment: "Section header (uppercase) for the connectivity toggles: mesh bridge, internet gateway, tor routing")
 
-            static let languageTitle = String(localized: "app_info.settings.language.title", defaultValue: "LANGUAGE", comment: "Section header (uppercase) for the app language picker in settings")
-            static let languagePickerLabel = String(localized: "app_info.settings.language.picker_label", defaultValue: "app language", comment: "Label of the app language picker row in settings")
-            static let languageSystem = String(localized: "app_info.settings.language.system", defaultValue: "system default", comment: "Menu option that clears the in-app language override so the app follows the device language")
-            static let languageRestartNote = String(localized: "app_info.settings.language.restart_note", defaultValue: "restart bitchat to apply the new language", comment: "Caption shown after the user picks a different app language; the change takes effect on next launch")
-
             static let bridgeTitle = String(localized: "app_info.settings.bridge.title", defaultValue: "mesh bridge", comment: "Title of the mesh bridge toggle in settings")
             static let bridgeSubtitle = String(localized: "app_info.settings.bridge.subtitle", defaultValue: "joins nearby mesh islands over the internet: what you say in the mesh channel also reaches people in your area beyond radio range, and their messages appear here marked with the network glyph. while you have internet, your device also carries bridge and location-channel traffic for phones around you that have none.", comment: "Subtitle explaining what the mesh bridge toggle does")
             static func bridgeCell(_ cell: String) -> String {
@@ -322,52 +313,6 @@ struct AppInfoView: View {
                 }
             }
 
-            // Language — an in-app override so the UI language can differ
-            // from the device language (takes effect on next launch).
-            VStack(alignment: .leading, spacing: 12) {
-                SectionHeader(verbatim: Strings.Settings.languageTitle)
-
-                settingsCard {
-                    Menu {
-                        Button {
-                            selectLanguage(nil)
-                        } label: {
-                            menuItemLabel(Strings.Settings.languageSystem, isSelected: languageOverride.isEmpty)
-                        }
-                        Divider()
-                        ForEach(AppLanguageSettings.availableLanguages, id: \.self) { code in
-                            Button {
-                                selectLanguage(code)
-                            } label: {
-                                menuItemLabel(AppLanguageSettings.endonym(for: code), isSelected: languageOverride == code)
-                            }
-                        }
-                    } label: {
-                        HStack {
-                            Text(Strings.Settings.languagePickerLabel)
-                                .bitchatFont(size: 12, weight: .semibold)
-                                .foregroundColor(textColor)
-                            Spacer()
-                            Text(languageOverride.isEmpty ? Strings.Settings.languageSystem : AppLanguageSettings.endonym(for: languageOverride))
-                                .bitchatFont(size: 12)
-                                .foregroundColor(palette.accent)
-                            Image(systemName: "chevron.up.chevron.down")
-                                .font(.system(size: 10))
-                                .foregroundColor(secondaryTextColor)
-                        }
-                        .contentShape(Rectangle())
-                    }
-                    .buttonStyle(.plain)
-
-                    if showLanguageRestartNote {
-                        Text(Strings.Settings.languageRestartNote)
-                            .bitchatFont(size: 11)
-                            .foregroundColor(secondaryTextColor)
-                            .fixedSize(horizontal: false, vertical: true)
-                    }
-                }
-            }
-
             // Voice — same card + IRC pill as every other toggle setting.
             VStack(alignment: .leading, spacing: 12) {
                 SectionHeader(Strings.Voice.title)
@@ -513,24 +458,6 @@ struct AppInfoView: View {
         .padding()
     }
 
-    private func selectLanguage(_ code: String?) {
-        let previous = languageOverride
-        AppLanguageSettings.setOverride(code)
-        languageOverride = code ?? ""
-        if languageOverride != previous {
-            showLanguageRestartNote = true
-        }
-    }
-
-    private func menuItemLabel(_ title: String, isSelected: Bool) -> some View {
-        HStack {
-            Text(title)
-            if isSelected {
-                Image(systemName: "checkmark")
-            }
-        }
-    }
-
     private var bridgeToggleBinding: Binding<Bool> {
         Binding(
             get: { bridgeService.isEnabled },

bitchat/Views/Components/TextMessageView.swift

@@ -41,7 +41,7 @@ struct TextMessageView: View {
             // first text line; a fixed top padding left the lock's solid body
             // hanging below the line's visual center.
             HStack(alignment: .firstTextBaseline, spacing: 0) {
-                let isLong = message.content.isLongForDisplay()
+                let isLong = (message.content.count > TransportConfig.uiLongMessageLengthThreshold || message.content.hasVeryLongToken(threshold: TransportConfig.uiVeryLongTokenThreshold)) && cashuLinks.isEmpty
                 let isExpanded = expandedMessageIDs.contains(message.id)
                 if message.isPrivate {
                     Image(systemName: "lock.fill")
@@ -103,7 +103,7 @@ struct TextMessageView: View {
             }
             
             // Expand/Collapse for very long messages
-            if message.content.isLongForDisplay() {
+            if (message.content.count > TransportConfig.uiLongMessageLengthThreshold || message.content.hasVeryLongToken(threshold: TransportConfig.uiVeryLongTokenThreshold)) && cashuLinks.isEmpty {
                 let isExpanded = expandedMessageIDs.contains(message.id)
                 let labelKey = isExpanded ? LocalizedStringKey("content.message.show_less") : LocalizedStringKey("content.message.show_more")
                 Button(labelKey) {

bitchat/Views/ContentSheetViews.swift

@@ -36,7 +36,6 @@ struct ContentPeopleSheetView: View {
     #endif
 
     var body: some View {
-        let legacyConsentRequest = conversationUIModel.legacyPrivateMediaConsentRequest
         NavigationStack {
             Group {
                 if privateConversationModel.selectedPeerID != nil {
@@ -98,63 +97,6 @@ struct ContentPeopleSheetView: View {
         }
         .themedSheetBackground()
         .foregroundColor(palette.primary)
-        .confirmationDialog(
-            String(
-                localized: "content.private_media.legacy_warning.title",
-                defaultValue: "Send without end-to-end encryption?",
-                comment: "Title warning before sending private media to an older client in a clear signed envelope"
-            ),
-            isPresented: Binding(
-                get: { legacyConsentRequest != nil },
-                set: { isPresented in
-                    if !isPresented, let requestID = legacyConsentRequest?.id {
-                        conversationUIModel.resolveLegacyPrivateMediaConsent(
-                            requestID: requestID,
-                            approved: false
-                        )
-                    }
-                }
-            ),
-            titleVisibility: .visible
-        ) {
-            Button(
-                String(
-                    localized: "content.private_media.legacy_warning.send",
-                    defaultValue: "send visible file",
-                    comment: "Destructive confirmation action for one legacy clear private-media send"
-                ),
-                role: .destructive
-            ) {
-                if let requestID = legacyConsentRequest?.id {
-                    conversationUIModel.resolveLegacyPrivateMediaConsent(
-                        requestID: requestID,
-                        approved: true
-                    )
-                }
-            }
-            Button("common.cancel", role: .cancel) {
-                if let requestID = legacyConsentRequest?.id {
-                    conversationUIModel.resolveLegacyPrivateMediaConsent(
-                        requestID: requestID,
-                        approved: false
-                    )
-                }
-            }
-        } message: {
-            if let request = legacyConsentRequest {
-                Text(
-                    String(
-                        format: String(
-                            localized: "content.private_media.legacy_warning.message",
-                            defaultValue: "%@'s client does not advertise encrypted private media. This file will be signed but not end-to-end encrypted, so mesh relays can see it. Send this file anyway?",
-                            comment: "Warning explaining the confidentiality loss for one legacy private-media send; parameter is the peer name"
-                        ),
-                        locale: .current,
-                        request.peerName
-                    )
-                )
-            }
-        }
         #if os(macOS)
         .frame(minWidth: 420, minHeight: 520)
         #endif

bitchat/Views/ContentView.swift

@@ -79,9 +79,6 @@ struct ContentView: View {
                 voiceRecordingVM.sessionProvider = { [weak conversationUIModel] in
                     conversationUIModel?.makeVoiceCaptureSession() ?? VoiceNoteCaptureSession()
                 }
-                appChromeModel.setPanicPreparation { [weak voiceRecordingVM] in
-                    voiceRecordingVM?.panicWipe()
-                }
                 #if os(macOS)
                 DispatchQueue.main.async {
                     isNicknameFieldFocused = false
@@ -232,7 +229,6 @@ struct ContentView: View {
         }
         .onDisappear {
             autocompleteDebounceTimer?.invalidate()
-            appChromeModel.setPanicPreparation(nil)
         }
     }
 

bitchat/Views/MessageTextHelpers.swift

@@ -21,26 +21,6 @@ extension String {
         return current >= threshold
     }
 
-    /// True when the message should collapse behind Show more in the UI.
-    /// Length alone decides this — embedding a Cashu-looking token must not
-    /// disable the guard (remote DoS via unbounded layout).
-    func isLongForDisplay(
-        lengthThreshold: Int = TransportConfig.uiLongMessageLengthThreshold,
-        tokenThreshold: Int = TransportConfig.uiVeryLongTokenThreshold
-    ) -> Bool {
-        count > lengthThreshold || hasVeryLongToken(threshold: tokenThreshold)
-    }
-
-    /// True when rich formatting (regex / link detectors) should be skipped.
-    /// Cashu presence used to exempt oversized content from the plain path;
-    /// that let untrusted input force expensive formatting work.
-    func isOversizedForRichFormatting(
-        lengthThreshold: Int = 4000,
-        tokenThreshold: Int = 1024
-    ) -> Bool {
-        count > lengthThreshold || hasVeryLongToken(threshold: tokenThreshold)
-    }
-
     // Extract up to `max` distinct Cashu tokens (cashuA/cashuB), as the bare
     // bearer strings. Allow dot '.' and shorter lengths. The `cashu:` URI
     // form matches too — the token embedded after the scheme is the match.

bitchatShareExtension/Localization/Localizable.xcstrings

@@ -38,12 +38,6 @@
             "comment" : "Fallback title when saving a shared link"
           }
         },
-        "fa" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "پیوند اشتراک‌گذاری‌شده"
-          }
-        },
         "fil" : {
           "stringUnit" : {
             "state" : "needs_review",
@@ -239,12 +233,6 @@
             "comment" : "Shown when the share payload cannot be encoded"
           }
         },
-        "fa" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "کدگذاری پیوند ناموفق بود"
-          }
-        },
         "fil" : {
           "stringUnit" : {
             "state" : "needs_review",
@@ -440,12 +428,6 @@
             "comment" : "Shown when provided content cannot be shared"
           }
         },
-        "fa" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "محتوای قابل اشتراک‌گذاری وجود ندارد"
-          }
-        },
         "fil" : {
           "stringUnit" : {
             "state" : "needs_review",
@@ -641,12 +623,6 @@
             "comment" : "Shown when the share extension receives no content"
           }
         },
-        "fa" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "چیزی برای اشتراک‌گذاری نیست"
-          }
-        },
         "fil" : {
           "stringUnit" : {
             "state" : "needs_review",
@@ -842,12 +818,6 @@
             "comment" : "Confirmation after successfully sharing a link"
           }
         },
-        "fa" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ پیوند در bitchat به اشتراک گذاشته شد"
-          }
-        },
         "fil" : {
           "stringUnit" : {
             "state" : "needs_review",
@@ -1043,12 +1013,6 @@
             "comment" : "Confirmation after successfully sharing text"
           }
         },
-        "fa" : {
-          "stringUnit" : {
-            "state" : "translated",
-            "value" : "✓ متن در bitchat به اشتراک گذاشته شد"
-          }
-        },
         "fil" : {
           "stringUnit" : {
             "state" : "needs_review",

bitchatTests/AppArchitectureTests.swift

@@ -147,44 +147,6 @@ struct AppArchitectureTests {
         #expect(store.teleportedGeo.isEmpty)
     }
 
-    @Test("LocationPresenceStore bounds and prunes teleported geohash participants")
-    @MainActor
-    func locationPresenceStoreBoundsTeleportedParticipants() {
-        let store = LocationPresenceStore(teleportedGeoCapacity: 2)
-
-        store.setCurrentGeohash("u4pruy")
-        store.markTeleported("AAAAAA")
-        store.markTeleported("BBBBBB")
-        store.markTeleported("CCCCCC")
-
-        #expect(store.teleportedGeo == Set(["bbbbbb", "cccccc"]))
-
-        store.retainTeleportedGeo(keeping: Set(["CCCCCC"]))
-        #expect(store.teleportedGeo == Set(["cccccc"]))
-
-        store.setCurrentGeohash("u4pruz")
-        #expect(store.teleportedGeo.isEmpty)
-    }
-
-    @Test("LocationPresenceStore bounds geohash nicknames and clears on channel switch")
-    @MainActor
-    func locationPresenceStoreBoundsGeoNicknames() {
-        let store = LocationPresenceStore(geoNicknameCapacity: 2)
-
-        store.setCurrentGeohash("u4pruy")
-        store.setNickname("alice", for: "AAAAAA")
-        store.setNickname("bob", for: "BBBBBB")
-        store.setNickname("carol", for: "CCCCCC")
-
-        #expect(store.geoNicknames == ["bbbbbb": "bob", "cccccc": "carol"])
-
-        store.retainGeoNicknames(keeping: Set(["CCCCCC"]))
-        #expect(store.geoNicknames == ["cccccc": "carol"])
-
-        store.setCurrentGeohash("u4pruz")
-        #expect(store.geoNicknames.isEmpty)
-    }
-
     @Test("PeerHandle equality and hashing use the canonical identity only")
     func peerHandleEqualityUsesCanonicalIdentity() {
         let first = PeerHandle(id: "noise:abc123", routingPeerID: PeerID(str: "peer-a"))

bitchatTests/BLEServiceCoreTests.swift

@@ -99,95 +99,6 @@ struct BLEServiceCoreTests {
         #expect(ble.currentPeerSnapshots().isEmpty)
     }
 
-    @Test
-    func unsignedAndBadSignatureLeaveDoNotEvictOrRelayClaimedPeer() async throws {
-        let ble = makeService()
-        let alice = NoiseEncryptionService(keychain: MockKeychain())
-        let mallory = NoiseEncryptionService(keychain: MockKeychain())
-        let alicePeerID = PeerID(publicKey: alice.getStaticPublicKeyData())
-        let outbound = OutboundPacketTap()
-        ble._test_onOutboundPacket = outbound.record
-
-        let unsigned = makeLeavePacket(sender: alicePeerID, marker: "unsigned")
-        ble._test_handlePacket(
-            unsigned,
-            fromPeerID: alicePeerID,
-            signingPublicKey: alice.getSigningPublicKeyData()
-        )
-
-        let unsignedRelayed = await TestHelpers.waitUntil(
-            { outbound.count(ofType: .leave) > 0 },
-            timeout: TestConstants.shortTimeout
-        )
-        #expect(!unsignedRelayed)
-        #expect(ble.currentPeerSnapshots().contains { $0.peerID == alicePeerID })
-
-        let badSignature = try #require(
-            mallory.signPacket(makeLeavePacket(sender: alicePeerID, marker: "bad-signature"))
-        )
-        ble._test_handlePacket(
-            badSignature,
-            fromPeerID: alicePeerID,
-            signingPublicKey: alice.getSigningPublicKeyData()
-        )
-
-        let badSignatureRelayed = await TestHelpers.waitUntil(
-            { outbound.count(ofType: .leave) > 0 },
-            timeout: TestConstants.shortTimeout
-        )
-        #expect(!badSignatureRelayed)
-        #expect(ble.currentPeerSnapshots().contains { $0.peerID == alicePeerID })
-    }
-
-    @Test
-    func validSignedLeaveEvictsSessionAndRelays() async throws {
-        let ble = makeService()
-        let alice = NoiseEncryptionService(keychain: MockKeychain())
-        let alicePeerID = PeerID(publicKey: alice.getStaticPublicKeyData())
-
-        // Establish a real session so the leave regression also verifies that
-        // stale secure-delivery state is retired, not just the peer-list row.
-        let message1 = try ble._test_noiseInitiateHandshake(with: alicePeerID)
-        let message2 = try #require(
-            try alice.processHandshakeMessage(from: ble.myPeerID, message: message1)
-        )
-        let message3 = try #require(
-            try ble._test_noiseProcessHandshakeMessage(from: alicePeerID, message: message2)
-        )
-        _ = try alice.processHandshakeMessage(from: ble.myPeerID, message: message3)
-        #expect(ble.canDeliverSecurely(to: alicePeerID))
-        let centralUUID = "central-valid-leave"
-        ble._test_bindCentral(centralUUID, to: alicePeerID)
-        ble._test_markNoiseAuthenticatedCentral(centralUUID, to: alicePeerID)
-        #expect(ble._test_isNoiseAuthenticatedCentral(centralUUID, for: alicePeerID))
-
-        let outbound = OutboundPacketTap()
-        ble._test_onOutboundPacket = outbound.record
-        let signedLeave = try #require(
-            alice.signPacket(makeLeavePacket(sender: alicePeerID, marker: "valid"))
-        )
-        ble._test_handlePacket(
-            signedLeave,
-            fromPeerID: alicePeerID,
-            signingPublicKey: alice.getSigningPublicKeyData()
-        )
-
-        let evicted = await TestHelpers.waitUntil(
-            {
-                !ble.currentPeerSnapshots().contains { $0.peerID == alicePeerID }
-                    && !ble.canDeliverSecurely(to: alicePeerID)
-                    && !ble._test_isNoiseAuthenticatedCentral(centralUUID, for: alicePeerID)
-            },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(evicted)
-        let relayed = await TestHelpers.waitUntil(
-            { outbound.count(ofType: .leave) == 1 },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(relayed)
-    }
-
     @Test
     func ingressAllowsRelayedSenderOnBoundLink() async throws {
         let ble = makeService()
@@ -502,26 +413,14 @@ struct BLEServiceCoreTests {
         )
         let replay = try #require(victim.signPacket(unsigned), "Failed to sign replayed announce")
         #expect(ble._test_recordIngressIfNew(packet: replay, linkID: attackerLink))
-        let rebindGate = VerifiedDirectRebindGate()
-        ble._test_afterVerifiedDirectRebindEnqueued = rebindGate.pause
-        defer {
-            rebindGate.release()
-            ble._test_afterVerifiedDirectRebindEnqueued = nil
-        }
         ble._test_handlePacket(replay, fromPeerID: victimPeerID, preseedPeer: false)
 
-        let announcePaused = await TestHelpers.waitUntil(
+        let rebound = await TestHelpers.waitUntil(
-            { rebindGate.hasPaused },
+            { ble._test_centralBinding(attackerLink) == victimPeerID },
             timeout: TestConstants.longTimeout
         )
-        try #require(announcePaused)
+        #expect(rebound)
-
+        #expect(ble.canDeliverSecurely(to: victimPeerID))
-        // Rebind and ordinary reconnect preparation are one bleQueue
-        // critical section. Once the binding is visible, stale sending keys
-        // must already be unavailable.
-        #expect(ble._test_centralBinding(attackerLink) == victimPeerID)
-        #expect(!ble.canDeliverSecurely(to: victimPeerID))
-        rebindGate.release()
 
         let outbound = OutboundPacketTap()
         ble._test_onOutboundPacket = { outbound.record($0) }
@@ -541,130 +440,6 @@ struct BLEServiceCoreTests {
         #expect(outbound.count(ofType: .courierEnvelope) == 0)
     }
 
-    @Test
-    func failedInboundReconnectRestoresAndDrainsTypedPayloadQueue() async throws {
-        let ble = makeService()
-        let alice = NoiseEncryptionService(keychain: MockKeychain())
-        let mallory = NoiseEncryptionService(keychain: MockKeychain())
-        let alicePeerID = PeerID(publicKey: alice.getStaticPublicKeyData())
-
-        // Establish BLE as responder so the following inbound reconnect is
-        // not intentionally coalesced by the initiator-completion grace path.
-        let message1 = try alice.initiateHandshake(with: ble.myPeerID)
-        let message2 = try #require(
-            try ble._test_noiseProcessHandshakeMessage(
-                from: alicePeerID,
-                message: message1
-            )
-        )
-        let message3 = try #require(
-            try alice.processHandshakeMessage(
-                from: ble.myPeerID,
-                message: message2
-            )
-        )
-        _ = try ble._test_noiseProcessHandshakeMessage(
-            from: alicePeerID,
-            message: message3
-        )
-        await ble._test_drainNoiseMessagePipeline()
-        #expect(ble.canDeliverSecurely(to: alicePeerID))
-
-        let outbound = OutboundPacketTap()
-        ble._test_onOutboundPacket = outbound.record
-        let forgedMessage1 = try mallory.initiateHandshake(with: ble.myPeerID)
-        let firstPacket = BitchatPacket(
-            type: MessageType.noiseHandshake.rawValue,
-            senderID: Data(hexString: alicePeerID.id) ?? Data(),
-            recipientID: Data(hexString: ble.myPeerID.id),
-            timestamp: UInt64(Date().timeIntervalSince1970 * 1_000),
-            payload: forgedMessage1,
-            signature: nil,
-            ttl: 7
-        )
-        ble._test_handlePacket(firstPacket, fromPeerID: alicePeerID)
-
-        let responseReady = await TestHelpers.waitUntil(
-            {
-                outbound.snapshot().contains {
-                    $0.type == MessageType.noiseHandshake.rawValue
-                        && PeerID(hexData: $0.senderID) == ble.myPeerID
-                        && $0.payload.count
-                            != NoiseSecurityConstants.xxInitialMessageSize
-                }
-            },
-            timeout: TestConstants.longTimeout
-        )
-        try #require(responseReady)
-        let forgedMessage2 = try #require(
-            outbound.snapshot().first {
-                $0.type == MessageType.noiseHandshake.rawValue
-                    && PeerID(hexData: $0.senderID) == ble.myPeerID
-                    && $0.payload.count
-                        != NoiseSecurityConstants.xxInitialMessageSize
-            }?.payload
-        )
-        #expect(!ble.canDeliverSecurely(to: alicePeerID))
-
-        // Typed control traffic must queue behind the ordinary responder,
-        // rather than attempting encryption and disappearing.
-        let privateMessageID = "quarantine-pm-\(UUID().uuidString)"
-        ble.sendPrivateMessage(
-            "queued private message",
-            to: alicePeerID,
-            recipientNickname: "Alice",
-            messageID: privateMessageID
-        )
-        ble.sendGroupInvite(Data("queued-during-quarantine".utf8), to: alicePeerID)
-        await ble._test_drainNoiseMessagePipeline()
-        #expect(outbound.count(ofType: .noiseEncrypted) == 0)
-
-        let forgedMessage3 = try #require(
-            try mallory.processHandshakeMessage(
-                from: ble.myPeerID,
-                message: forgedMessage2
-            )
-        )
-        let thirdPacket = BitchatPacket(
-            type: MessageType.noiseHandshake.rawValue,
-            senderID: Data(hexString: alicePeerID.id) ?? Data(),
-            recipientID: Data(hexString: ble.myPeerID.id),
-            timestamp: UInt64(Date().timeIntervalSince1970 * 1_000) + 1,
-            payload: forgedMessage3,
-            signature: nil,
-            ttl: 7
-        )
-        ble._test_handlePacket(thirdPacket, fromPeerID: alicePeerID)
-
-        // Restore re-enters the generation-bound authentication transition:
-        // authenticated state and both outbound queues drain exactly once.
-        let drained = await TestHelpers.waitUntil(
-            { outbound.count(ofType: .noiseEncrypted) >= 3 },
-            timeout: TestConstants.longTimeout
-        )
-        try #require(drained)
-        await ble._test_drainNoiseMessagePipeline()
-        let plaintexts = try outbound.snapshot()
-            .filter { $0.type == MessageType.noiseEncrypted.rawValue }
-            .map { try alice.decrypt($0.payload, from: ble.myPeerID) }
-        #expect(plaintexts.count == 3)
-        #expect(
-            plaintexts.filter {
-                $0.first == NoisePayloadType.authenticatedPeerState.rawValue
-            }.count == 1
-        )
-        #expect(
-            plaintexts.filter {
-                $0.first == NoisePayloadType.privateMessage.rawValue
-            }.count == 1
-        )
-        #expect(
-            plaintexts.filter {
-                $0.first == NoisePayloadType.groupInvite.rawValue
-            }.count == 1
-        )
-    }
-
     /// A legitimate rotation announce necessarily arrives on a link still
     /// bound to the OLD ID, so its registry upsert stores the new peer
     /// disconnected. The successful rebind must promote it: a healed
@@ -797,107 +572,6 @@ struct BLEServiceCoreTests {
         #expect(ble.myPeerID == PeerID(str: newFingerprint.prefix(16)))
     }
 
-    @Test
-    func panicSuspension_dropsLateOutboundWorkUntilCommit() async {
-        let ble = makeService()
-        let outbound = OutboundPacketTap()
-        ble._test_onOutboundPacket = outbound.record
-        let packet = makePublicPacket(
-            content: "late callback",
-            sender: ble.myPeerID,
-            timestamp: UInt64(Date().timeIntervalSince1970 * 1000)
-        )
-
-        ble.suspendForPanicReset()
-        ble.sendPacket(packet)
-        #expect(outbound.count(ofType: .message) == 0)
-
-        ble.completePanicReset(restartServices: false)
-        ble.sendPacket(packet)
-        #expect(outbound.count(ofType: .message) == 1)
-    }
-
-    @Test @MainActor
-    func panicSuspension_invalidatesQueuedMainActorIngress() async {
-        let ble = makeService()
-        let delegate = TransportEventCaptureDelegate()
-        ble.eventDelegate = delegate
-        let message = BitchatMessage(
-            id: "pre-panic-ingress",
-            sender: "Peer",
-            content: "must not survive panic",
-            timestamp: Date(),
-            isRelay: false,
-            isPrivate: true,
-            recipientNickname: "Me",
-            senderPeerID: PeerID(str: "1122334455667788")
-        )
-
-        // The test already owns MainActor, so this task cannot run until the
-        // synchronous panic boundary below has invalidated its generation.
-        ble._test_emitTransportEvent(.messageReceived(message))
-        ble.suspendForPanicReset()
-        await Task.yield()
-        #expect(delegate.messageIDs.isEmpty)
-
-        ble.completePanicReset(restartServices: false)
-        ble._test_emitTransportEvent(.messageReceived(message))
-        await Task.yield()
-        #expect(delegate.messageIDs == [message.id])
-    }
-
-    @Test @MainActor
-    func panicSuspension_rejectsPausedBLEReceiveBeforeMessageQueueHandoff() async {
-        let ble = makeService()
-        let gate = ReceivePacketHandoffGate()
-        ble._test_beforeReceivePacketHandoff = gate.pause
-        ble._test_onReceivePacketHandoff = gate.recordHandoff
-        defer {
-            gate.release()
-            ble._test_beforeReceivePacketHandoff = nil
-            ble._test_onReceivePacketHandoff = nil
-        }
-
-        let sender = PeerID(str: "1122334455667788")
-        let packet = makePublicPacket(
-            content: "must not cross panic",
-            sender: sender,
-            timestamp: UInt64(Date().timeIntervalSince1970 * 1000)
-        )
-        ble._test_handlePacketFromBLEQueue(packet, fromPeerID: sender)
-        #expect(await TestHelpers.waitUntil(
-            { gate.hasPaused },
-            timeout: TestConstants.longTimeout
-        ))
-
-        // Panic closes the lifecycle before waiting for the paused bleQueue
-        // callback. Releasing it afterward lets the callback enqueue its
-        // messageQueue handoff, where the captured generation must be rejected
-        // before packet processing starts.
-        let releaseAfterPanicCloses = Task.detached {
-            while ble._test_isPanicIngressOpen {
-                try? await Task.sleep(nanoseconds: 1_000_000)
-            }
-            gate.release()
-        }
-        let panic = Task { @MainActor in
-            ble.suspendForPanicReset()
-        }
-        await panic.value
-        await releaseAfterPanicCloses.value
-
-        #expect(gate.handoffCount == 0)
-
-        // A packet captured under the reopened lifecycle still crosses the
-        // same handoff, proving the test did not merely disable the hook.
-        ble.completePanicReset(restartServices: false)
-        ble._test_handlePacketFromBLEQueue(packet, fromPeerID: sender)
-        #expect(await TestHelpers.waitUntil(
-            { gate.handoffCount == 1 },
-            timeout: TestConstants.longTimeout
-        ))
-    }
-
     @Test
     func modifiedServices_rediscoverWhenBitChatServiceIsInvalidated() async throws {
         let otherService = CBUUID(string: "0000180F-0000-1000-8000-00805F9B34FB")
@@ -990,82 +664,6 @@ private final class OutboundPacketTap {
         lock.lock(); defer { lock.unlock() }
         return packets.filter { $0.type == type.rawValue }.count
     }
-
-    func snapshot() -> [BitchatPacket] {
-        lock.lock(); defer { lock.unlock() }
-        return packets
-    }
-}
-
-private final class VerifiedDirectRebindGate: @unchecked Sendable {
-    private let condition = NSCondition()
-    private var paused = false
-    private var released = false
-
-    var hasPaused: Bool {
-        condition.lock()
-        defer { condition.unlock() }
-        return paused
-    }
-
-    func pause() {
-        condition.lock()
-        paused = true
-        condition.broadcast()
-        while !released {
-            condition.wait()
-        }
-        condition.unlock()
-    }
-
-    func release() {
-        condition.lock()
-        released = true
-        condition.broadcast()
-        condition.unlock()
-    }
-}
-
-private final class ReceivePacketHandoffGate: @unchecked Sendable {
-    private let condition = NSCondition()
-    private var paused = false
-    private var released = false
-    private var recordedHandoffCount = 0
-
-    var hasPaused: Bool {
-        condition.lock()
-        defer { condition.unlock() }
-        return paused
-    }
-
-    var handoffCount: Int {
-        condition.lock()
-        defer { condition.unlock() }
-        return recordedHandoffCount
-    }
-
-    func pause() {
-        condition.lock()
-        paused = true
-        condition.broadcast()
-        while !released {
-            condition.wait()
-        }
-        condition.unlock()
-    }
-
-    func release() {
-        condition.lock()
-        released = true
-        condition.broadcast()
-        condition.unlock()
-    }
-
-    func recordHandoff() {
-        condition.lock()
-        recordedHandoffCount += 1
-        condition.unlock()
-    }
 }
 
 private func makeService() -> BLEService {
@@ -1092,18 +690,6 @@ private func makePublicPacket(content: String, sender: PeerID, timestamp: UInt64
     )
 }
 
-private func makeLeavePacket(sender: PeerID, marker: String) -> BitchatPacket {
-    BitchatPacket(
-        type: MessageType.leave.rawValue,
-        senderID: Data(hexString: sender.id) ?? Data(),
-        recipientID: nil,
-        timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
-        payload: Data(marker.utf8),
-        signature: nil,
-        ttl: TransportConfig.messageTTLDefault
-    )
-}
-
 private final class PublicCaptureDelegate: BitchatDelegate {
     private let lock = NSLock()
     private(set) var publicMessages: [BitchatMessage] = []
@@ -1138,13 +724,3 @@ private final class PublicCaptureDelegate: BitchatDelegate {
         return publicMessages
     }
 }
-
-@MainActor
-private final class TransportEventCaptureDelegate: TransportEventDelegate {
-    private(set) var messageIDs: [String] = []
-
-    func didReceiveTransportEvent(_ event: TransportEvent) {
-        guard case .messageReceived(let message) = event else { return }
-        messageIDs.append(message.id)
-    }
-}

bitchatTests/ChatMediaTransferCoordinatorContextTests.swift

@@ -7,9 +7,10 @@
 // `ChatViewModel`, following the `ChatDeliveryCoordinatorContextTests` /
 // `ChatPrivateConversationCoordinatorContextTests` exemplars.
 //
-// Real file/codec work remains covered by `ChatMediaPreparationTests`. These
+// Scope note: the async media-preparation pipelines (`ImageUtils`,
-// tests inject a paused voice-note preparer to exercise cancellation ownership
+// `ChatMediaPreparation`) run real file/codec work and remain covered by
-// across the detached-preparation/MainActor boundary deterministically.
+// `ChatMediaPreparationTests`; here we cover message enqueueing, transfer
+// bookkeeping, and the blocked-context guards.
 //
 
 import Testing
@@ -85,72 +86,11 @@ private final class MockChatMediaTransferContext: ChatMediaTransferContext {
 
     // Mesh file transfer
     private(set) var privateFileSends: [(peerID: PeerID, transferId: String)] = []
-    private(set) var privateFileLegacyAllowances: [Bool] = []
     private(set) var broadcastFileSends: [String] = []
     private(set) var cancelledTransfers: [String] = []
-    var privateMediaPolicy: PrivateMediaSendPolicy = .encrypted
-    var resolvedPrivateMediaPolicy: PrivateMediaSendPolicy?
-    private(set) var legacyConsentRequests: [(
-        id: UUID,
-        peerID: PeerID,
-        transferId: String,
-        messageID: String
-    )] = []
-    private(set) var invalidatedLegacyConsents: [(transferId: String, messageID: String)] = []
-    private var pendingLegacyConsentIDs: [UUID] = []
-    private var legacyConsentCompletions: [UUID: @MainActor (Bool) -> Void] = [:]
 
-    func privateMediaSendPolicy(to peerID: PeerID) -> PrivateMediaSendPolicy {
+    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {
-        privateMediaPolicy
-    }
-
-    func resolvePrivateMediaSendPolicy(
-        to peerID: PeerID,
-        completion: @escaping @MainActor (PrivateMediaSendPolicy) -> Void
-    ) {
-        completion(resolvedPrivateMediaPolicy ?? privateMediaPolicy)
-    }
-
-    func requestLegacyPrivateMediaConsent(
-        for peerID: PeerID,
-        transferId: String,
-        messageID: String,
-        completion: @escaping @MainActor (Bool) -> Void
-    ) {
-        let id = UUID()
-        legacyConsentRequests.append((id, peerID, transferId, messageID))
-        pendingLegacyConsentIDs.append(id)
-        legacyConsentCompletions[id] = completion
-    }
-
-    func cancelLegacyPrivateMediaConsent(transferId: String, messageID: String) {
-        invalidatedLegacyConsents.append((transferId, messageID))
-        let matchingIDs = Set(legacyConsentRequests.compactMap { request in
-            request.transferId == transferId && request.messageID == messageID
-                ? request.id
-                : nil
-        })
-        pendingLegacyConsentIDs.removeAll { matchingIDs.contains($0) }
-    }
-
-    func resolveNextLegacyConsent(_ approved: Bool) {
-        guard !pendingLegacyConsentIDs.isEmpty else { return }
-        let id = pendingLegacyConsentIDs.removeFirst()
-        legacyConsentCompletions[id]?(approved)
-    }
-
-    func invokeLegacyConsentEvenIfInvalidated(id: UUID, approved: Bool) {
-        legacyConsentCompletions[id]?(approved)
-    }
-
-    func sendFilePrivate(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        allowLegacyFallback: Bool
-    ) {
         privateFileSends.append((peerID, transferId))
-        privateFileLegacyAllowances.append(allowLegacyFallback)
     }
 
     func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String) {
@@ -162,56 +102,6 @@ private final class MockChatMediaTransferContext: ChatMediaTransferContext {
     }
 }
 
-private final class PausedVoiceNotePreparer: @unchecked Sendable {
-    private let condition = NSCondition()
-    private var started = false
-    private var released = false
-    private var finished = false
-    private let packet: BitchatFilePacket
-
-    init() {
-        let content = Data("voice".utf8)
-        packet = BitchatFilePacket(
-            fileName: "paused.m4a",
-            fileSize: UInt64(content.count),
-            mimeType: "audio/mp4",
-            content: content
-        )
-    }
-
-    func prepare(_: URL) throws -> BitchatFilePacket {
-        condition.lock()
-        started = true
-        condition.broadcast()
-        while !released {
-            condition.wait()
-        }
-        finished = true
-        condition.broadcast()
-        condition.unlock()
-        return packet
-    }
-
-    var hasStarted: Bool {
-        condition.lock()
-        defer { condition.unlock() }
-        return started
-    }
-
-    var hasFinished: Bool {
-        condition.lock()
-        defer { condition.unlock() }
-        return finished
-    }
-
-    func release() {
-        condition.lock()
-        released = true
-        condition.broadcast()
-        condition.unlock()
-    }
-}
-
 // MARK: - Coordinator Tests Against Mock Context
 
 /// Exercises `ChatMediaTransferCoordinator` against
@@ -276,14 +166,6 @@ struct ChatMediaTransferCoordinatorContextTests {
         #expect(context.removedMessages.count == 1)
         #expect(context.removedMessages.first?.messageID == "m2")
         #expect(context.removedMessages.first?.cleanupFile == true)
-
-        // A pre-start rejection keeps the placeholder visible and failed,
-        // including queued post-handshake encryption failures.
-        coordinator.registerTransfer(transferId: "t3", messageID: "m3")
-        coordinator.handleTransferEvent(.rejected(id: "t3", reason: "encryption failed"))
-        #expect(context.deliveryStatusUpdates.last?.messageID == "m3")
-        #expect(context.deliveryStatusUpdates.last?.status == .failed(reason: "encryption failed"))
-        #expect(coordinator.messageIDToTransferId["m3"] == nil)
     }
 
     @Test @MainActor
@@ -306,35 +188,6 @@ struct ChatMediaTransferCoordinatorContextTests {
         #expect(coordinator.messageIDToTransferId.isEmpty)
     }
 
-    @Test @MainActor
-    func resetForPanic_cancelsEveryTransportTransferAndClearsMappings() {
-        let context = MockChatMediaTransferContext()
-        let coordinator = ChatMediaTransferCoordinator(context: context)
-        coordinator.registerTransfer(transferId: "t1", messageID: "m1")
-        coordinator.registerTransfer(transferId: "t1", messageID: "m2")
-        coordinator.registerTransfer(transferId: "t2", messageID: "m3")
-
-        coordinator.resetForPanic()
-
-        #expect(Set(context.cancelledTransfers) == Set(["t1", "t2"]))
-        #expect(coordinator.transferIdToMessageIDs.isEmpty)
-        #expect(coordinator.messageIDToTransferId.isEmpty)
-    }
-
-    @Test @MainActor
-    func deleteMediaMessage_cancelsApprovedTransferBeforeRemovingMapping() {
-        let context = MockChatMediaTransferContext()
-        let coordinator = ChatMediaTransferCoordinator(context: context)
-        coordinator.registerTransfer(transferId: "approved-delete", messageID: "message-delete")
-
-        coordinator.deleteMediaMessage(messageID: "message-delete")
-
-        #expect(context.cancelledTransfers == ["approved-delete"])
-        #expect(coordinator.messageIDToTransferId["message-delete"] == nil)
-        #expect(context.removedMessages.map(\.messageID) == ["message-delete"])
-        #expect(context.removedMessages.first?.cleanupFile == true)
-    }
-
     @Test @MainActor
     func sendVoiceNote_blockedContextRemovesFileAndExplains() async throws {
         let context = MockChatMediaTransferContext()
@@ -353,249 +206,4 @@ struct ChatMediaTransferCoordinatorContextTests {
         #expect(context.appendedPublicMessages.isEmpty)
         #expect(coordinator.transferIdToMessageIDs.isEmpty)
     }
-
-    @Test @MainActor
-    func cancelVoiceNoteDuringDetachedPreparationCannotSendOrRestoreMapping() async throws {
-        let context = MockChatMediaTransferContext()
-        let peerID = PeerID(str: "5566778899aabbcc")
-        context.selectedPrivateChatPeer = peerID
-        let preparer = PausedVoiceNotePreparer()
-        let coordinator = ChatMediaTransferCoordinator(
-            context: context,
-            prepareVoiceNotePacket: { url in try preparer.prepare(url) }
-        )
-        let url = FileManager.default.temporaryDirectory
-            .appendingPathComponent("paused-private-\(UUID().uuidString).m4a")
-        try Data("voice".utf8).write(to: url)
-        defer {
-            preparer.release()
-            try? FileManager.default.removeItem(at: url)
-        }
-
-        coordinator.sendVoiceNote(at: url)
-        #expect(await TestHelpers.waitUntil({ preparer.hasStarted }, timeout: TestConstants.longTimeout))
-        let messageID = try #require(context.privateChats[peerID]?.first?.id)
-        let transferId = try #require(coordinator.messageIDToTransferId[messageID])
-
-        coordinator.cancelMediaSend(messageID: messageID)
-        preparer.release()
-        #expect(await TestHelpers.waitUntil({ preparer.hasFinished }, timeout: TestConstants.longTimeout))
-        for _ in 0..<10 { await Task.yield() }
-
-        #expect(context.cancelledTransfers == [transferId])
-        #expect(context.privateFileSends.isEmpty)
-        #expect(context.broadcastFileSends.isEmpty)
-        #expect(coordinator.messageIDToTransferId[messageID] == nil)
-        #expect(coordinator.transferIdToMessageIDs[transferId] == nil)
-        #expect(context.removedMessages.map(\.messageID) == [messageID])
-    }
-
-    @Test @MainActor
-    func deletePublicVoiceNoteDuringDetachedPreparationCannotBroadcastOrRestoreMapping() async throws {
-        let context = MockChatMediaTransferContext()
-        let preparer = PausedVoiceNotePreparer()
-        let coordinator = ChatMediaTransferCoordinator(
-            context: context,
-            prepareVoiceNotePacket: { url in try preparer.prepare(url) }
-        )
-        let url = FileManager.default.temporaryDirectory
-            .appendingPathComponent("paused-public-\(UUID().uuidString).m4a")
-        try Data("voice".utf8).write(to: url)
-        defer {
-            preparer.release()
-            try? FileManager.default.removeItem(at: url)
-        }
-
-        coordinator.sendVoiceNote(at: url)
-        #expect(await TestHelpers.waitUntil({ preparer.hasStarted }, timeout: TestConstants.longTimeout))
-        let messageID = try #require(context.appendedPublicMessages.first?.message.id)
-        let transferId = try #require(coordinator.messageIDToTransferId[messageID])
-
-        coordinator.deleteMediaMessage(messageID: messageID)
-        preparer.release()
-        #expect(await TestHelpers.waitUntil({ preparer.hasFinished }, timeout: TestConstants.longTimeout))
-        for _ in 0..<10 { await Task.yield() }
-
-        #expect(context.cancelledTransfers == [transferId])
-        #expect(context.broadcastFileSends.isEmpty)
-        #expect(context.privateFileSends.isEmpty)
-        #expect(coordinator.messageIDToTransferId[messageID] == nil)
-        #expect(coordinator.transferIdToMessageIDs[transferId] == nil)
-        #expect(context.removedMessages.map(\.messageID) == [messageID])
-    }
-
-    @Test @MainActor
-    func voicePreparationFailureMarksPlaceholderFailedAndClearsEarlyMapping() async throws {
-        let context = MockChatMediaTransferContext()
-        let peerID = PeerID(str: "66778899aabbccdd")
-        context.selectedPrivateChatPeer = peerID
-        let coordinator = ChatMediaTransferCoordinator(
-            context: context,
-            prepareVoiceNotePacket: { _ in
-                throw ChatMediaPreparationError.voiceNoteTooLarge(bytes: 999_999)
-            }
-        )
-        let url = FileManager.default.temporaryDirectory
-            .appendingPathComponent("failing-private-\(UUID().uuidString).m4a")
-        try Data("voice".utf8).write(to: url)
-        defer { try? FileManager.default.removeItem(at: url) }
-
-        coordinator.sendVoiceNote(at: url)
-        #expect(await TestHelpers.waitUntil(
-            {
-                context.deliveryStatusUpdates.contains { update in
-                    if case .failed = update.status { return true }
-                    return false
-                }
-            },
-            timeout: TestConstants.longTimeout
-        ))
-        let messageID = try #require(context.privateChats[peerID]?.first?.id)
-
-        #expect(coordinator.messageIDToTransferId[messageID] == nil)
-        #expect(coordinator.transferIdToMessageIDs.isEmpty)
-        #expect(context.privateFileSends.isEmpty)
-        #expect(context.broadcastFileSends.isEmpty)
-    }
-
-    @Test @MainActor
-    func legacyPrivateVoiceNoteWaitsForPerSendConsent() async throws {
-        let context = MockChatMediaTransferContext()
-        let coordinator = ChatMediaTransferCoordinator(context: context)
-        let peerID = PeerID(str: "1122334455667788")
-        context.selectedPrivateChatPeer = peerID
-        context.privateMediaPolicy = .legacyRequiresConsent
-        let url = FileManager.default.temporaryDirectory
-            .appendingPathComponent("legacy-consent-\(UUID().uuidString).m4a")
-        try (Data([0x00, 0x00, 0x00, 0x18]) + Data("ftypM4A voice".utf8)).write(to: url)
-        defer { try? FileManager.default.removeItem(at: url) }
-
-        coordinator.sendVoiceNote(at: url)
-
-        let prompted = await TestHelpers.waitUntil(
-            { context.legacyConsentRequests.count == 1 },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(prompted)
-        #expect(context.legacyConsentRequests.map { $0.peerID } == [peerID])
-        #expect(context.privateFileSends.isEmpty)
-
-        context.resolveNextLegacyConsent(true)
-
-        #expect(context.privateFileSends.count == 1)
-        #expect(context.privateFileLegacyAllowances == [true])
-    }
-
-    @Test @MainActor
-    func capabilityProofTimeoutTransitionsToConsentWithoutAutomaticRawSend() async throws {
-        let context = MockChatMediaTransferContext()
-        let coordinator = ChatMediaTransferCoordinator(context: context)
-        let peerID = PeerID(str: "1020304050607080")
-        context.selectedPrivateChatPeer = peerID
-        context.privateMediaPolicy = .awaitingCapabilityProof
-        context.resolvedPrivateMediaPolicy = .legacyRequiresConsent
-        let url = FileManager.default.temporaryDirectory
-            .appendingPathComponent("proof-timeout-consent-\(UUID().uuidString).m4a")
-        try Data("voice".utf8).write(to: url)
-        defer { try? FileManager.default.removeItem(at: url) }
-
-        coordinator.sendVoiceNote(at: url)
-
-        let prompted = await TestHelpers.waitUntil(
-            { context.legacyConsentRequests.count == 1 },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(prompted)
-        #expect(context.privateFileSends.isEmpty)
-        context.resolveNextLegacyConsent(false)
-        #expect(context.privateFileSends.isEmpty)
-    }
-
-    @Test @MainActor
-    func legacyConsentApprovalAfterCancelCannotSend() async throws {
-        let context = MockChatMediaTransferContext()
-        let coordinator = ChatMediaTransferCoordinator(context: context)
-        let peerID = PeerID(str: "2233445566778899")
-        context.selectedPrivateChatPeer = peerID
-        context.privateMediaPolicy = .legacyRequiresConsent
-        let url = FileManager.default.temporaryDirectory
-            .appendingPathComponent("legacy-cancel-\(UUID().uuidString).m4a")
-        try Data("voice".utf8).write(to: url)
-        defer { try? FileManager.default.removeItem(at: url) }
-
-        coordinator.sendVoiceNote(at: url)
-        let prompted = await TestHelpers.waitUntil(
-            { context.legacyConsentRequests.count == 1 },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(prompted)
-        let request = try #require(context.legacyConsentRequests.first)
-
-        coordinator.cancelMediaSend(messageID: request.messageID)
-        #expect(context.invalidatedLegacyConsents.contains {
-            $0.transferId == request.transferId && $0.messageID == request.messageID
-        })
-
-        // Model a stale framework callback that escaped active invalidation.
-        // The coordinator's transfer/message binding check is the final gate.
-        context.invokeLegacyConsentEvenIfInvalidated(id: request.id, approved: true)
-        #expect(context.privateFileSends.isEmpty)
-        #expect(coordinator.messageIDToTransferId[request.messageID] == nil)
-    }
-
-    @Test @MainActor
-    func legacyConsentApprovalAfterDeleteCannotSend() async throws {
-        let context = MockChatMediaTransferContext()
-        let coordinator = ChatMediaTransferCoordinator(context: context)
-        let peerID = PeerID(str: "33445566778899aa")
-        context.selectedPrivateChatPeer = peerID
-        context.privateMediaPolicy = .legacyRequiresConsent
-        let url = FileManager.default.temporaryDirectory
-            .appendingPathComponent("legacy-delete-\(UUID().uuidString).m4a")
-        try Data("voice".utf8).write(to: url)
-        defer { try? FileManager.default.removeItem(at: url) }
-
-        coordinator.sendVoiceNote(at: url)
-        let prompted = await TestHelpers.waitUntil(
-            { context.legacyConsentRequests.count == 1 },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(prompted)
-        let request = try #require(context.legacyConsentRequests.first)
-
-        coordinator.deleteMediaMessage(messageID: request.messageID)
-        context.invokeLegacyConsentEvenIfInvalidated(id: request.id, approved: true)
-
-        #expect(context.invalidatedLegacyConsents.contains {
-            $0.transferId == request.transferId && $0.messageID == request.messageID
-        })
-        #expect(context.privateFileSends.isEmpty)
-        #expect(coordinator.messageIDToTransferId[request.messageID] == nil)
-    }
-
-    @Test @MainActor
-    func pinnedPrivateMediaDowngradeNeverPromptsOrSends() async throws {
-        let context = MockChatMediaTransferContext()
-        let coordinator = ChatMediaTransferCoordinator(context: context)
-        let peerID = PeerID(str: "1122334455667788")
-        context.selectedPrivateChatPeer = peerID
-        context.privateMediaPolicy = .blockedDowngrade
-        let url = FileManager.default.temporaryDirectory
-            .appendingPathComponent("blocked-downgrade-\(UUID().uuidString).m4a")
-        try Data("voice".utf8).write(to: url)
-        defer { try? FileManager.default.removeItem(at: url) }
-
-        coordinator.sendVoiceNote(at: url)
-
-        let failed = await TestHelpers.waitUntil(
-            { context.deliveryStatusUpdates.contains { update in
-                if case .failed = update.status { return true }
-                return false
-            } },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(failed)
-        #expect(context.legacyConsentRequests.isEmpty)
-        #expect(context.privateFileSends.isEmpty)
-    }
 }

bitchatTests/ChatViewModelExtensionsTests.swift

@@ -1048,89 +1048,6 @@ struct ChatViewModelMediaTransferTests {
         #expect(viewModel.transferIdToMessageIDs.count == 1)
     }
 
-    @Test @MainActor
-    func legacyPrivateMediaConsentRequestsArePerSendAndQueued() async throws {
-        let (viewModel, _) = makeTestableViewModel()
-        let firstPeer = PeerID(str: "1111111111111111")
-        let secondPeer = PeerID(str: "2222222222222222")
-        var decisions: [Bool] = []
-
-        viewModel.enqueueLegacyPrivateMediaConsent(
-            for: firstPeer,
-            transferId: "transfer-1",
-            messageID: "message-1"
-        ) { decisions.append($0) }
-        viewModel.enqueueLegacyPrivateMediaConsent(
-            for: secondPeer,
-            transferId: "transfer-2",
-            messageID: "message-2"
-        ) { decisions.append($0) }
-
-        #expect(viewModel.legacyPrivateMediaConsentRequest?.peerID == firstPeer)
-        let firstRequestID = try #require(viewModel.legacyPrivateMediaConsentRequest?.id)
-        viewModel.resolveLegacyPrivateMediaConsent(requestID: firstRequestID, approved: true)
-        let showedSecond = await TestHelpers.waitUntil(
-            { viewModel.legacyPrivateMediaConsentRequest?.peerID == secondPeer },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(showedSecond)
-        let secondRequestID = try #require(viewModel.legacyPrivateMediaConsentRequest?.id)
-
-        // A button action and the dialog binding may both resolve the first
-        // ID. The stale second callback must not consume the queued request.
-        viewModel.resolveLegacyPrivateMediaConsent(requestID: firstRequestID, approved: false)
-        #expect(decisions == [true])
-        #expect(viewModel.legacyPrivateMediaConsentRequest?.id == secondRequestID)
-
-        viewModel.resolveLegacyPrivateMediaConsent(requestID: secondRequestID, approved: false)
-
-        #expect(decisions == [true, false])
-        #expect(viewModel.legacyPrivateMediaConsentRequest == nil)
-    }
-
-    @Test @MainActor
-    func invalidatingPresentedLegacyConsentAdvancesQueueAndStaleResolutionNoops() async throws {
-        let (viewModel, _) = makeTestableViewModel()
-        let firstPeer = PeerID(str: "3333333333333333")
-        let secondPeer = PeerID(str: "4444444444444444")
-        var decisions: [String] = []
-
-        viewModel.enqueueLegacyPrivateMediaConsent(
-            for: firstPeer,
-            transferId: "transfer-cancelled",
-            messageID: "message-cancelled"
-        ) { decisions.append("first:\($0)") }
-        viewModel.enqueueLegacyPrivateMediaConsent(
-            for: secondPeer,
-            transferId: "transfer-kept",
-            messageID: "message-kept"
-        ) { decisions.append("second:\($0)") }
-
-        let cancelledRequestID = try #require(viewModel.legacyPrivateMediaConsentRequest?.id)
-        viewModel.invalidateLegacyPrivateMediaConsent(
-            transferId: "transfer-cancelled",
-            messageID: "message-cancelled"
-        )
-        let advanced = await TestHelpers.waitUntil(
-            { viewModel.legacyPrivateMediaConsentRequest?.peerID == secondPeer },
-            timeout: TestConstants.longTimeout
-        )
-        #expect(advanced)
-        #expect(decisions.isEmpty, "Invalidation drops the request rather than resolving its send")
-
-        viewModel.resolveLegacyPrivateMediaConsent(
-            requestID: cancelledRequestID,
-            approved: true
-        )
-        #expect(viewModel.legacyPrivateMediaConsentRequest?.peerID == secondPeer)
-        #expect(decisions.isEmpty)
-
-        let keptRequestID = try #require(viewModel.legacyPrivateMediaConsentRequest?.id)
-        viewModel.resolveLegacyPrivateMediaConsent(requestID: keptRequestID, approved: true)
-        #expect(decisions == ["second:true"])
-        #expect(viewModel.legacyPrivateMediaConsentRequest == nil)
-    }
-
     @Test @MainActor
     func sendVoiceNote_oversizedFileFailsAndDeletesTempFile() async throws {
         let (viewModel, transport) = makeTestableViewModel()

bitchatTests/ChatViewModelTests.swift

@@ -15,11 +15,7 @@ import BitFoundation
 
 /// Creates a ChatViewModel with mock dependencies for testing
 @MainActor
-private func makeTestableViewModel(
+private func makeTestableViewModel() -> (viewModel: ChatViewModel, transport: MockTransport) {
-    panicMediaWipe: (() throws -> Void)? = nil,
-    panicRecoveryOperations: PanicRecoveryOperations? = nil,
-    panicNetworkLifecycle: PanicNetworkLifecycle = .noop
-) -> (viewModel: ChatViewModel, transport: MockTransport) {
     let keychain = MockKeychain()
     let keychainHelper = MockKeychainHelper()
     let idBridge = NostrIdentityBridge(keychain: keychainHelper)
@@ -30,10 +26,7 @@ private func makeTestableViewModel(
         keychain: keychain,
         idBridge: idBridge,
         identityManager: identityManager,
-        transport: transport,
+        transport: transport
-        panicMediaWipe: panicMediaWipe,
-        panicRecoveryOperations: panicRecoveryOperations,
-        panicNetworkLifecycle: panicNetworkLifecycle
     )
 
     return (viewModel, transport)
@@ -653,25 +646,6 @@ struct ChatViewModelFormattingTests {
         #expect(String(formatted.characters) == "<@Alice#a1b2> hello #mesh [\(message.formattedTimestamp)]")
     }
 
-    @Test @MainActor
-    func formatMessageAsText_longCashuFallsBackToPlain() async {
-        let (viewModel, _) = makeTestableViewModel()
-        let cashu = "cashuA" + String(repeating: "a", count: 40)
-        let longContent = "hi @bob " + cashu + " " + String(repeating: "x", count: 4_100)
-        let message = BitchatMessage(
-            id: "fmt-long-cashu",
-            sender: "Alice#a1b2",
-            content: longContent,
-            timestamp: Date(timeIntervalSince1970: 1_700_010_123),
-            isRelay: false,
-            senderPeerID: PeerID(str: "00000000000000b3")
-        )
-
-        let formatted = viewModel.formatMessageAsText(message, colorScheme: .light)
-
-        #expect(String(formatted.characters) == "<@Alice#a1b2> \(longContent) [\(message.formattedTimestamp)]")
-    }
-
     @Test @MainActor
     func formatMessageHeader_formatsSenderHeader() async {
         let (viewModel, _) = makeTestableViewModel()
@@ -1123,92 +1097,6 @@ struct ChatViewModelBluetoothTests {
 
 struct ChatViewModelPanicTests {
 
-    @Test @MainActor
-    func panicClearAllData_finishesMediaWipeBeforeReturning() {
-        var wipeFinished = false
-        let (viewModel, _) = makeTestableViewModel(panicMediaWipe: {
-            wipeFinished = true
-        })
-
-        viewModel.panicClearAllData()
-
-        #expect(wipeFinished)
-    }
-
-    @Test @MainActor
-    func panicClearAllData_stopsNetworkBeforeWipeAndRestartsAfterCommit() {
-        var events: [String] = []
-        let lifecycle = PanicNetworkLifecycle(
-            stop: { events.append("stop") },
-            restart: { events.append("restart") }
-        )
-        let (viewModel, _) = makeTestableViewModel(
-            panicMediaWipe: { events.append("wipe") },
-            panicNetworkLifecycle: lifecycle
-        )
-
-        let completed = viewModel.panicClearAllData()
-
-        #expect(completed)
-        #expect(events == ["stop", "wipe", "restart"])
-        #expect(viewModel.networkActivationAllowed)
-    }
-
-    @Test @MainActor
-    func pendingPanicRecoveryCompletesBeforeTransportBootstrap() {
-        var events: [String] = []
-        let operations = PanicRecoveryOperations(
-            isPending: {
-                events.append("read")
-                return true
-            },
-            begin: {
-                events.append("begin")
-                return PanicRecoveryIntent(
-                    fileMarkerEstablished: true,
-                    externalMarkerEstablished: false
-                )
-            },
-            wipeMedia: { _ in events.append("wipe") },
-            complete: { events.append("complete") }
-        )
-
-        let (viewModel, transport) = makeTestableViewModel(
-            panicRecoveryOperations: operations
-        )
-
-        #expect(events == ["read", "begin", "wipe", "complete"])
-        #expect(transport.emergencyDisconnectCallCount == 1)
-        #expect(transport.startServicesCallCount == 1)
-        #expect(viewModel.networkActivationAllowed)
-    }
-
-    @Test @MainActor
-    func failedStartupRecoveryLeavesTransportAndNetworkBlocked() {
-        enum WipeFailure: Error { case failed }
-        var completedMarker = false
-        let operations = PanicRecoveryOperations(
-            isPending: { true },
-            begin: {
-                PanicRecoveryIntent(
-                    fileMarkerEstablished: true,
-                    externalMarkerEstablished: false
-                )
-            },
-            wipeMedia: { _ in throw WipeFailure.failed },
-            complete: { completedMarker = true }
-        )
-
-        let (viewModel, transport) = makeTestableViewModel(
-            panicRecoveryOperations: operations
-        )
-
-        #expect(!completedMarker)
-        #expect(transport.emergencyDisconnectCallCount == 1)
-        #expect(transport.startServicesCallCount == 0)
-        #expect(!viewModel.networkActivationAllowed)
-    }
-
     @Test @MainActor
     func panicClearAllData_delegatesToTransport() async {
         let (viewModel, transport) = makeTestableViewModel()

bitchatTests/Integration/IntegrationTests.swift

@@ -12,7 +12,6 @@ import Testing
 @testable import BitFoundation // to avoid unnecessary public's
 @testable import bitchat
 
-@Suite("Integration Tests", .serialized)
 struct IntegrationTests {
     
     private var helper = TestNetworkHelper()
@@ -273,18 +272,8 @@ struct IntegrationTests {
         // Re-establish Noise handshake explicitly via managers
         do {
             let m1 = try helper.noiseManagers["Bob"]!.initiateHandshake(with: helper.nodes["Alice"]!.peerID)
-            let m2 = try #require(
+            let m2 = try helper.noiseManagers["Alice"]!.handleIncomingHandshake(from: helper.nodes["Bob"]!.peerID, message: m1)!
-                try helper.noiseManagers["Alice"]!.handleIncomingHandshake(
+            let m3 = try helper.noiseManagers["Bob"]!.handleIncomingHandshake(from: helper.nodes["Alice"]!.peerID, message: m2)!
-                    from: helper.nodes["Bob"]!.peerID,
-                    message: m1
-                )
-            )
-            let m3 = try #require(
-                try helper.noiseManagers["Bob"]!.handleIncomingHandshake(
-                    from: helper.nodes["Alice"]!.peerID,
-                    message: m2
-                )
-            )
             _ = try helper.noiseManagers["Alice"]!.handleIncomingHandshake(from: helper.nodes["Bob"]!.peerID, message: m3)
         } catch {
             Issue.record("Failed to re-establish Noise session after restart: \(error)")

bitchatTests/Integration/TestNetworkHelper.swift

@@ -8,7 +8,6 @@
 
 import Foundation
 import CryptoKit
-import Testing
 @testable import BitFoundation // to avoid unnecessary public's
 @testable import bitchat
 
@@ -28,14 +27,9 @@ final class TestNetworkHelper {
         node.mockNickname = name
         nodes[name] = node
         
-        // This synchronous helper directly drives all three XX messages and
+        // Create/replace Noise manager for this node
-        // has no transport callback loop for delayed collision recovery.
         let key = Curve25519.KeyAgreement.PrivateKey()
-        noiseManagers[name] = NoiseSessionManager(
+        noiseManagers[name] = NoiseSessionManager(localStaticKey: key, keychain: mockKeychain)
-            localStaticKey: key,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
         return node
     }
     
@@ -114,18 +108,8 @@ final class TestNetworkHelper {
               let peer2ID = nodes[node2]?.peerID else { return }
         
         let msg1 = try manager1.initiateHandshake(with: peer2ID)
-        let msg2 = try #require(
+        let msg2 = try manager2.handleIncomingHandshake(from: peer1ID, message: msg1)!
-            try manager2.handleIncomingHandshake(
+        let msg3 = try manager1.handleIncomingHandshake(from: peer2ID, message: msg2)!
-                from: peer1ID,
-                message: msg1
-            )
-        )
-        let msg3 = try #require(
-            try manager1.handleIncomingHandshake(
-                from: peer2ID,
-                message: msg2
-            )
-        )
         _ = try manager2.handleIncomingHandshake(from: peer1ID, message: msg3)
     }
 }

bitchatTests/MessageFormattingEngineTests.swift

@@ -323,32 +323,6 @@ struct MessageFormattingEngineTests {
         // Exactly at threshold DOES trigger (uses >= comparison)
         #expect(content.hasVeryLongToken(threshold: 50))
     }
-
-    @Test func isLongForDisplay_doesNotIgnoreCashuLinks() {
-        let cashu = "cashuA" + String(repeating: "a", count: 40)
-        let content = String(repeating: "a", count: TransportConfig.uiLongMessageLengthThreshold + 1) + " " + cashu
-
-        #expect(content.extractCashuLinks().count == 1)
-        #expect(content.isLongForDisplay())
-    }
-
-    @MainActor
-    @Test func formatMessage_longCashuMessageFallsBackToPlainContentPath() {
-        let context = MockMessageFormattingContext(nickname: "carol")
-        let cashu = "cashuA" + String(repeating: "a", count: 40)
-        let longContent = "hi @bob " + cashu + " " + String(repeating: "x", count: 4_100)
-        let message = BitchatMessage(
-            id: "long-cashu",
-            sender: "alice",
-            content: longContent,
-            timestamp: Date(timeIntervalSince1970: 1_700_000_999),
-            isRelay: false
-        )
-
-        let formatted = MessageFormattingEngine.formatMessage(message, context: context, colorScheme: .light)
-
-        #expect(String(formatted.characters) == "<@alice> \(longContent) [\(message.formattedTimestamp)]")
-    }
 }
 
 @MainActor

bitchatTests/MessageRateLimiterTests.swift

@@ -116,87 +116,4 @@ struct MessageRateLimiterTests {
         #expect(plain)
         #expect(!plainExhausted)
     }
-
-    @Test("Content buckets do not grow when sender is rate limited")
-    func contentBucketsDoNotGrowAfterSenderLimit() {
-        var limiter = MessageRateLimiter(
-            senderCapacity: 1,
-            senderRefillPerSec: 0,
-            contentCapacity: 1,
-            contentRefillPerSec: 0,
-            maxSenderBuckets: 10,
-            maxContentBuckets: 10,
-            bucketIdleTTL: 60
-        )
-        let now = Date()
-
-        let first = limiter.allow(senderKey: "sender", contentKey: "content-0", now: now)
-        var rejected = true
-        for index in 1...100 {
-            if limiter.allow(senderKey: "sender", contentKey: "content-\(index)", now: now) {
-                rejected = false
-            }
-        }
-
-        #expect(first)
-        #expect(rejected)
-        #expect(limiter.bucketCountsForTesting.sender == 1)
-        #expect(limiter.bucketCountsForTesting.content == 1)
-    }
-
-    @Test("Bucket maps evict entries at configured caps")
-    func bucketMapsEvictAtConfiguredCaps() {
-        let maxEntries = 3
-        var limiter = MessageRateLimiter(
-            senderCapacity: 1,
-            senderRefillPerSec: 0,
-            contentCapacity: 1,
-            contentRefillPerSec: 0,
-            maxSenderBuckets: maxEntries,
-            maxContentBuckets: maxEntries,
-            bucketIdleTTL: 60
-        )
-        let now = Date()
-
-        for index in 0..<25 {
-            _ = limiter.allow(
-                senderKey: "sender-\(index)",
-                contentKey: "content-\(index)",
-                now: now.addingTimeInterval(TimeInterval(index))
-            )
-        }
-
-        #expect(limiter.bucketCountsForTesting.sender == maxEntries)
-        #expect(limiter.bucketCountsForTesting.content == maxEntries)
-    }
-
-    @Test("PoW bypass still creates content buckets under the cap")
-    func powBypassCreatesBoundedContentBuckets() {
-        let maxEntries = 3
-        var limiter = MessageRateLimiter(
-            senderCapacity: 1,
-            senderRefillPerSec: 0,
-            contentCapacity: 100,
-            contentRefillPerSec: 0,
-            maxSenderBuckets: maxEntries,
-            maxContentBuckets: maxEntries,
-            bucketIdleTTL: 60
-        )
-        let now = Date()
-
-        var allAllowed = true
-        for index in 0..<10 {
-            let allowed = limiter.allow(
-                senderKey: "sender",
-                contentKey: "content-\(index)",
-                powBits: NostrPoW.rateLimitBypassBits,
-                now: now.addingTimeInterval(TimeInterval(index))
-            )
-            if !allowed { allAllowed = false }
-        }
-
-        #expect(allAllowed)
-        #expect(limiter.bucketCountsForTesting.sender == 0)
-        #expect(limiter.bucketCountsForTesting.content == maxEntries)
-    }
 }

bitchatTests/Mocks/MockIdentityManager.swift

@@ -14,8 +14,6 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
     private var blockedFingerprints: Set<String> = []
     private var blockedNostrPubkeys: Set<String> = []
     private var socialIdentities: [String: SocialIdentity] = [:]
-    private var privateMediaCapableFingerprints: Set<String> = []
-    private var authenticatedSigningKeys: [String: Data] = [:]
 
     init(_: KeychainManagerProtocol) {}
     
@@ -89,10 +87,7 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
     
     func registerEphemeralSession(peerID: PeerID, handshakeState: HandshakeState) {}
 
-    func clearAllIdentityData() {
+    func clearAllIdentityData() {}
-        privateMediaCapableFingerprints.removeAll()
-        authenticatedSigningKeys.removeAll()
-    }
     
     func removeEphemeralSession(peerID: PeerID) {}
     
@@ -106,22 +101,6 @@ final class MockIdentityManager: SecureIdentityStateManagerProtocol {
         Set()
     }
 
-    func markPrivateMediaCapable(fingerprint: String) {
-        privateMediaCapableFingerprints.insert(fingerprint)
-    }
-
-    func hasObservedPrivateMediaCapability(fingerprint: String) -> Bool {
-        privateMediaCapableFingerprints.contains(fingerprint)
-    }
-
-    func bindAuthenticatedSigningPublicKey(_ signingPublicKey: Data, fingerprint: String) {
-        authenticatedSigningKeys[fingerprint] = signingPublicKey
-    }
-
-    func authenticatedSigningPublicKey(forFingerprint fingerprint: String) -> Data? {
-        authenticatedSigningKeys[fingerprint]
-    }
-
     // MARK: Vouching (transitive verification)
 
     private var vouchesByVouchee: [String: [VouchRecord]] = [:]

bitchatTests/Mocks/MockTransport.swift

@@ -36,7 +36,6 @@ final class MockTransport: Transport {
     private(set) var sentFavoriteNotifications: [(peerID: PeerID, isFavorite: Bool)] = []
     private(set) var sentBroadcastFiles: [(packet: BitchatFilePacket, transferID: String)] = []
     private(set) var sentPrivateFiles: [(packet: BitchatFilePacket, peerID: PeerID, transferID: String)] = []
-    private(set) var sentPrivateFileLegacyAllowances: [Bool] = []
     private(set) var cancelledTransfers: [String] = []
     private(set) var sentVerifyChallenges: [(peerID: PeerID, noiseKeyHex: String, nonceA: Data)] = []
     private(set) var sentVerifyResponses: [(peerID: PeerID, noiseKeyHex: String, nonceA: Data)] = []
@@ -59,7 +58,6 @@ final class MockTransport: Transport {
     var peerNicknames: [PeerID: String] = [:]
     var peerFingerprints: [PeerID: String] = [:]
     var peerNoiseStates: [PeerID: LazyHandshakeState] = [:]
-    var privateMediaPolicies: [PeerID: PrivateMediaSendPolicy] = [:]
     private let mockKeychain = MockKeychain()
 
     // MARK: - Transport Protocol Implementation
@@ -188,29 +186,6 @@ final class MockTransport: Transport {
 
     func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {
         sentPrivateFiles.append((packet, peerID, transferId))
-        sentPrivateFileLegacyAllowances.append(false)
-    }
-
-    func sendFilePrivate(
-        _ packet: BitchatFilePacket,
-        to peerID: PeerID,
-        transferId: String,
-        allowLegacyFallback: Bool
-    ) {
-        sentPrivateFiles.append((packet, peerID, transferId))
-        sentPrivateFileLegacyAllowances.append(allowLegacyFallback)
-    }
-
-    func privateMediaSendPolicy(to peerID: PeerID) -> PrivateMediaSendPolicy {
-        privateMediaPolicies[peerID] ?? .encrypted
-    }
-
-    func resolvePrivateMediaSendPolicy(
-        to peerID: PeerID,
-        completion: @escaping @MainActor (PrivateMediaSendPolicy) -> Void
-    ) {
-        let policy = privateMediaPolicies[peerID] ?? .encrypted
-        Task { @MainActor in completion(policy) }
     }
 
     func cancelTransfer(_ transferId: String) {

bitchatTests/Noise/NoiseCoverageTests.swift

@@ -5,22 +5,15 @@ import BitFoundation
 
 @testable import bitchat
 
-@Suite("Noise Coverage Tests", .serialized)
+@Suite("Noise Coverage Tests")
 struct NoiseCoverageTests {
     private let keychain = MockKeychain()
     private let aliceStaticKey = Curve25519.KeyAgreement.PrivateKey()
     private let bobStaticKey = Curve25519.KeyAgreement.PrivateKey()
     private let charlieStaticKey = Curve25519.KeyAgreement.PrivateKey()
 
-    // Manager test dictionaries are keyed by the remote peer. Keep the
+    private let alicePeerID = PeerID(str: "0011223344556677")
-    // historical names, but derive each wire ID from the static key that the
+    private let bobPeerID = PeerID(str: "8899aabbccddeeff")
-    // corresponding manager authenticates during the handshake.
-    private var alicePeerID: PeerID {
-        PeerID(publicKey: bobStaticKey.publicKey.rawRepresentation)
-    }
-    private var bobPeerID: PeerID {
-        PeerID(publicKey: aliceStaticKey.publicKey.rawRepresentation)
-    }
     private let charliePeerID = PeerID(str: "fedcba9876543210")
 
     @Test("Protocol metadata and handshake patterns expose expected values")
@@ -542,12 +535,8 @@ struct NoiseCoverageTests {
         let aliceManager = NoiseSessionManager(localStaticKey: aliceStaticKey, keychain: keychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobStaticKey, keychain: keychain)
 
-        aliceManager.onSessionEstablished = establishedRecorder.recordEstablished(
+        aliceManager.onSessionEstablished = establishedRecorder.recordEstablished(peerID:remoteKey:)
-            peerID:remoteKey:sessionGeneration:
+        bobManager.onSessionEstablished = establishedRecorder.recordEstablished(peerID:remoteKey:)
-        )
-        bobManager.onSessionEstablished = establishedRecorder.recordEstablished(
-            peerID:remoteKey:sessionGeneration:
-        )
 
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
 
@@ -633,16 +622,8 @@ struct NoiseCoverageTests {
         )
         let replacementSession = try #require(manager.getSession(for: alicePeerID))
 
-        let localPeerID = PeerID(
+        #expect(replacementResponse != nil)
-            publicKey: aliceStaticKey.publicKey.rawRepresentation
+        #expect(replacementSession !== restartedSession)
-        )
-        if localPeerID < alicePeerID {
-            #expect(replacementResponse == nil)
-            #expect(replacementSession === restartedSession)
-        } else {
-            #expect(replacementResponse != nil)
-            #expect(replacementSession !== restartedSession)
-        }
 
         let aliceManager = NoiseSessionManager(localStaticKey: aliceStaticKey, keychain: keychain)
         let bobManager = NoiseSessionManager(localStaticKey: bobStaticKey, keychain: keychain)
@@ -662,128 +643,13 @@ struct NoiseCoverageTests {
             try aliceManager.initiateHandshake(with: alicePeerID)
         }
 
-        let rekeyInitiation = try aliceManager.initiateRekey(for: alicePeerID)
+        try aliceManager.initiateRekey(for: alicePeerID)
-        let rekeyHandshake = try #require(
-            aliceManager.claimHandshakeInitiation(
-                rekeyInitiation,
-                for: alicePeerID
-            )
-        )
-        #expect(!rekeyHandshake.isEmpty)
         let rekeyedSession = try #require(aliceManager.getSession(for: alicePeerID))
 
         #expect(rekeyedSession !== establishedSession)
         #expect(rekeyedSession.getState() == .handshaking)
     }
 
-    @Test("A stale decrypt generation cannot commit across session promotion")
-    func staleDecryptGenerationCannotCommitAcrossPromotion() throws {
-        let aliceManager = NoiseSessionManager(
-            localStaticKey: aliceStaticKey,
-            keychain: keychain,
-            recentInitiatorCompletionGracePeriod: 0,
-            sessionFactory: { peerID, role in
-                BlockingDecryptNoiseSession(
-                    peerID: peerID,
-                    role: role,
-                    keychain: self.keychain,
-                    localStaticKey: self.aliceStaticKey
-                )
-            }
-        )
-        let bobManager = NoiseSessionManager(localStaticKey: bobStaticKey, keychain: keychain)
-        try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
-
-        let oldSession = try #require(
-            aliceManager.getSession(for: alicePeerID) as? BlockingDecryptNoiseSession
-        )
-        let oldGeneration = try #require(aliceManager.sessionGeneration(for: alicePeerID))
-
-        // Prepare a fully authenticated responder candidate without promoting
-        // it yet. Its final XX message is the exact operation that replaces
-        // the old `sessions[peerID]` entry.
-        let replacementInitiator = NoiseSession(
-            peerID: bobPeerID,
-            role: .initiator,
-            keychain: keychain,
-            localStaticKey: bobStaticKey
-        )
-        let message1 = try replacementInitiator.startHandshake()
-        let message2 = try #require(
-            try aliceManager.handleIncomingHandshake(from: alicePeerID, message: message1)
-        )
-        let message3 = try #require(try replacementInitiator.processHandshakeMessage(message2))
-
-        let ciphertext = try bobManager.encrypt(Data("old session".utf8), for: bobPeerID)
-        oldSession.pauseNextDecrypt()
-
-        let decryptResult = ConcurrentTestResult<(plaintext: Data, sessionGeneration: UUID)>()
-        var promotionResultForCleanup: ConcurrentTestResult<Data?>?
-        defer {
-            // A failed startup requirement must not strand a late thread in
-            // the blocking test double after the test has returned.
-            oldSession.resumeDecrypt()
-            _ = decryptResult.wait(timeout: 5)
-            if let promotionResultForCleanup {
-                _ = promotionResultForCleanup.wait(timeout: 5)
-            }
-        }
-
-        let decryptThread = Thread {
-            decryptResult.capture {
-                try aliceManager.decryptWithSessionGeneration(ciphertext, from: self.alicePeerID)
-            }
-        }
-        decryptThread.name = "NoiseCoverageTests.staleDecrypt.decrypt"
-        decryptThread.qualityOfService = .userInitiated
-        decryptThread.start()
-        try #require(oldSession.waitForDecryptStart(timeout: 5))
-
-        let promotionStarted = DispatchSemaphore(value: 0)
-        let promotionResult = ConcurrentTestResult<Data?>()
-        promotionResultForCleanup = promotionResult
-        let promotionThread = Thread {
-            promotionStarted.signal()
-            promotionResult.capture {
-                try aliceManager.handleIncomingHandshake(from: self.alicePeerID, message: message3)
-            }
-        }
-        promotionThread.name = "NoiseCoverageTests.staleDecrypt.promote"
-        promotionThread.qualityOfService = .userInitiated
-        promotionThread.start()
-        try #require(promotionStarted.wait(timeout: .now() + 5) == .success)
-        #expect(
-            promotionResult.wait(timeout: 0.05) == nil,
-            "Promotion must wait for the exact decrypting-session lease"
-        )
-
-        oldSession.resumeDecrypt()
-        let decrypted = try #require(decryptResult.wait(timeout: 5)).get()
-        _ = try #require(promotionResult.wait(timeout: 5)).get()
-
-        #expect(decrypted.plaintext == Data("old session".utf8))
-        #expect(decrypted.sessionGeneration == oldGeneration)
-        #expect(aliceManager.sessionGeneration(for: alicePeerID) != oldGeneration)
-        #expect(throws: NoiseEncryptionError.sessionNotEstablished) {
-            try aliceManager.encrypt(
-                Data("stale send".utf8),
-                for: alicePeerID,
-                expectedSessionGeneration: oldGeneration
-            )
-        }
-
-        var staleCommitRan = false
-        let staleCommit = aliceManager.withCurrentSessionGeneration(
-            for: alicePeerID,
-            expected: decrypted.sessionGeneration
-        ) {
-            staleCommitRan = true
-            return true
-        }
-        #expect(staleCommit == nil)
-        #expect(!staleCommitRan)
-    }
-
     @Test("Secure noise sessions enforce limits and renegotiation thresholds")
     func secureNoiseSessionsEnforceLimitsAndThresholds() throws {
         let initiator = SecureNoiseSession(
@@ -978,11 +844,7 @@ private final class SessionCallbackRecorder: @unchecked Sendable {
         return establishedEntries.map(\.0)
     }
 
-    func recordEstablished(
+    func recordEstablished(peerID: PeerID, remoteKey: Curve25519.KeyAgreement.PublicKey) {
-        peerID: PeerID,
-        remoteKey: Curve25519.KeyAgreement.PublicKey,
-        sessionGeneration _: UUID
-    ) {
         lock.lock()
         establishedEntries.append((peerID, remoteKey.rawRepresentation))
         lock.unlock()
@@ -1004,62 +866,3 @@ private final class FailingNoiseSession: NoiseSession {
         throw Error.synthetic
     }
 }
-
-private final class BlockingDecryptNoiseSession: NoiseSession, @unchecked Sendable {
-    private let controlLock = NSLock()
-    private var shouldPauseNextDecrypt = false
-    private let decryptStarted = DispatchSemaphore(value: 0)
-    private let resumeDecryptSemaphore = DispatchSemaphore(value: 0)
-
-    func pauseNextDecrypt() {
-        controlLock.lock()
-        shouldPauseNextDecrypt = true
-        controlLock.unlock()
-    }
-
-    func waitForDecryptStart(timeout: TimeInterval) -> Bool {
-        decryptStarted.wait(timeout: .now() + timeout) == .success
-    }
-
-    func resumeDecrypt() {
-        resumeDecryptSemaphore.signal()
-    }
-
-    override func decrypt(_ ciphertext: Data) throws -> Data {
-        controlLock.lock()
-        let shouldPause = shouldPauseNextDecrypt
-        shouldPauseNextDecrypt = false
-        controlLock.unlock()
-
-        if shouldPause {
-            decryptStarted.signal()
-            resumeDecryptSemaphore.wait()
-        }
-        return try super.decrypt(ciphertext)
-    }
-}
-
-private final class ConcurrentTestResult<Value>: @unchecked Sendable {
-    private let lock = NSLock()
-    private let completed = DispatchGroup()
-    private var storedResult: Result<Value, Error>?
-
-    init() {
-        completed.enter()
-    }
-
-    func capture(_ operation: () throws -> Value) {
-        let result = Result(catching: operation)
-        lock.lock()
-        storedResult = result
-        lock.unlock()
-        completed.leave()
-    }
-
-    func wait(timeout: TimeInterval) -> Result<Value, Error>? {
-        guard completed.wait(timeout: .now() + timeout) == .success else { return nil }
-        lock.lock()
-        defer { lock.unlock() }
-        return storedResult
-    }
-}

bitchatTests/Noise/NoiseProtocolTests.swift

@@ -357,18 +357,8 @@ struct NoiseProtocolTests {
     
     @Test func peerRestartDetection() throws {
         // Establish initial sessions
-        // This test explicitly drives the three synchronous XX messages and
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
-        // does not exercise the transport's delayed collision recovery.
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
-        let aliceManager = NoiseSessionManager(
-            localStaticKey: aliceKey,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
-        let bobManager = NoiseSessionManager(
-            localStaticKey: bobKey,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
         
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
@@ -387,24 +377,15 @@ struct NoiseProtocolTests {
         let newHandshake1 = try bobManagerRestarted.initiateHandshake(with: bobPeerID)
         
         // Alice should accept the new handshake (clearing old session)
-        let newHandshake2 = try #require(
+        let newHandshake2 = try aliceManager.handleIncomingHandshake(
-            try aliceManager.handleIncomingHandshake(
+            from: alicePeerID, message: newHandshake1)
-                from: alicePeerID,
+        #expect(newHandshake2 != nil)
-                message: newHandshake1
-            )
-        )
         
         // Complete the new handshake
-        let newHandshake3 = try #require(
+        let newHandshake3 = try bobManagerRestarted.handleIncomingHandshake(
-            try bobManagerRestarted.handleIncomingHandshake(
+            from: bobPeerID, message: newHandshake2!)
-                from: bobPeerID,
+        #expect(newHandshake3 != nil)
-                message: newHandshake2
+        _ = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: newHandshake3!)
-            )
-        )
-        _ = try aliceManager.handleIncomingHandshake(
-            from: alicePeerID,
-            message: newHandshake3
-        )
         
         // Should be able to exchange messages with new sessions
         let testMessage = Data("After restart".utf8)
@@ -562,18 +543,8 @@ struct NoiseProtocolTests {
     
     @Test func nonceDesynchronizationCausesRehandshake() throws {
         // Test that nonce desynchronization leads to proper re-handshake
-        // This test explicitly drives the three synchronous XX messages and
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
-        // does not exercise the transport's delayed collision recovery.
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
-        let aliceManager = NoiseSessionManager(
-            localStaticKey: aliceKey,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
-        let bobManager = NoiseSessionManager(
-            localStaticKey: bobKey,
-            keychain: mockKeychain,
-            recentInitiatorCompletionGracePeriod: 0
-        )
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -601,25 +572,15 @@ struct NoiseProtocolTests {
         let rehandshake1 = try bobManager.initiateHandshake(with: bobPeerID)
         
         // Alice should accept despite having a "valid" (but desynced) session
-        let rehandshake2 = try #require(
+        let rehandshake2 = try aliceManager.handleIncomingHandshake(
-            try aliceManager.handleIncomingHandshake(
+            from: alicePeerID, message: rehandshake1)
-                from: alicePeerID,
+        #expect(rehandshake2 != nil, "Alice should accept handshake to fix desync")
-                message: rehandshake1
-            ),
-            "Alice should accept handshake to fix desync"
-        )
         
         // Complete handshake
-        let rehandshake3 = try #require(
+        let rehandshake3 = try bobManager.handleIncomingHandshake(
-            try bobManager.handleIncomingHandshake(
+            from: bobPeerID, message: rehandshake2!)
-                from: bobPeerID,
+        #expect(rehandshake3 != nil)
-                message: rehandshake2
+        _ = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: rehandshake3!)
-            )
-        )
-        _ = try aliceManager.handleIncomingHandshake(
-            from: alicePeerID,
-            message: rehandshake3
-        )
         
         // Verify communication works again
         let testResynced = Data("Resynced".utf8)

bitchatTests/NostrProtocolTests.swift

@@ -290,65 +290,7 @@ struct NostrProtocolTests {
         #expect(object["limit"] as? Int == 42)
     }
 
-
-    @Test func inboundNostrEventRejectsTooManyTags() throws {
-        var eventDict = Self.validInboundEventDict()
-        eventDict["tags"] = Array(
-            repeating: ["g", "u4pruyd"],
-            count: TransportConfig.nostrMaxEventTags + 1
-        )
-
-        #expect(throws: NostrError.invalidEvent) {
-            _ = try NostrEvent(from: eventDict)
-        }
-    }
-
-    @Test func inboundNostrEventRejectsTooManyTagValues() throws {
-        var eventDict = Self.validInboundEventDict()
-        eventDict["tags"] = [Array(
-            repeating: "value",
-            count: TransportConfig.nostrMaxEventTagValues + 1
-        )]
-
-        #expect(throws: NostrError.invalidEvent) {
-            _ = try NostrEvent(from: eventDict)
-        }
-    }
-
-    @Test func inboundNostrEventRejectsOversizedTagValues() throws {
-        var eventDict = Self.validInboundEventDict()
-        eventDict["tags"] = [[
-            "g",
-            String(repeating: "a", count: TransportConfig.nostrMaxEventTagValueBytes + 1)
-        ]]
-
-        #expect(throws: NostrError.invalidEvent) {
-            _ = try NostrEvent(from: eventDict)
-        }
-    }
-
-    @Test func inboundNostrEventAcceptsTagsWithinLimits() throws {
-        var eventDict = Self.validInboundEventDict()
-        eventDict["tags"] = [["g", "u4pruyd"], ["t", "teleport"]]
-
-        let event = try NostrEvent(from: eventDict)
-
-        #expect(event.tags.count == 2)
-    }
-
     // MARK: - Helpers
-    private static func validInboundEventDict() -> [String: Any] {
-        [
-            "id": String(repeating: "0", count: 64),
-            "pubkey": String(repeating: "1", count: 64),
-            "created_at": 1_234_567,
-            "kind": NostrProtocol.EventKind.ephemeralEvent.rawValue,
-            "tags": [["g", "u4pruyd"]],
-            "content": "hello",
-            "sig": String(repeating: "2", count: 128)
-        ]
-    }
-
     private static func base64URLDecode(_ s: String) -> Data? {
         var str = s.replacingOccurrences(of: "-", with: "+").replacingOccurrences(of: "_", with: "/")
         let rem = str.count % 4

bitchatTests/PreviewKeychainManagerTests.swift

@@ -1,31 +1,10 @@
 import Foundation
 import Testing
-import BitFoundation
 @testable import bitchat
 
 @Suite("PreviewKeychainManager Tests")
 struct PreviewKeychainManagerTests {
 
-    @Test("Install lifecycle distinguishes upgrade, reinstall, bootstrap, and unreadable keychain")
-    func installLifecycleDecision() {
-        #expect(KeychainManager.installLifecycleAction(
-            containerKnowsMarker: true,
-            markerRead: .success(Data([1]))
-        ) == .markerPresent)
-        #expect(KeychainManager.installLifecycleAction(
-            containerKnowsMarker: false,
-            markerRead: .success(Data([1]))
-        ) == .clearStaleKeys)
-        #expect(KeychainManager.installLifecycleAction(
-            containerKnowsMarker: false,
-            markerRead: .itemNotFound
-        ) == .bootstrapMarker)
-        #expect(KeychainManager.installLifecycleAction(
-            containerKnowsMarker: false,
-            markerRead: .deviceLocked
-        ) == .retryLater)
-    }
-
     @Test("Preview keychain manager stores identity and service-scoped data in memory")
     func previewKeychainManagerRoundTripsData() {
         let manager = PreviewKeychainManager()

bitchatTests/Protocols/PacketsTests.swift

@@ -145,39 +145,6 @@ struct PacketsTests {
         #expect(decoded.capabilities?.rawValue == 0x0180)
     }
 
-    @Test
-    func authenticatedPeerStateUsesVersionedCanonicalTLVs() throws {
-        let signingKey = Data(repeating: 0xA5, count: 32)
-        let packet = AuthenticatedPeerStatePacket(
-            capabilities: [.privateMedia, .vouch],
-            signingPublicKey: signingKey
-        )
-
-        var encoded = try #require(packet.encode())
-        #expect(encoded.prefix(5) == Data([0x01, 0x01, 0x02, 0x20, 0x01]))
-        // Unknown TLVs are forward-compatible and do not alter v1 state.
-        encoded.append(makeTLV(type: 0x7F, value: Data([0xCA, 0xFE])))
-
-        #expect(AuthenticatedPeerStatePacket.decode(from: encoded) == packet)
-    }
-
-    @Test
-    func authenticatedPeerStateRejectsMalformedAmbiguousOrUnknownVersion() {
-        let key = Data(repeating: 0x44, count: 32)
-        let capabilities = makeTLV(type: 0x01, value: Data([0x00, 0x01]))
-        let signing = makeTLV(type: 0x02, value: key)
-
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x02]) + capabilities + signing) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + signing) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + capabilities + capabilities + signing) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01, 0x01, 0x00]) + signing) == nil)
-        // 0x0001 is non-minimal little endian; the canonical form is [0x01].
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + makeTLV(type: 0x01, value: Data([0x01, 0x00])) + signing) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + capabilities + makeTLV(type: 0x02, value: Data(key.dropLast()))) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + capabilities + Data(signing.dropLast())) == nil)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data([0x01]) + makeTLV(type: 0x01, value: Data(repeating: 0x01, count: 9)) + signing) == nil)
-    }
-
     @Test
     func privateMessagePacketRejectsUnknownTypeAndTruncation() {
         let unknownTLV = Data([0x7F, 0x01, 0x41])

bitchatTests/Services/BLEAnnounceHandlerTests.swift

@@ -6,7 +6,6 @@ import Testing
 struct BLEAnnounceHandlerTests {
     private final class Recorder {
         var existingNoisePublicKey: Data?
-        var authenticatedSigningPublicKey: Data?
         var signatureValid = true
         var linkState: (hasPeripheral: Bool, hasCentral: Bool) = (false, false)
         var linkBoundToOtherPeer = false
@@ -38,7 +37,6 @@ struct BLEAnnounceHandlerTests {
             messageTTL: TransportConfig.messageTTLDefault,
             now: { now },
             existingNoisePublicKey: { _ in recorder.existingNoisePublicKey },
-            authenticatedSigningPublicKey: { _ in recorder.authenticatedSigningPublicKey },
             verifySignature: { packet, signingPublicKey in
                 recorder.verifySignatureCalls.append((packet, signingPublicKey))
                 return recorder.signatureValid

bitchatTests/Services/BLEAnnounceHandlingPolicyTests.swift

@@ -169,23 +169,6 @@ struct BLEAnnounceHandlingPolicyTests {
         #expect(decision.isVerified)
     }
 
-    @Test
-    func trustPolicyRejectsSigningKeyReplacementAfterNoiseBinding() {
-        let noiseKey = Data(repeating: 0xCC, count: 32)
-        let boundSigningKey = Data(repeating: 0x11, count: 32)
-
-        let decision = BLEAnnounceTrustPolicy.evaluate(
-            hasSignature: true,
-            signatureValid: true,
-            existingNoisePublicKey: noiseKey,
-            announcedNoisePublicKey: noiseKey,
-            authenticatedSigningPublicKey: boundSigningKey,
-            announcedSigningPublicKey: Data(repeating: 0x22, count: 32)
-        )
-
-        #expect(decision == .reject(.authenticatedSigningKeyMismatch))
-    }
-
     @Test
     func responsePolicyConnectsOnlyForDirectNewOrReconnectedPeers() {
         let directNew = BLEAnnounceResponsePolicy.plan(

bitchatTests/Services/BLEFileTransferHandlerTests.swift

@@ -33,7 +33,6 @@ struct BLEFileTransferHandlerTests {
                 recorder.signatureVerifyCount += 1
                 return recorder.signatureVerifies
             },
-            localSigningPublicKey: { [sampleSigningKey] in sampleSigningKey },
             signedSenderDisplayName: { _, peerID in
                 recorder.signedNameQueries.append(peerID)
                 return recorder.signedName
@@ -93,11 +92,12 @@ struct BLEFileTransferHandlerTests {
     @Test
     func selfEchoIsDropped() throws {
         let recorder = Recorder()
-        recorder.signatureVerifies = true
         let handler = makeHandler(recorder: recorder)
         let packet = try makeFileTransferPacket(sender: localPeerID, mimeType: "application/pdf", content: Data("%PDF-1.7".utf8), ttl: 3)
 
-        #expect(!handler.handle(packet, from: localPeerID))
+        // The relay pipeline already suppresses self-originated packets, so the
+        // handler reports "relayable" rather than treating the echo as forged.
+        #expect(handler.handle(packet, from: localPeerID))
 
         expectNoSideEffects(recorder)
     }
@@ -120,12 +120,7 @@ struct BLEFileTransferHandlerTests {
         let recorder = Recorder()
         recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Bob", isVerified: false, isConnected: true)]
         let handler = makeHandler(recorder: recorder)
-        let packet = try makeFileTransferPacket(
+        let packet = try makeFileTransferPacket(sender: remotePeerID, mimeType: "application/pdf", content: Data("%PDF-1.7".utf8))
-            sender: remotePeerID,
-            mimeType: "application/pdf",
-            content: Data("%PDF-1.7".utf8),
-            hasSignature: false
-        )
 
         // Failed sender authentication must also stop the packet from being
         // relayed to downstream nodes.
@@ -134,7 +129,7 @@ struct BLEFileTransferHandlerTests {
         // Broadcast files carry an attacker-controllable senderID, so — like
         // public messages — a connected-but-unverified peer must present a valid
         // packet signature. No signing key + no signed identity means dropped.
-        #expect(recorder.signedNameQueries.isEmpty)
+        #expect(recorder.signedNameQueries == [remotePeerID])
         #expect(recorder.trackedPackets.isEmpty)
         #expect(recorder.deliveredMessages.isEmpty)
     }
@@ -158,11 +153,12 @@ struct BLEFileTransferHandlerTests {
     }
 
     @Test
-    func signedSelfBroadcastReplayIsDelivered() throws {
+    func selfBroadcastReplayIsDeliveredWithoutSignatureCheck() throws {
-        // Our own broadcast file replayed via gossip sync arrives with ttl==0;
+        // Our own broadcast file replayed via gossip sync arrives with ttl==0
-        // it is verified against our local signing key before delivery.
+        // (so it is not treated as a self-echo) and cannot be verified against
+        // the peer registry — it must still be accepted, matching
+        // BLEPublicMessageHandler's self exemption.
         let recorder = Recorder()
-        recorder.signatureVerifies = true
         let handler = makeHandler(recorder: recorder)
         let packet = try makeFileTransferPacket(
             sender: localPeerID,
@@ -173,7 +169,7 @@ struct BLEFileTransferHandlerTests {
 
         #expect(handler.handle(packet, from: localPeerID))
 
-        #expect(recorder.signatureVerifyCount == 1)
+        #expect(recorder.signatureVerifyCount == 0)
         #expect(recorder.signedNameQueries.isEmpty)
         #expect(recorder.deliveredMessages.count == 1)
         #expect(recorder.deliveredMessages.first?.sender == "Me")
@@ -209,8 +205,7 @@ struct BLEFileTransferHandlerTests {
             sender: remotePeerID,
             mimeType: "audio/mp4",
             content: m4a,
-            fileName: "voice_1122334455667788",
+            fileName: "voice_1122334455667788"
-            hasSignature: false
         )
 
         // The spoofed note must be dropped locally AND not relayed onward.
@@ -220,7 +215,7 @@ struct BLEFileTransferHandlerTests {
     }
 
     @Test
-    func rawDirectedFileWithoutVerifiableSignatureIsDroppedWithoutWriteOrRelay() throws {
+    func privateFileFromConnectedUnverifiedPeerIsAccepted() throws {
         let recorder = Recorder()
         recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Bob", isVerified: false, isConnected: true)]
         let handler = makeHandler(recorder: recorder)
@@ -228,25 +223,23 @@ struct BLEFileTransferHandlerTests {
             sender: remotePeerID,
             mimeType: "application/pdf",
             content: Data("%PDF-1.7".utf8),
-            recipientID: Data(hexString: localPeerID.id),
+            recipientID: Data(hexString: localPeerID.id)
-            hasSignature: false
         )
 
-        #expect(!handler.handle(packet, from: remotePeerID))
+        #expect(handler.handle(packet, from: remotePeerID))
 
+        // Directed transfers keep the lenient connected-peer path (no broadcast
+        // exposure); no signature check is required.
         #expect(recorder.signatureVerifyCount == 0)
         #expect(recorder.signedNameQueries.isEmpty)
-        #expect(recorder.trackedPackets.isEmpty)
+        #expect(recorder.deliveredMessages.count == 1)
-        #expect(recorder.quotaReservations.isEmpty)
+        #expect(recorder.deliveredMessages.first?.isPrivate == true)
-        #expect(recorder.saveCalls.isEmpty)
-        #expect(recorder.deliveredMessages.isEmpty)
     }
 
     @Test
     func fileDirectedToAnotherPeerIsIgnored() throws {
         let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true, signingPublicKey: sampleSigningKey)]
+        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
-        recorder.signatureVerifies = true
         let handler = makeHandler(recorder: recorder)
         let packet = try makeFileTransferPacket(
             sender: remotePeerID,
@@ -267,8 +260,7 @@ struct BLEFileTransferHandlerTests {
     @Test
     func privateFileUpdatesLastSeenAndDeliversPrivateMessage() throws {
         let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true, signingPublicKey: sampleSigningKey)]
+        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
-        recorder.signatureVerifies = true
         let handler = makeHandler(recorder: recorder)
         let packet = try makeFileTransferPacket(
             sender: remotePeerID,
@@ -290,56 +282,6 @@ struct BLEFileTransferHandlerTests {
         #expect(recorder.deliveredMessages.first?.deliveryStatus == .delivered(to: "Me", at: Date(timeIntervalSince1970: 900)))
     }
 
-    @Test
-    func decryptedPrivateFileUsesValidationQuotaAndPrivateDeliveryWithoutRawSignature() throws {
-        let recorder = Recorder()
-        recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
-        let handler = makeHandler(recorder: recorder)
-        let content = Data([0xFF, 0xD8, 0xFF]) + Data(repeating: 0x41, count: 128)
-        let file = BitchatFilePacket(
-            fileName: "secret.jpg",
-            fileSize: UInt64(content.count),
-            mimeType: "image/jpeg",
-            content: content
-        )
-        let payload = try #require(file.encode())
-        let timestamp = Date(timeIntervalSince1970: 1_234)
-
-        #expect(handler.handlePrivatePayload(payload, from: remotePeerID, timestamp: timestamp))
-
-        #expect(recorder.signatureVerifyCount == 0)
-        #expect(recorder.signedNameQueries.isEmpty)
-        #expect(recorder.trackedPackets.isEmpty)
-        #expect(recorder.quotaReservations == [content.count])
-        #expect(recorder.saveCalls.first?.data == content)
-        #expect(recorder.lastSeenUpdates == [remotePeerID])
-        #expect(recorder.deliveredMessages.count == 1)
-        #expect(recorder.deliveredMessages.first?.isPrivate == true)
-        #expect(recorder.deliveredMessages.first?.timestamp == timestamp)
-    }
-
-    @Test
-    func decryptedPrivateFileOverPayloadCapIsRejectedBeforeQuotaOrDiskWrite() {
-        let recorder = Recorder()
-        let handler = makeHandler(recorder: recorder)
-        let oversizedCount = FileTransferLimits.maxPayloadBytes + 1
-        var length = UInt32(oversizedCount).bigEndian
-        var payload = Data([0x04]) // BitchatFilePacket CONTENT TLV
-        withUnsafeBytes(of: &length) { payload.append(contentsOf: $0) }
-        payload.append(Data(repeating: 0x41, count: oversizedCount))
-
-        #expect(!handler.handlePrivatePayload(
-            payload,
-            from: remotePeerID,
-            timestamp: Date(timeIntervalSince1970: 1_234)
-        ))
-
-        #expect(recorder.quotaReservations.isEmpty)
-        #expect(recorder.saveCalls.isEmpty)
-        #expect(recorder.lastSeenUpdates.isEmpty)
-        #expect(recorder.deliveredMessages.isEmpty)
-    }
-
     @Test
     func malformedPayloadIsTrackedForSyncButDropped() {
         let recorder = Recorder()
@@ -352,7 +294,7 @@ struct BLEFileTransferHandlerTests {
             recipientID: nil,
             timestamp: 900_000,
             payload: Data([0x01, 0x02, 0x03]),
-            signature: Data(repeating: 0x5A, count: 64),
+            signature: nil,
             ttl: TransportConfig.messageTTLDefault
         )
 
@@ -428,132 +370,6 @@ struct BLEFileTransferHandlerTests {
         #expect(!FileManager.default.fileExists(atPath: evictable.path))
     }
 
-    @Test
-    func panicWipeDeletesEveryManagedMediaFileAndRecreatesEmptyDirectories() throws {
-        let base = FileManager.default.temporaryDirectory
-            .appendingPathComponent("panic-media-wipe-\(UUID().uuidString)", isDirectory: true)
-        defer { try? FileManager.default.removeItem(at: base) }
-        let store = BLEIncomingFileStore(baseDirectory: base)
-        let subdirectories = [
-            "voicenotes/incoming",
-            "voicenotes/outgoing",
-            "images/incoming",
-            "images/outgoing",
-            "files/incoming",
-            "files/outgoing"
-        ]
-
-        for subdirectory in subdirectories {
-            let directory = base
-                .appendingPathComponent("files", isDirectory: true)
-                .appendingPathComponent(subdirectory, isDirectory: true)
-            try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
-            try Data("secret".utf8).write(to: directory.appendingPathComponent("artifact.bin"))
-        }
-        let unmanaged = base.appendingPathComponent("files/legacy/secret.bin")
-        try FileManager.default.createDirectory(at: unmanaged.deletingLastPathComponent(), withIntermediateDirectories: true)
-        try Data("legacy".utf8).write(to: unmanaged)
-
-        try store.panicWipe()
-
-        #expect(!FileManager.default.fileExists(atPath: unmanaged.path))
-        for subdirectory in subdirectories {
-            let directory = base
-                .appendingPathComponent("files", isDirectory: true)
-                .appendingPathComponent(subdirectory, isDirectory: true)
-            var isDirectory: ObjCBool = false
-            #expect(FileManager.default.fileExists(atPath: directory.path, isDirectory: &isDirectory))
-            #expect(isDirectory.boolValue)
-            #expect(try FileManager.default.contentsOfDirectory(atPath: directory.path).isEmpty)
-        }
-    }
-
-    @Test
-    func panicWipeAttemptsDeletionWhenMarkerPersistenceFails() throws {
-        enum MarkerFailure: Error { case unavailable }
-
-        let base = FileManager.default.temporaryDirectory
-            .appendingPathComponent(
-                "panic-marker-failure-\(UUID().uuidString)",
-                isDirectory: true
-            )
-        defer { try? FileManager.default.removeItem(at: base) }
-        let secret = base
-            .appendingPathComponent("files/images/outgoing", isDirectory: true)
-            .appendingPathComponent("secret.jpg")
-        try FileManager.default.createDirectory(
-            at: secret.deletingLastPathComponent(),
-            withIntermediateDirectories: true
-        )
-        try Data("secret".utf8).write(to: secret)
-        let store = BLEIncomingFileStore(
-            baseDirectory: base,
-            panicMarkerWriter: { _, _ in throw MarkerFailure.unavailable }
-        )
-
-        do {
-            try store.panicWipe(hasDurablePendingMarker: false)
-            Issue.record("Expected the missing durable marker to fail closed")
-        } catch {
-            // The marker error is reported only after the deletion attempt.
-        }
-
-        #expect(!FileManager.default.fileExists(atPath: secret.path))
-        #expect(
-            FileManager.default.fileExists(
-                atPath: secret.deletingLastPathComponent().path
-            )
-        )
-    }
-
-    @Test
-    func externalMarkerAllowsDeletionToCommitWhenFileMarkerFails() throws {
-        enum MarkerFailure: Error { case unavailable }
-
-        let base = FileManager.default.temporaryDirectory
-            .appendingPathComponent(
-                "panic-external-marker-\(UUID().uuidString)",
-                isDirectory: true
-            )
-        defer { try? FileManager.default.removeItem(at: base) }
-        let secret = base
-            .appendingPathComponent("files/voicenotes/incoming", isDirectory: true)
-            .appendingPathComponent("secret.m4a")
-        try FileManager.default.createDirectory(
-            at: secret.deletingLastPathComponent(),
-            withIntermediateDirectories: true
-        )
-        try Data("secret".utf8).write(to: secret)
-        let store = BLEIncomingFileStore(
-            baseDirectory: base,
-            panicMarkerWriter: { _, _ in throw MarkerFailure.unavailable }
-        )
-
-        try store.panicWipe(hasDurablePendingMarker: true)
-
-        #expect(!FileManager.default.fileExists(atPath: secret.path))
-    }
-
-    @Test
-    func panicRecoveryMarkerPersistsUntilExplicitCommit() throws {
-        let base = FileManager.default.temporaryDirectory
-            .appendingPathComponent(
-                "panic-recovery-marker-\(UUID().uuidString)",
-                isDirectory: true
-            )
-        defer { try? FileManager.default.removeItem(at: base) }
-        let store = BLEIncomingFileStore(baseDirectory: base)
-
-        try store.markPanicRecoveryPending()
-        #expect(try store.isPanicRecoveryPending())
-        try store.panicWipe(hasDurablePendingMarker: true)
-        #expect(try store.isPanicRecoveryPending())
-
-        try store.completePanicRecovery()
-
-        #expect(try !store.isPanicRecoveryPending())
-    }
-
     private func expectNoSideEffects(_ recorder: Recorder) {
         #expect(recorder.signedNameQueries.isEmpty)
         #expect(recorder.trackedPackets.isEmpty)
@@ -587,8 +403,7 @@ struct BLEFileTransferHandlerTests {
         content: Data,
         ttl: UInt8 = TransportConfig.messageTTLDefault,
         recipientID: Data? = nil,
-        fileName: String = "sample",
+        fileName: String = "sample"
-        hasSignature: Bool = true
     ) throws -> BitchatPacket {
         let filePacket = BitchatFilePacket(
             fileName: fileName,
@@ -603,7 +418,7 @@ struct BLEFileTransferHandlerTests {
             recipientID: recipientID,
             timestamp: 900_000,
             payload: payload,
-            signature: hasSignature ? Data(repeating: 0x5A, count: 64) : nil,
+            signature: nil,
             ttl: ttl
         )
     }

bitchatTests/Services/BLEFragmentAssemblyBufferTests.swift

@@ -117,35 +117,6 @@ struct BLEFragmentAssemblyBufferTests {
         }
     }
 
-    @Test
-    func encryptedPrivateFileAssemblyGetsFramedFileHeadroom() throws {
-        var buffer = BLEFragmentAssemblyBuffer()
-        let fragmentID = Data(repeating: 0x15, count: 8)
-        let first = try #require(BLEFragmentHeader(packet: makeFragmentPacket(
-            fragmentID: fragmentID,
-            index: 0,
-            total: 2,
-            originalType: MessageType.noiseEncrypted.rawValue,
-            fragmentData: Data(repeating: 0x01, count: FileTransferLimits.maxPayloadBytes)
-        )))
-        let second = try #require(BLEFragmentHeader(packet: makeFragmentPacket(
-            fragmentID: fragmentID,
-            index: 1,
-            total: 2,
-            originalType: MessageType.noiseEncrypted.rawValue,
-            fragmentData: Data([0x02])
-        )))
-
-        _ = buffer.append(first, maxInFlightAssemblies: 8)
-        let result = buffer.append(second, maxInFlightAssemblies: 8)
-
-        if case let .complete(_, data, _) = result {
-            #expect(data.count == FileTransferLimits.maxPayloadBytes + 1)
-        } else {
-            Issue.record("Expected encrypted private-file assembly to use framed-file limit")
-        }
-    }
-
     @Test
     func removeExpiredDropsOldAssemblies() throws {
         var buffer = BLEFragmentAssemblyBuffer()

bitchatTests/Services/BLENoisePacketHandlerTests.swift

@@ -9,7 +9,6 @@ struct BLENoisePacketHandlerTests {
     private final class Recorder {
         var handshakeResult: Result<Data?, Error> = .success(nil)
         var hasSession = false
-        let sessionGeneration = UUID()
         var decryptResult: Result<Data, Error> = .success(Data())
 
         var processedHandshakes: [(peerID: PeerID, message: Data)] = []
@@ -19,7 +18,6 @@ struct BLENoisePacketHandlerTests {
         var lastSeenUpdates: [PeerID] = []
         var decryptCalls: [(payload: Data, peerID: PeerID)] = []
         var clearedSessions: [PeerID] = []
-        var authenticatedPeerStates: [(peerID: PeerID, payload: Data, generation: UUID)] = []
         var deliveries: [(peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date)] = []
         /// Ordered side-effect log to assert recovery sequencing.
         var events: [String] = []
@@ -58,18 +56,12 @@ struct BLENoisePacketHandlerTests {
             },
             decrypt: { payload, peerID in
                 recorder.decryptCalls.append((payload, peerID))
-                return BLENoiseDecryptionResult(
+                return try recorder.decryptResult.get()
-                    plaintext: try recorder.decryptResult.get(),
-                    sessionGeneration: recorder.sessionGeneration
-                )
             },
             clearSession: { peerID in
                 recorder.clearedSessions.append(peerID)
                 recorder.events.append("clearSession")
             },
-            handleAuthenticatedPeerState: { peerID, payload, generation in
-                recorder.authenticatedPeerStates.append((peerID, payload, generation))
-            },
             deliverNoisePayload: { peerID, type, payload, timestamp in
                 recorder.deliveries.append((peerID, type, payload, timestamp))
             }
@@ -160,39 +152,6 @@ struct BLENoisePacketHandlerTests {
         #expect(recorder.initiatedHandshakes.isEmpty)
     }
 
-    @Test
-    func peerIdentityMismatchDoesNotRecreateHandshakeState() {
-        let recorder = Recorder()
-        recorder.handshakeResult = .failure(NoiseSessionError.peerIdentityMismatch)
-        recorder.hasSession = false
-        let handler = makeHandler(recorder: recorder)
-        let packet = makeHandshakePacket(recipientID: Data(hexString: localPeerID.id))
-
-        #expect(!handler.handleHandshake(packet, from: remotePeerID))
-
-        #expect(recorder.hasSessionQueries.isEmpty)
-        #expect(recorder.initiatedHandshakes.isEmpty)
-        #expect(recorder.broadcastPackets.isEmpty)
-    }
-
-    @Test
-    func managedHandshakeFailureDoesNotStartASecondRecovery() {
-        let recorder = Recorder()
-        recorder.handshakeResult = .failure(
-            NoiseManagedHandshakeFailure(underlying: TestError())
-        )
-        recorder.hasSession = false
-        let handler = makeHandler(recorder: recorder)
-        let packet = makeHandshakePacket(
-            recipientID: Data(hexString: localPeerID.id)
-        )
-
-        #expect(!handler.handleHandshake(packet, from: remotePeerID))
-        #expect(recorder.hasSessionQueries.isEmpty)
-        #expect(recorder.initiatedHandshakes.isEmpty)
-        #expect(recorder.broadcastPackets.isEmpty)
-    }
-
     // MARK: Encrypted
 
     @Test
@@ -247,25 +206,6 @@ struct BLENoisePacketHandlerTests {
         #expect(recorder.initiatedHandshakes.isEmpty)
     }
 
-    @Test
-    func authenticatedPeerStateIsConsumedByTransportNotDeliveredToUI() {
-        let recorder = Recorder()
-        recorder.decryptResult = .success(Data([
-            NoisePayloadType.authenticatedPeerState.rawValue,
-            0x01, 0x02, 0x03
-        ]))
-        let handler = makeHandler(recorder: recorder)
-        let packet = makeEncryptedPacket(recipientID: Data(hexString: localPeerID.id))
-
-        handler.handleEncrypted(packet, from: remotePeerID)
-
-        #expect(recorder.authenticatedPeerStates.count == 1)
-        #expect(recorder.authenticatedPeerStates.first?.peerID == remotePeerID)
-        #expect(recorder.authenticatedPeerStates.first?.payload == Data([0x01, 0x02, 0x03]))
-        #expect(recorder.authenticatedPeerStates.first?.generation == recorder.sessionGeneration)
-        #expect(recorder.deliveries.isEmpty)
-    }
-
     @Test
     func emptyDecryptedPayloadIsIgnored() {
         let recorder = Recorder()

bitchatTests/Services/BLENoisePayloadFactoryTests.swift

@@ -1,6 +1,5 @@
 import Foundation
 import Testing
-import BitFoundation
 @testable import bitchat
 
 struct BLENoisePayloadFactoryTests {
@@ -32,63 +31,4 @@ struct BLENoisePayloadFactoryTests {
 
         #expect(payload == Data([NoisePayloadType.verifyChallenge.rawValue, 0xCA, 0xFE]))
     }
-
-    @Test
-    func privateFilePayloadPrefixesCanonicalFilePacket() throws {
-        let content = Data("%PDF-secret".utf8)
-        let file = BitchatFilePacket(
-            fileName: "secret.pdf",
-            fileSize: UInt64(content.count),
-            mimeType: "application/pdf",
-            content: content
-        )
-
-        let payload = try #require(BLENoisePayloadFactory.privateFile(file))
-
-        #expect(payload.first == 0x20, "Encrypted files must use Android's deployed wire value")
-        let decoded = try #require(BitchatFilePacket.decode(Data(payload.dropFirst())))
-        #expect(decoded.fileName == "secret.pdf")
-        #expect(decoded.mimeType == "application/pdf")
-        #expect(decoded.content == content)
-    }
-
-    @Test
-    func androidB7f0b33PrivateFilePlaintextFixtureIsByteCompatible() throws {
-        // Runtime-emitted by Android commit b7f0b33d from
-        // BitchatFilePacket("a.txt", 3, "text/plain", [01, 02, 03]) and
-        // NoisePayload(type = FILE_TRANSFER, data = file.encode()).encode().
-        let fixtureHex = "20010005612e7478740200040000000303000a746578742f706c61696e0400000003010203"
-        let fixture = try #require(Data(hexString: fixtureHex))
-
-        let typed = try #require(NoisePayload.decode(fixture))
-        #expect(typed.type == .privateFile)
-        let file = try #require(BitchatFilePacket.decode(typed.data))
-        #expect(file.fileName == "a.txt")
-        #expect(file.fileSize == 3)
-        #expect(file.mimeType == "text/plain")
-        #expect(file.content == Data([0x01, 0x02, 0x03]))
-        #expect(BLENoisePayloadFactory.privateFile(file) == fixture)
-    }
-
-    @Test
-    func prereleasePrivateFileTypeCanonicalizesOnDecode() throws {
-        let encoded = Data([NoisePayloadType.prereleasePrivateFileRawValue, 0xCA, 0xFE])
-        let decoded = try #require(NoisePayload.decode(encoded))
-
-        #expect(decoded.type == .privateFile)
-        #expect(decoded.data == Data([0xCA, 0xFE]))
-        #expect(decoded.encode().first == 0x20)
-    }
-
-    @Test
-    func authenticatedPeerStateUsesPermanent0x21Type() throws {
-        let state = AuthenticatedPeerStatePacket(
-            capabilities: .privateMedia,
-            signingPublicKey: Data(repeating: 0x77, count: 32)
-        )
-        let encoded = try #require(BLENoisePayloadFactory.authenticatedPeerState(state))
-
-        #expect(encoded.first == 0x21)
-        #expect(AuthenticatedPeerStatePacket.decode(from: Data(encoded.dropFirst())) == state)
-    }
 }

bitchatTests/Services/BLENoiseReconnectPolicyTests.swift

@@ -1,115 +0,0 @@
-import BitFoundation
-import Foundation
-import Testing
-@testable import bitchat
-
-@Suite("BLE Noise reconnect policy")
-struct BLENoiseReconnectPolicyTests {
-    @Test("Revalidation requires a cached session and no authenticated link")
-    func revalidationPreconditions() {
-        var policy = BLENoiseReconnectPolicy()
-        let link = BLEIngressLinkID.peripheral("peripheral-a")
-        let now = Date(timeIntervalSince1970: 1_000)
-
-        let withoutSession = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: false,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: now
-        )
-        #expect(!withoutSession)
-        let authenticated = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: true,
-            hasAuthenticatedPeerLink: true,
-            now: now
-        )
-        #expect(!authenticated)
-        let eligible = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: now
-        )
-        #expect(eligible)
-    }
-
-    @Test("Revalidation is once per link epoch or after sixty seconds")
-    func revalidationIsBoundPerLinkEpoch() {
-        var policy = BLENoiseReconnectPolicy()
-        let link = BLEIngressLinkID.central("central-a")
-        let start = Date(timeIntervalSince1970: 2_000)
-
-        let initial = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start
-        )
-        #expect(initial)
-        let duringCooldown = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start.addingTimeInterval(59.999)
-        )
-        #expect(!duringCooldown)
-        let afterCooldown = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start.addingTimeInterval(60)
-        )
-        #expect(afterCooldown)
-
-        policy.endLinkEpoch(link)
-        let nextEpoch = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start.addingTimeInterval(60.001)
-        )
-        #expect(nextEpoch)
-    }
-
-    @Test("An authenticated sibling suppresses redundant reconnect")
-    func authenticatedSiblingSuppressesReconnect() {
-        var policy = BLENoiseReconnectPolicy()
-        let link = BLEIngressLinkID.peripheral("unproven-sibling")
-        let start = Date(timeIntervalSince1970: 3_000)
-
-        let suppressed = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: true,
-            now: start
-        )
-        #expect(!suppressed)
-        let eligible = policy.shouldRevalidate(
-            on: link,
-            hasEstablishedSession: true,
-            isNoiseAuthenticatedLink: false,
-            hasAuthenticatedPeerLink: false,
-            now: start
-        )
-        #expect(eligible)
-    }
-
-    @Test("Reserved replacement bit is not advertised")
-    func reservedReplacementBitIsNotAdvertised() {
-        #expect(
-            !PeerCapabilities.localSupported.contains(
-                .nonDestructiveNoiseReplacement
-            )
-        )
-        #expect(PeerCapabilities.localSupported.contains(.privateMedia))
-    }
-}

bitchatTests/Services/BLENoiseSessionQueuesTests.swift

@@ -48,10 +48,7 @@ struct BLENoiseSessionQueuesTests {
         queues.appendTypedPayload(Data([0x01]), for: peerID)
         queues.appendTypedPayload(Data([0x02]), for: peerID)
 
-        #expect(queues.takeTypedPayloads(for: peerID) == [
+        #expect(queues.takeTypedPayloads(for: peerID) == [Data([0x01]), Data([0x02])])
-            BLEPendingTypedPayload(payload: Data([0x01]), transferId: nil),
-            BLEPendingTypedPayload(payload: Data([0x02]), transferId: nil)
-        ])
         #expect(queues.takeTypedPayloads(for: peerID).isEmpty)
         #expect(queues.takePrivateMessages(for: peerID).map(\.messageID) == ["m1"])
     }
@@ -67,21 +64,4 @@ struct BLENoiseSessionQueuesTests {
 
         #expect(queues.isEmpty)
     }
-
-    @Test
-    func transferIDSurvivesHandshakeQueueAndCanBeCancelledBeforeDrain() {
-        let peerID = PeerID(str: "aaaaaaaaaaaaaaaa")
-        var queues = BLENoiseSessionQueues()
-
-        queues.appendTypedPayload(Data([0x20, 0xAA]), transferId: "media-1", for: peerID)
-        queues.appendTypedPayload(Data([0x01, 0xBB]), for: peerID)
-
-        let removed = queues.removeTypedPayload(transferId: "media-1")
-        let removedAgain = queues.removeTypedPayload(transferId: "media-1")
-        #expect(removed)
-        #expect(!removedAgain)
-        #expect(queues.takeTypedPayloads(for: peerID) == [
-            BLEPendingTypedPayload(payload: Data([0x01, 0xBB]), transferId: nil)
-        ])
-    }
 }

bitchatTests/Services/BLEOutboundFragmentPlannerTests.swift

@@ -108,58 +108,6 @@ struct BLEOutboundFragmentPlannerTests {
         ) == nil)
     }
 
-    @Test("private media v1 accepts exactly 256 fragments and rejects 257")
-    func privateMediaCrossPlatformFragmentBoundary() throws {
-        let maxPayload = makePayload(count: 160 * 1024, seed: 0xFACE_CAFE)
-
-        func plan(payloadCount: Int) throws -> BLEOutboundFragmentPlan {
-            let packet = BitchatPacket(
-                type: MessageType.noiseEncrypted.rawValue,
-                senderID: Data(hexString: "0011223344556677") ?? Data(),
-                recipientID: Data(hexString: "8877665544332211"),
-                timestamp: 0x0102030405,
-                payload: Data(maxPayload.prefix(payloadCount)),
-                signature: nil,
-                ttl: 3,
-                version: 2
-            )
-            return try #require(BLEOutboundFragmentPlanner.makePlan(
-                for: BLEOutboundFragmentTransferRequest(
-                    packet: packet,
-                    pad: false,
-                    maxChunk: nil,
-                    directedPeer: PeerID(str: "8877665544332211"),
-                    transferId: "boundary"
-                ),
-                defaultChunkSize: TransportConfig.bleDefaultFragmentSize,
-                bleMaxMTU: 512,
-                fragmentID: Data(repeating: 0xD4, count: 8)
-            ))
-        }
-
-        func firstPlan(withAtLeast target: Int) throws -> BLEOutboundFragmentPlan {
-            var low = 1
-            var high = maxPayload.count
-            while low < high {
-                let mid = low + (high - low) / 2
-                if try plan(payloadCount: mid).totalFragments >= target {
-                    high = mid
-                } else {
-                    low = mid + 1
-                }
-            }
-            return try plan(payloadCount: low)
-        }
-
-        let at256 = try firstPlan(withAtLeast: 256)
-        let at257 = try firstPlan(withAtLeast: 257)
-
-        #expect(at256.totalFragments == 256)
-        #expect(BLEOutboundFragmentPlanner.isPrivateMediaV1Compatible(at256))
-        #expect(at257.totalFragments == 257)
-        #expect(!BLEOutboundFragmentPlanner.isPrivateMediaV1Compatible(at257))
-    }
-
     private func makePacket(
         payload: Data,
         route: [Data]? = nil,

bitchatTests/Services/BLEOutboundFragmentTransferSchedulerTests.swift

@@ -20,24 +20,6 @@ struct BLEOutboundFragmentTransferSchedulerTests {
         }
     }
 
-    @Test
-    func explicitTransferIDReservesEncryptedPrivateFileFragments() {
-        var scheduler = BLEOutboundFragmentTransferScheduler()
-        let request = makeRequest(
-            type: MessageType.noiseEncrypted.rawValue,
-            transferId: "private-media"
-        )
-
-        let result = scheduler.submit(request, maxConcurrentTransfers: 1)
-
-        if case let .start(_, reservedTransferId) = result {
-            #expect(reservedTransferId == "private-media")
-            #expect(scheduler.activeCount == 1)
-        } else {
-            Issue.record("Expected encrypted private media to reserve its progress slot")
-        }
-    }
-
     @Test
     func submitQueuesFileTransferWhenSlotsAreFull() {
         var scheduler = BLEOutboundFragmentTransferScheduler()

bitchatTests/Services/BLEPeerRegistryTests.swift

@@ -42,37 +42,6 @@ struct BLEPeerRegistryTests {
         #expect(registry.info(for: peerID)?.nickname == "alice-renamed")
     }
 
-    @Test("registry preserves absent versus explicit empty capabilities")
-    func capabilitiesPresenceIsPreserved() {
-        var registry = BLEPeerRegistry()
-        let oldPeer = PeerID(str: "1122334455667788")
-        let modernPeer = PeerID(str: "8877665544332211")
-
-        _ = registry.upsertVerifiedAnnounce(
-            peerID: oldPeer,
-            nickname: "old",
-            noisePublicKey: Data(repeating: 0x11, count: 32),
-            signingPublicKey: Data(repeating: 0x12, count: 32),
-            isConnected: true,
-            now: Date(),
-            capabilities: nil
-        )
-        _ = registry.upsertVerifiedAnnounce(
-            peerID: modernPeer,
-            nickname: "modern",
-            noisePublicKey: Data(repeating: 0x21, count: 32),
-            signingPublicKey: Data(repeating: 0x22, count: 32),
-            isConnected: true,
-            now: Date(),
-            capabilities: []
-        )
-
-        #expect(registry.capabilities(for: oldPeer).isEmpty)
-        #expect(!registry.capabilitiesWereExplicitlyAdvertised(for: oldPeer))
-        #expect(registry.capabilities(for: modernPeer).isEmpty)
-        #expect(registry.capabilitiesWereExplicitlyAdvertised(for: modernPeer))
-    }
-
     @Test("reachability keeps recent verified offline peers only when mesh is attached")
     func reachabilityRequiresMeshAttachmentForOfflinePeers() {
         let offlinePeer = PeerID(str: "1122334455667788")

bitchatTests/Services/GeohashPresenceServiceTests.swift

@@ -76,7 +76,6 @@ final class GeohashPresenceServiceTests: XCTestCase {
             burstMaxDelay: 0
         )
 
-        service.start()
         service.performHeartbeat()
 
         let sentAllAllowedChannels = await waitUntil { sentGeohashes.count == 3 }
@@ -84,7 +83,7 @@ final class GeohashPresenceServiceTests: XCTestCase {
         XCTAssertEqual(Set(sentGeohashes), Set(["9q", "9q8y", "9q8yy"]))
         XCTAssertEqual(Set(lookedUpGeohashes), Set(["9q", "9q8y", "9q8yy"]))
         XCTAssertEqual(sleptNanoseconds.count, 3)
-        XCTAssertEqual(scheduler.intervals, [17, 17])
+        XCTAssertEqual(scheduler.intervals, [17])
     }
 
     func test_performHeartbeat_skipsBroadcastWhenTorIsNotReady() async {
@@ -98,12 +97,11 @@ final class GeohashPresenceServiceTests: XCTestCase {
             loopMaxInterval: 21
         )
 
-        service.start()
         service.performHeartbeat()
         try? await Task.sleep(nanoseconds: 20_000_000)
 
         XCTAssertEqual(sendCount, 0)
-        XCTAssertEqual(scheduler.intervals, [21, 21])
+        XCTAssertEqual(scheduler.intervals, [21])
     }
 
     func test_performHeartbeat_skipsBroadcastWhenAppIsBackgrounded() async {
@@ -117,45 +115,11 @@ final class GeohashPresenceServiceTests: XCTestCase {
             loopMaxInterval: 22
         )
 
-        service.start()
         service.performHeartbeat()
         try? await Task.sleep(nanoseconds: 20_000_000)
 
         XCTAssertEqual(sendCount, 0)
-        XCTAssertEqual(scheduler.intervals, [22, 22])
+        XCTAssertEqual(scheduler.intervals, [22])
-    }
-
-    func test_stopForPanic_cancelsTimerAndSuppressesDelayedBroadcast() async throws {
-        let identity = try NostrIdentity.generate()
-        let scheduler = MockGeohashPresenceScheduler()
-        var sleeperContinuation: CheckedContinuation<Void, Never>?
-        var sendCount = 0
-        let service = makeService(
-            scheduler: scheduler,
-            deriveIdentity: { _ in identity },
-            relaySender: { _, _ in sendCount += 1 },
-            sleeper: { _ in
-                await withCheckedContinuation { continuation in
-                    sleeperContinuation = continuation
-                }
-            },
-            burstMinDelay: 1,
-            burstMaxDelay: 1
-        )
-
-        service.start()
-        service.performHeartbeat()
-        let delayStarted = await waitUntil {
-            sleeperContinuation != nil
-        }
-        XCTAssertTrue(delayStarted)
-
-        service.stopForPanic()
-        sleeperContinuation?.resume()
-        try? await Task.sleep(nanoseconds: 20_000_000)
-
-        XCTAssertEqual(sendCount, 0)
-        XCTAssertEqual(scheduler.timers.first?.invalidateCallCount, 1)
     }
 
     func test_broadcastPresence_skipsSendWhenNoRelaysAreAvailable() async throws {

bitchatTests/Services/NetworkActivationServiceTests.swift

@@ -91,53 +91,6 @@ final class NetworkActivationServiceTests: XCTestCase {
         XCTAssertGreaterThanOrEqual(context.relayController.connectCallCount, 1)
     }
 
-    func test_stopForPanic_synchronouslyStopsAndIgnoresPublisherUpdates() async {
-        let context = makeService(permission: .authorized, favorites: [])
-
-        context.service.start()
-        context.service.stopForPanic()
-        let connectCountAfterStop = context.relayController.connectCallCount
-        let startCountAfterStop = context.torController.startIfNeededCallCount
-
-        context.favoritesSubject.send([Data([0x01])])
-        context.reachability.set(false)
-        context.reachability.set(true)
-        try? await Task.sleep(nanoseconds: 30_000_000)
-
-        XCTAssertFalse(context.service.activationAllowed)
-        XCTAssertEqual(context.reachability.stopCallCount, 1)
-        XCTAssertEqual(context.torController.autoStartAllowedValues.last, false)
-        XCTAssertEqual(context.proxyController.proxyModes.last, false)
-        XCTAssertGreaterThanOrEqual(
-            context.torController.shutdownCompletelyCallCount,
-            1
-        )
-        XCTAssertGreaterThanOrEqual(
-            context.relayController.disconnectCallCount,
-            1
-        )
-        XCTAssertEqual(
-            context.relayController.connectCallCount,
-            connectCountAfterStop
-        )
-        XCTAssertEqual(
-            context.torController.startIfNeededCallCount,
-            startCountAfterStop
-        )
-    }
-
-    func test_start_afterPanicStop_reestablishesSubscriptions() {
-        let context = makeService(permission: .authorized, favorites: [])
-
-        context.service.start()
-        context.service.stopForPanic()
-        context.service.start()
-
-        XCTAssertTrue(context.service.activationAllowed)
-        XCTAssertEqual(context.reachability.startCallCount, 2)
-        XCTAssertEqual(context.relayController.connectCallCount, 2)
-    }
-
     private func makeService(
         permission: LocationChannelManager.PermissionState,
         favorites: Set<Data>
@@ -151,7 +104,6 @@ final class NetworkActivationServiceTests: XCTestCase {
         let torController = MockNetworkActivationTorController()
         let relayController = MockNetworkActivationRelayController()
         let proxyController = MockNetworkActivationProxyController()
-        let reachability = MockNetworkActivationReachability()
         let notificationCenter = NotificationCenter()
         let service = NetworkActivationService(
             storage: storage,
@@ -159,7 +111,7 @@ final class NetworkActivationServiceTests: XCTestCase {
             mutualFavoritesPublisher: favoritesSubject.eraseToAnyPublisher(),
             permissionProvider: { permissionSubject.value },
             mutualFavoritesProvider: { favoritesSubject.value },
-            reachabilityMonitor: reachability,
+            reachabilityMonitor: AlwaysReachableMonitor(),
             torController: torController,
             relayController: relayController,
             proxyController: proxyController,
@@ -169,7 +121,6 @@ final class NetworkActivationServiceTests: XCTestCase {
             service: service,
             storage: storage,
             favoritesSubject: favoritesSubject,
-            reachability: reachability,
             torController: torController,
             relayController: relayController,
             proxyController: proxyController,
@@ -197,38 +148,12 @@ private struct NetworkActivationTestContext {
     let service: NetworkActivationService
     let storage: UserDefaults
     let favoritesSubject: CurrentValueSubject<Set<Data>, Never>
-    let reachability: MockNetworkActivationReachability
     let torController: MockNetworkActivationTorController
     let relayController: MockNetworkActivationRelayController
     let proxyController: MockNetworkActivationProxyController
     let notificationCenter: NotificationCenter
 }
 
-@MainActor
-private final class MockNetworkActivationReachability:
-    NetworkReachabilityMonitoring {
-    private let subject = CurrentValueSubject<Bool, Never>(true)
-    private(set) var startCallCount = 0
-    private(set) var stopCallCount = 0
-
-    var isReachable: Bool { subject.value }
-    var reachabilityPublisher: AnyPublisher<Bool, Never> {
-        subject.removeDuplicates().dropFirst().eraseToAnyPublisher()
-    }
-
-    func start() {
-        startCallCount += 1
-    }
-
-    func stop() {
-        stopCallCount += 1
-    }
-
-    func set(_ reachable: Bool) {
-        subject.send(reachable)
-    }
-}
-
 @MainActor
 private final class MockNetworkActivationTorController: NetworkActivationTorControlling {
     private(set) var autoStartAllowedValues: [Bool] = []

bitchatTests/Services/NetworkReachabilityGateTests.swift

@@ -213,7 +213,6 @@ private final class ControllableReachabilityMonitor: NetworkReachabilityMonitori
         subject.removeDuplicates().dropFirst().eraseToAnyPublisher()
     }
     func start() { startCalled = true }
-    func stop() { startCalled = false }
     func set(_ reachable: Bool) { subject.send(reachable) }
 }
 

bitchatTests/Services/SecureIdentityStateManagerTests.swift

@@ -399,59 +399,6 @@ final class SecureIdentityStateManagerTests: XCTestCase {
         XCTAssertTrue(cleared)
     }
 
-    func test_privateMediaCapabilityPinPersistsMonotonicallyAndPanicClearRemovesIt() async {
-        let keychain = MockKeychain()
-        let fingerprint = Data(repeating: 0x42, count: 32).sha256Fingerprint()
-        let manager = SecureIdentityStateManager(keychain)
-
-        XCTAssertFalse(manager.hasObservedPrivateMediaCapability(fingerprint: fingerprint))
-        manager.markPrivateMediaCapable(fingerprint: fingerprint)
-        XCTAssertTrue(
-            manager.hasObservedPrivateMediaCapability(fingerprint: fingerprint),
-            "pin insertion must be synchronously visible to the next downgrade decision"
-        )
-
-        // Re-marking is idempotent, and the encrypted cache carries the pin
-        // across launches.
-        manager.markPrivateMediaCapable(fingerprint: fingerprint)
-        manager.forceSave()
-        let reloaded = SecureIdentityStateManager(keychain)
-        XCTAssertTrue(reloaded.hasObservedPrivateMediaCapability(fingerprint: fingerprint))
-
-        // ChatViewModel's panic path calls this same wipe after deleting
-        // keychain data; the in-memory pin must disappear immediately too.
-        reloaded.clearAllIdentityData()
-        let cleared = await waitUntil {
-            !reloaded.hasObservedPrivateMediaCapability(fingerprint: fingerprint)
-        }
-        XCTAssertTrue(cleared)
-    }
-
-    func test_noiseAuthenticatedSigningKeyBindingPersistsAndPanicClearRemovesIt() async {
-        let keychain = MockKeychain()
-        let fingerprint = Data(repeating: 0x31, count: 32).sha256Fingerprint()
-        let firstKey = Data(repeating: 0x41, count: 32)
-        let rotatedKey = Data(repeating: 0x42, count: 32)
-        let manager = SecureIdentityStateManager(keychain)
-
-        manager.bindAuthenticatedSigningPublicKey(firstKey, fingerprint: fingerprint)
-        XCTAssertEqual(manager.authenticatedSigningPublicKey(forFingerprint: fingerprint), firstKey)
-        // A later authenticated Noise session may legitimately rotate the
-        // announcement signing key.
-        manager.bindAuthenticatedSigningPublicKey(rotatedKey, fingerprint: fingerprint)
-        XCTAssertEqual(manager.authenticatedSigningPublicKey(forFingerprint: fingerprint), rotatedKey)
-
-        manager.forceSave()
-        let reloaded = SecureIdentityStateManager(keychain)
-        XCTAssertEqual(reloaded.authenticatedSigningPublicKey(forFingerprint: fingerprint), rotatedKey)
-
-        reloaded.clearAllIdentityData()
-        let cleared = await waitUntil {
-            reloaded.authenticatedSigningPublicKey(forFingerprint: fingerprint) == nil
-        }
-        XCTAssertTrue(cleared)
-    }
-
     func test_forceSave_withFailingCacheWriteDoesNotPersistCache() async {
         let keychain = FailingCacheSaveKeychain()
         let manager = SecureIdentityStateManager(keychain)

bitchatTests/Services/TransferProgressManagerTests.swift

@@ -49,7 +49,7 @@ struct TransferProgressManagerTests {
                 recorder.append("updated:\(id):\(sent):\(total)")
             case .completed(let id, let total):
                 recorder.append("completed:\(id):\(total)")
-            case .cancelled, .rejected:
+            case .cancelled:
                 break
             }
         }
@@ -85,7 +85,7 @@ struct TransferProgressManagerTests {
                 recorder.append("started:\(id):\(total)")
             case .cancelled(let id, let sent, let total):
                 recorder.append("cancelled:\(id):\(sent):\(total)")
-            case .updated, .completed, .rejected:
+            case .updated, .completed:
                 break
             }
         }
@@ -105,28 +105,6 @@ struct TransferProgressManagerTests {
         #expect(manager.snapshot(id: transferID) == nil)
         _ = cancellable
     }
-
-    @Test("Preflight policy rejection publishes a visible failure reason")
-    @MainActor
-    func rejectBeforeStartPublishesReason() async {
-        let manager = TransferProgressManager()
-        let transferID = "transfer-visible-reject"
-        let recorder = EventRecorder()
-        let cancellable = manager.publisher.sink { event in
-            if case .rejected(let id, let reason) = event {
-                recorder.append("rejected:\(id):\(reason)")
-            }
-        }
-
-        manager.rejectBeforeStart(id: transferID, reason: "upgrade required")
-
-        let didReceive = await TestHelpers.waitUntil({
-            recorder.values == ["rejected:\(transferID):upgrade required"]
-        }, timeout: 5.0)
-        #expect(didReceive)
-        #expect(manager.snapshot(id: transferID) == nil)
-        _ = cancellable
-    }
 }
 
 private final class EventRecorder: @unchecked Sendable {

bitchatTests/Services/UnifiedPeerServiceTests.swift

@@ -266,11 +266,6 @@ private final class TestIdentityManager: SecureIdentityStateManagerProtocol {
         verified.removeAll()
     }
 
-    func markPrivateMediaCapable(fingerprint: String) {}
-    func hasObservedPrivateMediaCapability(fingerprint: String) -> Bool { false }
-    func bindAuthenticatedSigningPublicKey(_ signingPublicKey: Data, fingerprint: String) {}
-    func authenticatedSigningPublicKey(forFingerprint fingerprint: String) -> Data? { nil }
-
     func removeEphemeralSession(peerID: PeerID) {}
 
     func setVerified(fingerprint: String, verified: Bool) {

bitchatTests/VoiceCaptureSessionTests.swift

@@ -61,7 +61,6 @@ private final class GatedVoiceCaptureSession: VoiceCaptureSession {
     private let startError: Error?
     private(set) var finishStarted = false
     private(set) var cancelCount = 0
-    private(set) var panicCancelCount = 0
     private var finishContinuation: CheckedContinuation<URL?, Never>?
 
     init(startError: Error? = nil) {
@@ -84,10 +83,6 @@ private final class GatedVoiceCaptureSession: VoiceCaptureSession {
         cancelCount += 1
     }
 
-    func panicCancelSynchronously() {
-        panicCancelCount += 1
-    }
-
     func resolveFinish(with url: URL?) {
         let continuation = finishContinuation
         finishContinuation = nil
@@ -209,57 +204,4 @@ struct VoiceCaptureSessionTests {
         }
         #expect(viewModel.state == .idle)
     }
-
-    @Test func panicSynchronouslyCancelsActiveCaptureAndResetsUI() async {
-        let session = GatedVoiceCaptureSession()
-        let viewModel = VoiceRecordingViewModel()
-        viewModel.sessionProvider = { session }
-
-        viewModel.start(shouldShow: true)
-        await waitUntil { self.isRecording(viewModel.state) }
-
-        viewModel.panicWipe()
-
-        #expect(session.panicCancelCount == 1)
-        #expect(viewModel.state == .idle)
-        #expect(!viewModel.isLiveStreaming)
-    }
-
-    @Test func panicInvalidatesARecordingAlreadyFinalizing() async throws {
-        let session = GatedVoiceCaptureSession()
-        let viewModel = VoiceRecordingViewModel()
-        viewModel.sessionProvider = { session }
-        let url = FileManager.default.temporaryDirectory
-            .appendingPathComponent("voice-panic-\(UUID().uuidString).m4a")
-        try Data([0x01]).write(to: url)
-        var delivered = false
-
-        viewModel.start(shouldShow: true)
-        await waitUntil { self.isRecording(viewModel.state) }
-        viewModel.finish { _ in delivered = true }
-        await waitUntil { session.finishStarted }
-
-        viewModel.panicWipe()
-        session.resolveFinish(with: url)
-        await waitUntil {
-            !FileManager.default.fileExists(atPath: url.path)
-        }
-
-        #expect(!delivered)
-        #expect(viewModel.state == .idle)
-    }
-
-    @Test func liveSessionPanicStopsCaptureWithoutSendingControl() {
-        let capture = StubPTTCapture(stopResult: (nil, 0))
-        var sentPackets: [Data] = []
-        let session = PTTLiveVoiceSession(
-            sendPacket: { sentPackets.append($0) },
-            capture: capture
-        )
-
-        session.panicCancelSynchronously()
-
-        #expect(capture.cancelCount == 1)
-        #expect(sentPackets.isEmpty)
-    }
 }

bitchatTests/VoiceRecorderTests.swift

@@ -360,35 +360,6 @@ struct VoiceRecorderTests {
         #expect(FileManager.default.fileExists(atPath: secondURL.path))
     }
 
-    @Test func classicSessionPanicStopsRecorderAndDeletesFileBeforeReturning() async throws {
-        let directory = try makeTemporaryDirectory()
-        defer { try? FileManager.default.removeItem(at: directory) }
-
-        let rawSession = VoiceRecorderTestSession()
-        let coordinator = AudioSessionCoordinator(session: rawSession)
-        let factory = TestVoiceAudioRecorderFactory(plans: [.success])
-        let voiceRecorder = VoiceRecorder(
-            sessionCoordinator: coordinator,
-            recorderFactory: factory,
-            permissionGranted: { true },
-            paddingInterval: 0,
-            outputDirectory: directory
-        )
-        let capture = VoiceNoteCaptureSession(recorder: voiceRecorder)
-
-        try await capture.start()
-        let url = try #require(factory.urls.first)
-        let recorder = try #require(factory.recorders.first)
-
-        capture.panicCancelSynchronously()
-
-        #expect(recorder.stopCallCount == 1)
-        #expect(!recorder.isRecording)
-        #expect(!FileManager.default.fileExists(atPath: url.path))
-        await coordinator.drain()
-        #expect(rawSession.activationCalls == [true, false])
-    }
-
     private func verifyFailedStart(
         firstPlan: TestVoiceAudioRecorderFactory.Plan,
         expectedPrepareCalls: Int,

docs/PRIVATE-MEDIA-MIGRATION.md

@@ -1,107 +0,0 @@
-# Private-media wire migration
-
-Private files use the `BitchatFilePacket` TLV shared by iOS and Android. The
-preferred direct-message wire form encrypts that complete TLV inside the
-peer's Noise session before BLE fragmentation.
-
-## Wire values and capability
-
-- `NoisePayloadType.privateFile` is `0x20`, the value already deployed by the
-  Android client. New sends must use this value.
-- iOS temporarily accepts `0x09`, which appeared in prerelease builds of the
-  private-media change. Decoders canonicalize it to `privateFile`; they never
-  emit it.
-- `NoisePayloadType.authenticatedPeerState` is permanently assigned `0x21`.
-  It is emitted after every completed/rekeyed Noise XX session and echoed at
-  most once when the remote state arrives, so message-3/proof reordering over
-  different mesh links converges. This type is part of the protocol security
-  boundary and is not removed when the media migration ends.
-- The `0x21` payload starts with version `0x01`, followed by one-byte
-  type/length/value fields. Version 1 requires canonical TLV `0x01` (the
-  minimal little-endian `PeerCapabilities` bitfield, 1-8 bytes) and TLV `0x02`
-  (the 32-byte Ed25519 announcement signing key). Duplicate required fields,
-  non-minimal capabilities, malformed lengths, missing fields, and unknown
-  versions are ignored without changing state. Unknown TLVs are skipped.
-- The public `PeerCapabilities.privateMedia` announce bit is a discovery hint:
-  it starts a Noise handshake, but never selects encrypted sending or creates
-  a pin. A private transfer waits boundedly for the exact session's encrypted
-  `0x21`. A valid bit-8 proof selects Noise `0x20`; a valid no-bit proof or a
-  no-proof timeout reaches the explicit legacy-consent path for an unpinned
-  peer. No timeout automatically sends raw bytes.
-- An unpinned peer with a stable Noise key but without that capability is
-  eligible for one signed, directed
-  `fileTransfer`, matching the pre-migration wire form used by older iOS and
-  accepted by current Android clients, only after the sender confirms a
-  per-send warning that the file is not end-to-end encrypted and mesh relays
-  can see it. The
-  consent is consumed by that invocation and is never remembered.
-- A signed announce never creates a pin by itself: an attacker can copy a
-  victim's public Noise key, supply its own Ed25519 key and capability bits,
-  and self-sign an internally consistent announce. Only successfully
-  decrypted `0x21` state pins the authenticated Noise fingerprint and binds
-  the Ed25519 key used by later announces/public messages. A later valid
-  no-bit `0x21` is treated as a downgrade, and raw fallback is blocked even if
-  a caller presents legacy consent. Public no-bit announces cannot overwrite
-  current session-authenticated state.
-- During migration, both an absent capabilities TLV and an explicit TLV
-  without `privateMedia` are legacy-eligible when that stable fingerprint is
-  not pinned. This supports clients that added capability advertisement before
-  encrypted media. Neither shape bypasses a previously authenticated pin.
-
-Older clients decrypt and ignore unknown inner type `0x21`; they do not need to
-understand it to continue using text or the warned legacy media path. They are
-never inferred capable merely because the handshake succeeded.
-
-Removal gates are independent and must not share an arbitrary calendar date:
-
-- Remove the `0x09` receive alias only after every TestFlight/internal build
-  that emitted it has expired and minimum-supported-client policy excludes it.
-- Remove the signed directed raw `0x22` fallback only after minimum-supported
-  iOS and Android clients emit authenticated bit-8 `0x21` state and the legacy
-  population has aged out.
-- Nostr kind `1059` compatibility is a separate envelope migration. Its dual
-  publish/removal gate is not evidence that either BLE compatibility shape can
-  be removed.
-
-## Security boundary
-
-The encrypted form provides Noise confidentiality and peer authentication.
-The fallback is signed and its signature is required on receive, so relays
-cannot forge its sender or contents. It is not confidential: relays can see
-the raw file TLV. The UI says this explicitly and asks on every send. A peer
-without a stable Noise key from a verified registry entry cannot use the
-fallback. Keep it only for the mixed-version migration, and remove it only
-after minimum-supported Android and iOS releases emit authenticated bit-8
-`0x21` state and the legacy population has aged out. Never replace it with an
-unsigned fallback, persist blanket consent, or send both forms.
-
-Incoming clients accept all three migration-era shapes:
-
-| Sender | Inbound form | Result |
-| --- | --- | --- |
-| Current Android | Noise `0x20` | Decrypt and deliver |
-| Prerelease iOS | Noise `0x09` | Decrypt, canonicalize, and deliver |
-| Older client | Signed directed `fileTransfer` | Verify signature and deliver |
-| Forged/unsigned raw sender | Directed `fileTransfer` | Reject |
-
-Panic wipe clears the persistent capability pins together with the rest of
-the encrypted identity cache.
-
-This migration path is mesh-Noise-only (BLE and compatible direct mesh links).
-Nostr private-media transport is unchanged and remains a follow-up. Nostr
-inbound paths explicitly ignore `0x21`; do not infer the mesh consent fallback
-or capability-pin semantics for Nostr delivery.
-
-## Size interoperability
-
-iOS bounds inbound file content at 1 MiB and applies the expanded allocation
-budget only after a large Noise ciphertext authenticates to `0x20` or the
-temporary `0x09` alias. Ordinary Noise messages retain their 64 KiB limit.
-
-Current Android builds cap each reassembly at 256 fragments. Depending on the
-negotiated BLE packet size and routing overhead, that is roughly 110-120 KiB,
-well below iOS's absolute inbound ceiling. Private-media v1 therefore runs the
-actual route-aware BLE fragment planner before both encrypted and consented
-legacy sends and rejects any plan above 256 fragments with a visible failure.
-This fragment-count contract, rather than a guessed byte threshold, stays
-correct as route overhead changes.