Extract Noise into a dedicated module

* Run local packages’ tests as well on CI

* BitFoundation module to centralize shared components

.gitattributes

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

.github/workflows/fetch_georelays.yml

@@ -0,0 +1,42 @@
+name: Fetch GeoRelays Data
+
+on:
+  schedule:
+    - cron: '0 6 * * 0'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  update-relay-data:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
+
+      - name: Fetch GeoRelays
+        run: |
+          wget -q https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv
+          mv nostr_relays.csv ./relays/online_relays_gps.csv
+
+      - name: Check for changes
+        id: git-check
+        run: |
+          git diff --exit-code || echo "changes=true" >> $GITHUB_OUTPUT
+    
+      - name: Commit and push changes
+        if: steps.git-check.outputs.changes == 'true'
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git add relays/online_relays_gps.csv
+          git commit -m "Automated update of relay data - $(date -u)"
+          git push
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/swift-tests.yml

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

.gitignore

@@ -8,9 +8,7 @@ plans/
 ## AI
 CLAUDE.md
 AGENTS.md
-
-## User settings
-xcuserdata/
+.claude/
 
 ## compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9)
 *.xcscmblueprint
@@ -57,7 +55,8 @@ iOSInjectionProject/
 
 ## Xcode project
 *.xcodeproj/project.xcworkspace/
-*.xcodeproj/xcshareddata/
+## Xcode User settings
+xcuserdata/
 
 ## Python
 __pycache__/
@@ -68,6 +67,9 @@ __pycache__/
 *.tmp
 *.temp
 
+## Cache
+.cache/
+
 # Local build results
 .Result*/
 .Result*.xcresult/
@@ -75,3 +77,6 @@ TestResult.xcresult/
 *.xcresult/
 build.log
 *.log
+
+# Local configs
+Local.xcconfig

BRING_THE_NOISE.md

@@ -37,7 +37,7 @@ This three-message pattern provides:
 #### NoiseEncryptionService
 The main service managing all Noise operations:
 ```swift
-class NoiseEncryptionService {
+final class NoiseEncryptionService {
     private let staticIdentityKey: Curve25519.KeyAgreement.PrivateKey
     private let sessionManager: NoiseSessionManager
     private let channelEncryption = NoiseChannelEncryption()
@@ -47,7 +47,7 @@ class NoiseEncryptionService {
 #### NoiseSession
 Individual session state for each peer:
 ```swift
-class NoiseSession {
+final class NoiseSession {
     private var handshakeState: NoiseHandshakeState?
     private var sendCipher: NoiseCipherState?
     private var receiveCipher: NoiseCipherState?
@@ -58,7 +58,7 @@ class NoiseSession {
 #### NoiseSessionManager
 Thread-safe session management:
 ```swift
-class NoiseSessionManager {
+final class NoiseSessionManager {
     private var sessions: [String: NoiseSession] = [:]
     private let sessionsQueue = DispatchQueue(label: "noise.sessions", attributes: .concurrent)
 }

Configs/Debug.xcconfig

@@ -0,0 +1,4 @@
+#include "Release.xcconfig"
+
+// Optional include of local configs
+#include? "Local.xcconfig"

Configs/Local.xcconfig.example

@@ -0,0 +1,5 @@
+// Your Apple Developer Team ID - https://stackoverflow.com/a/18727947
+DEVELOPMENT_TEAM = ABC123
+
+// Unique bundle id to be able to register and run locally
+PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.$(DEVELOPMENT_TEAM)

Configs/Release.xcconfig

@@ -0,0 +1,12 @@
+MARKETING_VERSION = 1.5.1
+CURRENT_PROJECT_VERSION = 1
+
+IPHONEOS_DEPLOYMENT_TARGET = 16.0
+MACOSX_DEPLOYMENT_TARGET = 13.0
+SWIFT_VERSION = 5.0
+
+DEVELOPMENT_TEAM = L3N5LHJD5Y
+CODE_SIGN_STYLE = Automatic
+
+PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat
+APP_GROUP_ID = group.chat.bitchat

Justfile

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

Package.swift

@@ -4,6 +4,7 @@ import PackageDescription
 
 let package = Package(
     name: "bitchat",
+    defaultLocalization: "en",
     platforms: [
         .iOS(.v16),
         .macOS(.v13)
@@ -15,22 +16,50 @@ let package = Package(
         ),
     ],
     dependencies:[
-        .package(url: "https://github.com/21-DOT-DEV/swift-secp256k1", exact: "0.21.1"),
+        .package(path: "localPackages/Arti"),
+        .package(path: "localPackages/Noise"),
+        .package(path: "localPackages/BitFoundation"),
+        .package(path: "localPackages/BitLogger"),
+        .package(url: "https://github.com/21-DOT-DEV/swift-secp256k1", exact: "0.21.1")
     ],
     targets: [
         .executableTarget(
             name: "bitchat",
             dependencies: [
-                .product(name: "P256K", package: "swift-secp256k1")
+                .product(name: "P256K", package: "swift-secp256k1"),
+                .product(name: "BitFoundation", package: "BitFoundation"),
+                .product(name: "BitLogger", package: "BitLogger"),
+                .product(name: "Noise", package: "Noise"),
+                .product(name: "Tor", package: "Arti")
             ],
             path: "bitchat",
             exclude: [
                 "Info.plist",
                 "Assets.xcassets",
+                "_PreviewHelpers/PreviewAssets.xcassets",
                 "bitchat.entitlements",
                 "bitchat-macOS.entitlements",
-                "LaunchScreen.storyboard"
+                "LaunchScreen.storyboard",
+                "ViewModels/Extensions/README.md"
+            ],
+            resources: [
+                .process("Localizable.xcstrings")
             ]
         ),
+        .testTarget(
+            name: "bitchatTests",
+            dependencies: [
+                "bitchat",
+                .product(name: "BitFoundation", package: "BitFoundation")
+            ],
+            path: "bitchatTests",
+            exclude: [
+                "Info.plist",
+                "README.md"
+            ],
+            resources: [
+                .process("Localization")
+            ]
+        )
     ]
 )

README.md

@@ -8,9 +8,6 @@ A decentralized peer-to-peer messaging app with dual transport architecture: loc
 
 📲 [App Store](https://apps.apple.com/us/app/bitchat-mesh/id6748219622)
 
-> [!WARNING]
-> Private messages have not received external security review and may contain vulnerabilities. Do not use for sensitive use cases, and do not rely on its security until it has been reviewed. Now uses the [Noise Protocol](http://www.noiseprotocol.org) for identity and encryption. Public local chat (the main feature) has no security concerns.
-
 ## License
 
 This project is released into the public domain. See the [LICENSE](LICENSE) file for details.
@@ -22,7 +19,7 @@ This project is released into the public domain. See the [LICENSE](LICENSE) file
 - **Intelligent Message Routing**: Automatically chooses best transport (Bluetooth → Nostr fallback)
 - **Decentralized Mesh Network**: Automatic peer discovery and multi-hop message relay over Bluetooth LE
 - **Privacy First**: No accounts, no phone numbers, no persistent identifiers
-- **Private Message End-to-End Encryption**: [Noise Protocol](http://noiseprotocol.org) for mesh, NIP-17 for Nostr
+- **Private Message End-to-End Encryption**: [Noise Protocol](https://noiseprotocol.org) for mesh, NIP-17 for Nostr
 - **IRC-Style Commands**: Familiar `/slap`, `/msg`, `/who` style interface
 - **Universal App**: Native support for iOS and macOS
 - **Emergency Wipe**: Triple-tap to instantly clear all data
@@ -94,45 +91,32 @@ For detailed protocol documentation, see the [Technical Whitepaper](WHITEPAPER.m
 
 ## Setup
 
-### Option 1: Using XcodeGen (Recommended)
-
-1. Install XcodeGen if you haven't already:
-
-   ```bash
-   brew install xcodegen
-   ```
-
-2. Generate the Xcode project:
+### Option 1: Using Xcode
 
    ```bash
    cd bitchat
-   xcodegen generate
-   ```
-
-3. Open the generated project:
-   ```bash
    open bitchat.xcodeproj
    ```
 
-### Option 2: Using Swift Package Manager
+   To run on a device there're a few steps to prepare the code:
+   - Clone the local configs: `cp Configs/Local.xcconfig.example Configs/Local.xcconfig`
+   - Add your Developer Team ID into the newly created `Configs/Local.xcconfig`
+      - Bundle ID would be set to `chat.bitchat.<team_id>` (unless you set to something else)
+   - Entitlements need to be updated manually (TODO: Automate):
+      - Search and replace `group.chat.bitchat` with `group.<your_bundle_id>` (e.g. `group.chat.bitchat.ABC123`)
 
-1. Open the project in Xcode:
+### Option 2: Using `just`
 
    ```bash
-   cd bitchat
-   open Package.swift
+   brew install just
    ```
 
-2. Select your target device and run
-
-### Option 3: Manual Xcode Project
-
-1. Open Xcode and create a new iOS/macOS App
-2. Copy all Swift files from the `bitchat` directory into your project
-3. Update Info.plist with Bluetooth permissions
-4. Set deployment target to iOS 16.0 / macOS 13.0
-
-### Option 4: just
-
 Want to try this on macos: `just run` will set it up and run from source.
 Run `just clean` afterwards to restore things to original state for mobile app building and development.
+
+## Localization
+
+- Base app resources live under `bitchat/Localization/Base.lproj/`. Add new copy to `Localizable.strings` and plural rules to `Localizable.stringsdict`.
+- Share extension strings are separate in `bitchatShareExtension/Localization/Base.lproj/Localizable.strings`.
+- Prefer keys that describe intent (`app_info.features.offline.title`) and reuse existing ones where possible.
+- Run `xcodebuild -project bitchat.xcodeproj -scheme "bitchat (macOS)" -configuration Debug CODE_SIGNING_ALLOWED=NO build` to compile-check any localization updates.

WHITEPAPER.md

@@ -184,6 +184,28 @@ To minimize bandwidth, `BitchatPacket`s are serialized into a compact binary for
 
 **Padding:** All packets are padded to the next standard block size (256, 512, 1024, or 2048 bytes) using a PKCS#7-style scheme to obscure the true message length from network observers.
 
+```mermaid
+---
+config:
+  theme: dark
+---
+---
+title: "BitchatPacket"
+---
+packet
++8: "Version"
++8: "Type"
++8: "TTL"
++64: "Timestamp"
++8: "Flags"
++16: "Payload Length"
++64: "Sender ID"
++64: "Recipient ID (optional)"
++48: "Payload (variable)"
++64: "Signature (optional)"
+```
+_A representation of the sizes of the fields in `BitchatPacket`_
+
 ### 6.2. Application Message Format (`BitchatMessage`)
 
 For packets of type `message`, the payload is a binary-serialized `BitchatMessage` containing the chat content.
@@ -198,6 +220,25 @@ For packets of type `message`, the payload is a binary-serialized `BitchatMessag
 | Original Sender     | 1 + len (opt)| Nickname of the original sender if the message is a relay.               |
 | Recipient Nickname  | 1 + len (opt)| Nickname of the recipient for private messages.                          |
 
+```mermaid
+---
+config:
+  theme: dark
+---
+---
+title: "BitchatMessage"
+---
+packet
++8: "Flags"
++64: "Timestamp"
++24: "ID (variable)"
++32: "Sender (variable)"
++32: "Content (variable)"
++32: "Original Sender (variable) (optional)"
++32: "Recipient Nickname (variable) (optional)"
+```
+_A representation of the sizes of the fields in `BitchatMessage`_
+
 ---
 
 ## 7. Message Routing and Propagation

bitchat.xcodeproj/xcshareddata/xcschemes/bitchat (iOS).xcscheme

@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1640"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "57CA17A36A2532A6CFF367BB"
+               BuildableName = "bitchatShareExtension.appex"
+               BlueprintName = "bitchatShareExtension"
+               ReferencedContainer = "container:bitchat.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "AF077EA0474EDEDE2C72716C"
+               BuildableName = "bitchat.app"
+               BlueprintName = "bitchat_iOS"
+               ReferencedContainer = "container:bitchat.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      codeCoverageEnabled = "YES"
+      onlyGenerateCoverageForSpecifiedTargets = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "AF077EA0474EDEDE2C72716C"
+            BuildableName = "bitchat.app"
+            BlueprintName = "bitchat_iOS"
+            ReferencedContainer = "container:bitchat.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <CodeCoverageTargets>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "AF077EA0474EDEDE2C72716C"
+            BuildableName = "bitchat.app"
+            BlueprintName = "bitchat_iOS"
+            ReferencedContainer = "container:bitchat.xcodeproj">
+         </BuildableReference>
+      </CodeCoverageTargets>
+      <Testables>
+         <TestableReference
+            skipped = "NO"
+            parallelizable = "YES"
+            testExecutionOrdering = "random">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "6CB97DF2EA57234CB3E563B8"
+               BuildableName = "bitchatTests_iOS.xctest"
+               BlueprintName = "bitchatTests_iOS"
+               ReferencedContainer = "container:bitchat.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "AF077EA0474EDEDE2C72716C"
+            BuildableName = "bitchat.app"
+            BlueprintName = "bitchat_iOS"
+            ReferencedContainer = "container:bitchat.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "BITCHAT_LOG_LEVEL"
+            value = "debug"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "AF077EA0474EDEDE2C72716C"
+            BuildableName = "bitchat.app"
+            BlueprintName = "bitchat_iOS"
+            ReferencedContainer = "container:bitchat.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

bitchat.xcodeproj/xcshareddata/xcschemes/bitchat (macOS).xcscheme

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1640"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "0576A29205865664C0937536"
+               BuildableName = "bitchat.app"
+               BlueprintName = "bitchat_macOS"
+               ReferencedContainer = "container:bitchat.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "0576A29205865664C0937536"
+            BuildableName = "bitchat.app"
+            BlueprintName = "bitchat_macOS"
+            ReferencedContainer = "container:bitchat.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <Testables>
+         <TestableReference
+            skipped = "NO"
+            parallelizable = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "47FF23248747DD7CB666CB91"
+               BuildableName = "bitchatTests_macOS.xctest"
+               BlueprintName = "bitchatTests_macOS"
+               ReferencedContainer = "container:bitchat.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "0576A29205865664C0937536"
+            BuildableName = "bitchat.app"
+            BlueprintName = "bitchat_macOS"
+            ReferencedContainer = "container:bitchat.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "BITCHAT_LOG_LEVEL"
+            value = "debug"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "0576A29205865664C0937536"
+            BuildableName = "bitchat.app"
+            BlueprintName = "bitchat_macOS"
+            ReferencedContainer = "container:bitchat.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

bitchat/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -1,111 +1,9 @@
 {
   "images" : [
-    {
-      "filename" : "icon_20x20@2x.png",
-      "idiom" : "iphone",
-      "scale" : "2x",
-      "size" : "20x20"
-    },
-    {
-      "filename" : "icon_20x20@3x.png",
-      "idiom" : "iphone",
-      "scale" : "3x",
-      "size" : "20x20"
-    },
-    {
-      "filename" : "icon_29x29@2x.png",
-      "idiom" : "iphone",
-      "scale" : "2x",
-      "size" : "29x29"
-    },
-    {
-      "filename" : "icon_29x29@3x.png",
-      "idiom" : "iphone",
-      "scale" : "3x",
-      "size" : "29x29"
-    },
-    {
-      "filename" : "icon_40x40@2x.png",
-      "idiom" : "iphone",
-      "scale" : "2x",
-      "size" : "40x40"
-    },
-    {
-      "filename" : "icon_40x40@3x.png",
-      "idiom" : "iphone",
-      "scale" : "3x",
-      "size" : "40x40"
-    },
-    {
-      "filename" : "icon_60x60@2x.png",
-      "idiom" : "iphone",
-      "scale" : "2x",
-      "size" : "60x60"
-    },
-    {
-      "filename" : "icon_60x60@3x.png",
-      "idiom" : "iphone",
-      "scale" : "3x",
-      "size" : "60x60"
-    },
-    {
-      "filename" : "icon_20x20.png",
-      "idiom" : "ipad",
-      "scale" : "1x",
-      "size" : "20x20"
-    },
-    {
-      "filename" : "icon_20x20@2x.png",
-      "idiom" : "ipad",
-      "scale" : "2x",
-      "size" : "20x20"
-    },
-    {
-      "filename" : "icon_29x29.png",
-      "idiom" : "ipad",
-      "scale" : "1x",
-      "size" : "29x29"
-    },
-    {
-      "filename" : "icon_29x29@2x.png",
-      "idiom" : "ipad",
-      "scale" : "2x",
-      "size" : "29x29"
-    },
-    {
-      "filename" : "icon_40x40.png",
-      "idiom" : "ipad",
-      "scale" : "1x",
-      "size" : "40x40"
-    },
-    {
-      "filename" : "icon_40x40@2x.png",
-      "idiom" : "ipad",
-      "scale" : "2x",
-      "size" : "40x40"
-    },
-    {
-      "filename" : "icon_76x76.png",
-      "idiom" : "ipad",
-      "scale" : "1x",
-      "size" : "76x76"
-    },
-    {
-      "filename" : "icon_76x76@2x.png",
-      "idiom" : "ipad",
-      "scale" : "2x",
-      "size" : "76x76"
-    },
-    {
-      "filename" : "icon_83.5x83.5@2x.png",
-      "idiom" : "ipad",
-      "scale" : "2x",
-      "size" : "83.5x83.5"
-    },
     {
       "filename" : "icon_1024x1024.png",
-      "idiom" : "ios-marketing",
-      "scale" : "1x",
+      "idiom" : "universal",
+      "platform" : "ios",
       "size" : "1024x1024"
     },
     {

bitchat/Assets.xcassets/AppIconDebug.appiconset/Contents.json

@@ -0,0 +1,36 @@
+{
+  "images" : [
+    {
+      "filename" : "image-1024.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "dark"
+        }
+      ],
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "tinted"
+        }
+      ],
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

bitchat/Assets.xcassets/Contents.json

@@ -3,4 +3,4 @@
     "author" : "xcode",
     "version" : 1
   }
-}
+}

bitchat/BitchatApp.swift

@@ -6,20 +6,40 @@
 // For more information, see <https://unlicense.org>
 //
 
+import Tor
 import SwiftUI
+import BitFoundation
 import UserNotifications
 
 @main
 struct BitchatApp: App {
-    @StateObject private var chatViewModel = ChatViewModel()
+    static let bundleID = Bundle.main.bundleIdentifier ?? "chat.bitchat"
+    static let groupID = "group.\(bundleID)"
+    
+    @StateObject private var chatViewModel: ChatViewModel
     #if os(iOS)
     @Environment(\.scenePhase) var scenePhase
     @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
+    // Skip the very first .active-triggered Tor restart on cold launch
+    @State private var didHandleInitialActive: Bool = false
+    @State private var didEnterBackground: Bool = false
     #elseif os(macOS)
     @NSApplicationDelegateAdaptor(MacAppDelegate.self) var appDelegate
     #endif
     
+    private let idBridge = NostrIdentityBridge()
+    
     init() {
+        let keychain = KeychainManager()
+        let idBridge = self.idBridge
+        _chatViewModel = StateObject(
+            wrappedValue: ChatViewModel(
+                keychain: keychain,
+                idBridge: idBridge,
+                identityManager: SecureIdentityStateManager(keychain)
+            )
+        )
+        
         UNUserNotificationCenter.current().delegate = NotificationDelegate.shared
         // Warm up georelay directory and refresh if stale (once/day)
         GeoRelayDirectory.shared.prefetchIfNeeded()
@@ -34,15 +54,20 @@ struct BitchatApp: App {
                     // Inject live Noise service into VerificationService to avoid creating new BLE instances
                     VerificationService.shared.configure(with: chatViewModel.meshService.getNoiseService())
                     // Prewarm Nostr identity and QR to make first VERIFY sheet fast
+                    let nickname = chatViewModel.nickname
                     DispatchQueue.global(qos: .utility).async {
-                        let npub = try? NostrIdentityBridge.getCurrentNostrIdentity()?.npub
-                        _ = VerificationService.shared.buildMyQRString(nickname: chatViewModel.nickname, npub: npub)
+                        let npub = try? idBridge.getCurrentNostrIdentity()?.npub
+                        _ = VerificationService.shared.buildMyQRString(nickname: nickname, npub: npub)
                     }
-                    #if os(iOS)
+
                     appDelegate.chatViewModel = chatViewModel
-                    #elseif os(macOS)
-                    appDelegate.chatViewModel = chatViewModel
-                    #endif
+
+                    // Initialize network activation policy; will start Tor/Nostr only when allowed
+                    NetworkActivationService.shared.start()
+                    
+                    // Start presence service (will wait for Tor readiness)
+                    GeohashPresenceService.shared.start()
+
                     // Check for shared content
                     checkForSharedContent()
                 }
@@ -54,10 +79,41 @@ struct BitchatApp: App {
                     switch newPhase {
                     case .background:
                         // Keep BLE mesh running in background; BLEService adapts scanning automatically
-                        break
+                        // Always send Tor to dormant on background for a clean restart later.
+                        TorManager.shared.setAppForeground(false)
+                        TorManager.shared.goDormantOnBackground()
+                        // Stop geohash sampling while backgrounded
+                        Task { @MainActor in
+                            chatViewModel.endGeohashSampling()
+                        }
+                        // Proactively disconnect Nostr to avoid spurious socket errors while Tor is down
+                        NostrRelayManager.shared.disconnect()
+                        didEnterBackground = true
                     case .active:
                         // Restart services when becoming active
                         chatViewModel.meshService.startServices()
+                        TorManager.shared.setAppForeground(true)
+                        // On initial cold launch, Tor was just started in onAppear.
+                        // Skip the deterministic restart the first time we become active.
+                        if didHandleInitialActive && didEnterBackground {
+                            if TorManager.shared.isAutoStartAllowed() && !TorManager.shared.isReady {
+                                TorManager.shared.ensureRunningOnForeground()
+                            }
+                        } else {
+                            didHandleInitialActive = true
+                        }
+                        didEnterBackground = false
+                        if TorManager.shared.isAutoStartAllowed() {
+                            Task.detached {
+                                let _ = await TorManager.shared.awaitReady(timeout: 60)
+                                await MainActor.run {
+                                    // Rebuild proxied sessions to bind to the live Tor after readiness
+                                    TorURLSession.shared.rebuild()
+                                    // Reconnect Nostr via fresh sessions; will gate until Tor 100%
+                                    NostrRelayManager.shared.resetAllConnections()
+                                }
+                            }
+                        }
                         checkForSharedContent()
                     case .inactive:
                         break
@@ -90,7 +146,7 @@ struct BitchatApp: App {
     
     private func checkForSharedContent() {
         // Check app group for shared content from extension
-        guard let userDefaults = UserDefaults(suiteName: "group.chat.bitchat") else {
+        guard let userDefaults = UserDefaults(suiteName: BitchatApp.groupID) else {
             return
         }
         
@@ -131,19 +187,23 @@ struct BitchatApp: App {
 }
 
 #if os(iOS)
-class AppDelegate: NSObject, UIApplicationDelegate {
+final class AppDelegate: NSObject, UIApplicationDelegate {
     weak var chatViewModel: ChatViewModel?
     
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
         return true
     }
+    
+    func applicationWillTerminate(_ application: UIApplication) {
+        chatViewModel?.applicationWillTerminate()
+    }
 }
 #endif
 
 #if os(macOS)
 import AppKit
 
-class MacAppDelegate: NSObject, NSApplicationDelegate {
+final class MacAppDelegate: NSObject, NSApplicationDelegate {
     weak var chatViewModel: ChatViewModel?
     
     func applicationWillTerminate(_ notification: Notification) {
@@ -156,7 +216,7 @@ class MacAppDelegate: NSObject, NSApplicationDelegate {
 }
 #endif
 
-class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
+final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
     static let shared = NotificationDelegate()
     weak var chatViewModel: ChatViewModel?
     
@@ -169,7 +229,7 @@ class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
             // Get peer ID from userInfo
             if let peerID = userInfo["peerID"] as? String {
                 DispatchQueue.main.async {
-                    self.chatViewModel?.startPrivateChat(with: peerID)
+                    self.chatViewModel?.startPrivateChat(with: PeerID(str: peerID))
                 }
             }
         }
@@ -194,10 +254,15 @@ class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
             // Get peer ID from userInfo
             if let peerID = userInfo["peerID"] as? String {
                 // Don't show notification if the private chat is already open
-                if chatViewModel?.selectedPrivateChatPeer == peerID {
-                    completionHandler([])
-                    return
+                // Access main-actor-isolated property via Task
+                Task { @MainActor in
+                    if self.chatViewModel?.selectedPrivateChatPeer == PeerID(str: peerID) {
+                        completionHandler([])
+                    } else {
+                        completionHandler([.banner, .sound])
+                    }
                 }
+                return
             }
         }
         // Suppress geohash activity notification if we're already in that geohash channel
@@ -215,8 +280,3 @@ class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
     }
 }
 
-extension String {
-    var nilIfEmpty: String? {
-        self.isEmpty ? nil : self
-    }
-}

bitchat/Features/media/ImageUtils.swift

@@ -0,0 +1,203 @@
+import Foundation
+import ImageIO
+import UniformTypeIdentifiers
+#if os(iOS)
+import UIKit
+#else
+import AppKit
+#endif
+
+enum ImageUtilsError: Error {
+    case invalidImage
+    case encodingFailed
+}
+
+enum ImageUtils {
+    private static let compressionQuality: CGFloat = 0.82
+    private static let targetImageBytes: Int = 45_000
+
+    static func processImage(at url: URL, maxDimension: CGFloat = 448) throws -> URL {
+        // Security H1: Check file size BEFORE reading into memory
+        let attrs = try FileManager.default.attributesOfItem(atPath: url.path)
+        guard let fileSize = attrs[.size] as? Int else {
+            throw ImageUtilsError.invalidImage
+        }
+        // Allow up to 10MB source images (will be scaled down)
+        guard fileSize <= 10 * 1024 * 1024 else {
+            throw ImageUtilsError.invalidImage
+        }
+
+        let data = try Data(contentsOf: url)
+        #if os(iOS)
+        guard let image = UIImage(data: data) else { throw ImageUtilsError.invalidImage }
+        return try processImage(image, maxDimension: maxDimension)
+        #else
+        guard let image = NSImage(data: data) else { throw ImageUtilsError.invalidImage }
+        return try processImage(image, maxDimension: maxDimension)
+        #endif
+    }
+
+    #if os(iOS)
+    static func processImage(_ image: UIImage, maxDimension: CGFloat = 448) throws -> URL {
+        return try autoreleasepool {
+            // Scale the image first
+            let scaled = scaledImage(image, maxDimension: maxDimension)
+
+            // Get CGImage from UIImage - this is the key to stripping metadata
+            guard let cgImage = scaled.cgImage else {
+                throw ImageUtilsError.encodingFailed
+            }
+
+            // Use CGImageDestination to encode without metadata (same as macOS)
+            var quality = compressionQuality
+            guard var jpegData = encodeJPEG(from: cgImage, quality: quality) else {
+                throw ImageUtilsError.encodingFailed
+            }
+
+            // Compress to target size
+            while jpegData.count > targetImageBytes && quality > 0.3 {
+                quality -= 0.1
+                autoreleasepool {
+                    if let next = encodeJPEG(from: cgImage, quality: quality) {
+                        jpegData = next
+                    }
+                }
+            }
+
+            let outputURL = try makeOutputURL()
+            try jpegData.write(to: outputURL, options: .atomic)
+            return outputURL
+        }
+    }
+
+    private static func scaledImage(_ image: UIImage, maxDimension: CGFloat) -> UIImage {
+        let size = image.size
+        let maxSide = max(size.width, size.height)
+        guard maxSide > maxDimension else { return image }
+        let scale = maxDimension / maxSide
+        let newSize = CGSize(width: size.width * scale, height: size.height * scale)
+
+        // Draw into a new context to get a clean CGImage without metadata
+        UIGraphicsBeginImageContextWithOptions(newSize, true, 1.0)
+        image.draw(in: CGRect(origin: .zero, size: newSize))
+        let rendered = UIGraphicsGetImageFromCurrentImageContext()
+        UIGraphicsEndImageContext()
+        return rendered ?? image
+    }
+
+    // Shared EXIF-stripping JPEG encoder for both iOS and macOS
+    private static func encodeJPEG(from cgImage: CGImage, quality: CGFloat) -> Data? {
+        guard let data = CFDataCreateMutable(nil, 0) else {
+            return nil
+        }
+        guard let destination = CGImageDestinationCreateWithData(data, UTType.jpeg.identifier as CFString, 1, nil) else {
+            return nil
+        }
+        // Security: Strip ALL metadata (EXIF, GPS, TIFF, IPTC, XMP)
+        // By only specifying compression quality and no metadata keys,
+        // we ensure a clean JPEG with no privacy-leaking information
+        let options: [CFString: Any] = [
+            kCGImageDestinationLossyCompressionQuality: quality
+        ]
+        CGImageDestinationAddImage(destination, cgImage, options as CFDictionary)
+        guard CGImageDestinationFinalize(destination) else {
+            return nil
+        }
+        return data as Data
+    }
+    #else
+    static func processImage(_ image: NSImage, maxDimension: CGFloat = 448) throws -> URL {
+        return try autoreleasepool {
+            let scaled = scaledImage(image, maxDimension: maxDimension)
+            guard let inputCG = scaled.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
+                throw ImageUtilsError.encodingFailed
+            }
+            let width = inputCG.width
+            let height = inputCG.height
+            let colorSpace = CGColorSpace(name: CGColorSpace.sRGB) ?? CGColorSpaceCreateDeviceRGB()
+            guard let context = CGContext(
+                data: nil,
+                width: width,
+                height: height,
+                bitsPerComponent: 8,
+                bytesPerRow: 0,
+                space: colorSpace,
+                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+            ) else {
+                throw ImageUtilsError.encodingFailed
+            }
+            context.draw(inputCG, in: CGRect(x: 0, y: 0, width: width, height: height))
+            guard let cgImage = context.makeImage() else {
+                throw ImageUtilsError.encodingFailed
+            }
+            var quality = compressionQuality
+            guard var jpegData = encodeJPEG(from: cgImage, quality: quality) else {
+                throw ImageUtilsError.encodingFailed
+            }
+            while jpegData.count > targetImageBytes && quality > 0.3 {
+                quality -= 0.1
+                autoreleasepool {
+                    if let next = encodeJPEG(from: cgImage, quality: quality) {
+                        jpegData = next
+                    }
+                }
+            }
+            let outputURL = try makeOutputURL()
+            try jpegData.write(to: outputURL, options: .atomic)
+            return outputURL
+        }
+    }
+
+    private static func scaledImage(_ image: NSImage, maxDimension: CGFloat) -> NSImage {
+        let size = image.size
+        let maxSide = max(size.width, size.height)
+        guard maxSide > maxDimension else { return image }
+        let scale = maxDimension / maxSide
+        let newSize = NSSize(width: size.width * scale, height: size.height * scale)
+        let scaledImage = NSImage(size: newSize)
+        scaledImage.lockFocus()
+        image.draw(in: NSRect(origin: .zero, size: newSize),
+                   from: NSRect(origin: .zero, size: size),
+                   operation: .copy,
+                   fraction: 1.0)
+        scaledImage.unlockFocus()
+        return scaledImage
+    }
+
+    // Shared EXIF-stripping JPEG encoder for both iOS and macOS
+    private static func encodeJPEG(from cgImage: CGImage, quality: CGFloat) -> Data? {
+        guard let data = CFDataCreateMutable(nil, 0) else {
+            return nil
+        }
+        guard let destination = CGImageDestinationCreateWithData(data, UTType.jpeg.identifier as CFString, 1, nil) else {
+            return nil
+        }
+        // Security: Strip ALL metadata (EXIF, GPS, TIFF, IPTC, XMP)
+        // By only specifying compression quality and no metadata keys,
+        // we ensure a clean JPEG with no privacy-leaking information
+        let options: [CFString: Any] = [
+            kCGImageDestinationLossyCompressionQuality: quality
+        ]
+        CGImageDestinationAddImage(destination, cgImage, options as CFDictionary)
+        guard CGImageDestinationFinalize(destination) else {
+            return nil
+        }
+        return data as Data
+    }
+    #endif
+
+    private static func makeOutputURL() throws -> URL {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyyMMdd_HHmmss"
+        let fileName = "img_\(formatter.string(from: Date())).jpg"
+
+        let directory = try applicationFilesDirectory().appendingPathComponent("images/outgoing", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true, attributes: nil)
+        return directory.appendingPathComponent(fileName)
+    }
+
+    private static func applicationFilesDirectory() throws -> URL {
+        let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+        return base.appendingPathComponent("files", isDirectory: true)
+    }
+}

bitchat/Features/voice/VoiceNotePlaybackController.swift

@@ -0,0 +1,205 @@
+import Foundation
+import AVFoundation
+import BitLogger
+
+/// Controls playback for a single voice note and coordinates exclusive playback across the app.
+final class VoiceNotePlaybackController: NSObject, ObservableObject, AVAudioPlayerDelegate {
+    @Published private(set) var isPlaying: Bool = false
+    @Published private(set) var currentTime: TimeInterval = 0
+    @Published private(set) var duration: TimeInterval = 0
+    @Published private(set) var progress: Double = 0
+
+    /// rounded so 4.9s shows "00:05"
+    var roundedDuration: Int {
+        guard duration.isFinite else { return 0 }
+        return Int(duration.rounded())
+    }
+
+    /// ceil so "00:01" stays visible until playback ends, capped to rounded duration
+    var remainingSeconds: Int {
+        let remaining = max(0, duration - currentTime)
+        return min(roundedDuration, Int(ceil(remaining)))
+    }
+
+    private var player: AVAudioPlayer?
+    private var timer: Timer?
+    private var url: URL
+
+    init(url: URL) {
+        self.url = url
+        super.init()
+        // Don't load anything eagerly - wait until user interaction or view is fully displayed
+    }
+
+    func loadDuration() {
+        guard duration == 0 else { return }
+
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            guard let self = self else { return }
+            do {
+                let player = try AVAudioPlayer(contentsOf: self.url)
+                let loadedDuration = player.duration
+                DispatchQueue.main.async { [weak self] in
+                    guard let self = self, self.duration == 0 else { return }
+                    self.duration = loadedDuration
+                }
+            } catch {
+                SecureLogger.error("Failed to load audio duration: \(error)", category: .session)
+            }
+        }
+    }
+
+    deinit {
+        timer?.invalidate()
+    }
+
+    func replaceURL(_ url: URL) {
+        guard url != self.url else { return }
+        stop()
+        self.url = url
+        player = nil
+        duration = 0
+        // Duration will be loaded on demand when needed
+    }
+
+    func togglePlayback() {
+        isPlaying ? pause() : play()
+    }
+
+    func play() {
+        guard ensurePlayerReady() else { return }
+        VoiceNotePlaybackCoordinator.shared.activate(self)
+        player?.play()
+        startTimer()
+        updateProgress()
+        isPlaying = true
+    }
+
+    func pause() {
+        player?.pause()
+        stopTimer()
+        updateProgress()
+        isPlaying = false
+    }
+
+    func stop() {
+        player?.stop()
+        player?.currentTime = 0
+        stopTimer()
+        updateProgress()
+        isPlaying = false
+        VoiceNotePlaybackCoordinator.shared.deactivate(self)
+    }
+
+    func seek(to fraction: Double) {
+        guard ensurePlayerReady() else { return }
+        let clamped = max(0, min(1, fraction))
+        if let player = player {
+            player.currentTime = clamped * player.duration
+            if isPlaying {
+                player.play()
+            }
+            updateProgress()
+        }
+    }
+
+    // MARK: - AVAudioPlayerDelegate
+
+    func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
+        // Delegate callback may be on background thread - ensure main thread for UI updates
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.stopTimer()
+            self.updateProgress()
+            self.isPlaying = false
+            VoiceNotePlaybackCoordinator.shared.deactivate(self)
+        }
+    }
+
+    // MARK: - Private Helpers
+
+    private func preparePlayer(for url: URL) {
+        // Prepare player synchronously (only called when playback is requested)
+        do {
+            let player = try AVAudioPlayer(contentsOf: url)
+            player.delegate = self
+            player.prepareToPlay()
+            self.player = player
+            duration = player.duration
+            currentTime = player.currentTime
+            progress = duration > 0 ? currentTime / duration : 0
+        } catch {
+            SecureLogger.error("Voice note playback failed for \(url.lastPathComponent): \(error)", category: .session)
+            player = nil
+            duration = 0
+            currentTime = 0
+            progress = 0
+        }
+    }
+
+    private func ensurePlayerReady() -> Bool {
+        if player == nil {
+            preparePlayer(for: url)
+        }
+        #if os(iOS)
+        let session = AVAudioSession.sharedInstance()
+        do {
+            try session.setCategory(.playback, mode: .spokenAudio, options: [.mixWithOthers])
+            try session.setActive(true, options: [])
+        } catch {
+            SecureLogger.error("Failed to activate audio session: \(error)", category: .session)
+        }
+        #endif
+        return player != nil
+    }
+
+    private func startTimer() {
+        if timer != nil { return }
+        timer = Timer.scheduledTimer(withTimeInterval: 0.05, repeats: true) { [weak self] _ in
+            self?.updateProgress()
+        }
+        if let timer = timer {
+            RunLoop.main.add(timer, forMode: .common)
+        }
+    }
+
+    private func stopTimer() {
+        timer?.invalidate()
+        timer = nil
+    }
+
+    private func updateProgress() {
+        guard let player = player else {
+            currentTime = 0
+            duration = 0
+            progress = 0
+            return
+        }
+        currentTime = player.currentTime
+        duration = player.duration
+        progress = duration > 0 ? currentTime / duration : 0
+    }
+}
+
+/// Ensures only one voice note plays at a time.
+final class VoiceNotePlaybackCoordinator {
+    static let shared = VoiceNotePlaybackCoordinator()
+
+    private weak var activeController: VoiceNotePlaybackController?
+
+    private init() {}
+
+    func activate(_ controller: VoiceNotePlaybackController) {
+        if activeController === controller {
+            return
+        }
+        activeController?.pause()
+        activeController = controller
+    }
+
+    func deactivate(_ controller: VoiceNotePlaybackController) {
+        if activeController === controller {
+            activeController = nil
+        }
+    }
+}

bitchat/Features/voice/VoiceRecorder.swift

@@ -0,0 +1,155 @@
+import Foundation
+import AVFoundation
+
+/// Manages audio capture for mesh voice notes with predictable encoding settings.
+actor VoiceRecorder {
+    enum RecorderError: Error {
+        case microphoneAccessDenied
+        case recorderInitializationFailed
+        case recordingInProgress
+    }
+
+    static let shared = VoiceRecorder()
+
+    private let paddingInterval: TimeInterval = 0.5
+    private let maxRecordingDuration: TimeInterval = 120
+    static let minRecordingDuration: TimeInterval = 1
+
+    private var recorder: AVAudioRecorder?
+    private var currentURL: URL?
+
+    // MARK: - Permissions
+
+    nonisolated
+    func requestPermission() async -> Bool {
+        #if os(iOS)
+        return await withCheckedContinuation { continuation in
+            AVAudioSession.sharedInstance().requestRecordPermission { granted in
+                continuation.resume(returning: granted)
+            }
+        }
+        #elseif os(macOS)
+        return await withCheckedContinuation { continuation in
+            AVCaptureDevice.requestAccess(for: .audio) { granted in
+                continuation.resume(returning: granted)
+            }
+        }
+        #else
+        return true
+        #endif
+    }
+
+    // MARK: - Recording Lifecycle
+
+    @discardableResult
+    func startRecording() throws -> URL {
+        if recorder?.isRecording == true {
+            throw RecorderError.recordingInProgress
+        }
+
+        #if os(iOS)
+        let session = AVAudioSession.sharedInstance()
+        guard session.recordPermission == .granted else {
+            throw RecorderError.microphoneAccessDenied
+        }
+        #if targetEnvironment(simulator)
+        // allowBluetoothHFP is not available on iOS Simulator
+        try session.setCategory(
+            .playAndRecord,
+            mode: .default,
+            options: [.defaultToSpeaker, .allowBluetoothA2DP]
+        )
+        #else
+        try session.setCategory(
+            .playAndRecord,
+            mode: .default,
+            options: [.defaultToSpeaker, .allowBluetoothA2DP, .allowBluetoothHFP]
+        )
+        #endif
+        try session.setActive(true, options: .notifyOthersOnDeactivation)
+        #endif
+        #if os(macOS)
+        guard AVCaptureDevice.authorizationStatus(for: .audio) == .authorized else {
+            throw RecorderError.microphoneAccessDenied
+        }
+        #endif
+
+        let outputURL = try makeOutputURL()
+        let settings: [String: Any] = [
+            AVFormatIDKey: kAudioFormatMPEG4AAC,
+            AVSampleRateKey: 16_000,
+            AVNumberOfChannelsKey: 1,
+            AVEncoderBitRateKey: 16_000
+        ]
+
+        let audioRecorder = try AVAudioRecorder(url: outputURL, settings: settings)
+        audioRecorder.isMeteringEnabled = true
+        audioRecorder.prepareToRecord()
+        audioRecorder.record(forDuration: maxRecordingDuration)
+
+        recorder = audioRecorder
+        currentURL = outputURL
+        return outputURL
+    }
+
+    func stopRecording() async -> URL? {
+        guard let recorder, recorder.isRecording else {
+            return currentURL
+        }
+
+        let sessionURL = currentURL
+
+        try? await Task.sleep(nanoseconds: UInt64(paddingInterval * 1_000_000_000))
+
+        recorder.stop()
+
+        // A new session may have started during the sleep — don't touch its state
+        if self.recorder === recorder {
+            cleanupSession()
+            self.recorder = nil
+            currentURL = nil
+        }
+
+        return sessionURL
+    }
+
+    func cancelRecording() {
+        if let recorder, recorder.isRecording {
+            recorder.stop()
+        }
+        cleanupSession()
+        if let currentURL {
+            try? FileManager.default.removeItem(at: currentURL)
+        }
+        recorder = nil
+        currentURL = nil
+    }
+
+    // MARK: - Helpers
+
+    private func makeOutputURL() throws -> URL {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyyMMdd_HHmmss"
+        let fileName = "voice_\(formatter.string(from: Date())).m4a"
+
+        let baseDirectory = try applicationFilesDirectory().appendingPathComponent("voicenotes/outgoing", isDirectory: true)
+        try FileManager.default.createDirectory(at: baseDirectory, withIntermediateDirectories: true, attributes: nil)
+        return baseDirectory.appendingPathComponent(fileName)
+    }
+
+    private func applicationFilesDirectory() throws -> URL {
+        #if os(iOS)
+        return try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+            .appendingPathComponent("files", isDirectory: true)
+        #else
+        let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+        return base.appendingPathComponent("files", isDirectory: true)
+        #endif
+    }
+
+    private func cleanupSession() {
+        #if os(iOS)
+        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+        #endif
+    }
+}

bitchat/Features/voice/Waveform.swift

@@ -0,0 +1,113 @@
+import AVFoundation
+import Foundation
+import BitLogger
+
+/// Generates and caches downsampled waveforms for audio files so UI rendering is cheap.
+final class WaveformCache {
+    static let shared = WaveformCache()
+
+    private let queue = DispatchQueue(label: "com.bitchat.waveform-cache", attributes: .concurrent)
+    private var cache: [URL: (waveform: [Float], lastAccess: Date)] = [:]
+    private let maxCacheSize = 20  // Limit cache to prevent unbounded memory growth
+
+    private init() {}
+
+    func cachedWaveform(for url: URL) -> [Float]? {
+        queue.sync {
+            guard let entry = cache[url] else { return nil }
+            return entry.waveform
+        }
+    }
+
+    func waveform(for url: URL, bins: Int = 120, completion: @escaping ([Float]) -> Void) {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+
+            // Check cache (read-only, no update needed on cache hit for performance)
+            if let entry = self.cache[url] {
+                DispatchQueue.main.async { completion(entry.waveform) }
+                return
+            }
+
+            guard let computed = self.computeWaveform(url: url, bins: bins) else {
+                DispatchQueue.main.async { completion([]) }
+                return
+            }
+
+            self.queue.async(flags: .barrier) { [weak self] in
+                guard let self = self else { return }
+
+                // Evict oldest entry if cache is full
+                if self.cache.count >= self.maxCacheSize {
+                    if let oldest = self.cache.min(by: { $0.value.lastAccess < $1.value.lastAccess }) {
+                        self.cache.removeValue(forKey: oldest.key)
+                    }
+                }
+
+                self.cache[url] = (computed, Date())
+            }
+            DispatchQueue.main.async { completion(computed) }
+        }
+    }
+
+    func purge(url: URL) {
+        queue.async(flags: .barrier) { [weak self] in
+            self?.cache.removeValue(forKey: url)
+        }
+    }
+
+    func purgeAll() {
+        queue.async(flags: .barrier) { [weak self] in
+            self?.cache.removeAll()
+        }
+    }
+
+    private func computeWaveform(url: URL, bins: Int) -> [Float]? {
+        guard bins > 0 else { return nil }
+        // Use autoreleasepool to manage memory from audio buffer allocations
+        return autoreleasepool {
+            do {
+                let audioFile = try AVAudioFile(forReading: url)
+                let length = Int(audioFile.length)
+                guard length > 0 else { return nil }
+
+                guard let buffer = AVAudioPCMBuffer(pcmFormat: audioFile.processingFormat, frameCapacity: AVAudioFrameCount(length)) else {
+                    return nil
+                }
+                try audioFile.read(into: buffer, frameCount: AVAudioFrameCount(length))
+                guard let channelData = buffer.floatChannelData else { return nil }
+
+                let channelCount = Int(audioFile.processingFormat.channelCount)
+                let frameLength = Int(buffer.frameLength)
+                let samplesPerBin = max(1, frameLength / bins)
+
+                var magnitudes: [Float] = Array(repeating: 0, count: bins)
+                for bin in 0..<bins {
+                    let start = bin * samplesPerBin
+                    let end = min(frameLength, start + samplesPerBin)
+                    if start >= end { break }
+
+                    var sum: Float = 0
+                    var sampleCount = 0
+                    for frame in start..<end {
+                        var sampleValue: Float = 0
+                        for channel in 0..<channelCount {
+                            sampleValue += fabsf(channelData[channel][frame])
+                        }
+                        sum += sampleValue / Float(channelCount)
+                        sampleCount += 1
+                    }
+                    magnitudes[bin] = sampleCount > 0 ? sum / Float(sampleCount) : 0
+                }
+
+                if let maxMagnitude = magnitudes.max(), maxMagnitude > 0 {
+                    magnitudes = magnitudes.map { min($0 / maxMagnitude, 1.0) }
+                }
+                return magnitudes
+            } catch {
+                SecureLogger.error("Waveform extraction failed for \(url.lastPathComponent): \(error)", category: .session)
+                return nil
+            }
+        }
+    }
+}

bitchat/Identity/IdentityModels.swift

@@ -81,13 +81,14 @@
 ///
 
 import Foundation
+import BitFoundation
 
 // MARK: - Three-Layer Identity Model
 
 /// Represents the ephemeral layer of identity - short-lived peer IDs that provide network privacy.
 /// These IDs rotate periodically to prevent tracking while maintaining cryptographic relationships.
 struct EphemeralIdentity {
-    let peerID: String          // 8 random bytes
+    let peerID: PeerID          // 8 random bytes
     let sessionStart: Date
     var handshakeState: HandshakeState
 }
@@ -158,23 +159,6 @@ struct IdentityCache: Codable {
     var version: Int = 1
 }
 
-// MARK: - Identity Resolution
-
-enum IdentityHint {
-    case unknown
-    case likelyKnown(fingerprint: String)
-    case ambiguous(candidates: Set<String>)
-    case verified(fingerprint: String)
-}
-
-// MARK: - Pending Actions
-
-struct PendingActions {
-    var toggleFavorite: Bool?
-    var setTrustLevel: TrustLevel?
-    var setPetname: String?
-}
-
 //
 
 // MARK: - Migration Support

bitchat/Identity/SecureIdentityStateManager.swift

@@ -90,27 +90,64 @@
 /// - Advanced conflict resolution
 ///
 
+import BitLogger
+import BitFoundation
 import Foundation
 import CryptoKit
 
+protocol SecureIdentityStateManagerProtocol {
+    // MARK: Secure Loading/Saving
+    func forceSave()
+    
+    // MARK: Social Identity Management
+    func getSocialIdentity(for fingerprint: String) -> SocialIdentity?
+    
+    // MARK: Cryptographic Identities
+    func upsertCryptographicIdentity(fingerprint: String, noisePublicKey: Data, signingPublicKey: Data?, claimedNickname: String?)
+    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: PeerID) -> [CryptographicIdentity]
+    func updateSocialIdentity(_ identity: SocialIdentity)
+    
+    // MARK: Favorites Management
+    func getFavorites() -> Set<String>
+    func setFavorite(_ fingerprint: String, isFavorite: Bool)
+    func isFavorite(fingerprint: String) -> Bool
+    
+    // MARK: Blocked Users Management
+    func isBlocked(fingerprint: String) -> Bool
+    func setBlocked(_ fingerprint: String, isBlocked: Bool)
+    
+    // MARK: Geohash (Nostr) Blocking
+    func isNostrBlocked(pubkeyHexLowercased: String) -> Bool
+    func setNostrBlocked(_ pubkeyHexLowercased: String, isBlocked: Bool)
+    func getBlockedNostrPubkeys() -> Set<String>
+    
+    // MARK: Ephemeral Session Management
+    func registerEphemeralSession(peerID: PeerID, handshakeState: HandshakeState)
+    func updateHandshakeState(peerID: PeerID, state: HandshakeState)
+    
+    // MARK: Cleanup
+    func clearAllIdentityData()
+    func removeEphemeralSession(peerID: PeerID)
+    
+    // MARK: Verification
+    func setVerified(fingerprint: String, verified: Bool)
+    func isVerified(fingerprint: String) -> Bool
+    func getVerifiedFingerprints() -> Set<String>
+}
+
 /// Singleton manager for secure identity state persistence and retrieval.
 /// Provides thread-safe access to identity mappings with encryption at rest.
 /// All identity data is stored encrypted in the device Keychain for security.
-class SecureIdentityStateManager {
-    static let shared = SecureIdentityStateManager()
-    
-    private let keychain = KeychainManager.shared
+final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
+    private let keychain: KeychainManagerProtocol
     private let cacheKey = "bitchat.identityCache.v2"
     private let encryptionKeyName = "identityCacheEncryptionKey"
     
     // In-memory state
-    private var ephemeralSessions: [String: EphemeralIdentity] = [:]
+    private var ephemeralSessions: [PeerID: EphemeralIdentity] = [:]
     private var cryptographicIdentities: [String: CryptographicIdentity] = [:]
     private var cache: IdentityCache = IdentityCache()
     
-    // Pending actions before handshake
-    private var pendingActions: [String: PendingActions] = [:]
-    
     // Thread safety
     private let queue = DispatchQueue(label: "bitchat.identity.state", attributes: .concurrent)
     
@@ -122,14 +159,16 @@ class SecureIdentityStateManager {
     // Encryption key
     private let encryptionKey: SymmetricKey
     
-    private init() {
+    init(_ keychain: KeychainManagerProtocol) {
+        self.keychain = keychain
+        
         // Generate or retrieve encryption key from keychain
         let loadedKey: SymmetricKey
         
         // Try to load from keychain
         if let keyData = keychain.getIdentityKey(forKey: encryptionKeyName) {
             loadedKey = SymmetricKey(data: keyData)
-            SecureLogger.logKeyOperation("load", keyType: "identity cache encryption key", success: true)
+            SecureLogger.logKeyOperation(.load, keyType: "identity cache encryption key", success: true)
         }
         // Generate new key if needed
         else {
@@ -137,7 +176,7 @@ class SecureIdentityStateManager {
             let keyData = loadedKey.withUnsafeBytes { Data($0) }
             // Save to keychain
             let saved = keychain.saveIdentityKey(keyData, forKey: encryptionKeyName)
-            SecureLogger.logKeyOperation("generate", keyType: "identity cache encryption key", success: saved)
+            SecureLogger.logKeyOperation(.generate, keyType: "identity cache encryption key", success: saved)
         }
         
         self.encryptionKey = loadedKey
@@ -146,9 +185,13 @@ class SecureIdentityStateManager {
         loadIdentityCache()
     }
     
+    deinit {
+        forceSave()
+    }
+    
     // MARK: - Secure Loading/Saving
     
-    func loadIdentityCache() {
+    private func loadIdentityCache() {
         guard let encryptedData = keychain.getIdentityKey(forKey: cacheKey) else {
             // No existing cache, start fresh
             return
@@ -160,16 +203,11 @@ class SecureIdentityStateManager {
             cache = try JSONDecoder().decode(IdentityCache.self, from: decryptedData)
         } catch {
             // Log error but continue with empty cache
-            SecureLogger.logError(error, context: "Failed to load identity cache", category: SecureLogger.security)
+            SecureLogger.error(error, context: "Failed to load identity cache", category: .security)
         }
     }
     
-    deinit {
-        // Force save any pending changes
-        forceSave()
-    }
-    
-    func saveIdentityCache() {
+    private func saveIdentityCache() {
         // Mark that we need to save
         pendingSave = true
         
@@ -191,35 +229,17 @@ class SecureIdentityStateManager {
             let sealedBox = try AES.GCM.seal(data, using: encryptionKey)
             let saved = keychain.saveIdentityKey(sealedBox.combined!, forKey: cacheKey)
             if saved {
-                SecureLogger.log("Identity cache saved to keychain", category: SecureLogger.security, level: .debug)
+                SecureLogger.debug("Identity cache saved to keychain", category: .security)
             }
         } catch {
-            SecureLogger.logError(error, context: "Failed to save identity cache", category: SecureLogger.security)
+            SecureLogger.error(error, context: "Failed to save identity cache", category: .security)
         }
     }
     
     // Force immediate save (for app termination)
     func forceSave() {
         saveTimer?.invalidate()
-        if pendingSave {
-            performSave()
-        }
-    }
-    
-    // MARK: - Identity Resolution
-    
-    func resolveIdentity(peerID: String, claimedNickname: String) -> IdentityHint {
-        queue.sync {
-            // Check if we have candidates based on nickname
-            if let fingerprints = cache.nicknameIndex[claimedNickname] {
-                if fingerprints.count == 1 {
-                    return .likelyKnown(fingerprint: fingerprints.first!)
-                } else {
-                    return .ambiguous(candidates: fingerprints)
-                }
-            }
-            return .unknown
-        }
+        performSave()
     }
     
     // MARK: - Social Identity Management
@@ -301,38 +321,26 @@ class SecureIdentityStateManager {
         }
     }
 
-    /// Retrieve cryptographic identity by fingerprint
-    func getCryptographicIdentity(for fingerprint: String) -> CryptographicIdentity? {
-        queue.sync { cryptographicIdentities[fingerprint] }
-    }
-
     /// Find cryptographic identities whose fingerprint prefix matches a peerID (16-hex) short ID
-    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: String) -> [CryptographicIdentity] {
+    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: PeerID) -> [CryptographicIdentity] {
         queue.sync {
             // Defensive: ensure hex and correct length
-            guard peerID.count == 16, peerID.allSatisfy({ $0.isHexDigit }) else { return [] }
-            return cryptographicIdentities.values.filter { $0.fingerprint.hasPrefix(peerID) }
-        }
-    }
-    
-    func getAllSocialIdentities() -> [SocialIdentity] {
-        queue.sync {
-            return Array(cache.socialIdentities.values)
+            guard peerID.isShort else { return [] }
+            return cryptographicIdentities.values.filter { $0.fingerprint.hasPrefix(peerID.id) }
         }
     }
     
     func updateSocialIdentity(_ identity: SocialIdentity) {
         queue.async(flags: .barrier) {
+            let previousClaimedNickname = self.cache.socialIdentities[identity.fingerprint]?.claimedNickname
             self.cache.socialIdentities[identity.fingerprint] = identity
             
             // Update nickname index
-            if let existingIdentity = self.cache.socialIdentities[identity.fingerprint] {
-                // Remove old nickname from index if changed
-                if existingIdentity.claimedNickname != identity.claimedNickname {
-                    self.cache.nicknameIndex[existingIdentity.claimedNickname]?.remove(identity.fingerprint)
-                    if self.cache.nicknameIndex[existingIdentity.claimedNickname]?.isEmpty == true {
-                        self.cache.nicknameIndex.removeValue(forKey: existingIdentity.claimedNickname)
-                    }
+            if let previousClaimedNickname,
+               previousClaimedNickname != identity.claimedNickname {
+                self.cache.nicknameIndex[previousClaimedNickname]?.remove(identity.fingerprint)
+                if self.cache.nicknameIndex[previousClaimedNickname]?.isEmpty == true {
+                    self.cache.nicknameIndex.removeValue(forKey: previousClaimedNickname)
                 }
             }
             
@@ -395,7 +403,7 @@ class SecureIdentityStateManager {
     }
     
     func setBlocked(_ fingerprint: String, isBlocked: Bool) {
-        SecureLogger.log("User \(isBlocked ? "blocked" : "unblocked"): \(fingerprint)", category: SecureLogger.security, level: .info)
+        SecureLogger.info("User \(isBlocked ? "blocked" : "unblocked"): \(fingerprint)", category: .security)
         
         queue.async(flags: .barrier) {
             if var identity = self.cache.socialIdentities[fingerprint] {
@@ -447,7 +455,7 @@ class SecureIdentityStateManager {
     
     // MARK: - Ephemeral Session Management
     
-    func registerEphemeralSession(peerID: String, handshakeState: HandshakeState = .none) {
+    func registerEphemeralSession(peerID: PeerID, handshakeState: HandshakeState = .none) {
         queue.async(flags: .barrier) {
             self.ephemeralSessions[peerID] = EphemeralIdentity(
                 peerID: peerID,
@@ -457,7 +465,7 @@ class SecureIdentityStateManager {
         }
     }
     
-    func updateHandshakeState(peerID: String, state: HandshakeState) {
+    func updateHandshakeState(peerID: PeerID, state: HandshakeState) {
         queue.async(flags: .barrier) {
             self.ephemeralSessions[peerID]?.handshakeState = state
             
@@ -469,81 +477,32 @@ class SecureIdentityStateManager {
         }
     }
     
-    func getHandshakeState(peerID: String) -> HandshakeState? {
-        queue.sync {
-            return ephemeralSessions[peerID]?.handshakeState
-        }
-    }
-    
-    // MARK: - Pending Actions
-    
-    func setPendingAction(peerID: String, action: PendingActions) {
-        queue.async(flags: .barrier) {
-            self.pendingActions[peerID] = action
-        }
-    }
-    
-    func applyPendingActions(peerID: String, fingerprint: String) {
-        queue.async(flags: .barrier) {
-            guard let actions = self.pendingActions[peerID] else { return }
-            
-            // Get or create social identity
-            var identity = self.cache.socialIdentities[fingerprint] ?? SocialIdentity(
-                fingerprint: fingerprint,
-                localPetname: nil,
-                claimedNickname: "Unknown",
-                trustLevel: .unknown,
-                isFavorite: false,
-                isBlocked: false,
-                notes: nil
-            )
-            
-            // Apply pending actions
-            if let toggleFavorite = actions.toggleFavorite {
-                identity.isFavorite = toggleFavorite
-            }
-            if let trustLevel = actions.setTrustLevel {
-                identity.trustLevel = trustLevel
-            }
-            if let petname = actions.setPetname {
-                identity.localPetname = petname
-            }
-            
-            // Save updated identity
-            self.cache.socialIdentities[fingerprint] = identity
-            self.pendingActions.removeValue(forKey: peerID)
-            self.saveIdentityCache()
-        }
-    }
-    
     // MARK: - Cleanup
     
     func clearAllIdentityData() {
-        SecureLogger.log("Clearing all identity data", category: SecureLogger.security, level: .warning)
+        SecureLogger.warning("Clearing all identity data", category: .security)
         
         queue.async(flags: .barrier) {
             self.cache = IdentityCache()
             self.ephemeralSessions.removeAll()
             self.cryptographicIdentities.removeAll()
-            self.pendingActions.removeAll()
             
             // Delete from keychain
             let deleted = self.keychain.deleteIdentityKey(forKey: self.cacheKey)
-            SecureLogger.logKeyOperation("delete", keyType: "identity cache", success: deleted)
+            SecureLogger.logKeyOperation(.delete, keyType: "identity cache", success: deleted)
         }
     }
     
-    func removeEphemeralSession(peerID: String) {
+    func removeEphemeralSession(peerID: PeerID) {
         queue.async(flags: .barrier) {
             self.ephemeralSessions.removeValue(forKey: peerID)
-            self.pendingActions.removeValue(forKey: peerID)
         }
     }
     
     // MARK: - Verification
     
     func setVerified(fingerprint: String, verified: Bool) {
-        SecureLogger.log("Fingerprint \(verified ? "verified" : "unverified"): \(fingerprint)", category: SecureLogger.security, level: .info)
+        SecureLogger.info("Fingerprint \(verified ? "verified" : "unverified"): \(fingerprint)", category: .security)
         
         queue.async(flags: .barrier) {
             if verified {
@@ -573,4 +532,16 @@ class SecureIdentityStateManager {
             return cache.verifiedFingerprints
         }
     }
+
+    var debugNicknameIndex: [String: Set<String>] {
+        queue.sync { cache.nicknameIndex }
+    }
+
+    func debugEphemeralSession(for peerID: PeerID) -> EphemeralIdentity? {
+        queue.sync { ephemeralSessions[peerID] }
+    }
+
+    func debugLastInteraction(for fingerprint: String) -> Date? {
+        queue.sync { cache.lastInteractions[fingerprint] }
+    }
 }

bitchat/Info.plist

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

bitchat/Models/BitchatMessage+Media.swift

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

bitchat/Models/BitchatPeer.swift

@@ -1,9 +1,10 @@
 import Foundation
 import CoreBluetooth
+import BitFoundation
 
 /// Represents a peer in the BitChat network with all associated metadata
-struct BitchatPeer: Identifiable, Equatable {
-    let id: String // Hex-encoded peer ID
+struct BitchatPeer: Equatable {
+    let peerID: PeerID // Hex-encoded peer ID
     let noisePublicKey: Data
     let nickname: String
     let lastSeen: Date
@@ -51,7 +52,7 @@ struct BitchatPeer: Identifiable, Equatable {
     
     // Display helpers
     var displayName: String {
-        nickname.isEmpty ? String(id.prefix(8)) : nickname
+        nickname.isEmpty ? String(peerID.id.prefix(8)) : nickname
     }
     
     var statusIcon: String {
@@ -73,14 +74,14 @@ struct BitchatPeer: Identifiable, Equatable {
     
     // Initialize from mesh service data
     init(
-        id: String,
+        peerID: PeerID,
         noisePublicKey: Data,
         nickname: String,
         lastSeen: Date = Date(),
         isConnected: Bool = false,
         isReachable: Bool = false
     ) {
-        self.id = id
+        self.peerID = peerID
         self.noisePublicKey = noisePublicKey
         self.nickname = nickname
         self.lastSeen = lastSeen
@@ -93,8 +94,6 @@ struct BitchatPeer: Identifiable, Equatable {
     }
     
     static func == (lhs: BitchatPeer, rhs: BitchatPeer) -> Bool {
-        lhs.id == rhs.id
+        lhs.peerID == rhs.peerID
     }
 }
-
-//

bitchat/Models/CommandInfo.swift

@@ -0,0 +1,58 @@
+//
+// CommandsInfo.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+// MARK: - CommandInfo Enum
+
+enum CommandInfo: String, Identifiable {
+    case block
+    case clear
+    case hug
+    case message = "dm"
+    case slap
+    case unblock
+    case who
+    case favorite
+    case unfavorite
+    
+    var id: String { rawValue }
+    
+    var alias: String { "/" + rawValue }
+    
+    var placeholder: String? {
+        switch self {
+        case .block, .hug, .message, .slap, .unblock, .favorite, .unfavorite:
+            return "<" + String(localized: "content.input.nickname_placeholder") + ">"
+        case .clear, .who:
+            return nil
+        }
+    }
+    
+    var description: String {
+        switch self {
+        case .block:        String(localized: "content.commands.block")
+        case .clear:        String(localized: "content.commands.clear")
+        case .hug:          String(localized: "content.commands.hug")
+        case .message:      String(localized: "content.commands.message")
+        case .slap:         String(localized: "content.commands.slap")
+        case .unblock:      String(localized: "content.commands.unblock")
+        case .who:          String(localized: "content.commands.who")
+        case .favorite:     String(localized: "content.commands.favorite")
+        case .unfavorite:   String(localized: "content.commands.unfavorite")
+        }
+    }
+    
+    static func all(isGeoPublic: Bool, isGeoDM: Bool) -> [CommandInfo] {
+        let baseCommands: [CommandInfo] = [.block, .unblock, .clear, .hug, .message, .slap, .who]
+        if isGeoPublic || isGeoDM {
+            return baseCommands + [.favorite, .unfavorite]
+        }
+        return baseCommands
+    }
+}

bitchat/Models/NoisePayload.swift

@@ -0,0 +1,41 @@
+//
+// NoisePayload.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+/// Helper to create typed Noise payloads
+struct NoisePayload {
+    let type: NoisePayloadType
+    let data: Data
+    
+    /// Encode payload with type prefix
+    func encode() -> Data {
+        var encoded = Data()
+        encoded.append(type.rawValue)
+        encoded.append(data)
+        return encoded
+    }
+    
+    /// Decode payload from data
+    static func decode(_ data: Data) -> NoisePayload? {
+        // Ensure we have at least 1 byte for the type
+        guard !data.isEmpty else {
+            return nil
+        }
+        
+        // Safely get the first byte
+        let firstByte = data[data.startIndex]
+        guard let type = NoisePayloadType(rawValue: firstByte) else {
+            return nil
+        }
+        
+        // Create a proper Data copy (not a subsequence) for thread safety
+        let payloadData = data.count > 1 ? Data(data.dropFirst()) : Data()
+        return NoisePayload(type: type, data: payloadData)
+    }
+}

bitchat/Models/ReadReceipt.swift

@@ -0,0 +1,96 @@
+//
+// ReadReceipt.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+import BitFoundation
+
+struct ReadReceipt: Codable {
+    let originalMessageID: String
+    let receiptID: String
+    var readerID: PeerID  // Who read it
+    let readerNickname: String
+    let timestamp: Date
+    
+    init(originalMessageID: String, readerID: PeerID, readerNickname: String) {
+        self.originalMessageID = originalMessageID
+        self.receiptID = UUID().uuidString
+        self.readerID = readerID
+        self.readerNickname = readerNickname
+        self.timestamp = Date()
+    }
+    
+    // For binary decoding
+    private init(originalMessageID: String, receiptID: String, readerID: PeerID, readerNickname: String, timestamp: Date) {
+        self.originalMessageID = originalMessageID
+        self.receiptID = receiptID
+        self.readerID = readerID
+        self.readerNickname = readerNickname
+        self.timestamp = timestamp
+    }
+    
+    func encode() -> Data? {
+        try? JSONEncoder().encode(self)
+    }
+    
+    static func decode(from data: Data) -> ReadReceipt? {
+        try? JSONDecoder().decode(ReadReceipt.self, from: data)
+    }
+    
+    // MARK: - Binary Encoding
+    
+    func toBinaryData() -> Data {
+        var data = Data()
+        data.appendUUID(originalMessageID)
+        data.appendUUID(receiptID)
+        // ReaderID as 8-byte hex string
+        var readerData = Data()
+        var tempID = readerID.id
+        while tempID.count >= 2 && readerData.count < 8 {
+            let hexByte = String(tempID.prefix(2))
+            if let byte = UInt8(hexByte, radix: 16) {
+                readerData.append(byte)
+            }
+            tempID = String(tempID.dropFirst(2))
+        }
+        while readerData.count < 8 {
+            readerData.append(0)
+        }
+        data.append(readerData)
+        data.appendDate(timestamp)
+        data.appendString(readerNickname)
+        return data
+    }
+    
+    static func fromBinaryData(_ data: Data) -> ReadReceipt? {
+        // Create defensive copy
+        let dataCopy = Data(data)
+        
+        // Minimum size: 2 UUIDs (32) + readerID (8) + timestamp (8) + min nickname
+        guard dataCopy.count >= 49 else { return nil }
+        
+        var offset = 0
+        
+        guard let originalMessageID = dataCopy.readUUID(at: &offset),
+              let receiptID = dataCopy.readUUID(at: &offset) else { return nil }
+        
+        guard let readerIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
+        let readerID = PeerID(hexData: readerIDData)
+        guard readerID.isValid else { return nil }
+        
+        guard let timestamp = dataCopy.readDate(at: &offset),
+              InputValidator.validateTimestamp(timestamp),
+              let readerNicknameRaw = dataCopy.readString(at: &offset),
+              let readerNickname = InputValidator.validateNickname(readerNicknameRaw) else { return nil }
+        
+        return ReadReceipt(originalMessageID: originalMessageID,
+                          receiptID: receiptID,
+                          readerID: readerID,
+                          readerNickname: readerNickname,
+                          timestamp: timestamp)
+    }
+}

bitchat/Models/RequestSyncPacket.swift

@@ -0,0 +1,102 @@
+import Foundation
+
+// REQUEST_SYNC payload TLV (type, length16, value)
+//  - 0x01: P (uint8) — Golomb-Rice parameter
+//  - 0x02: M (uint32, big-endian) — hash range (N * 2^P)
+//  - 0x03: data (opaque) — GR bitstream bytes (MSB-first)
+struct RequestSyncPacket {
+    let p: Int
+    let m: UInt32
+    let data: Data
+    let types: SyncTypeFlags?
+    let sinceTimestamp: UInt64?
+    let fragmentIdFilter: String?
+
+    init(p: Int, m: UInt32, data: Data, types: SyncTypeFlags? = nil, sinceTimestamp: UInt64? = nil, fragmentIdFilter: String? = nil) {
+        self.p = p
+        self.m = m
+        self.data = data
+        self.types = types
+        self.sinceTimestamp = sinceTimestamp
+        self.fragmentIdFilter = fragmentIdFilter
+    }
+
+    func encode() -> Data {
+        var out = Data()
+        func putTLV(_ t: UInt8, _ v: Data) {
+            out.append(t)
+            let len = UInt16(v.count)
+            out.append(UInt8((len >> 8) & 0xFF))
+            out.append(UInt8(len & 0xFF))
+            out.append(v)
+        }
+        // P
+        putTLV(0x01, Data([UInt8(p & 0xFF)]))
+        // M (uint32)
+        var mBE = m.bigEndian
+        putTLV(0x02, withUnsafeBytes(of: &mBE) { Data($0) })
+        // data
+        putTLV(0x03, data)
+        if let typesData = types?.toData() {
+            putTLV(0x04, typesData)
+        }
+        if let ts = sinceTimestamp {
+            var tsBE = ts.bigEndian
+            putTLV(0x05, withUnsafeBytes(of: &tsBE) { Data($0) })
+        }
+        if let fid = fragmentIdFilter, let fidData = fid.data(using: .utf8) {
+            putTLV(0x06, fidData)
+        }
+        return out
+    }
+    
+    static func decode(from data: Data, maxAcceptBytes: Int = 1024) -> RequestSyncPacket? {
+        var off = 0
+        var p: Int? = nil
+        var m: UInt32? = nil
+        var payload: Data? = nil
+        var types: SyncTypeFlags? = nil
+        var sinceTimestamp: UInt64? = nil
+        var fragmentIdFilter: String? = nil
+
+        while off + 3 <= data.count {
+            let t = Int(data[off]); off += 1
+            guard off + 2 <= data.count else { return nil }
+            let len = (Int(data[off]) << 8) | Int(data[off+1]); off += 2
+            guard off + len <= data.count else { return nil }
+            let v = data.subdata(in: off..<(off+len)); off += len
+            switch t {
+            case 0x01:
+                if v.count == 1 { p = Int(v[0]) }
+            case 0x02:
+                if v.count == 4 {
+                    var mm: UInt32 = 0
+                    for b in v { mm = (mm << 8) | UInt32(b) }
+                    m = mm
+                }
+            case 0x03:
+                if v.count > maxAcceptBytes { return nil }
+                payload = v
+            case 0x04:
+                if let decoded = SyncTypeFlags.decode(v) {
+                    types = decoded
+                }
+            case 0x05:
+                if v.count == 8 {
+                    var ts: UInt64 = 0
+                    for b in v { ts = (ts << 8) | UInt64(b) }
+                    sinceTimestamp = ts
+                }
+            case 0x06:
+                if let fid = String(data: v, encoding: .utf8) {
+                    fragmentIdFilter = fid
+                }
+            default:
+                break // forward compatible; ignore unknown TLVs
+            }
+        }
+
+        guard let pp = p, let mm = m, let dd = payload, pp >= 1, mm > 0 else { return nil }
+        return RequestSyncPacket(p: pp, m: mm, data: dd, types: types, sinceTimestamp: sinceTimestamp, fragmentIdFilter: fragmentIdFilter)
+    }
+}

bitchat/Noise/NoiseHandshakeCoordinator.swift

@@ -1,369 +0,0 @@
-//
-// NoiseHandshakeCoordinator.swift
-// bitchat
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import Foundation
-
-/// Coordinates Noise handshakes to prevent race conditions and ensure reliable encryption establishment
-class NoiseHandshakeCoordinator {
-    
-    // MARK: - Handshake State
-    
-    enum HandshakeState: Equatable {
-        case idle
-        case waitingToInitiate(since: Date)
-        case initiating(attempt: Int, lastAttempt: Date)
-        case responding(since: Date)
-        case waitingForResponse(messagesSent: [Data], timeout: Date)
-        case established(since: Date)
-        case failed(reason: String, canRetry: Bool, lastAttempt: Date)
-        
-        var isActive: Bool {
-            switch self {
-            case .idle, .established, .failed:
-                return false
-            default:
-                return true
-            }
-        }
-    }
-    
-    // MARK: - Properties
-    
-    private var handshakeStates: [String: HandshakeState] = [:]
-    private var handshakeQueue = DispatchQueue(label: "chat.bitchat.noise.handshake", attributes: .concurrent)
-    
-    // Configuration
-    private let maxHandshakeAttempts = 3
-    private let handshakeTimeout: TimeInterval = 10.0
-    private let retryDelay: TimeInterval = 2.0
-    private let minTimeBetweenHandshakes: TimeInterval = 1.0 // Reduced from 5.0 for faster recovery
-    private let establishedSessionTTL: TimeInterval = 300.0 // 5 minutes - sessions older than this can be cleaned up
-    private let maxEstablishedSessions = 50 // Limit total established sessions
-    
-    // Track handshake messages to detect duplicates
-    private var processedHandshakeMessages: Set<Data> = []
-    private let messageHistoryLimit = 100
-    
-    // MARK: - Role Determination
-    
-    /// Deterministically determine who should initiate the handshake
-    /// Lower peer ID becomes the initiator to prevent simultaneous attempts
-    func determineHandshakeRole(myPeerID: String, remotePeerID: String) -> NoiseRole {
-        // Use simple string comparison for deterministic ordering
-        return myPeerID < remotePeerID ? .initiator : .responder
-    }
-    
-    /// Check if we should initiate handshake with a peer
-    func shouldInitiateHandshake(myPeerID: String, remotePeerID: String, forceIfStale: Bool = false) -> Bool {
-        return handshakeQueue.sync {
-            // Check if we're already in an active handshake
-            if let state = handshakeStates[remotePeerID], state.isActive {
-                // Check if the handshake is stale and we should force a new one
-                if forceIfStale {
-                    switch state {
-                    case .initiating(_, let lastAttempt):
-                        if Date().timeIntervalSince(lastAttempt) > handshakeTimeout {
-                            SecureLogger.log("Forcing new handshake with \(remotePeerID) - previous stuck in initiating", 
-                                           category: SecureLogger.handshake, level: .warning)
-                            return true
-                        }
-                    default:
-                        break
-                    }
-                }
-                
-                SecureLogger.log("Already in active handshake with \(remotePeerID), state: \(state)", 
-                               category: SecureLogger.handshake, level: .debug)
-                return false
-            }
-            
-            // Check role
-            let role = determineHandshakeRole(myPeerID: myPeerID, remotePeerID: remotePeerID)
-            if role != .initiator {
-                return false
-            }
-            
-            // Check if we've failed recently and can't retry yet
-            if case .failed(_, let canRetry, let lastAttempt) = handshakeStates[remotePeerID] {
-                if !canRetry {
-                    return false
-                }
-                if Date().timeIntervalSince(lastAttempt) < retryDelay {
-                    return false
-                }
-            }
-            
-            return true
-        }
-    }
-    
-    /// Record that we're initiating a handshake
-    func recordHandshakeInitiation(peerID: String) {
-        handshakeQueue.async(flags: .barrier) {
-            let attempt = self.getCurrentAttempt(for: peerID) + 1
-            self.handshakeStates[peerID] = .initiating(attempt: attempt, lastAttempt: Date())
-            SecureLogger.log("Recording handshake initiation with \(peerID), attempt \(attempt)", 
-                           category: SecureLogger.handshake, level: .info)
-        }
-    }
-    
-    /// Record that we're responding to a handshake
-    func recordHandshakeResponse(peerID: String) {
-        handshakeQueue.async(flags: .barrier) {
-            self.handshakeStates[peerID] = .responding(since: Date())
-            SecureLogger.log("Recording handshake response to \(peerID)", 
-                           category: SecureLogger.handshake, level: .info)
-        }
-    }
-    
-    /// Record successful handshake completion
-    func recordHandshakeSuccess(peerID: String) {
-        handshakeQueue.async(flags: .barrier) {
-            self.handshakeStates[peerID] = .established(since: Date())
-            SecureLogger.log("Handshake successfully established with \(peerID)", 
-                           category: SecureLogger.handshake, level: .info)
-        }
-    }
-    
-    /// Record handshake failure
-    func recordHandshakeFailure(peerID: String, reason: String) {
-        handshakeQueue.async(flags: .barrier) {
-            let attempts = self.getCurrentAttempt(for: peerID)
-            let canRetry = attempts < self.maxHandshakeAttempts
-            self.handshakeStates[peerID] = .failed(reason: reason, canRetry: canRetry, lastAttempt: Date())
-            SecureLogger.log("Handshake failed with \(peerID): \(reason), canRetry: \(canRetry)", 
-                           category: SecureLogger.handshake, level: .warning)
-        }
-    }
-    
-    /// Check if we should accept an incoming handshake initiation
-    func shouldAcceptHandshakeInitiation(myPeerID: String, remotePeerID: String) -> Bool {
-        return handshakeQueue.sync {
-            // If we're already established, reject new handshakes
-            if case .established = handshakeStates[remotePeerID] {
-                SecureLogger.log("Rejecting handshake from \(remotePeerID) - already established", 
-                               category: SecureLogger.handshake, level: .debug)
-                return false
-            }
-            
-            let role = determineHandshakeRole(myPeerID: myPeerID, remotePeerID: remotePeerID)
-            
-            // If we're the initiator and already initiating, this is a race condition
-            if role == .initiator {
-                if case .initiating = handshakeStates[remotePeerID] {
-                    // They shouldn't be initiating, but accept it to recover from race condition
-                    SecureLogger.log("Accepting handshake from \(remotePeerID) despite being initiator (race condition recovery)", 
-                                   category: SecureLogger.handshake, level: .warning)
-                    return true
-                }
-            }
-            
-            // If we're the responder, we should accept
-            return true
-        }
-    }
-    
-    /// Check if this is a duplicate handshake message
-    func isDuplicateHandshakeMessage(_ data: Data) -> Bool {
-        return handshakeQueue.sync {
-            if processedHandshakeMessages.contains(data) {
-                return true
-            }
-            
-            // Add to processed messages with size limit
-            if processedHandshakeMessages.count >= messageHistoryLimit {
-                processedHandshakeMessages.removeAll()
-            }
-            processedHandshakeMessages.insert(data)
-            return false
-        }
-    }
-    
-    /// Get time to wait before next handshake attempt
-    func getRetryDelay(for peerID: String) -> TimeInterval? {
-        return handshakeQueue.sync {
-            guard let state = handshakeStates[peerID] else { return nil }
-            
-            switch state {
-            case .failed(_, let canRetry, let lastAttempt):
-                if !canRetry { return nil }
-                let timeSinceFailure = Date().timeIntervalSince(lastAttempt)
-                if timeSinceFailure >= retryDelay {
-                    return 0
-                }
-                return retryDelay - timeSinceFailure
-                
-            case .initiating(_, let lastAttempt):
-                let timeSinceAttempt = Date().timeIntervalSince(lastAttempt)
-                if timeSinceAttempt >= minTimeBetweenHandshakes {
-                    return 0
-                }
-                return minTimeBetweenHandshakes - timeSinceAttempt
-                
-            default:
-                return nil
-            }
-        }
-    }
-    
-    /// Reset handshake state for a peer
-    func resetHandshakeState(for peerID: String) {
-        handshakeQueue.async(flags: .barrier) {
-            self.handshakeStates.removeValue(forKey: peerID)
-            SecureLogger.log("Reset handshake state for \(peerID)", 
-                           category: SecureLogger.handshake, level: .debug)
-        }
-    }
-    
-    /// Clean up stale handshake states and old established sessions
-    func cleanupStaleHandshakes(staleTimeout: TimeInterval = 30.0) -> [String] {
-        return handshakeQueue.sync {
-            let now = Date()
-            var stalePeerIDs: [String] = []
-            var establishedSessions: [(peerID: String, since: Date)] = []
-            
-            for (peerID, state) in handshakeStates {
-                var isStale = false
-                
-                switch state {
-                case .initiating(_, let lastAttempt):
-                    if now.timeIntervalSince(lastAttempt) > staleTimeout {
-                        isStale = true
-                    }
-                case .responding(let since):
-                    if now.timeIntervalSince(since) > staleTimeout {
-                        isStale = true
-                    }
-                case .waitingForResponse(_, let timeout):
-                    if now > timeout {
-                        isStale = true
-                    }
-                case .established(let since):
-                    // Track established sessions for potential cleanup
-                    establishedSessions.append((peerID, since))
-                    // Clean up very old established sessions
-                    if now.timeIntervalSince(since) > establishedSessionTTL {
-                        isStale = true
-                    }
-                default:
-                    break
-                }
-                
-                if isStale {
-                    stalePeerIDs.append(peerID)
-                    SecureLogger.log("Found stale handshake state for \(peerID): \(state)", 
-                                   category: SecureLogger.handshake, level: .warning)
-                }
-            }
-            
-            // If we have too many established sessions, clean up the oldest ones
-            if establishedSessions.count > maxEstablishedSessions {
-                // Sort by age (oldest first)
-                let sortedSessions = establishedSessions.sorted { $0.since < $1.since }
-                let sessionsToRemove = sortedSessions.count - maxEstablishedSessions
-                
-                for i in 0..<sessionsToRemove {
-                    let peerID = sortedSessions[i].peerID
-                    stalePeerIDs.append(peerID)
-                    SecureLogger.log("Removing old established session for \(peerID) to maintain session limit", 
-                                   category: SecureLogger.handshake, level: .info)
-                }
-            }
-            
-            // Clean up stale states
-            for peerID in stalePeerIDs {
-                handshakeStates.removeValue(forKey: peerID)
-            }
-            
-            if !stalePeerIDs.isEmpty {
-                SecureLogger.log("Cleaned up \(stalePeerIDs.count) stale handshake states", 
-                               category: SecureLogger.handshake, level: .info)
-            }
-            
-            return stalePeerIDs
-        }
-    }
-    
-    /// Get current handshake state
-    func getHandshakeState(for peerID: String) -> HandshakeState {
-        return handshakeQueue.sync {
-            return handshakeStates[peerID] ?? .idle
-        }
-    }
-    
-    /// Get current retry count for a peer
-    func getRetryCount(for peerID: String) -> Int {
-        return handshakeQueue.sync {
-            switch handshakeStates[peerID] {
-            case .initiating(let attempt, _):
-                return attempt - 1  // Attempts start at 1, retries start at 0
-            default:
-                return 0
-            }
-        }
-    }
-    
-    /// Increment retry count for a peer
-    func incrementRetryCount(for peerID: String) {
-        handshakeQueue.async(flags: .barrier) {
-            let currentAttempt = self.getCurrentAttempt(for: peerID)
-            self.handshakeStates[peerID] = .initiating(attempt: currentAttempt + 1, lastAttempt: Date())
-        }
-    }
-    
-    // MARK: - Private Helpers
-    
-    private func getCurrentAttempt(for peerID: String) -> Int {
-        switch handshakeStates[peerID] {
-        case .initiating(let attempt, _):
-            return attempt
-        case .failed(_, _, _):
-            // Count previous attempts
-            return 1 // Simplified for now
-        default:
-            return 0
-        }
-    }
-    
-    /// Log current handshake states for debugging
-    func logHandshakeStates() {
-        handshakeQueue.sync {
-            SecureLogger.log("=== Handshake States ===", category: SecureLogger.handshake, level: .debug)
-            for (peerID, state) in handshakeStates {
-                let stateDesc: String
-                switch state {
-                case .idle:
-                    stateDesc = "idle"
-                case .waitingToInitiate(let since):
-                    stateDesc = "waiting to initiate (since \(since))"
-                case .initiating(let attempt, let lastAttempt):
-                    stateDesc = "initiating (attempt \(attempt), last: \(lastAttempt))"
-                case .responding(let since):
-                    stateDesc = "responding (since: \(since))"
-                case .waitingForResponse(let messages, let timeout):
-                    stateDesc = "waiting for response (\(messages.count) messages, timeout: \(timeout))"
-                case .established(let since):
-                    stateDesc = "established (since \(since))"
-                case .failed(let reason, let canRetry, let lastAttempt):
-                    stateDesc = "failed: \(reason) (canRetry: \(canRetry), last: \(lastAttempt))"
-                }
-                SecureLogger.log("  \(peerID): \(stateDesc)", category: SecureLogger.handshake, level: .debug)
-            }
-            SecureLogger.log("========================", category: SecureLogger.handshake, level: .debug)
-        }
-    }
-    
-    /// Clear all handshake states - used during panic mode
-    func clearAllHandshakeStates() {
-        handshakeQueue.async(flags: .barrier) {
-            SecureLogger.log("Clearing all handshake states for panic mode", category: SecureLogger.handshake, level: .warning)
-            self.handshakeStates.removeAll()
-            self.processedHandshakeMessages.removeAll()
-        }
-    }
-}

bitchat/Noise/NoiseSecurityConsiderations.swift

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

bitchat/Noise/NoiseSession.swift

@@ -1,477 +0,0 @@
-//
-// NoiseSession.swift
-// bitchat
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-import Foundation
-import CryptoKit
-import os.log
-
-// MARK: - Noise Session State
-
-enum NoiseSessionState: Equatable {
-    case uninitialized
-    case handshaking
-    case established
-    case failed(Error)
-    
-    static func == (lhs: NoiseSessionState, rhs: NoiseSessionState) -> Bool {
-        switch (lhs, rhs) {
-        case (.uninitialized, .uninitialized),
-             (.handshaking, .handshaking),
-             (.established, .established):
-            return true
-        case (.failed, .failed):
-            return true // We don't compare the errors
-        default:
-            return false
-        }
-    }
-}
-
-// MARK: - Noise Session
-
-class NoiseSession {
-    let peerID: String
-    let role: NoiseRole
-    private var state: NoiseSessionState = .uninitialized
-    private var handshakeState: NoiseHandshakeState?
-    private var sendCipher: NoiseCipherState?
-    private var receiveCipher: NoiseCipherState?
-    
-    // Keys
-    private let localStaticKey: Curve25519.KeyAgreement.PrivateKey
-    private var remoteStaticPublicKey: Curve25519.KeyAgreement.PublicKey?
-    
-    // Handshake messages for retransmission
-    private var sentHandshakeMessages: [Data] = []
-    private var handshakeHash: Data?
-    
-    // Thread safety
-    private let sessionQueue = DispatchQueue(label: "chat.bitchat.noise.session", attributes: .concurrent)
-    
-    init(peerID: String, role: NoiseRole, localStaticKey: Curve25519.KeyAgreement.PrivateKey, remoteStaticKey: Curve25519.KeyAgreement.PublicKey? = nil) {
-        self.peerID = peerID
-        self.role = role
-        self.localStaticKey = localStaticKey
-        self.remoteStaticPublicKey = remoteStaticKey
-    }
-    
-    // MARK: - Handshake
-    
-    func startHandshake() throws -> Data {
-        return try sessionQueue.sync(flags: .barrier) {
-            guard case .uninitialized = state else {
-                throw NoiseSessionError.invalidState
-            }
-            
-            // For XX pattern, we don't need remote static key upfront
-            handshakeState = NoiseHandshakeState(
-                role: role,
-                pattern: .XX,
-                localStaticKey: localStaticKey,
-                remoteStaticKey: nil
-            )
-            
-            state = .handshaking
-            
-            // Only initiator writes the first message
-            if role == .initiator {
-                let message = try handshakeState!.writeMessage()
-                sentHandshakeMessages.append(message)
-                return message
-            } else {
-                // Responder doesn't send first message in XX pattern
-                return Data()
-            }
-        }
-    }
-    
-    func processHandshakeMessage(_ message: Data) throws -> Data? {
-        return try sessionQueue.sync(flags: .barrier) {
-            SecureLogger.log("NoiseSession[\(peerID)]: Processing handshake message, current state: \(state), role: \(role)", category: SecureLogger.noise, level: .debug)
-            
-            // Initialize handshake state if needed (for responders)
-            if state == .uninitialized && role == .responder {
-                handshakeState = NoiseHandshakeState(
-                    role: role,
-                    pattern: .XX,
-                    localStaticKey: localStaticKey,
-                    remoteStaticKey: nil
-                )
-                state = .handshaking
-                SecureLogger.log("NoiseSession[\(peerID)]: Initialized handshake state for responder", category: SecureLogger.noise, level: .debug)
-            }
-            
-            guard case .handshaking = state, let handshake = handshakeState else {
-                throw NoiseSessionError.invalidState
-            }
-            
-            // Process incoming message
-            _ = try handshake.readMessage(message)
-            SecureLogger.log("NoiseSession[\(peerID)]: Read handshake message, checking if complete", category: SecureLogger.noise, level: .debug)
-            
-            // Check if handshake is complete
-            if handshake.isHandshakeComplete() {
-                // Get transport ciphers
-                let (send, receive) = try handshake.getTransportCiphers()
-                sendCipher = send
-                receiveCipher = receive
-                
-                // Store remote static key
-                remoteStaticPublicKey = handshake.getRemoteStaticPublicKey()
-                
-                // Store handshake hash for channel binding
-                handshakeHash = handshake.getHandshakeHash()
-                
-                state = .established
-                handshakeState = nil // Clear handshake state
-                
-                SecureLogger.log("NoiseSession[\(peerID)]: Handshake complete (no response needed), transitioning to established", category: SecureLogger.noise, level: .debug)
-                SecureLogger.logSecurityEvent(.handshakeCompleted(peerID: peerID))
-                
-                return nil
-            } else {
-                // Generate response
-                let response = try handshake.writeMessage()
-                sentHandshakeMessages.append(response)
-                SecureLogger.log("NoiseSession[\(peerID)]: Generated handshake response of size \(response.count)", category: SecureLogger.noise, level: .debug)
-                
-                // Check if handshake is complete after writing
-                if handshake.isHandshakeComplete() {
-                    // Get transport ciphers
-                    let (send, receive) = try handshake.getTransportCiphers()
-                    sendCipher = send
-                    receiveCipher = receive
-                    
-                    // Store remote static key
-                    remoteStaticPublicKey = handshake.getRemoteStaticPublicKey()
-                    
-                    // Store handshake hash for channel binding
-                    handshakeHash = handshake.getHandshakeHash()
-                    
-                    state = .established
-                    handshakeState = nil // Clear handshake state
-                    
-                    SecureLogger.log("NoiseSession[\(peerID)]: Handshake complete after writing response, transitioning to established", category: SecureLogger.noise, level: .debug)
-                    SecureLogger.logSecurityEvent(.handshakeCompleted(peerID: peerID))
-                }
-                
-                return response
-            }
-        }
-    }
-    
-    // MARK: - Transport
-    
-    func encrypt(_ plaintext: Data) throws -> Data {
-        return try sessionQueue.sync(flags: .barrier) {
-            guard case .established = state, let cipher = sendCipher else {
-                throw NoiseSessionError.notEstablished
-            }
-            
-            return try cipher.encrypt(plaintext: plaintext)
-        }
-    }
-    
-    func decrypt(_ ciphertext: Data) throws -> Data {
-        return try sessionQueue.sync(flags: .barrier) {
-            guard case .established = state, let cipher = receiveCipher else {
-                throw NoiseSessionError.notEstablished
-            }
-            
-            return try cipher.decrypt(ciphertext: ciphertext)
-        }
-    }
-    
-    // MARK: - State Management
-    
-    func getState() -> NoiseSessionState {
-        return sessionQueue.sync {
-            return state
-        }
-    }
-    
-    func isEstablished() -> Bool {
-        return sessionQueue.sync {
-            if case .established = state {
-                return true
-            }
-            return false
-        }
-    }
-    
-    func getRemoteStaticPublicKey() -> Curve25519.KeyAgreement.PublicKey? {
-        return sessionQueue.sync {
-            return remoteStaticPublicKey
-        }
-    }
-    
-    func getHandshakeHash() -> Data? {
-        return sessionQueue.sync {
-            return handshakeHash
-        }
-    }
-    
-    func reset() {
-        sessionQueue.sync(flags: .barrier) {
-            let wasEstablished = state == .established
-            state = .uninitialized
-            handshakeState = nil
-            
-            // Clear sensitive cipher states
-            sendCipher?.clearSensitiveData()
-            receiveCipher?.clearSensitiveData()
-            sendCipher = nil
-            receiveCipher = nil
-            
-            // Clear sent handshake messages
-            for i in 0..<sentHandshakeMessages.count {
-                var message = sentHandshakeMessages[i]
-                KeychainManager.secureClear(&message)
-            }
-            sentHandshakeMessages.removeAll()
-            
-            // Clear handshake hash
-            if var hash = handshakeHash {
-                KeychainManager.secureClear(&hash)
-            }
-            handshakeHash = nil
-            
-            if wasEstablished {
-                SecureLogger.logSecurityEvent(.sessionExpired(peerID: peerID))
-            }
-        }
-    }
-}
-
-// MARK: - Session Manager
-
-class NoiseSessionManager {
-    private var sessions: [String: NoiseSession] = [:]
-    private let localStaticKey: Curve25519.KeyAgreement.PrivateKey
-    private let managerQueue = DispatchQueue(label: "chat.bitchat.noise.manager", attributes: .concurrent)
-    
-    // Callbacks
-    var onSessionEstablished: ((String, Curve25519.KeyAgreement.PublicKey) -> Void)?
-    var onSessionFailed: ((String, Error) -> Void)?
-    
-    init(localStaticKey: Curve25519.KeyAgreement.PrivateKey) {
-        self.localStaticKey = localStaticKey
-    }
-    
-    // MARK: - Session Management
-    
-    func createSession(for peerID: String, role: NoiseRole) -> NoiseSession {
-        return managerQueue.sync(flags: .barrier) {
-            let session = SecureNoiseSession(
-                peerID: peerID,
-                role: role,
-                localStaticKey: localStaticKey
-            )
-            sessions[peerID] = session
-            return session
-        }
-    }
-    
-    func getSession(for peerID: String) -> NoiseSession? {
-        return managerQueue.sync {
-            return sessions[peerID]
-        }
-    }
-    
-    func removeSession(for peerID: String) {
-        managerQueue.sync(flags: .barrier) {
-            if let session = sessions[peerID] {
-                if session.isEstablished() {
-                    SecureLogger.logSecurityEvent(.sessionExpired(peerID: peerID))
-                }
-                // Clear sensitive data before removing
-                session.reset()
-            }
-            _ = sessions.removeValue(forKey: peerID)
-        }
-    }
-    
-    func getEstablishedSessions() -> [String: NoiseSession] {
-        return managerQueue.sync {
-            return sessions.filter { $0.value.isEstablished() }
-        }
-    }
-    
-    // MARK: - Handshake Helpers
-    
-    func initiateHandshake(with peerID: String) throws -> Data {
-        return try managerQueue.sync(flags: .barrier) {
-            // Check if we already have an established session
-            if let existingSession = sessions[peerID], existingSession.isEstablished() {
-                // Session already established, don't recreate
-                throw NoiseSessionError.alreadyEstablished
-            }
-            
-            // Remove any existing non-established session
-            if let existingSession = sessions[peerID], !existingSession.isEstablished() {
-                _ = sessions.removeValue(forKey: peerID)
-            }
-            
-            // Create new initiator session
-            let session = SecureNoiseSession(
-                peerID: peerID,
-                role: .initiator,
-                localStaticKey: localStaticKey
-            )
-            sessions[peerID] = session
-            
-            do {
-                let handshakeData = try session.startHandshake()
-                return handshakeData
-            } catch {
-                // Clean up failed session
-                _ = sessions.removeValue(forKey: peerID)
-                SecureLogger.logSecurityEvent(.handshakeFailed(peerID: peerID, error: error.localizedDescription), level: .error)
-                throw error
-            }
-        }
-    }
-    
-    func handleIncomingHandshake(from peerID: String, message: Data) throws -> Data? {
-        // Process everything within the synchronized block to prevent race conditions
-        return try managerQueue.sync(flags: .barrier) {
-            var shouldCreateNew = false
-            var existingSession: NoiseSession? = nil
-            
-            if let existing = sessions[peerID] {
-                // If we have an established session, the peer must have cleared their session
-                // for a good reason (e.g., decryption failure, restart, etc.)
-                // We should accept the new handshake to re-establish encryption
-                if existing.isEstablished() {
-                    SecureLogger.log("Accepting handshake from \(peerID) despite existing session - peer likely cleared their session", 
-                                   category: SecureLogger.session, level: .info)
-                    _ = sessions.removeValue(forKey: peerID)
-                    shouldCreateNew = true
-                } else {
-                    // If we're in the middle of a handshake and receive a new initiation,
-                    // reset and start fresh (the other side may have restarted)
-                    if existing.getState() == .handshaking && message.count == 32 {
-                        _ = sessions.removeValue(forKey: peerID)
-                        shouldCreateNew = true
-                    } else {
-                        existingSession = existing
-                    }
-                }
-            } else {
-                shouldCreateNew = true
-            }
-            
-            // Get or create session
-            let session: NoiseSession
-            if shouldCreateNew {
-                let newSession = SecureNoiseSession(
-                    peerID: peerID,
-                    role: .responder,
-                    localStaticKey: localStaticKey
-                )
-                sessions[peerID] = newSession
-                session = newSession
-            } else {
-                session = existingSession!
-            }
-            
-            // Process the handshake message within the synchronized block
-            do {
-                let response = try session.processHandshakeMessage(message)
-                
-                // Check if session is established after processing
-                if session.isEstablished() {
-                    if let remoteKey = session.getRemoteStaticPublicKey() {
-                        // Schedule callback outside the synchronized block to prevent deadlock
-                        DispatchQueue.global().async { [weak self] in
-                            self?.onSessionEstablished?(peerID, remoteKey)
-                        }
-                    }
-                }
-                
-                return response
-            } catch {
-                // Reset the session on handshake failure so next attempt can start fresh
-                _ = sessions.removeValue(forKey: peerID)
-                
-                // Schedule callback outside the synchronized block to prevent deadlock
-                DispatchQueue.global().async { [weak self] in
-                    self?.onSessionFailed?(peerID, error)
-                }
-                
-                SecureLogger.logSecurityEvent(.handshakeFailed(peerID: peerID, error: error.localizedDescription), level: .error)
-                throw error
-            }
-        }
-    }
-    
-    // MARK: - Encryption/Decryption
-    
-    func encrypt(_ plaintext: Data, for peerID: String) throws -> Data {
-        guard let session = getSession(for: peerID) else {
-            throw NoiseSessionError.sessionNotFound
-        }
-        
-        return try session.encrypt(plaintext)
-    }
-    
-    func decrypt(_ ciphertext: Data, from peerID: String) throws -> Data {
-        guard let session = getSession(for: peerID) else {
-            throw NoiseSessionError.sessionNotFound
-        }
-        
-        return try session.decrypt(ciphertext)
-    }
-    
-    // MARK: - Key Management
-    
-    func getRemoteStaticKey(for peerID: String) -> Curve25519.KeyAgreement.PublicKey? {
-        return getSession(for: peerID)?.getRemoteStaticPublicKey()
-    }
-    
-    func getHandshakeHash(for peerID: String) -> Data? {
-        return getSession(for: peerID)?.getHandshakeHash()
-    }
-    
-    // MARK: - Session Rekeying
-    
-    func getSessionsNeedingRekey() -> [(peerID: String, needsRekey: Bool)] {
-        return managerQueue.sync {
-            var needingRekey: [(peerID: String, needsRekey: Bool)] = []
-            
-            for (peerID, session) in sessions {
-                if let secureSession = session as? SecureNoiseSession,
-                   secureSession.isEstablished(),
-                   secureSession.needsRenegotiation() {
-                    needingRekey.append((peerID: peerID, needsRekey: true))
-                }
-            }
-            
-            return needingRekey
-        }
-    }
-    
-    func initiateRekey(for peerID: String) throws {
-        // Remove old session
-        removeSession(for: peerID)
-        
-        // Initiate new handshake
-        _ = try initiateHandshake(with: peerID)
-        
-    }
-}
-
-// MARK: - Errors
-
-enum NoiseSessionError: Error {
-    case invalidState
-    case notEstablished
-    case sessionNotFound
-    case handshakeFailed(Error)
-    case alreadyEstablished
-}

bitchat/Nostr/Bech32.swift

@@ -0,0 +1,135 @@
+import Foundation
+
+/// Bech32 encoding for Nostr (minimal implementation)
+enum Bech32 {
+    private static let charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+    private static let generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+    
+    static func encode(hrp: String, data: Data) throws -> String {
+        let values = convertBits(from: 8, to: 5, pad: true, data: Array(data))
+        let checksum = createChecksum(hrp: hrp, values: values)
+        let combined = values + checksum
+        
+        return hrp + "1" + combined.map { 
+            let index = charset.index(charset.startIndex, offsetBy: Int($0))
+            return String(charset[index])
+        }.joined()
+    }
+    
+    static func decode(_ bech32String: String) throws -> (hrp: String, data: Data) {
+        // Find the last occurrence of '1'
+        guard let separatorIndex = bech32String.lastIndex(of: "1") else {
+            throw Bech32Error.invalidFormat
+        }
+        
+        let hrp = String(bech32String[..<separatorIndex])
+        
+        // Validate HRP contains only ASCII characters
+        for char in hrp {
+            guard char.asciiValue != nil else {
+                throw Bech32Error.invalidCharacter
+            }
+        }
+        
+        let dataString = String(bech32String[bech32String.index(after: separatorIndex)...])
+        
+        // Convert characters to values
+        var values = [UInt8]()
+        for char in dataString {
+            guard let index = charset.firstIndex(of: char) else {
+                throw Bech32Error.invalidCharacter
+            }
+            values.append(UInt8(charset.distance(from: charset.startIndex, to: index)))
+        }
+        
+        // Verify checksum
+        guard values.count >= 6 else {
+            throw Bech32Error.invalidChecksum
+        }
+        
+        let payloadValues = Array(values.dropLast(6))
+        let checksum = Array(values.suffix(6))
+        let expectedChecksum = createChecksum(hrp: hrp, values: payloadValues)
+        
+        guard checksum == expectedChecksum else {
+            throw Bech32Error.invalidChecksum
+        }
+        
+        // Convert back to bytes
+        let bytes = convertBits(from: 5, to: 8, pad: false, data: payloadValues)
+        return (hrp: hrp, data: Data(bytes))
+    }
+    
+    enum Bech32Error: Error {
+        case invalidFormat
+        case invalidCharacter
+        case invalidChecksum
+    }
+    
+    private static func convertBits(from: Int, to: Int, pad: Bool, data: [UInt8]) -> [UInt8] {
+        var acc = 0
+        var bits = 0
+        var result = [UInt8]()
+        let maxv = (1 << to) - 1
+        
+        for value in data {
+            acc = (acc << from) | Int(value)
+            bits += from
+            
+            while bits >= to {
+                bits -= to
+                result.append(UInt8((acc >> bits) & maxv))
+            }
+        }
+        
+        if pad && bits > 0 {
+            result.append(UInt8((acc << (to - bits)) & maxv))
+        }
+        
+        return result
+    }
+    
+    private static func createChecksum(hrp: String, values: [UInt8]) -> [UInt8] {
+        let checksumValues = hrpExpand(hrp) + values + [0, 0, 0, 0, 0, 0]
+        let polymod = polymod(checksumValues) ^ 1
+        var checksum = [UInt8]()
+        
+        for i in 0..<6 {
+            checksum.append(UInt8((polymod >> (5 * (5 - i))) & 31))
+        }
+        
+        return checksum
+    }
+    
+    private static func hrpExpand(_ hrp: String) -> [UInt8] {
+        var result = [UInt8]()
+        for c in hrp {
+            guard let asciiValue = c.asciiValue else {
+                return [] // Return empty array for invalid input
+            }
+            result.append(UInt8(asciiValue >> 5))
+        }
+        result.append(0)
+        for c in hrp {
+            guard let asciiValue = c.asciiValue else {
+                return [] // Return empty array for invalid input
+            }
+            result.append(UInt8(asciiValue & 31))
+        }
+        return result
+    }
+    
+    private static func polymod(_ values: [UInt8]) -> Int {
+        var chk = 1
+        for value in values {
+            let b = chk >> 25
+            chk = (chk & 0x1ffffff) << 5 ^ Int(value)
+            for i in 0..<5 {
+                if (b >> i) & 1 == 1 {
+                    chk ^= generator[i]
+                }
+            }
+        }
+        return chk
+    }
+}

bitchat/Nostr/GeoRelayDirectory.swift

@@ -1,26 +1,161 @@
+import BitLogger
 import Foundation
+import Tor
+#if os(iOS)
+import UIKit
+#elseif os(macOS)
+import AppKit
+#endif
 
 /// Directory of online Nostr relays with approximate GPS locations, used for geohash routing.
+struct GeoRelayDirectoryDependencies {
+    var userDefaults: UserDefaults
+    var notificationCenter: NotificationCenter
+    var now: () -> Date
+    var remoteURL: URL
+    var fetchInterval: TimeInterval
+    var refreshCheckInterval: TimeInterval
+    var retryInitialSeconds: TimeInterval
+    var retryMaxSeconds: TimeInterval
+    var awaitTorReady: @Sendable () async -> Bool
+    var makeFetchData: @MainActor @Sendable () -> (@Sendable (URLRequest) async throws -> Data)
+    var readData: (URL) -> Data?
+    var writeData: (Data, URL) throws -> Void
+    var cacheURL: () -> URL?
+    var bundledCSVURLs: () -> [URL]
+    var currentDirectoryPath: () -> String?
+    var retrySleep: (TimeInterval) async -> Void
+    var activeNotificationName: Notification.Name?
+    var autoStart: Bool
+}
+
+private extension GeoRelayDirectoryDependencies {
+    @MainActor
+    static func live() -> Self {
+#if os(iOS)
+        let activeNotificationName: Notification.Name? = UIApplication.didBecomeActiveNotification
+#elseif os(macOS)
+        let activeNotificationName: Notification.Name? = NSApplication.didBecomeActiveNotification
+#else
+        let activeNotificationName: Notification.Name? = nil
+#endif
+
+        return Self(
+            userDefaults: .standard,
+            notificationCenter: .default,
+            now: Date.init,
+            remoteURL: URL(string: "https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv")!,
+            fetchInterval: TransportConfig.geoRelayFetchIntervalSeconds,
+            refreshCheckInterval: TransportConfig.geoRelayRefreshCheckIntervalSeconds,
+            retryInitialSeconds: TransportConfig.geoRelayRetryInitialSeconds,
+            retryMaxSeconds: TransportConfig.geoRelayRetryMaxSeconds,
+            awaitTorReady: { await TorManager.shared.awaitReady() },
+            makeFetchData: {
+                let session = TorURLSession.shared.session
+                return { request in
+                    let (data, _) = try await session.data(for: request)
+                    return data
+                }
+            },
+            readData: { try? Data(contentsOf: $0) },
+            writeData: { data, url in
+                try data.write(to: url, options: .atomic)
+            },
+            cacheURL: {
+                do {
+                    let base = try FileManager.default.url(
+                        for: .applicationSupportDirectory,
+                        in: .userDomainMask,
+                        appropriateFor: nil,
+                        create: true
+                    )
+                    let dir = base.appendingPathComponent("bitchat", isDirectory: true)
+                    try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+                    return dir.appendingPathComponent("georelays_cache.csv")
+                } catch {
+                    return nil
+                }
+            },
+            bundledCSVURLs: {
+                [
+                    Bundle.main.url(forResource: "nostr_relays", withExtension: "csv"),
+                    Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv"),
+                    Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv", subdirectory: "relays")
+                ].compactMap { $0 }
+            },
+            currentDirectoryPath: { FileManager.default.currentDirectoryPath },
+            retrySleep: { delay in
+                let nanoseconds = UInt64(delay * 1_000_000_000)
+                try? await Task.sleep(nanoseconds: nanoseconds)
+            },
+            activeNotificationName: activeNotificationName,
+            autoStart: true
+        )
+    }
+}
+
 @MainActor
 final class GeoRelayDirectory {
-    struct Entry: Hashable {
+    private final class CleanupState {
+        let notificationCenter: NotificationCenter
+        var observers: [NSObjectProtocol] = []
+        var refreshTimer: Timer?
+        var retryTask: Task<Void, Never>?
+
+        init(notificationCenter: NotificationCenter) {
+            self.notificationCenter = notificationCenter
+        }
+
+        deinit {
+            observers.forEach { notificationCenter.removeObserver($0) }
+            refreshTimer?.invalidate()
+            retryTask?.cancel()
+        }
+    }
+
+    struct Entry: Hashable, Sendable {
         let host: String
         let lat: Double
         let lon: Double
     }
 
+    private enum DetachedFetchOutcome: Sendable {
+        case success(entries: [Entry], csv: String)
+        case torNotReady
+        case invalidData
+        case network(String)
+    }
+
     static let shared = GeoRelayDirectory()
+
     private(set) var entries: [Entry] = []
-    private let cacheFileName = "georelays_cache.csv"
     private let lastFetchKey = "georelay.lastFetchAt"
-    private let remoteURL = URL(string: "https://raw.githubusercontent.com/permissionlesstech/georelays/refs/heads/main/nostr_relays.csv")!
-    private let fetchInterval: TimeInterval = TransportConfig.geoRelayFetchIntervalSeconds // 24h
+    private let dependencies: GeoRelayDirectoryDependencies
+    private let cleanupState: CleanupState
+
+    private var retryAttempt: Int = 0
+    private var isFetching: Bool = false
 
     private init() {
-        // Load cached or bundled data synchronously
-        self.entries = self.loadLocalEntries()
-        // Fire-and-forget remote refresh if stale
-        prefetchIfNeeded()
+        self.dependencies = .live()
+        self.cleanupState = CleanupState(notificationCenter: dependencies.notificationCenter)
+        entries = loadLocalEntries()
+        if dependencies.autoStart {
+            registerObservers()
+            startRefreshTimer()
+            prefetchIfNeeded()
+        }
+    }
+
+    internal init(dependencies: GeoRelayDirectoryDependencies) {
+        self.dependencies = dependencies
+        self.cleanupState = CleanupState(notificationCenter: dependencies.notificationCenter)
+        entries = loadLocalEntries()
+        if dependencies.autoStart {
+            registerObservers()
+            startRefreshTimer()
+            prefetchIfNeeded()
+        }
     }
 
     /// Returns up to `count` relay URLs (wss://) closest to the geohash center.
@@ -31,93 +166,220 @@ final class GeoRelayDirectory {
 
     /// Returns up to `count` relay URLs (wss://) closest to the given coordinate.
     func closestRelays(toLat lat: Double, lon: Double, count: Int = 5) -> [String] {
-        guard !entries.isEmpty else { return [] }
-        let sorted = entries
-            .sorted { a, b in
-                haversineKm(lat, lon, a.lat, a.lon) < haversineKm(lat, lon, b.lat, b.lon)
+        guard !entries.isEmpty, count > 0 else { return [] }
+
+        if entries.count <= count {
+            return entries
+                .sorted { a, b in
+                    haversineKm(lat, lon, a.lat, a.lon) < haversineKm(lat, lon, b.lat, b.lon)
+                }
+                .map { "wss://\($0.host)" }
+        }
+
+        var best: [(entry: Entry, distance: Double)] = []
+        best.reserveCapacity(count)
+
+        for entry in entries {
+            let distance = haversineKm(lat, lon, entry.lat, entry.lon)
+            if best.count < count {
+                let idx = best.firstIndex { $0.distance > distance } ?? best.count
+                best.insert((entry, distance), at: idx)
+            } else if let worstDistance = best.last?.distance, distance < worstDistance {
+                let idx = best.firstIndex { $0.distance > distance } ?? best.count
+                best.insert((entry, distance), at: idx)
+                best.removeLast()
             }
-            .prefix(count)
-        return sorted.map { "wss://\($0.host)" }
+        }
+
+        return best.map { "wss://\($0.entry.host)" }
     }
 
     // MARK: - Remote Fetch
-    func prefetchIfNeeded() {
-        let now = Date()
-        let last = UserDefaults.standard.object(forKey: lastFetchKey) as? Date ?? .distantPast
-        guard now.timeIntervalSince(last) >= fetchInterval else { return }
+    func prefetchIfNeeded(force: Bool = false) {
+        guard !isFetching else { return }
+
+        let now = dependencies.now()
+        let last = dependencies.userDefaults.object(forKey: lastFetchKey) as? Date ?? .distantPast
+
+        if !force {
+            guard now.timeIntervalSince(last) >= dependencies.fetchInterval else { return }
+        } else if last != .distantPast,
+                  now.timeIntervalSince(last) < dependencies.retryInitialSeconds {
+            // Skip forced fetches if we just refreshed moments ago.
+            return
+        }
+
+        cancelRetry()
         fetchRemote()
     }
 
     private func fetchRemote() {
-        let req = URLRequest(url: remoteURL, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 15)
-        let task = URLSession.shared.dataTask(with: req) { [weak self] data, _, error in
-            guard let self = self else { return }
-            if let data = data, error == nil, let text = String(data: data, encoding: .utf8) {
-                let parsed = GeoRelayDirectory.parseCSV(text)
-                if !parsed.isEmpty {
-                    Task { @MainActor in
-                        self.entries = parsed
-                        self.persistCache(text)
-                        UserDefaults.standard.set(Date(), forKey: self.lastFetchKey)
-                        SecureLogger.log("GeoRelayDirectory: refreshed \(parsed.count) relays from remote", category: SecureLogger.session, level: .info)
-                    }
-                    return
-                }
+        guard !isFetching else { return }
+        isFetching = true
+
+        let request = URLRequest(
+            url: dependencies.remoteURL,
+            cachePolicy: .reloadIgnoringLocalCacheData,
+            timeoutInterval: 15
+        )
+        let awaitTorReady = dependencies.awaitTorReady
+        let fetchData = dependencies.makeFetchData()
+
+        Task { [weak self] in
+            guard let self else { return }
+
+            let outcome = await Self.fetchRemoteOutcome(
+                request: request,
+                awaitTorReady: awaitTorReady,
+                fetchData: fetchData
+            )
+
+            switch outcome {
+            case .success(let parsed, let csv):
+                self.handleFetchSuccess(entries: parsed, csv: csv)
+            case .torNotReady:
+                self.handleFetchFailure(.torNotReady)
+            case .invalidData:
+                self.handleFetchFailure(.invalidData)
+            case .network(let description):
+                self.handleFetchFailure(.network(description))
             }
-            SecureLogger.log("GeoRelayDirectory: remote fetch failed; keeping local entries", category: SecureLogger.session, level: .warning)
         }
-        task.resume()
+    }
+
+    nonisolated private static func fetchRemoteOutcome(
+        request: URLRequest,
+        awaitTorReady: @escaping @Sendable () async -> Bool,
+        fetchData: @escaping @Sendable (URLRequest) async throws -> Data
+    ) async -> DetachedFetchOutcome {
+        await Task.detached(priority: .utility) {
+            let ready = await awaitTorReady()
+            guard ready else { return .torNotReady }
+
+            do {
+                let data = try await fetchData(request)
+                guard let text = String(data: data, encoding: .utf8) else {
+                    return .invalidData
+                }
+
+                let parsed = Self.parseCSV(text)
+                guard !parsed.isEmpty else {
+                    return .invalidData
+                }
+
+                return .success(entries: parsed, csv: text)
+            } catch {
+                return .network(error.localizedDescription)
+            }
+        }.value
+    }
+
+    private enum FetchFailure {
+        case torNotReady
+        case invalidData
+        case network(String)
+    }
+
+    @MainActor
+    private func handleFetchSuccess(entries parsed: [Entry], csv: String) {
+        entries = parsed
+        persistCache(csv)
+        dependencies.userDefaults.set(dependencies.now(), forKey: lastFetchKey)
+        SecureLogger.info("GeoRelayDirectory: refreshed \(parsed.count) relays from remote", category: .session)
+        isFetching = false
+        retryAttempt = 0
+        cancelRetry()
+    }
+
+    @MainActor
+    private func handleFetchFailure(_ reason: FetchFailure) {
+        switch reason {
+        case .torNotReady:
+            SecureLogger.warning("GeoRelayDirectory: Tor not ready; scheduling retry", category: .session)
+        case .invalidData:
+            SecureLogger.warning("GeoRelayDirectory: remote fetch returned invalid data; scheduling retry", category: .session)
+        case .network(let errorDescription):
+            SecureLogger.warning("GeoRelayDirectory: remote fetch failed with error: \(errorDescription)", category: .session)
+        }
+        isFetching = false
+        scheduleRetry()
+    }
+
+    @MainActor
+    private func scheduleRetry() {
+        retryAttempt = min(retryAttempt + 1, 10)
+        let base = dependencies.retryInitialSeconds
+        let maxDelay = dependencies.retryMaxSeconds
+        let multiplier = pow(2.0, Double(max(retryAttempt - 1, 0)))
+        let calculated = base * multiplier
+        let delay = min(maxDelay, max(base, calculated))
+
+        cancelRetry()
+        cleanupState.retryTask = Task { [weak self] in
+            guard let self else { return }
+            await self.dependencies.retrySleep(delay)
+            guard !Task.isCancelled else { return }
+            await MainActor.run {
+                self.prefetchIfNeeded(force: true)
+            }
+        }
+    }
+
+    @MainActor
+    private func cancelRetry() {
+        cleanupState.retryTask?.cancel()
+        cleanupState.retryTask = nil
     }
 
     private func persistCache(_ text: String) {
-        guard let url = cacheURL() else { return }
+        guard let url = dependencies.cacheURL() else { return }
+        guard let data = text.data(using: .utf8) else { return }
         do {
-            try text.data(using: .utf8)?.write(to: url, options: .atomic)
+            try dependencies.writeData(data, url)
         } catch {
-            SecureLogger.log("GeoRelayDirectory: failed to write cache: \(error)", category: SecureLogger.session, level: .warning)
+            SecureLogger.warning("GeoRelayDirectory: failed to write cache: \(error)", category: .session)
         }
     }
 
     // MARK: - Loading
     private func loadLocalEntries() -> [Entry] {
         // Prefer cached file if present
-        if let cache = self.cacheURL(),
-           let data = try? Data(contentsOf: cache),
+        if let cache = dependencies.cacheURL(),
+           let data = dependencies.readData(cache),
            let text = String(data: data, encoding: .utf8) {
             let arr = Self.parseCSV(text)
             if !arr.isEmpty { return arr }
         }
+
         // Try bundled resource(s)
-        let bundleCandidates = [
-            Bundle.main.url(forResource: "nostr_relays", withExtension: "csv"),
-            Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv"),
-            Bundle.main.url(forResource: "online_relays_gps", withExtension: "csv", subdirectory: "relays")
-        ].compactMap { $0 }
+        let bundleCandidates = dependencies.bundledCSVURLs()
+
         for url in bundleCandidates {
-            if let data = try? Data(contentsOf: url), let text = String(data: data, encoding: .utf8) {
+            if let data = dependencies.readData(url),
+               let text = String(data: data, encoding: .utf8) {
                 let arr = Self.parseCSV(text)
                 if !arr.isEmpty { return arr }
             }
         }
+
         // Try filesystem path (development/test)
-        if let cwd = FileManager.default.currentDirectoryPath as String?,
-           let data = try? Data(contentsOf: URL(fileURLWithPath: cwd).appendingPathComponent("relays/online_relays_gps.csv")),
+        if let cwd = dependencies.currentDirectoryPath(),
+           let data = dependencies.readData(URL(fileURLWithPath: cwd).appendingPathComponent("relays/online_relays_gps.csv")),
            let text = String(data: data, encoding: .utf8) {
             return Self.parseCSV(text)
         }
-        SecureLogger.log("GeoRelayDirectory: no local CSV found; entries empty", category: SecureLogger.session, level: .warning)
+
+        SecureLogger.warning("GeoRelayDirectory: no local CSV found; entries empty", category: .session)
         return []
     }
 
     nonisolated static func parseCSV(_ text: String) -> [Entry] {
         var result: Set<Entry> = []
         let lines = text.split(whereSeparator: { $0.isNewline })
-        // Skip header if present
         for (idx, raw) in lines.enumerated() {
-            let line = raw.trimmingCharacters(in: .whitespacesAndNewlines)
-            if line.isEmpty { continue }
+            guard let line = raw.trimmedOrNilIfEmpty else { continue }
             if idx == 0 && line.lowercased().contains("relay url") { continue }
-            let parts = line.split(separator: ",").map { String($0).trimmingCharacters(in: .whitespaces) }
+            let parts = line.split(separator: ",").map { $0.trimmed }
             guard parts.count >= 3 else { continue }
             var host = parts[0]
             host = host.replacingOccurrences(of: "https://", with: "")
@@ -131,14 +393,55 @@ final class GeoRelayDirectory {
         return Array(result)
     }
 
-    private func cacheURL() -> URL? {
-        do {
-            let base = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
-            let dir = base.appendingPathComponent("bitchat", isDirectory: true)
-            try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-            return dir.appendingPathComponent(cacheFileName)
-        } catch { return nil }
+    // MARK: - Observers & Timers
+    private func registerObservers() {
+        let center = dependencies.notificationCenter
+
+        let torReady = center.addObserver(
+            forName: .TorDidBecomeReady,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            guard let self else { return }
+            Task { @MainActor in
+                self.prefetchIfNeeded(force: true)
+            }
+        }
+        cleanupState.observers.append(torReady)
+
+        if let activeNotificationName = dependencies.activeNotificationName {
+            let didBecomeActive = center.addObserver(
+                forName: activeNotificationName,
+                object: nil,
+                queue: .main
+            ) { [weak self] _ in
+                guard let self else { return }
+                Task { @MainActor in
+                    self.prefetchIfNeeded()
+                }
+            }
+            cleanupState.observers.append(didBecomeActive)
+        }
     }
+
+    private func startRefreshTimer() {
+        cleanupState.refreshTimer?.invalidate()
+        let interval = dependencies.refreshCheckInterval
+        guard interval > 0 else { return }
+
+        let timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
+            guard let self else { return }
+            Task { @MainActor in
+                self.prefetchIfNeeded()
+            }
+        }
+        cleanupState.refreshTimer = timer
+        RunLoop.main.add(timer, forMode: .common)
+    }
+
+    var debugRetryAttempt: Int { retryAttempt }
+    var debugHasRetryTask: Bool { cleanupState.retryTask != nil }
+    var debugObserverCount: Int { cleanupState.observers.count }
 }
 
 // MARK: - Distance

bitchat/Nostr/NostrEmbeddedBitChat.swift

@@ -1,10 +1,11 @@
 import Foundation
+import BitFoundation
 
 // MARK: - BitChat-over-Nostr Adapter
 
 struct NostrEmbeddedBitChat {
     /// Build a `bitchat1:` base64url-encoded BitChat packet carrying a private message for Nostr DMs.
-    static func encodePMForNostr(content: String, messageID: String, recipientPeerID: String, senderPeerID: String) -> String? {
+    static func encodePMForNostr(content: String, messageID: String, recipientPeerID: PeerID, senderPeerID: PeerID) -> String? {
         // TLV-encode the private message
         let pm = PrivateMessagePacket(messageID: messageID, content: content)
         guard let tlv = pm.encode() else { return nil }
@@ -14,12 +15,12 @@ struct NostrEmbeddedBitChat {
         payload.append(tlv)
 
         // Determine 8-byte recipient ID to embed
-        let recipientIDHex: String = normalizeRecipientPeerID(recipientPeerID)
+        let recipientID = normalizeRecipientPeerID(recipientPeerID)
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
-            recipientID: Data(hexString: recipientIDHex),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
+            recipientID: Data(hexString: recipientID.id),
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
             signature: nil,
@@ -31,18 +32,18 @@ struct NostrEmbeddedBitChat {
     }
 
     /// Build a `bitchat1:` base64url-encoded BitChat packet carrying a delivery/read ack for Nostr DMs.
-    static func encodeAckForNostr(type: NoisePayloadType, messageID: String, recipientPeerID: String, senderPeerID: String) -> String? {
+    static func encodeAckForNostr(type: NoisePayloadType, messageID: String, recipientPeerID: PeerID, senderPeerID: PeerID) -> String? {
         guard type == .delivered || type == .readReceipt else { return nil }
 
         var payload = Data([type.rawValue])
         payload.append(Data(messageID.utf8))
 
-        let recipientIDHex: String = normalizeRecipientPeerID(recipientPeerID)
+        let recipientID = normalizeRecipientPeerID(recipientPeerID)
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
-            recipientID: Data(hexString: recipientIDHex),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
+            recipientID: Data(hexString: recipientID.id),
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
             signature: nil,
@@ -54,7 +55,7 @@ struct NostrEmbeddedBitChat {
     }
 
     /// Build a `bitchat1:` ACK (delivered/read) without an embedded recipient peer ID (geohash DMs).
-    static func encodeAckForNostrNoRecipient(type: NoisePayloadType, messageID: String, senderPeerID: String) -> String? {
+    static func encodeAckForNostrNoRecipient(type: NoisePayloadType, messageID: String, senderPeerID: PeerID) -> String? {
         guard type == .delivered || type == .readReceipt else { return nil }
 
         var payload = Data([type.rawValue])
@@ -62,7 +63,7 @@ struct NostrEmbeddedBitChat {
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -75,7 +76,7 @@ struct NostrEmbeddedBitChat {
     }
 
     /// Build a `bitchat1:` payload without an embedded recipient peer ID (used for geohash DMs).
-    static func encodePMForNostrNoRecipient(content: String, messageID: String, senderPeerID: String) -> String? {
+    static func encodePMForNostrNoRecipient(content: String, messageID: String, senderPeerID: PeerID) -> String? {
         let pm = PrivateMessagePacket(messageID: messageID, content: content)
         guard let tlv = pm.encode() else { return nil }
 
@@ -84,7 +85,7 @@ struct NostrEmbeddedBitChat {
 
         let packet = BitchatPacket(
             type: MessageType.noiseEncrypted.rawValue,
-            senderID: Data(hexString: senderPeerID) ?? Data(),
+            senderID: Data(hexString: senderPeerID.id) ?? Data(),
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -96,11 +97,11 @@ struct NostrEmbeddedBitChat {
         return "bitchat1:" + base64URLEncode(data)
     }
 
-    private static func normalizeRecipientPeerID(_ recipientPeerID: String) -> String {
-        if let maybeData = Data(hexString: recipientPeerID) {
+    private static func normalizeRecipientPeerID(_ recipientPeerID: PeerID) -> PeerID {
+        if let maybeData = Data(hexString: recipientPeerID.id) {
             if maybeData.count == 32 {
                 // Treat as Noise static public key; derive peerID from fingerprint
-                return PeerIDUtils.derivePeerID(fromPublicKey: maybeData)
+                return PeerID(publicKey: maybeData)
             } else if maybeData.count == 8 {
                 // Already an 8-byte peer ID
                 return recipientPeerID

bitchat/Nostr/NostrIdentity.swift

@@ -1,50 +1,5 @@
 import Foundation
-import CryptoKit
 import P256K
-import Security
-
-// Keychain helper for secure storage
-struct KeychainHelper {
-    static func save(key: String, data: Data, service: String, accessible: CFString? = nil) {
-        var query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: service,
-            kSecAttrAccount as String: key,
-            kSecValueData as String: data
-        ]
-        if let accessible = accessible {
-            query[kSecAttrAccessible as String] = accessible
-        }
-        
-        SecItemDelete(query as CFDictionary)
-        SecItemAdd(query as CFDictionary, nil)
-    }
-    
-    static func load(key: String, service: String) -> Data? {
-        let query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: service,
-            kSecAttrAccount as String: key,
-            kSecReturnData as String: true
-        ]
-        
-        var result: AnyObject?
-        let status = SecItemCopyMatching(query as CFDictionary, &result)
-        
-        guard status == errSecSuccess else { return nil }
-        return result as? Data
-    }
-    
-    static func delete(key: String, service: String) {
-        let query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: service,
-            kSecAttrAccount as String: key
-        ]
-        
-        SecItemDelete(query as CFDictionary)
-    }
-}
 
 /// Manages Nostr identity (secp256k1 keypair) for NIP-17 private messaging
 struct NostrIdentity: Codable {
@@ -103,251 +58,3 @@ struct NostrIdentity: Codable {
         return publicKey.hexEncodedString()
     }
 }
-
-/// Bridge between Noise and Nostr identities
-struct NostrIdentityBridge {
-    private static let keychainService = "chat.bitchat.nostr"
-    private static let currentIdentityKey = "nostr-current-identity"
-    private static let deviceSeedKey = "nostr-device-seed"
-    // In-memory cache to avoid transient keychain access issues
-    private static var deviceSeedCache: Data?
-    
-    /// Get or create the current Nostr identity
-    static func getCurrentNostrIdentity() throws -> NostrIdentity? {
-        // Check if we already have a Nostr identity
-        if let existingData = KeychainHelper.load(key: currentIdentityKey, service: keychainService),
-           let identity = try? JSONDecoder().decode(NostrIdentity.self, from: existingData) {
-            return identity
-        }
-        
-        // Generate new Nostr identity
-        let nostrIdentity = try NostrIdentity.generate()
-        
-        // Store it
-        let data = try JSONEncoder().encode(nostrIdentity)
-        KeychainHelper.save(key: currentIdentityKey, data: data, service: keychainService)
-        
-        return nostrIdentity
-    }
-    
-    /// Associate a Nostr identity with a Noise public key (for favorites)
-    static func associateNostrIdentity(_ nostrPubkey: String, with noisePublicKey: Data) {
-        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
-        if let data = nostrPubkey.data(using: .utf8) {
-            KeychainHelper.save(key: key, data: data, service: keychainService)
-        }
-    }
-    
-    /// Get Nostr public key associated with a Noise public key
-    static func getNostrPublicKey(for noisePublicKey: Data) -> String? {
-        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
-        guard let data = KeychainHelper.load(key: key, service: keychainService),
-              let pubkey = String(data: data, encoding: .utf8) else {
-            return nil
-        }
-        return pubkey
-    }
-    
-    /// Clear all Nostr identity associations and current identity
-    static func clearAllAssociations() {
-        // Delete current Nostr identity
-        KeychainHelper.delete(key: currentIdentityKey, service: keychainService)
-        KeychainHelper.delete(key: deviceSeedKey, service: keychainService)
-        
-        // Note: We can't efficiently delete all noise-nostr associations 
-        // without tracking them, but they'll be orphaned and eventually cleaned up
-        // The important part is deleting the current identity so a new one is generated
-    }
-
-    // MARK: - Per-Geohash Identities (Location Channels)
-
-    /// Returns a stable device seed used to derive unlinkable per-geohash identities.
-    /// Stored only on device keychain.
-    private static func getOrCreateDeviceSeed() -> Data {
-        if let cached = deviceSeedCache { return cached }
-        if let existing = KeychainHelper.load(key: deviceSeedKey, service: keychainService) {
-            // Migrate to AfterFirstUnlockThisDeviceOnly for stability during lock
-            KeychainHelper.save(key: deviceSeedKey, data: existing, service: keychainService, accessible: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly)
-            deviceSeedCache = existing
-            return existing
-        }
-        var seed = Data(count: 32)
-        _ = seed.withUnsafeMutableBytes { ptr in
-            SecRandomCopyBytes(kSecRandomDefault, 32, ptr.baseAddress!)
-        }
-        // Ensure availability after first unlock to prevent unintended rotation when locked
-        KeychainHelper.save(key: deviceSeedKey, data: seed, service: keychainService, accessible: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly)
-        deviceSeedCache = seed
-        return seed
-    }
-
-    /// Derive a deterministic, unlinkable Nostr identity for a given geohash.
-    /// Uses HMAC-SHA256(deviceSeed, geohash) as private key material, with fallback rehashing
-    /// if the candidate is not a valid secp256k1 private key.
-    static func deriveIdentity(forGeohash geohash: String) throws -> NostrIdentity {
-        let seed = getOrCreateDeviceSeed()
-        guard let msg = geohash.data(using: .utf8) else {
-            throw NSError(domain: "NostrIdentity", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid geohash string"])
-        }
-
-        func candidateKey(iteration: UInt32) -> Data {
-            var input = Data(msg)
-            var iterBE = iteration.bigEndian
-            withUnsafeBytes(of: &iterBE) { bytes in
-                input.append(contentsOf: bytes)
-            }
-            let code = CryptoKit.HMAC<CryptoKit.SHA256>.authenticationCode(for: input, using: SymmetricKey(data: seed))
-            return Data(code)
-        }
-
-        // Try a few iterations to ensure a valid key can be formed
-        for i in 0..<10 {
-            let keyData = candidateKey(iteration: UInt32(i))
-            if let identity = try? NostrIdentity(privateKeyData: keyData) {
-                return identity
-            }
-        }
-        // As a final fallback, hash the seed+msg and try again
-        var combined = Data()
-        combined.append(seed)
-        combined.append(msg)
-        let fallback = Data(CryptoKit.SHA256.hash(data: combined))
-        return try NostrIdentity(privateKeyData: fallback)
-    }
-}
-
-// Bech32 encoding for Nostr (minimal implementation)
-enum Bech32 {
-    private static let charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
-    private static let generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
-    
-    static func encode(hrp: String, data: Data) throws -> String {
-        let values = convertBits(from: 8, to: 5, pad: true, data: Array(data))
-        let checksum = createChecksum(hrp: hrp, values: values)
-        let combined = values + checksum
-        
-        return hrp + "1" + combined.map { 
-            let index = charset.index(charset.startIndex, offsetBy: Int($0))
-            return String(charset[index])
-        }.joined()
-    }
-    
-    static func decode(_ bech32String: String) throws -> (hrp: String, data: Data) {
-        // Find the last occurrence of '1'
-        guard let separatorIndex = bech32String.lastIndex(of: "1") else {
-            throw Bech32Error.invalidFormat
-        }
-        
-        let hrp = String(bech32String[..<separatorIndex])
-        
-        // Validate HRP contains only ASCII characters
-        for char in hrp {
-            guard char.asciiValue != nil else {
-                throw Bech32Error.invalidCharacter
-            }
-        }
-        
-        let dataString = String(bech32String[bech32String.index(after: separatorIndex)...])
-        
-        // Convert characters to values
-        var values = [UInt8]()
-        for char in dataString {
-            guard let index = charset.firstIndex(of: char) else {
-                throw Bech32Error.invalidCharacter
-            }
-            values.append(UInt8(charset.distance(from: charset.startIndex, to: index)))
-        }
-        
-        // Verify checksum
-        guard values.count >= 6 else {
-            throw Bech32Error.invalidChecksum
-        }
-        
-        let payloadValues = Array(values.dropLast(6))
-        let checksum = Array(values.suffix(6))
-        let expectedChecksum = createChecksum(hrp: hrp, values: payloadValues)
-        
-        guard checksum == expectedChecksum else {
-            throw Bech32Error.invalidChecksum
-        }
-        
-        // Convert back to bytes
-        let bytes = convertBits(from: 5, to: 8, pad: false, data: payloadValues)
-        return (hrp: hrp, data: Data(bytes))
-    }
-    
-    enum Bech32Error: Error {
-        case invalidFormat
-        case invalidCharacter
-        case invalidChecksum
-    }
-    
-    private static func convertBits(from: Int, to: Int, pad: Bool, data: [UInt8]) -> [UInt8] {
-        var acc = 0
-        var bits = 0
-        var result = [UInt8]()
-        let maxv = (1 << to) - 1
-        
-        for value in data {
-            acc = (acc << from) | Int(value)
-            bits += from
-            
-            while bits >= to {
-                bits -= to
-                result.append(UInt8((acc >> bits) & maxv))
-            }
-        }
-        
-        if pad && bits > 0 {
-            result.append(UInt8((acc << (to - bits)) & maxv))
-        }
-        
-        return result
-    }
-    
-    private static func createChecksum(hrp: String, values: [UInt8]) -> [UInt8] {
-        let checksumValues = hrpExpand(hrp) + values + [0, 0, 0, 0, 0, 0]
-        let polymod = polymod(checksumValues) ^ 1
-        var checksum = [UInt8]()
-        
-        for i in 0..<6 {
-            checksum.append(UInt8((polymod >> (5 * (5 - i))) & 31))
-        }
-        
-        return checksum
-    }
-    
-    private static func hrpExpand(_ hrp: String) -> [UInt8] {
-        var result = [UInt8]()
-        for c in hrp {
-            guard let asciiValue = c.asciiValue else {
-                return [] // Return empty array for invalid input
-            }
-            result.append(UInt8(asciiValue >> 5))
-        }
-        result.append(0)
-        for c in hrp {
-            guard let asciiValue = c.asciiValue else {
-                return [] // Return empty array for invalid input
-            }
-            result.append(UInt8(asciiValue & 31))
-        }
-        return result
-    }
-    
-    private static func polymod(_ values: [UInt8]) -> Int {
-        var chk = 1
-        for value in values {
-            let b = chk >> 25
-            chk = (chk & 0x1ffffff) << 5 ^ Int(value)
-            for i in 0..<5 {
-                if (b >> i) & 1 == 1 {
-                    chk ^= generator[i]
-                }
-            }
-        }
-        return chk
-    }
-}
-
-// Data hex encoding extension moved to BinaryEncodingUtils.swift to avoid duplication

bitchat/Nostr/NostrIdentityBridge.swift

@@ -0,0 +1,158 @@
+import BitFoundation
+import Foundation
+import CryptoKit
+
+/// Bridge between Noise and Nostr identities
+final class NostrIdentityBridge {
+    private let keychainService = "chat.bitchat.nostr"
+    private let currentIdentityKey = "nostr-current-identity"
+    private let deviceSeedKey = "nostr-device-seed"
+    // In-memory cache to avoid transient keychain access issues
+    private var deviceSeedCache: Data?
+    // Cache derived identities to avoid repeated crypto during view rendering
+    private var derivedIdentityCache: [String: NostrIdentity] = [:]
+    private let cacheLock = NSLock()
+
+    private let keychain: KeychainManagerProtocol
+
+    init(keychain: KeychainManagerProtocol = KeychainManager()) {
+        self.keychain = keychain
+    }
+    
+    /// Get or create the current Nostr identity
+    func getCurrentNostrIdentity() throws -> NostrIdentity? {
+        // Check if we already have a Nostr identity
+        if let existingData = keychain.load(key: currentIdentityKey, service: keychainService),
+           let identity = try? JSONDecoder().decode(NostrIdentity.self, from: existingData) {
+            return identity
+        }
+        
+        // Generate new Nostr identity
+        let nostrIdentity = try NostrIdentity.generate()
+        
+        // Store it
+        let data = try JSONEncoder().encode(nostrIdentity)
+        keychain.save(key: currentIdentityKey, data: data, service: keychainService, accessible: nil)
+        
+        return nostrIdentity
+    }
+    
+    /// Associate a Nostr identity with a Noise public key (for favorites)
+    func associateNostrIdentity(_ nostrPubkey: String, with noisePublicKey: Data) {
+        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
+        if let data = nostrPubkey.data(using: .utf8) {
+            keychain.save(key: key, data: data, service: keychainService, accessible: nil)
+        }
+    }
+    
+    /// Get Nostr public key associated with a Noise public key
+    func getNostrPublicKey(for noisePublicKey: Data) -> String? {
+        let key = "nostr-noise-\(noisePublicKey.base64EncodedString())"
+        guard let data = keychain.load(key: key, service: keychainService),
+              let pubkey = String(data: data, encoding: .utf8) else {
+            return nil
+        }
+        return pubkey
+    }
+    
+    /// Clear all Nostr identity associations and current identity
+    func clearAllAssociations() {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: keychainService,
+            kSecMatchLimit as String: kSecMatchLimitAll,
+            kSecReturnAttributes as String: true
+        ]
+
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        if status == errSecSuccess, let items = result as? [[String: Any]] {
+            for item in items {
+                var deleteQuery: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: keychainService
+                ]
+                if let account = item[kSecAttrAccount as String] as? String {
+                    deleteQuery[kSecAttrAccount as String] = account
+                }
+                SecItemDelete(deleteQuery as CFDictionary)
+            }
+        } else if status == errSecItemNotFound {
+            // nothing persisted; no action needed
+        }
+
+        deviceSeedCache = nil
+    }
+
+    // MARK: - Per-Geohash Identities (Location Channels)
+
+    /// Returns a stable device seed used to derive unlinkable per-geohash identities.
+    /// Stored only on device keychain.
+    private func getOrCreateDeviceSeed() -> Data {
+        if let cached = deviceSeedCache { return cached }
+        if let existing = keychain.load(key: deviceSeedKey, service: keychainService) {
+            // Migrate to AfterFirstUnlockThisDeviceOnly for stability during lock
+            keychain.save(key: deviceSeedKey, data: existing, service: keychainService, accessible: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly)
+            deviceSeedCache = existing
+            return existing
+        }
+        var seed = Data(count: 32)
+        _ = seed.withUnsafeMutableBytes { ptr in
+            SecRandomCopyBytes(kSecRandomDefault, 32, ptr.baseAddress!)
+        }
+        // Ensure availability after first unlock to prevent unintended rotation when locked
+        keychain.save(key: deviceSeedKey, data: seed, service: keychainService, accessible: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly)
+        deviceSeedCache = seed
+        return seed
+    }
+
+    /// Derive a deterministic, unlinkable Nostr identity for a given geohash.
+    /// Uses HMAC-SHA256(deviceSeed, geohash) as private key material, with fallback rehashing
+    /// if the candidate is not a valid secp256k1 private key.
+    func deriveIdentity(forGeohash geohash: String) throws -> NostrIdentity {
+        // Check cache first to avoid repeated crypto + keychain I/O during view rendering
+        cacheLock.lock()
+        if let cached = derivedIdentityCache[geohash] {
+            cacheLock.unlock()
+            return cached
+        }
+        cacheLock.unlock()
+
+        let seed = getOrCreateDeviceSeed()
+        guard let msg = geohash.data(using: .utf8) else {
+            throw NSError(domain: "NostrIdentity", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid geohash string"])
+        }
+
+        func candidateKey(iteration: UInt32) -> Data {
+            var input = Data(msg)
+            var iterBE = iteration.bigEndian
+            withUnsafeBytes(of: &iterBE) { bytes in
+                input.append(contentsOf: bytes)
+            }
+            let code = HMAC<SHA256>.authenticationCode(for: input, using: SymmetricKey(data: seed))
+            return Data(code)
+        }
+
+        // Try a few iterations to ensure a valid key can be formed
+        for i in 0..<10 {
+            let keyData = candidateKey(iteration: UInt32(i))
+            if let identity = try? NostrIdentity(privateKeyData: keyData) {
+                // Cache the result
+                cacheLock.lock()
+                derivedIdentityCache[geohash] = identity
+                cacheLock.unlock()
+                return identity
+            }
+        }
+        // As a final fallback, hash the seed+msg and try again
+        let fallback = (seed + msg).sha256Hash()
+        let identity = try NostrIdentity(privateKeyData: fallback)
+
+        // Cache the result
+        cacheLock.lock()
+        derivedIdentityCache[geohash] = identity
+        cacheLock.unlock()
+
+        return identity
+    }
+}

bitchat/Nostr/NostrProtocol.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import CryptoKit
 import P256K
@@ -17,6 +18,7 @@ struct NostrProtocol {
         case seal = 13 // NIP-17 sealed event
         case giftWrap = 1059 // NIP-59 gift wrap
         case ephemeralEvent = 20000
+        case geohashPresence = 20001
     }
     
     /// Create a NIP-17 private message
@@ -78,8 +80,7 @@ struct NostrProtocol {
             )
             // Successfully unwrapped gift wrap
         } catch {
-            SecureLogger.log("❌ Failed to unwrap gift wrap: \(error)", 
-                            category: SecureLogger.session, level: .error)
+            SecureLogger.error("❌ Failed to unwrap gift wrap: \(error)", category: .session)
             throw error
         }
         
@@ -92,8 +93,7 @@ struct NostrProtocol {
             )
             // Successfully opened seal
         } catch {
-            SecureLogger.log("❌ Failed to open seal: \(error)", 
-                            category: SecureLogger.session, level: .error)
+            SecureLogger.error("❌ Failed to open seal: \(error)", category: .session)
             throw error
         }
         
@@ -109,7 +109,7 @@ struct NostrProtocol {
         teleported: Bool = false
     ) throws -> NostrEvent {
         var tags = [["g", geohash]]
-        if let nickname = nickname, !nickname.isEmpty {
+        if let nickname = nickname?.trimmedOrNilIfEmpty {
             tags.append(["n", nickname])
         }
         if teleported {
@@ -125,6 +125,46 @@ struct NostrProtocol {
         let schnorrKey = try senderIdentity.schnorrSigningKey()
         return try event.sign(with: schnorrKey)
     }
+
+    /// Create a geohash presence heartbeat (kind 20001)
+    /// Must contain empty content and NO nickname tag
+    static func createGeohashPresenceEvent(
+        geohash: String,
+        senderIdentity: NostrIdentity
+    ) throws -> NostrEvent {
+        let tags = [["g", geohash]]
+        let event = NostrEvent(
+            pubkey: senderIdentity.publicKeyHex,
+            createdAt: Date(),
+            kind: .geohashPresence,
+            tags: tags,
+            content: ""
+        )
+        let schnorrKey = try senderIdentity.schnorrSigningKey()
+        return try event.sign(with: schnorrKey)
+    }
+
+    /// Create a persistent location note (kind 1: text note) tagged to a street-level geohash.
+    static func createGeohashTextNote(
+        content: String,
+        geohash: String,
+        senderIdentity: NostrIdentity,
+        nickname: String? = nil
+    ) throws -> NostrEvent {
+        var tags = [["g", geohash]]
+        if let nickname = nickname?.trimmedOrNilIfEmpty {
+            tags.append(["n", nickname])
+        }
+        let event = NostrEvent(
+            pubkey: senderIdentity.publicKeyHex,
+            createdAt: Date(),
+            kind: .textNote,
+            tags: tags,
+            content: content
+        )
+        let schnorrKey = try senderIdentity.schnorrSigningKey()
+        return try event.sign(with: schnorrKey)
+    }
     
     // MARK: - Private Methods
     
@@ -488,6 +528,26 @@ struct NostrEvent: Codable {
         signed.sig = signatureHex
         return signed
     }
+
+    /// Validate that the event ID and Schnorr signature match the content and pubkey.
+    /// Returns false when the signature is missing, malformed, or does not verify.
+    func isValidSignature() -> Bool {
+        guard let sig = sig,
+              let sigData = Data(hexString: sig),
+              let pubData = Data(hexString: pubkey),
+              sigData.count == 64,
+              pubData.count == 32,
+              let signature = try? P256K.Schnorr.SchnorrSignature(dataRepresentation: sigData),
+              let (expectedId, eventHash) = try? calculateEventId(),
+              expectedId == id
+        else {
+            return false
+        }
+
+        var messageBytes = [UInt8](eventHash)
+        let xonly = P256K.Schnorr.XonlyKey(dataRepresentation: pubData)
+        return xonly.isValid(signature, for: &messageBytes)
+    }
     
     private func calculateEventId() throws -> (String, Data) {
         let serialized = [
@@ -500,10 +560,7 @@ struct NostrEvent: Codable {
         ] as [Any]
         
         let data = try JSONSerialization.data(withJSONObject: serialized, options: [.withoutEscapingSlashes])
-        let hash = CryptoKit.SHA256.hash(data: data)
-        let hashData = Data(hash)
-        let hashHex = hash.compactMap { String(format: "%02x", $0) }.joined()
-        return (hashHex, hashData)
+        return (data.sha256Fingerprint(), data.sha256Hash())
     }
     
     func jsonString() throws -> String {

bitchat/Nostr/NostrRelayManager.swift

@@ -1,10 +1,106 @@
+import BitLogger
 import Foundation
 import Network
 import Combine
+import Tor
+
+protocol NostrRelayConnectionProtocol: AnyObject {
+    func resume()
+    func cancel(with closeCode: URLSessionWebSocketTask.CloseCode, reason: Data?)
+    func send(_ message: URLSessionWebSocketTask.Message, completionHandler: @escaping (Error?) -> Void)
+    func receive(completionHandler: @escaping (Result<URLSessionWebSocketTask.Message, Error>) -> Void)
+    func sendPing(pongReceiveHandler: @escaping (Error?) -> Void)
+}
+
+protocol NostrRelaySessionProtocol {
+    func webSocketTask(with url: URL) -> NostrRelayConnectionProtocol
+}
+
+private final class URLSessionWebSocketTaskAdapter: NostrRelayConnectionProtocol {
+    private let base: URLSessionWebSocketTask
+
+    init(base: URLSessionWebSocketTask) {
+        self.base = base
+    }
+
+    func resume() {
+        base.resume()
+    }
+
+    func cancel(with closeCode: URLSessionWebSocketTask.CloseCode, reason: Data?) {
+        base.cancel(with: closeCode, reason: reason)
+    }
+
+    func send(_ message: URLSessionWebSocketTask.Message, completionHandler: @escaping (Error?) -> Void) {
+        base.send(message, completionHandler: completionHandler)
+    }
+
+    func receive(completionHandler: @escaping (Result<URLSessionWebSocketTask.Message, Error>) -> Void) {
+        base.receive(completionHandler: completionHandler)
+    }
+
+    func sendPing(pongReceiveHandler: @escaping (Error?) -> Void) {
+        base.sendPing(pongReceiveHandler: pongReceiveHandler)
+    }
+}
+
+private struct URLSessionAdapter: NostrRelaySessionProtocol {
+    let base: URLSession
+
+    func webSocketTask(with url: URL) -> NostrRelayConnectionProtocol {
+        URLSessionWebSocketTaskAdapter(base: base.webSocketTask(with: url))
+    }
+}
+
+struct NostrRelayManagerDependencies {
+    var activationAllowed: () -> Bool
+    var userTorEnabled: () -> Bool
+    var hasMutualFavorites: () -> Bool
+    var hasLocationPermission: () -> Bool
+    var mutualFavoritesPublisher: AnyPublisher<Set<Data>, Never>
+    var locationPermissionPublisher: AnyPublisher<LocationChannelManager.PermissionState, Never>
+    var torEnforced: () -> Bool
+    var torIsReady: () -> Bool
+    var torIsForeground: () -> Bool
+    var awaitTorReady: (@escaping (Bool) -> Void) -> Void
+    var makeSession: () -> NostrRelaySessionProtocol
+    var scheduleAfter: @Sendable (TimeInterval, @escaping @Sendable () -> Void) -> Void
+    var now: () -> Date
+}
+
+private extension NostrRelayManagerDependencies {
+    @MainActor
+    static func live() -> Self {
+        Self(
+            activationAllowed: { NetworkActivationService.shared.activationAllowed },
+            userTorEnabled: { NetworkActivationService.shared.userTorEnabled },
+            hasMutualFavorites: { !FavoritesPersistenceService.shared.mutualFavorites.isEmpty },
+            hasLocationPermission: { LocationChannelManager.shared.permissionState == .authorized },
+            mutualFavoritesPublisher: FavoritesPersistenceService.shared.$mutualFavorites.eraseToAnyPublisher(),
+            locationPermissionPublisher: LocationChannelManager.shared.$permissionState.eraseToAnyPublisher(),
+            torEnforced: { TorManager.shared.torEnforced },
+            torIsReady: { TorManager.shared.isReady },
+            torIsForeground: { TorManager.shared.isForeground() },
+            awaitTorReady: { completion in
+                Task.detached {
+                    let ready = await TorManager.shared.awaitReady()
+                    await MainActor.run {
+                        completion(ready)
+                    }
+                }
+            },
+            makeSession: { URLSessionAdapter(base: TorURLSession.shared.session) },
+            scheduleAfter: { delay, action in
+                DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: action)
+            },
+            now: Date.init
+        )
+    }
+}
 
 /// Manages WebSocket connections to Nostr relays
 @MainActor
-class NostrRelayManager: ObservableObject {
+final class NostrRelayManager: ObservableObject {
     static let shared = NostrRelayManager()
     // Track gift-wraps (kind 1059) we initiated so we can log OK acks at info
     private(set) static var pendingGiftWrapIDs = Set<String>()
@@ -34,14 +130,30 @@ class NostrRelayManager: ObservableObject {
         "wss://nostr21.com"
         // For local testing, you can add: "ws://localhost:8080"
     ]
+    private static let defaultRelaySet = Set(defaultRelays)
     
     @Published private(set) var relays: [Relay] = []
     @Published private(set) var isConnected = false
     
-    private var connections: [String: URLSessionWebSocketTask] = [:]
-    private var subscriptions: [String: Set<String>] = [:] // relay URL -> subscription IDs
+    private let dependencies: NostrRelayManagerDependencies
+    private var allowDefaultRelays: Bool = false
+    private var hasMutualFavorites: Bool = false
+    private var hasLocationPermission: Bool = false
+    private var connections: [String: NostrRelayConnectionProtocol] = [:]
+    private var subscriptions: [String: Set<String>] = [:] // relay URL -> active subscription IDs
+    private var pendingSubscriptions: [String: [String: String]] = [:] // relay URL -> (subscription id -> encoded REQ JSON)
     private var messageHandlers: [String: (NostrEvent) -> Void] = [:]
+    // Coalesce duplicate subscribe requests for the same id within a short window
+    private var subscribeCoalesce: [String: Date] = [:]
     private var cancellables = Set<AnyCancellable>()
+
+    // Track EOSE per subscription to signal when initial stored events are done
+    private struct EOSETracker {
+        var pendingRelays: Set<String>
+        var callback: () -> Void
+        var timer: Timer?
+    }
+    private var eoseTrackers: [String: EOSETracker] = [:]
     
     // Message queue for reliability
     // Pending sends held only for relays that are not yet connected.
@@ -52,7 +164,7 @@ class NostrRelayManager: ObservableObject {
     private var messageQueue: [PendingSend] = []
     private let messageQueueLock = NSLock()
     private let encoder = JSONEncoder()
-    private let decoder = JSONDecoder()
+    private var shouldUseTor: Bool { dependencies.userTorEnabled() }
     
     // Exponential backoff configuration
     private let initialBackoffInterval: TimeInterval = TransportConfig.nostrRelayInitialBackoffSeconds
@@ -60,49 +172,140 @@ class NostrRelayManager: ObservableObject {
     private let backoffMultiplier: Double = TransportConfig.nostrRelayBackoffMultiplier
     private let maxReconnectAttempts = TransportConfig.nostrRelayMaxReconnectAttempts
     
-    // Reconnection timer
-    private var reconnectionTimer: Timer?
+    // Bump generation to invalidate scheduled reconnects when we reset/disconnect
+    private var connectionGeneration: Int = 0
     
     init() {
-        // Initialize with default relays
-        self.relays = Self.defaultRelays.map { Relay(url: $0) }
+        self.dependencies = .live()
+        hasMutualFavorites = dependencies.hasMutualFavorites()
+        hasLocationPermission = dependencies.hasLocationPermission()
+        applyDefaultRelayPolicy(force: true)
         // Deterministic JSON shape for outbound requests
         self.encoder.outputFormatting = .sortedKeys
+        dependencies.mutualFavoritesPublisher
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] favorites in
+                guard let self = self else { return }
+                self.hasMutualFavorites = !favorites.isEmpty
+                self.applyDefaultRelayPolicy()
+            }
+            .store(in: &cancellables)
+        dependencies.locationPermissionPublisher
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] state in
+                guard let self = self else { return }
+                let authorized = (state == .authorized)
+                if authorized == self.hasLocationPermission { return }
+                self.hasLocationPermission = authorized
+                self.applyDefaultRelayPolicy()
+            }
+            .store(in: &cancellables)
+    }
+
+    internal init(dependencies: NostrRelayManagerDependencies) {
+        self.dependencies = dependencies
+        hasMutualFavorites = dependencies.hasMutualFavorites()
+        hasLocationPermission = dependencies.hasLocationPermission()
+        applyDefaultRelayPolicy(force: true)
+        // Deterministic JSON shape for outbound requests
+        self.encoder.outputFormatting = .sortedKeys
+        dependencies.mutualFavoritesPublisher
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] favorites in
+                guard let self = self else { return }
+                self.hasMutualFavorites = !favorites.isEmpty
+                self.applyDefaultRelayPolicy()
+            }
+            .store(in: &cancellables)
+        dependencies.locationPermissionPublisher
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] state in
+                guard let self = self else { return }
+                let authorized = (state == .authorized)
+                if authorized == self.hasLocationPermission { return }
+                self.hasLocationPermission = authorized
+                self.applyDefaultRelayPolicy()
+            }
+            .store(in: &cancellables)
     }
     
     /// Connect to all configured relays
     func connect() {
-        SecureLogger.log("🌐 Connecting to \(relays.count) Nostr relays", category: SecureLogger.session, level: .debug)
-        for relay in relays {
-            connectToRelay(relay.url)
+        // Global network policy gate
+        guard dependencies.activationAllowed() else { return }
+        if shouldUseTor {
+            // Ensure Tor is started early and wait for readiness off-main; then hop back to connect.
+            dependencies.awaitTorReady { [weak self] ready in
+                guard let self = self else { return }
+                if !ready {
+                    SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
+                    return
+                }
+                SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
+                for relay in self.relays {
+                    self.connectToRelay(relay.url)
+                }
+            }
+        } else {
+            SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (direct)", category: .session)
+            for relay in self.relays {
+                connectToRelay(relay.url)
+            }
         }
     }
     
     /// Disconnect from all relays
     func disconnect() {
+        connectionGeneration &+= 1
         for (_, task) in connections {
             task.cancel(with: .goingAway, reason: nil)
         }
         connections.removeAll()
+        // Clear known subscriptions and any queued subs since connections are gone
+        subscriptions.removeAll()
+        pendingSubscriptions.removeAll()
         updateConnectionStatus()
     }
     
     /// Ensure connections exist to the given relay URLs (idempotent).
     func ensureConnections(to relayUrls: [String]) {
-        let existing = Set(relays.map { $0.url })
-        for url in Set(relayUrls) {
-            if !existing.contains(url) {
-                relays.append(Relay(url: url))
-            }
-            if connections[url] == nil {
-                connectToRelay(url)
+        // Global network policy gate
+        guard dependencies.activationAllowed() else { return }
+        let targets = allowedRelayList(from: relayUrls)
+        guard !targets.isEmpty else { return }
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady() {
+            // Defer until Tor is fully ready; avoid queuing connection attempts early
+            dependencies.awaitTorReady { [weak self] ready in
+                guard let self = self else { return }
+                if ready { self.ensureConnections(to: relayUrls) }
             }
+            return
+        }
+        var existing = Set(relays.map { $0.url })
+        for url in targets where !existing.contains(url) {
+            relays.append(Relay(url: url))
+            existing.insert(url)
+        }
+        for url in targets where connections[url] == nil {
+            connectToRelay(url)
         }
     }
 
     /// Send an event to specified relays (or all if none specified)
     func sendEvent(_ event: NostrEvent, to relayUrls: [String]? = nil) {
-        let targetRelays = relayUrls ?? Self.defaultRelays
+        // Global network policy gate
+        guard dependencies.activationAllowed() else { return }
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady() {
+            // Defer sends until Tor is ready to avoid premature queueing
+            dependencies.awaitTorReady { [weak self] ready in
+                guard let self = self else { return }
+                if ready { self.sendEvent(event, to: relayUrls) }
+            }
+            return
+        }
+        let requestedRelays = relayUrls ?? Self.defaultRelays
+        let targetRelays = allowedRelayList(from: requestedRelays)
+        guard !targetRelays.isEmpty else { return }
         ensureConnections(to: targetRelays)
 
         // Attempt immediate send to relays with active connections; queue the rest
@@ -164,63 +367,145 @@ class NostrRelayManager: ObservableObject {
         filter: NostrFilter,
         id: String = UUID().uuidString,
         relayUrls: [String]? = nil,
-        handler: @escaping (NostrEvent) -> Void
+        handler: @escaping (NostrEvent) -> Void,
+        onEOSE: (() -> Void)? = nil
     ) {
+        // Global network policy gate
+        guard dependencies.activationAllowed() else { return }
+        // Coalesce rapid duplicate subscribe requests only if a handler already exists
+        let now = dependencies.now()
+        if messageHandlers[id] != nil {
+            if let last = subscribeCoalesce[id], now.timeIntervalSince(last) < 1.0 {
+                return
+            }
+        }
+        subscribeCoalesce[id] = now
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady() {
+            // Defer subscription setup until Tor is ready; avoid queuing subs early
+            dependencies.awaitTorReady { [weak self] ready in
+                guard let self = self else { return }
+                if ready {
+                    self.subscribe(filter: filter, id: id, relayUrls: relayUrls, handler: handler, onEOSE: onEOSE)
+                }
+            }
+            return
+        }
         messageHandlers[id] = handler
         
-        SecureLogger.log("📡 Subscribing to Nostr filter id=\(id) kinds=\(filter.kinds ?? []) since=\(filter.since ?? 0)", 
-                        category: SecureLogger.session, level: .debug)
-        
         let req = NostrRequest.subscribe(id: id, filters: [filter])
         
         do {
             let message = try encoder.encode(req)
             guard let messageString = String(data: message, encoding: .utf8) else { 
-                SecureLogger.log("❌ Failed to encode subscription request", category: SecureLogger.session, level: .error)
+                SecureLogger.error("❌ Failed to encode subscription request", category: .session)
                 return 
             }
             
-            // SecureLogger.log("📋 Subscription filter JSON: \(messageString.prefix(200))...", 
-            //                 category: SecureLogger.session, level: .debug)
+            // SecureLogger.debug("📋 Subscription filter JSON: \(messageString.prefix(200))...", category: .session)
             
-            // Target specific relays if provided; else all connections
-            let urls = relayUrls ?? Self.defaultRelays
-            ensureConnections(to: urls)
-            let targets: [(String, URLSessionWebSocketTask)] = urls.compactMap { url in
-                connections[url].map { (url, $0) }
+            // Target specific relays if provided; else default. Filter permanently failed relays.
+            let baseUrls = relayUrls ?? Self.defaultRelays
+            let candidateUrls = baseUrls.filter { !isPermanentlyFailed($0) }
+            let urls = allowedRelayList(from: candidateUrls)
+            // Always queue subscriptions; sending happens when a relay reports connected
+            let existingSet = Set(relays.map { $0.url })
+            for url in urls where !existingSet.contains(url) {
+                relays.append(Relay(url: url))
             }
-
-            for (relayUrl, connection) in targets {
-                connection.send(.string(messageString)) { error in
-                    if let error = error {
-                        SecureLogger.log("❌ Failed to send subscription to \(relayUrl): \(error)", 
-                                        category: SecureLogger.session, level: .error)
-                    } else {
-                        // SecureLogger.log("✅ Subscription '\(id)' sent to relay: \(relayUrl)", 
-                        //                 category: SecureLogger.session, level: .debug)
-                        // Subscription sent successfully
+            for url in urls {
+                var map = self.pendingSubscriptions[url] ?? [:]
+                map[id] = messageString
+                self.pendingSubscriptions[url] = map
+            }
+            // Initialize EOSE tracking if requested
+            if let onEOSE = onEOSE {
+                if urls.isEmpty {
+                    onEOSE()
+                } else {
+                    var tracker = EOSETracker(pendingRelays: Set(urls), callback: onEOSE, timer: nil)
+                    // Fallback timeout to avoid hanging if a relay never sends EOSE
+                    tracker.timer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
                         Task { @MainActor in
-                            var subs = self.subscriptions[relayUrl] ?? Set<String>()
-                            subs.insert(id)
-                            self.subscriptions[relayUrl] = subs
+                            guard let self = self else { return }
+                            if let t = self.eoseTrackers[id] {
+                                t.timer?.invalidate()
+                                self.eoseTrackers.removeValue(forKey: id)
+                                onEOSE()
+                            }
                         }
                     }
+                    eoseTrackers[id] = tracker
                 }
             }
-            
-            if connections.isEmpty {
-                SecureLogger.log("⚠️ No relay connections available for subscription", 
-                                category: SecureLogger.session, level: .warning)
+            SecureLogger.debug("📋 Queued subscription id=\(id) for \(urls.count) relay(s)", category: .session)
+            // Ensure we actually have sockets opening to these relays so queued REQs can flush
+            ensureConnections(to: urls)
+            // If some targets are already connected, flush immediately for them
+            for url in urls {
+                if let r = relays.first(where: { $0.url == url }), r.isConnected {
+                    flushPendingSubscriptions(for: url)
+                }
             }
         } catch {
-            SecureLogger.log("❌ Failed to encode subscription request: \(error)", 
-                            category: SecureLogger.session, level: .error)
+            SecureLogger.error("❌ Failed to encode subscription request: \(error)", category: .session)
         }
     }
+
+    private func applyDefaultRelayPolicy(force: Bool = false) {
+        let shouldAllow = hasMutualFavorites || hasLocationPermission
+        if !force && shouldAllow == allowDefaultRelays { return }
+        allowDefaultRelays = shouldAllow
+        if shouldAllow {
+            var existing = Set(relays.map { $0.url })
+            for url in Self.defaultRelays where !existing.contains(url) {
+                relays.append(Relay(url: url))
+                existing.insert(url)
+            }
+            if dependencies.activationAllowed() {
+                ensureConnections(to: Self.defaultRelays)
+            }
+        } else {
+            for url in Self.defaultRelays {
+                if let connection = connections[url] {
+                    connection.cancel(with: .goingAway, reason: nil)
+                }
+                connections.removeValue(forKey: url)
+                subscriptions.removeValue(forKey: url)
+                pendingSubscriptions.removeValue(forKey: url)
+            }
+            messageQueueLock.lock()
+            for index in (0..<messageQueue.count).reversed() {
+                var item = messageQueue[index]
+                item.pendingRelays.subtract(Self.defaultRelaySet)
+                if item.pendingRelays.isEmpty {
+                    messageQueue.remove(at: index)
+                } else {
+                    messageQueue[index] = item
+                }
+            }
+            messageQueueLock.unlock()
+            relays.removeAll { Self.defaultRelaySet.contains($0.url) }
+            updateConnectionStatus()
+        }
+    }
+
+    private func allowedRelayList(from urls: [String]) -> [String] {
+        var seen = Set<String>()
+        var result: [String] = []
+        for url in urls {
+            if !allowDefaultRelays && Self.defaultRelaySet.contains(url) { continue }
+            if seen.insert(url).inserted {
+                result.append(url)
+            }
+        }
+        return result
+    }
     
     /// Unsubscribe from a subscription
     func unsubscribe(id: String) {
         messageHandlers.removeValue(forKey: id)
+        // Allow immediate re-subscription by clearing coalescer timestamp
+        subscribeCoalesce.removeValue(forKey: id)
         
         let req = NostrRequest.close(id: id)
         let message = try? encoder.encode(req)
@@ -231,10 +516,9 @@ class NostrRelayManager: ObservableObject {
         // Send unsubscribe to all relays
         for (relayUrl, connection) in connections {
             if subscriptions[relayUrl]?.contains(id) == true {
+                subscriptions[relayUrl]?.remove(id)
                 connection.send(.string(messageString)) { _ in
-                    Task { @MainActor in
-                        self.subscriptions[relayUrl]?.remove(id)
-                    }
+                    // Local state is cleared before sending so callers can re-subscribe immediately.
                 }
             }
         }
@@ -243,19 +527,39 @@ class NostrRelayManager: ObservableObject {
     // MARK: - Private Methods
     
     private func connectToRelay(_ urlString: String) {
+        // Global network policy gate
+        guard dependencies.activationAllowed() else { return }
         guard let url = URL(string: urlString) else { 
-            SecureLogger.log("Invalid relay URL: \(urlString)", category: SecureLogger.session, level: .warning)
+            SecureLogger.warning("Invalid relay URL: \(urlString)", category: .session)
             return 
         }
+
+        // Avoid initiating connections while app is backgrounded; we'll reconnect on foreground
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsForeground() {
+            return
+        }
         
         // Skip if we already have a connection object
         if connections[urlString] != nil {
             return
         }
+        if isPermanentlyFailed(urlString) {
+            return
+        }
         
-        // Attempting to connect to Nostr relay
+        // Attempting to connect to Nostr relay via the proxied session
         
-        let session = URLSession(configuration: .default)
+        // If Tor is enforced but not ready, delay connection until it is.
+        if shouldUseTor && dependencies.torEnforced() && !dependencies.torIsReady() {
+            dependencies.awaitTorReady { [weak self] ready in
+                guard let self = self else { return }
+                if ready { self.connectToRelay(urlString) }
+                else { SecureLogger.error("❌ Tor not ready; skipping connection to \(urlString)", category: .session) }
+            }
+            return
+        }
+        
+        let session = dependencies.makeSession()
         let task = session.webSocketTask(with: url)
         
         connections[urlString] = task
@@ -268,12 +572,12 @@ class NostrRelayManager: ObservableObject {
         task.sendPing { [weak self] error in
             DispatchQueue.main.async {
                 if error == nil {
-                    SecureLogger.log("✅ Connected to Nostr relay: \(urlString)", 
-                                   category: SecureLogger.session, level: .debug)
+                    SecureLogger.debug("✅ Connected to Nostr relay: \(urlString)", category: .session)
                     self?.updateRelayStatus(urlString, isConnected: true)
+                    // Flush any pending subscriptions for this relay
+                    self?.flushPendingSubscriptions(for: urlString)
                 } else {
-                    SecureLogger.log("❌ Failed to connect to Nostr relay \(urlString): \(error?.localizedDescription ?? "Unknown error")", 
-                                   category: SecureLogger.session, level: .error)
+                    SecureLogger.error("❌ Failed to connect to Nostr relay \(urlString): \(error?.localizedDescription ?? "Unknown error")", category: .session)
                     self?.updateRelayStatus(urlString, isConnected: false, error: error)
                     // Trigger disconnection handler for proper backoff
                     self?.handleDisconnection(relayUrl: urlString, error: error ?? NSError(domain: "NostrRelay", code: -1, userInfo: nil))
@@ -281,33 +585,40 @@ class NostrRelayManager: ObservableObject {
             }
         }
     }
+
+    /// Send any queued subscriptions for a relay that just connected.
+    private func flushPendingSubscriptions(for relayUrl: String) {
+        guard let map = pendingSubscriptions[relayUrl], !map.isEmpty else { return }
+        guard let connection = connections[relayUrl] else { return }
+        for (id, messageString) in map {
+            if self.subscriptions[relayUrl]?.contains(id) == true { continue }
+            connection.send(.string(messageString)) { error in
+                if let error = error {
+                    SecureLogger.error("❌ Failed to send pending subscription to \(relayUrl): \(error)", category: .session)
+                } else {
+                    Task { @MainActor in
+                        var subs = self.subscriptions[relayUrl] ?? Set<String>()
+                        subs.insert(id)
+                        self.subscriptions[relayUrl] = subs
+                    }
+                }
+            }
+        }
+        pendingSubscriptions[relayUrl] = nil
+    }
     
-    private func receiveMessage(from task: URLSessionWebSocketTask, relayUrl: String) {
+    private func receiveMessage(from task: NostrRelayConnectionProtocol, relayUrl: String) {
         task.receive { [weak self] result in
             guard let self = self else { return }
             
             switch result {
             case .success(let message):
-                switch message {
-                case .string(let text):
-                    // Parse off-main to reduce UI jank, then hop back for state updates
-                    Task.detached(priority: .utility) {
-                        guard let parsed = parseInboundMessage(text) else { return }
-                        await MainActor.run {
-                            NostrRelayManager.shared.handleParsedMessage(parsed, from: relayUrl)
-                        }
+                // Parse off-main to reduce UI jank, then hop back for state updates
+                Task.detached(priority: .utility) {
+                    guard let parsed = ParsedInbound(message) else { return }
+                    await MainActor.run {
+                        self.handleParsedMessage(parsed, from: relayUrl)
                     }
-                case .data(let data):
-                    if let text = String(data: data, encoding: .utf8) {
-                        Task.detached(priority: .utility) {
-                            guard let parsed = parseInboundMessage(text) else { return }
-                            await MainActor.run {
-                                NostrRelayManager.shared.handleParsedMessage(parsed, from: relayUrl)
-                            }
-                        }
-                    }
-                @unknown default:
-                    break
                 }
                 
                 // Continue receiving
@@ -332,8 +643,7 @@ class NostrRelayManager: ObservableObject {
         switch parsed {
         case .event(let subId, let event):
             if event.kind != 1059 {
-                SecureLogger.log("📥 Event kind=\(event.kind) id=\(event.id.prefix(16))… relay=\(relayUrl)",
-                                category: SecureLogger.session, level: .debug)
+                SecureLogger.debug("📥 Event kind=\(event.kind) id=\(event.id.prefix(16))… relay=\(relayUrl)", category: .session)
             }
             if let index = self.relays.firstIndex(where: { $0.url == relayUrl }) {
                 self.relays[index].messagesReceived += 1
@@ -341,45 +651,51 @@ class NostrRelayManager: ObservableObject {
             if let handler = self.messageHandlers[subId] {
                 handler(event)
             } else {
-                SecureLogger.log("⚠️ No handler for subscription \(subId)", 
-                                category: SecureLogger.session, level: .warning)
+                SecureLogger.warning("⚠️ No handler for subscription \(subId)", category: .session)
+            }
+        case .eose(let subId):
+            if var tracker = eoseTrackers[subId] {
+                tracker.pendingRelays.remove(relayUrl)
+                if tracker.pendingRelays.isEmpty {
+                    tracker.timer?.invalidate()
+                    eoseTrackers.removeValue(forKey: subId)
+                    tracker.callback()
+                } else {
+                    eoseTrackers[subId] = tracker
+                }
             }
-        case .eose:
-            // No-op for now
-            break
         case .ok(let eventId, let success, let reason):
             if success {
                 _ = Self.pendingGiftWrapIDs.remove(eventId)
-                SecureLogger.log("✅ Accepted id=\(eventId.prefix(16))… relay=\(relayUrl)",
-                                category: SecureLogger.session, level: .debug)
+                SecureLogger.debug("✅ Accepted id=\(eventId.prefix(16))… relay=\(relayUrl)", category: .session)
             } else {
                 let isGiftWrap = Self.pendingGiftWrapIDs.remove(eventId) != nil
-                SecureLogger.log("📮 Rejected id=\(eventId.prefix(16))… reason=\(reason)",
-                                category: SecureLogger.session, level: isGiftWrap ? .warning : .error)
+                if isGiftWrap {
+                    SecureLogger.warning("📮 Rejected id=\(eventId.prefix(16))… reason=\(reason)", category: .session)
+                } else {
+                    SecureLogger.error("📮 Rejected id=\(eventId.prefix(16))… reason=\(reason)", category: .session)
+                }
             }
         case .notice:
             break
         }
     }
     
-    private func sendToRelay(event: NostrEvent, connection: URLSessionWebSocketTask, relayUrl: String) {
+    private func sendToRelay(event: NostrEvent, connection: NostrRelayConnectionProtocol, relayUrl: String) {
         let req = NostrRequest.event(event)
         
         do {
             let data = try encoder.encode(req)
             let message = String(data: data, encoding: .utf8) ?? ""
             
-            SecureLogger.log("📤 Send kind=\(event.kind) id=\(event.id.prefix(16))… relay=\(relayUrl)", 
-                            category: SecureLogger.session, level: .debug)
+            SecureLogger.debug("📤 Send kind=\(event.kind) id=\(event.id.prefix(16))… relay=\(relayUrl)", category: .session)
             
             connection.send(.string(message)) { [weak self] error in
                 DispatchQueue.main.async {
                     if let error = error {
-                        SecureLogger.log("❌ Failed to send event to \(relayUrl): \(error)", 
-                                        category: SecureLogger.session, level: .error)
+                        SecureLogger.error("❌ Failed to send event to \(relayUrl): \(error)", category: .session)
                     } else {
-                        // SecureLogger.log("✅ Event sent to relay: \(relayUrl)", 
-                        //                 category: SecureLogger.session, level: .debug)
+                        // SecureLogger.debug("✅ Event sent to relay: \(relayUrl)", category: .session)
                         // Update relay stats
                         if let index = self?.relays.firstIndex(where: { $0.url == relayUrl }) {
                             self?.relays[index].messagesSent += 1
@@ -388,7 +704,7 @@ class NostrRelayManager: ObservableObject {
                 }
             }
         } catch {
-            SecureLogger.log("Failed to encode event: \(error)", category: SecureLogger.session, level: .error)
+            SecureLogger.error("Failed to encode event: \(error)", category: .session)
         }
     }
     
@@ -397,11 +713,11 @@ class NostrRelayManager: ObservableObject {
             relays[index].isConnected = isConnected
             relays[index].lastError = error
             if isConnected {
-                relays[index].lastConnectedAt = Date()
+                relays[index].lastConnectedAt = dependencies.now()
                 relays[index].reconnectAttempts = 0  // Reset on successful connection
                 relays[index].nextReconnectTime = nil
             } else {
-                relays[index].lastDisconnectedAt = Date()
+                relays[index].lastDisconnectedAt = dependencies.now()
             }
         }
         updateConnectionStatus()
@@ -416,22 +732,32 @@ class NostrRelayManager: ObservableObject {
     }
     
     private func handleDisconnection(relayUrl: String, error: Error) {
+        // If networking is disallowed, do not schedule reconnection
+        if !dependencies.activationAllowed() {
+            connections.removeValue(forKey: relayUrl)
+            subscriptions.removeValue(forKey: relayUrl)
+            updateRelayStatus(relayUrl, isConnected: false, error: error)
+            return
+        }
         connections.removeValue(forKey: relayUrl)
         subscriptions.removeValue(forKey: relayUrl)
         updateRelayStatus(relayUrl, isConnected: false, error: error)
         
-        // Check if this is a DNS error
+        // Check if this is a DNS or handshake error; treat as permanent
         let errorDescription = error.localizedDescription.lowercased()
+        let ns = error as NSError
         if errorDescription.contains("hostname could not be found") || 
-           errorDescription.contains("dns") {
-            // Only log once for DNS failures
+           errorDescription.contains("dns") ||
+           (ns.domain == NSURLErrorDomain && ns.code == NSURLErrorBadServerResponse) {
             if relays.first(where: { $0.url == relayUrl })?.lastError == nil {
-                SecureLogger.log("Nostr relay DNS failure for \(relayUrl) - not retrying", category: SecureLogger.session, level: .warning)
+                SecureLogger.warning("Nostr relay permanent failure for \(relayUrl) - not retrying (code=\(ns.code))", category: .session)
             }
-            // Mark relay as permanently failed
             if let index = relays.firstIndex(where: { $0.url == relayUrl }) {
                 relays[index].lastError = error
+                relays[index].reconnectAttempts = maxReconnectAttempts
+                relays[index].nextReconnectTime = nil
             }
+            pendingSubscriptions[relayUrl] = nil
             return
         }
         
@@ -442,8 +768,7 @@ class NostrRelayManager: ObservableObject {
         
         // Stop attempting after max attempts
         if relays[index].reconnectAttempts >= maxReconnectAttempts {
-            SecureLogger.log("Max reconnection attempts (\(maxReconnectAttempts)) reached for \(relayUrl)", 
-                           category: SecureLogger.session, level: .warning)
+            SecureLogger.warning("Max reconnection attempts (\(maxReconnectAttempts)) reached for \(relayUrl)", category: .session)
             return
         }
         
@@ -453,17 +778,21 @@ class NostrRelayManager: ObservableObject {
             maxBackoffInterval
         )
         
-        let nextReconnectTime = Date().addingTimeInterval(backoffInterval)
+        let nextReconnectTime = dependencies.now().addingTimeInterval(backoffInterval)
         relays[index].nextReconnectTime = nextReconnectTime
         
         
         // Schedule reconnection with exponential backoff
-        DispatchQueue.main.asyncAfter(deadline: .now() + backoffInterval) { [weak self] in
-            guard let self = self else { return }
-            
-            // Check if we should still reconnect (relay might have been removed)
-            if self.relays.contains(where: { $0.url == relayUrl }) {
-                self.connectToRelay(relayUrl)
+        let gen = connectionGeneration
+        dependencies.scheduleAfter(backoffInterval) { [weak self] in
+            Task { @MainActor [weak self] in
+                guard let self = self else { return }
+                // Ignore stale scheduled reconnects from a previous generation
+                guard gen == self.connectionGeneration else { return }
+                // Check if we should still reconnect (relay might have been removed)
+                if self.relays.contains(where: { $0.url == relayUrl }) {
+                    self.connectToRelay(relayUrl)
+                }
             }
         }
     }
@@ -477,6 +806,7 @@ class NostrRelayManager: ObservableObject {
         // Reset reconnection attempts
         relays[index].reconnectAttempts = 0
         relays[index].nextReconnectTime = nil
+        relays[index].lastError = nil
         
         // Disconnect if connected
         if let connection = connections[relayUrl] {
@@ -497,10 +827,26 @@ class NostrRelayManager: ObservableObject {
              nextReconnectTime: relay.nextReconnectTime)
         }
     }
+
+    var debugPendingMessageQueueCount: Int {
+        messageQueueLock.lock()
+        defer { messageQueueLock.unlock() }
+        return messageQueue.count
+    }
+
+    func debugPendingSubscriptionCount(for relayUrl: String) -> Int {
+        pendingSubscriptions[relayUrl]?.count ?? 0
+    }
+
+    func debugFlushMessageQueue() {
+        flushMessageQueue(for: nil)
+    }
     
     /// Reset all relay connections
     func resetAllConnections() {
         disconnect()
+        // New generation begins now
+        connectionGeneration &+= 1
         
         // Reset all relay states
         for index in relays.indices {
@@ -512,6 +858,18 @@ class NostrRelayManager: ObservableObject {
         // Reconnect
         connect()
     }
+
+    // MARK: - Failure classification
+    private func isPermanentlyFailed(_ url: String) -> Bool {
+        guard let r = relays.first(where: { $0.url == url }) else { return false }
+        if r.reconnectAttempts >= maxReconnectAttempts { return true }
+        if let ns = r.lastError as NSError?, ns.domain == NSURLErrorDomain {
+            if ns.code == NSURLErrorBadServerResponse || ns.code == NSURLErrorCannotFindHost {
+                return true
+            }
+        }
+        return false
+    }
 }
 
 // MARK: - Off-main inbound parsing helpers (file scope, non-isolated)
@@ -521,42 +879,61 @@ private enum ParsedInbound {
     case ok(eventId: String, success: Bool, reason: String)
     case eose(subscriptionId: String)
     case notice(String)
+    
+    init?(_ message: URLSessionWebSocketTask.Message) {
+        guard let data = message.data,
+              let array = try? JSONSerialization.jsonObject(with: data) as? [Any],
+              array.count >= 2,
+              let type = array[0] as? String else {
+            return nil
+        }
+
+        switch type {
+        case "EVENT":
+            if array.count >= 3,
+               let subId = array[1] as? String,
+               let eventDict = array[2] as? [String: Any],
+               let event = try? NostrEvent(from: eventDict),
+               event.isValidSignature() {
+                self = .event(subId: subId, event: event)
+                return
+            }
+            return nil
+        case "EOSE":
+            if let subId = array[1] as? String {
+                self = .eose(subscriptionId: subId)
+                return
+            }
+            return nil
+        case "OK":
+            if array.count >= 3,
+               let eventId = array[1] as? String,
+               let success = array[2] as? Bool {
+                let reason = array.count >= 4 ? (array[3] as? String ?? "no reason given") : "no reason given"
+                self = .ok(eventId: eventId, success: success, reason: reason)
+                return
+            }
+            return nil
+        case "NOTICE":
+            if array.count >= 2, let msg = array[1] as? String {
+                self = .notice(msg)
+                return
+            }
+            return nil
+        default:
+            return nil
+        }
+    }
 }
 
-// Off-main JSON parse to avoid UI jank; pure function, not actor-isolated
-private func parseInboundMessage(_ message: String) -> ParsedInbound? {
-    guard let data = message.data(using: .utf8) else { return nil }
-    do {
-        if let array = try JSONSerialization.jsonObject(with: data) as? [Any],
-           array.count >= 2,
-           let type = array[0] as? String {
-            switch type {
-            case "EVENT":
-                if array.count >= 3,
-                   let subId = array[1] as? String,
-                   let eventDict = array[2] as? [String: Any] {
-                    let event = try NostrEvent(from: eventDict)
-                    return .event(subId: subId, event: event)
-                }
-            case "EOSE":
-                if let subId = array[1] as? String { return .eose(subscriptionId: subId) }
-            case "OK":
-                if array.count >= 3,
-                   let eventId = array[1] as? String,
-                   let success = array[2] as? Bool {
-                    let reason = array.count >= 4 ? (array[3] as? String ?? "no reason given") : "no reason given"
-                    return .ok(eventId: eventId, success: success, reason: reason)
-                }
-            case "NOTICE":
-                if array.count >= 2, let msg = array[1] as? String { return .notice(msg) }
-            default:
-                return nil
-            }
+private extension URLSessionWebSocketTask.Message {
+    var data: Data? {
+        switch self {
+        case .string(let text): text.data(using: .utf8)
+        case .data(let data):   data
+        @unknown default:       nil
         }
-    } catch {
-        // Ignore
     }
-    return nil
 }
 
 // MARK: - Nostr Protocol Types
@@ -637,15 +1014,35 @@ struct NostrFilter: Encodable {
         return filter
     }
 
-    // For location channels: geohash-scoped ephemeral events (kind 20000)
-    static func geohashEphemeral(_ geohash: String, since: Date? = nil, limit: Int = 200) -> NostrFilter {
+    // For location channels: geohash-scoped ephemeral events (kind 20000) and presence (kind 20001)
+    static func geohashEphemeral(_ geohash: String, since: Date? = nil, limit: Int = 1000) -> NostrFilter {
         var filter = NostrFilter()
-        filter.kinds = [20000]
+        filter.kinds = [20000, 20001]
         filter.since = since?.timeIntervalSince1970.toInt()
         filter.tagFilters = ["g": [geohash]]
         filter.limit = limit
         return filter
     }
+
+    // For location notes: persistent text notes (kind 1) tagged with geohash
+    static func geohashNotes(_ geohash: String, since: Date? = nil, limit: Int = 200) -> NostrFilter {
+        var filter = NostrFilter()
+        filter.kinds = [1]
+        filter.since = since?.timeIntervalSince1970.toInt()
+        filter.tagFilters = ["g": [geohash]]
+        filter.limit = limit
+        return filter
+    }
+
+    // For location notes with neighbors: subscribe to multiple geohashes (center + neighbors)
+    static func geohashNotes(_ geohashes: [String], since: Date? = nil, limit: Int = 200) -> NostrFilter {
+        var filter = NostrFilter()
+        filter.kinds = [1]
+        filter.since = since?.timeIntervalSince1970.toInt()
+        filter.tagFilters = ["g": geohashes]
+        filter.limit = limit
+        return filter
+    }
 }
 
 // Dynamic coding key for tag filters

bitchat/Nostr/XChaCha20Poly1305Compat.swift

@@ -5,16 +5,27 @@ import CryptoKit
 /// Implements HChaCha20 to derive a subkey and reduces the 24-byte nonce to a 12-byte nonce
 /// as per XChaCha20 construction.
 enum XChaCha20Poly1305Compat {
+
+    /// Errors that can occur during XChaCha20-Poly1305 operations
+    enum Error: Swift.Error {
+        case invalidKeyLength(expected: Int, got: Int)
+        case invalidNonceLength(expected: Int, got: Int)
+    }
+
     struct SealBox {
         let ciphertext: Data
         let tag: Data
     }
 
     static func seal(plaintext: Data, key: Data, nonce24: Data, aad: Data? = nil) throws -> SealBox {
-        precondition(key.count == 32, "XChaCha20 key must be 32 bytes")
-        precondition(nonce24.count == 24, "XChaCha20 nonce must be 24 bytes")
+        guard key.count == 32 else {
+            throw Error.invalidKeyLength(expected: 32, got: key.count)
+        }
+        guard nonce24.count == 24 else {
+            throw Error.invalidNonceLength(expected: 24, got: nonce24.count)
+        }
 
-        let subkey = hchacha20(key: key, nonce16: nonce24.prefix(16))
+        let subkey = try hchacha20(key: key, nonce16: Data(nonce24.prefix(16)))
         let nonce12 = derive12ByteNonce(from24: nonce24)
         let chachaKey = SymmetricKey(data: subkey)
         let nonce = try ChaChaPoly.Nonce(data: nonce12)
@@ -23,10 +34,14 @@ enum XChaCha20Poly1305Compat {
     }
 
     static func open(ciphertext: Data, tag: Data, key: Data, nonce24: Data, aad: Data? = nil) throws -> Data {
-        precondition(key.count == 32, "XChaCha20 key must be 32 bytes")
-        precondition(nonce24.count == 24, "XChaCha20 nonce must be 24 bytes")
+        guard key.count == 32 else {
+            throw Error.invalidKeyLength(expected: 32, got: key.count)
+        }
+        guard nonce24.count == 24 else {
+            throw Error.invalidNonceLength(expected: 24, got: nonce24.count)
+        }
 
-        let subkey = hchacha20(key: key, nonce16: nonce24.prefix(16))
+        let subkey = try hchacha20(key: key, nonce16: Data(nonce24.prefix(16)))
         let nonce12 = derive12ByteNonce(from24: nonce24)
         let chachaKey = SymmetricKey(data: subkey)
         let box = try ChaChaPoly.SealedBox(nonce: ChaChaPoly.Nonce(data: nonce12), ciphertext: ciphertext, tag: tag)
@@ -43,10 +58,14 @@ enum XChaCha20Poly1305Compat {
         return out
     }
 
-    private static func hchacha20(key: Data, nonce16: Data) -> Data {
+    private static func hchacha20(key: Data, nonce16: Data) throws -> Data {
         // HChaCha20 based on the original ChaCha20 core with a 16-byte nonce.
-        precondition(key.count == 32)
-        precondition(nonce16.count == 16)
+        guard key.count == 32 else {
+            throw Error.invalidKeyLength(expected: 32, got: key.count)
+        }
+        guard nonce16.count == 16 else {
+            throw Error.invalidNonceLength(expected: 16, got: nonce16.count)
+        }
 
         // Constants "expand 32-byte k"
         var state: [UInt32] = [

bitchat/Protocols/BinaryProtocol.swift

@@ -1,563 +0,0 @@
-//
-// BinaryProtocol.swift
-// bitchat
-//
-// This is free and unencumbered software released into the public domain.
-// For more information, see <https://unlicense.org>
-//
-
-///
-/// # BinaryProtocol
-///
-/// Low-level binary encoding and decoding for BitChat protocol messages.
-/// Optimized for Bluetooth LE's limited bandwidth and MTU constraints.
-///
-/// ## Overview
-/// BinaryProtocol implements an efficient binary wire format that minimizes
-/// overhead while maintaining extensibility. It handles:
-/// - Compact binary encoding with fixed headers
-/// - Optional field support via flags
-/// - Automatic compression for large payloads
-/// - Endianness handling for cross-platform compatibility
-///
-/// ## Wire Format
-/// ```
-/// Header (Fixed 13 bytes):
-/// +--------+------+-----+-----------+-------+----------------+
-/// |Version | Type | TTL | Timestamp | Flags | PayloadLength  |
-/// |1 byte  |1 byte|1byte| 8 bytes   | 1 byte| 2 bytes        |
-/// +--------+------+-----+-----------+-------+----------------+
-///
-/// Variable sections:
-/// +----------+-------------+---------+------------+
-/// | SenderID | RecipientID | Payload | Signature  |
-/// | 8 bytes  | 8 bytes*    | Variable| 64 bytes*  |
-/// +----------+-------------+---------+------------+
-/// * Optional fields based on flags
-/// ```
-///
-/// ## Design Rationale
-/// The protocol is designed for:
-/// - **Efficiency**: Minimal overhead for small messages
-/// - **Flexibility**: Optional fields via flag bits
-/// - **Compatibility**: Network byte order (big-endian)
-/// - **Performance**: Zero-copy where possible
-///
-/// ## Compression Strategy
-/// - Automatic compression for payloads > 256 bytes
-/// - zlib compression for broad compatibility on Apple platforms
-/// - Original size stored for decompression
-/// - Flag bit indicates compressed payload
-///
-/// ## Flag Bits
-/// - Bit 0: Has recipient ID (directed message)
-/// - Bit 1: Has signature (authenticated message)
-/// - Bit 2: Is compressed (LZ4 compression applied)
-/// - Bits 3-7: Reserved for future use
-///
-/// ## Size Constraints
-/// - Maximum packet size: 65,535 bytes (16-bit length field)
-/// - Typical packet size: < 512 bytes (BLE MTU)
-/// - Minimum packet size: 21 bytes (header + sender ID)
-///
-/// ## Encoding Process
-/// 1. Construct header with fixed fields
-/// 2. Set appropriate flags
-/// 3. Compress payload if beneficial
-/// 4. Append variable-length fields
-/// 5. Calculate and append signature if needed
-///
-/// ## Decoding Process
-/// 1. Validate minimum packet size
-/// 2. Parse fixed header
-/// 3. Extract flags and determine field presence
-/// 4. Parse variable fields based on flags
-/// 5. Decompress payload if compressed
-/// 6. Verify signature if present
-///
-/// ## Error Handling
-/// - Graceful handling of malformed packets
-/// - Clear error messages for debugging
-/// - No crashes on invalid input
-/// - Logging of protocol violations
-///
-/// ## Performance Notes
-/// - Allocation-free for small messages
-/// - Streaming support for large payloads
-/// - Efficient bit manipulation
-/// - Platform-optimized byte swapping
-///
-
-import Foundation
-
-extension Data {
-    func trimmingNullBytes() -> Data {
-        // Find the first null byte
-        if let nullIndex = self.firstIndex(of: 0) {
-            return self.prefix(nullIndex)
-        }
-        return self
-    }
-}
-
-/// Implements binary encoding and decoding for BitChat protocol messages.
-/// Provides static methods for converting between BitchatPacket objects and
-/// their binary wire format representation.
-/// - Note: All multi-byte values use network byte order (big-endian)
-struct BinaryProtocol {
-    static let headerSize = 13
-    static let senderIDSize = 8
-    static let recipientIDSize = 8
-    static let signatureSize = 64
-    
-    struct Flags {
-        static let hasRecipient: UInt8 = 0x01
-        static let hasSignature: UInt8 = 0x02
-        static let isCompressed: UInt8 = 0x04
-    }
-    
-    // Encode BitchatPacket to binary format
-    static func encode(_ packet: BitchatPacket, padding: Bool = true) -> Data? {
-        var data = Data()
-        
-        
-        // Try to compress payload if beneficial
-        var payload = packet.payload
-        var originalPayloadSize: UInt16? = nil
-        var isCompressed = false
-        
-        if CompressionUtil.shouldCompress(payload) {
-            if let compressedPayload = CompressionUtil.compress(payload) {
-                // Store original size for decompression (2 bytes after payload)
-                originalPayloadSize = UInt16(payload.count)
-                payload = compressedPayload
-                isCompressed = true
-                
-            } else {
-            }
-        } else {
-        }
-        
-        // Header
-        // Reserve capacity to reduce reallocations. Estimate base size conservatively.
-        // header(13) + sender(8) + opt recipient(8) + opt originalSize(2) + payload + opt signature(64) + up to 255 pad
-        let estimatedPayload = payload.count + (isCompressed ? 2 : 0)
-        let estimated = headerSize + senderIDSize + (packet.recipientID == nil ? 0 : recipientIDSize) + estimatedPayload + (packet.signature == nil ? 0 : signatureSize) + 255
-        data.reserveCapacity(estimated)
-        data.append(packet.version)
-        data.append(packet.type)
-        data.append(packet.ttl)
-        
-        // Timestamp (8 bytes, big-endian)
-        for i in (0..<8).reversed() {
-            data.append(UInt8((packet.timestamp >> (i * 8)) & 0xFF))
-        }
-        
-        // Flags
-        var flags: UInt8 = 0
-        if packet.recipientID != nil {
-            flags |= Flags.hasRecipient
-        }
-        if packet.signature != nil {
-            flags |= Flags.hasSignature
-        }
-        if isCompressed {
-            flags |= Flags.isCompressed
-        }
-        data.append(flags)
-        
-        // Payload length (2 bytes, big-endian) - includes original size if compressed
-        let payloadDataSize = payload.count + (isCompressed ? 2 : 0)
-        let payloadLength = UInt16(payloadDataSize)
-        
-        
-        data.append(UInt8((payloadLength >> 8) & 0xFF))
-        data.append(UInt8(payloadLength & 0xFF))
-        
-        // SenderID (exactly 8 bytes)
-        let senderBytes = packet.senderID.prefix(senderIDSize)
-        data.append(senderBytes)
-        if senderBytes.count < senderIDSize {
-            data.append(Data(repeating: 0, count: senderIDSize - senderBytes.count))
-        }
-        
-        // RecipientID (if present)
-        if let recipientID = packet.recipientID {
-            let recipientBytes = recipientID.prefix(recipientIDSize)
-            data.append(recipientBytes)
-            if recipientBytes.count < recipientIDSize {
-                data.append(Data(repeating: 0, count: recipientIDSize - recipientBytes.count))
-            }
-        }
-        
-        // Payload (with original size prepended if compressed)
-        if isCompressed, let originalSize = originalPayloadSize {
-            // Prepend original size (2 bytes, big-endian)
-            data.append(UInt8((originalSize >> 8) & 0xFF))
-            data.append(UInt8(originalSize & 0xFF))
-        }
-        data.append(payload)
-        
-        // Signature (if present)
-        if let signature = packet.signature {
-            data.append(signature.prefix(signatureSize))
-        }
-        
-        
-        // Apply padding to standard block sizes for traffic analysis resistance
-        if padding {
-            let optimalSize = MessagePadding.optimalBlockSize(for: data.count)
-            let paddedData = MessagePadding.pad(data, toSize: optimalSize)
-            return paddedData
-        } else {
-            // Caller explicitly requested no padding (e.g., BLE write path)
-            return data
-        }
-    }
-    
-    // Decode binary data to BitchatPacket
-    static func decode(_ data: Data) -> BitchatPacket? {
-        // Try decode as-is first (robust when padding wasn't applied)
-        if let pkt = decodeCore(data) { return pkt }
-        // If that fails, try after removing padding
-        let unpadded = MessagePadding.unpad(data)
-        if unpadded as NSData === data as NSData { return nil }
-        return decodeCore(unpadded)
-    }
-
-    // Core decoding implementation used by decode(_:) with and without padding removal
-    private static func decodeCore(_ raw: Data) -> BitchatPacket? {
-        // Minimum size: header + senderID
-        guard raw.count >= headerSize + senderIDSize else { return nil }
-
-        return raw.withUnsafeBytes { (buf: UnsafeRawBufferPointer) -> BitchatPacket? in
-            guard let base = buf.baseAddress else { return nil }
-            var offset = 0
-            func require(_ n: Int) -> Bool { offset + n <= buf.count }
-            // Read single byte
-            func read8() -> UInt8? {
-                guard require(1) else { return nil }
-                let v = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self).pointee
-                offset += 1
-                return v
-            }
-            // Read big-endian 16-bit
-            func read16() -> UInt16? {
-                guard require(2) else { return nil }
-                let p = base.advanced(by: offset).assumingMemoryBound(to: UInt8.self)
-                let v = (UInt16(p[0]) << 8) | UInt16(p[1])
-                offset += 2
-                return v
-            }
-            // Copy N bytes into Data
-            func readData(_ n: Int) -> Data? {
-                guard require(n) else { return nil }
-                let ptr = base.advanced(by: offset)
-                let d = Data(bytes: ptr, count: n)
-                offset += n
-                return d
-            }
-
-            // Version
-            guard let version = read8(), version == 1 else { return nil }
-            guard let type = read8() else { return nil }
-            guard let ttl = read8() else { return nil }
-
-            // Timestamp 8 bytes BE
-            guard require(8) else { return nil }
-            var ts: UInt64 = 0
-            for _ in 0..<8 {
-                guard let b = read8() else { return nil }
-                ts = (ts << 8) | UInt64(b)
-            }
-
-            // Flags
-            guard let flags = read8() else { return nil }
-            let hasRecipient = (flags & Flags.hasRecipient) != 0
-            let hasSignature = (flags & Flags.hasSignature) != 0
-            let isCompressed = (flags & Flags.isCompressed) != 0
-
-            // Payload length
-            guard let payloadLen = read16(), payloadLen <= 65535 else { return nil }
-
-            // SenderID
-            guard let senderID = readData(senderIDSize) else { return nil }
-
-            // Recipient
-            var recipientID: Data? = nil
-            if hasRecipient {
-                recipientID = readData(recipientIDSize)
-                if recipientID == nil { return nil }
-            }
-
-            // Payload
-            let payload: Data
-            if isCompressed {
-                // Need original size (2 bytes)
-                guard let origSize16 = read16() else { return nil }
-                let originalSize = Int(origSize16)
-                guard originalSize >= 0 && originalSize <= 1_048_576 else { return nil }
-                let compSize = Int(payloadLen) - 2
-                guard compSize >= 0, let compressed = readData(compSize) else { return nil }
-                guard let decompressed = CompressionUtil.decompress(compressed, originalSize: originalSize),
-                      decompressed.count == originalSize else { return nil }
-                payload = decompressed
-            } else {
-                guard let p = readData(Int(payloadLen)) else { return nil }
-                payload = p
-            }
-
-            // Signature
-            var signature: Data? = nil
-            if hasSignature {
-                signature = readData(signatureSize)
-                if signature == nil { return nil }
-            }
-
-            guard offset <= buf.count else { return nil }
-
-            return BitchatPacket(
-                type: type,
-                senderID: senderID,
-                recipientID: recipientID,
-                timestamp: ts,
-                payload: payload,
-                signature: signature,
-                ttl: ttl
-            )
-        }
-    }
-}
-
-// Binary encoding for BitchatMessage
-extension BitchatMessage {
-    func toBinaryPayload() -> Data? {
-        var data = Data()
-        
-        // Message format:
-        // - Flags: 1 byte (bit 0: isRelay, bit 1: isPrivate, bit 2: hasOriginalSender, bit 3: hasRecipientNickname, bit 4: hasSenderPeerID, bit 5: hasMentions)
-        // - Timestamp: 8 bytes (seconds since epoch)
-        // - ID length: 1 byte
-        // - ID: variable
-        // - Sender length: 1 byte
-        // - Sender: variable
-        // - Content length: 2 bytes
-        // - Content: variable
-        // Optional fields based on flags:
-        // - Original sender length + data
-        // - Recipient nickname length + data
-        // - Sender peer ID length + data
-        // - Mentions array
-        
-        var flags: UInt8 = 0
-        if isRelay { flags |= 0x01 }
-        if isPrivate { flags |= 0x02 }
-        if originalSender != nil { flags |= 0x04 }
-        if recipientNickname != nil { flags |= 0x08 }
-        if senderPeerID != nil { flags |= 0x10 }
-        if mentions != nil && !mentions!.isEmpty { flags |= 0x20 }
-        
-        data.append(flags)
-        
-        // Timestamp (in milliseconds)
-        let timestampMillis = UInt64(timestamp.timeIntervalSince1970 * 1000)
-        // Encode as 8 bytes, big-endian
-        for i in (0..<8).reversed() {
-            data.append(UInt8((timestampMillis >> (i * 8)) & 0xFF))
-        }
-        
-        // ID
-        if let idData = id.data(using: .utf8) {
-            data.append(UInt8(min(idData.count, 255)))
-            data.append(idData.prefix(255))
-        } else {
-            data.append(0)
-        }
-        
-        // Sender
-        if let senderData = sender.data(using: .utf8) {
-            data.append(UInt8(min(senderData.count, 255)))
-            data.append(senderData.prefix(255))
-        } else {
-            data.append(0)
-        }
-        
-        // Content
-        if let contentData = content.data(using: .utf8) {
-            let length = UInt16(min(contentData.count, 65535))
-            // Encode length as 2 bytes, big-endian
-            data.append(UInt8((length >> 8) & 0xFF))
-            data.append(UInt8(length & 0xFF))
-            data.append(contentData.prefix(Int(length)))
-        } else {
-            data.append(contentsOf: [0, 0])
-        }
-        
-        // Optional fields
-        if let originalSender = originalSender, let origData = originalSender.data(using: .utf8) {
-            data.append(UInt8(min(origData.count, 255)))
-            data.append(origData.prefix(255))
-        }
-        
-        if let recipientNickname = recipientNickname, let recipData = recipientNickname.data(using: .utf8) {
-            data.append(UInt8(min(recipData.count, 255)))
-            data.append(recipData.prefix(255))
-        }
-        
-        if let senderPeerID = senderPeerID, let peerData = senderPeerID.data(using: .utf8) {
-            data.append(UInt8(min(peerData.count, 255)))
-            data.append(peerData.prefix(255))
-        }
-        
-        // Mentions array
-        if let mentions = mentions {
-            data.append(UInt8(min(mentions.count, 255))) // Number of mentions
-            for mention in mentions.prefix(255) {
-                if let mentionData = mention.data(using: .utf8) {
-                    data.append(UInt8(min(mentionData.count, 255)))
-                    data.append(mentionData.prefix(255))
-                } else {
-                    data.append(0)
-                }
-            }
-        }
-        
-        
-        return data
-    }
-    
-    static func fromBinaryPayload(_ data: Data) -> BitchatMessage? {
-        // Create an immutable copy to prevent threading issues
-        let dataCopy = Data(data)
-        
-        
-        guard dataCopy.count >= 13 else { 
-            return nil 
-        }
-        
-        var offset = 0
-        
-        // Flags
-        guard offset < dataCopy.count else { 
-            return nil 
-        }
-        let flags = dataCopy[offset]; offset += 1
-        let isRelay = (flags & 0x01) != 0
-        let isPrivate = (flags & 0x02) != 0
-        let hasOriginalSender = (flags & 0x04) != 0
-        let hasRecipientNickname = (flags & 0x08) != 0
-        let hasSenderPeerID = (flags & 0x10) != 0
-        let hasMentions = (flags & 0x20) != 0
-        
-        // Timestamp
-        guard offset + 8 <= dataCopy.count else { 
-            return nil 
-        }
-        let timestampData = dataCopy[offset..<offset+8]
-        let timestampMillis = timestampData.reduce(0) { result, byte in
-            (result << 8) | UInt64(byte)
-        }
-        offset += 8
-        let timestamp = Date(timeIntervalSince1970: TimeInterval(timestampMillis) / 1000.0)
-        
-        // ID
-        guard offset < dataCopy.count else { 
-            return nil 
-        }
-        let idLength = Int(dataCopy[offset]); offset += 1
-        guard offset + idLength <= dataCopy.count else { 
-            return nil 
-        }
-        let id = String(data: dataCopy[offset..<offset+idLength], encoding: .utf8) ?? UUID().uuidString
-        offset += idLength
-        
-        // Sender
-        guard offset < dataCopy.count else { 
-            return nil 
-        }
-        let senderLength = Int(dataCopy[offset]); offset += 1
-        guard offset + senderLength <= dataCopy.count else { 
-            return nil 
-        }
-        let sender = String(data: dataCopy[offset..<offset+senderLength], encoding: .utf8) ?? "unknown"
-        offset += senderLength
-        
-        // Content
-        guard offset + 2 <= dataCopy.count else { 
-            return nil 
-        }
-        let contentLengthData = dataCopy[offset..<offset+2]
-        let contentLength = Int(contentLengthData.reduce(0) { result, byte in
-            (result << 8) | UInt16(byte)
-        })
-        offset += 2
-        guard offset + contentLength <= dataCopy.count else { 
-            return nil 
-        }
-        
-        let content = String(data: dataCopy[offset..<offset+contentLength], encoding: .utf8) ?? ""
-        offset += contentLength
-        
-        // Optional fields
-        var originalSender: String?
-        if hasOriginalSender && offset < dataCopy.count {
-            let length = Int(dataCopy[offset]); offset += 1
-            if offset + length <= dataCopy.count {
-                originalSender = String(data: dataCopy[offset..<offset+length], encoding: .utf8)
-                offset += length
-            }
-        }
-        
-        var recipientNickname: String?
-        if hasRecipientNickname && offset < dataCopy.count {
-            let length = Int(dataCopy[offset]); offset += 1
-            if offset + length <= dataCopy.count {
-                recipientNickname = String(data: dataCopy[offset..<offset+length], encoding: .utf8)
-                offset += length
-            }
-        }
-        
-        var senderPeerID: String?
-        if hasSenderPeerID && offset < dataCopy.count {
-            let length = Int(dataCopy[offset]); offset += 1
-            if offset + length <= dataCopy.count {
-                senderPeerID = String(data: dataCopy[offset..<offset+length], encoding: .utf8)
-                offset += length
-            }
-        }
-        
-        // Mentions array
-        var mentions: [String]?
-        if hasMentions && offset < dataCopy.count {
-            let mentionCount = Int(dataCopy[offset]); offset += 1
-            if mentionCount > 0 {
-                mentions = []
-                for _ in 0..<mentionCount {
-                    if offset < dataCopy.count {
-                        let length = Int(dataCopy[offset]); offset += 1
-                        if offset + length <= dataCopy.count {
-                            if let mention = String(data: dataCopy[offset..<offset+length], encoding: .utf8) {
-                                mentions?.append(mention)
-                            }
-                            offset += length
-                        }
-                    }
-                }
-            }
-        }
-        
-        let message = BitchatMessage(
-            id: id,
-            sender: sender,
-            content: content,
-            timestamp: timestamp,
-            isRelay: isRelay,
-            originalSender: originalSender,
-            isPrivate: isPrivate,
-            recipientNickname: recipientNickname,
-            senderPeerID: senderPeerID,
-            mentions: mentions
-        )
-        return message
-    }
-}

bitchat/Protocols/BitchatFilePacket.swift

@@ -0,0 +1,156 @@
+//
+// BitchatFilePacket.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+import BitFoundation
+import BitLogger
+
+/// TLV payload for Bluetooth mesh file transfers (voice notes, images, generic files).
+/// Mirrors the Android client specification to ensure cross-platform interoperability.
+struct BitchatFilePacket {
+    var fileName: String?
+    var fileSize: UInt64?
+    var mimeType: String?
+    var content: Data
+
+    /// Canonical TLV tags defined by the Android implementation.
+    private enum TLVType: UInt8 {
+        case fileName = 0x01
+        case fileSize = 0x02
+        case mimeType = 0x03
+        case content = 0x04
+    }
+
+    /// Encodes the packet using v2 canonical TLVs (4-byte FILE_SIZE, 4-byte CONTENT length).
+    /// Returns `nil` when fields exceed protocol limits (e.g., content > UInt32.max).
+    func encode() -> Data? {
+        let resolvedSize = fileSize ?? UInt64(content.count)
+        guard resolvedSize <= UInt64(UInt32.max) else { return nil }
+        guard resolvedSize <= UInt64(FileTransferLimits.maxPayloadBytes) else { return nil }
+        guard content.count <= Int(UInt32.max) else { return nil }
+        guard FileTransferLimits.isValidPayload(content.count) else { return nil }
+
+        func appendBE<T: FixedWidthInteger>(_ value: T, into data: inout Data) {
+            var big = value.bigEndian
+            withUnsafeBytes(of: &big) { data.append(contentsOf: $0) }
+        }
+
+        var encoded = Data()
+
+        if let name = fileName, let nameData = name.data(using: .utf8), nameData.count <= Int(UInt16.max) {
+            encoded.append(TLVType.fileName.rawValue)
+            appendBE(UInt16(nameData.count), into: &encoded)
+            encoded.append(nameData)
+        }
+
+        encoded.append(TLVType.fileSize.rawValue)
+        appendBE(UInt16(4), into: &encoded)
+        appendBE(UInt32(resolvedSize), into: &encoded)
+
+        if let mime = mimeType, let mimeData = mime.data(using: .utf8), mimeData.count <= Int(UInt16.max) {
+            encoded.append(TLVType.mimeType.rawValue)
+            appendBE(UInt16(mimeData.count), into: &encoded)
+            encoded.append(mimeData)
+        }
+
+        encoded.append(TLVType.content.rawValue)
+        appendBE(UInt32(content.count), into: &encoded)
+        encoded.append(content)
+
+        return encoded
+    }
+
+    /// Decodes TLV payloads, tolerating legacy encodings (FILE_SIZE len=8, CONTENT len=2) when possible.
+    static func decode(_ data: Data) -> BitchatFilePacket? {
+        var cursor = data.startIndex
+        let end = data.endIndex
+
+        var fileName: String?
+        var fileSize: UInt64?
+        var mimeType: String?
+        var content = Data()
+
+        while cursor < end {
+            let typeRaw = data[cursor]
+            cursor = data.index(after: cursor)
+
+            guard cursor <= end else { return nil }
+            let tlvType = TLVType(rawValue: typeRaw)
+
+            func readBigEndianLength(bytes: Int) -> Int? {
+                guard data.distance(from: cursor, to: end) >= bytes else { return nil }
+                // Use UInt64 to prevent integer overflow during shift operations
+                var result: UInt64 = 0
+                for _ in 0..<bytes {
+                    result = (result << 8) | UInt64(data[cursor])
+                    cursor = data.index(after: cursor)
+                }
+                // Safely convert to Int with overflow check
+                guard result <= Int.max else { return nil }
+                return Int(result)
+            }
+
+            let length: Int?
+            if tlvType == .content {
+                let snapshot = cursor
+                let canonical = readBigEndianLength(bytes: 4)
+                if let canonical = canonical,
+                   canonical <= data.distance(from: cursor, to: end) {
+                    length = canonical
+                } else {
+                    cursor = snapshot
+                    length = readBigEndianLength(bytes: 2)
+                }
+            } else {
+                length = readBigEndianLength(bytes: 2)
+            }
+
+            guard let tlvLength = length, tlvLength >= 0 else { return nil }
+            guard data.distance(from: cursor, to: end) >= tlvLength else { return nil }
+
+            let valueStart = cursor
+            cursor = data.index(cursor, offsetBy: tlvLength)
+            let value = data[valueStart..<cursor]
+
+            switch tlvType {
+            case .fileName:
+                fileName = String(data: Data(value), encoding: .utf8)
+            case .fileSize:
+                if tlvLength == 4 || tlvLength == 8 {
+                    var size: UInt64 = 0
+                    for byte in value {
+                        size = (size << 8) | UInt64(byte)
+                    }
+                    if size > UInt64(FileTransferLimits.maxPayloadBytes) {
+                        return nil
+                    }
+                    fileSize = size
+                }
+            case .mimeType:
+                mimeType = String(data: Data(value), encoding: .utf8)
+            case .content:
+                let proposedSize = content.count + value.count
+                if proposedSize > FileTransferLimits.maxPayloadBytes {
+                    return nil
+                }
+                content.append(contentsOf: value)
+            case nil:
+                continue
+            }
+        }
+
+        guard !content.isEmpty else { return nil }
+        guard FileTransferLimits.isValidPayload(content.count) else { return nil }
+        return BitchatFilePacket(
+            fileName: fileName,
+            fileSize: fileSize ?? UInt64(content.count),
+            mimeType: mimeType,
+            content: content
+        )
+    }
+}

bitchat/Protocols/BitchatProtocol.swift

@@ -59,91 +59,8 @@
 ///
 
 import Foundation
-import CryptoKit
-
-// MARK: - Message Padding
-
-/// Provides privacy-preserving message padding to obscure actual content length.
-/// Uses PKCS#7-style padding with random bytes to prevent traffic analysis.
-struct MessagePadding {
-    // Standard block sizes for padding
-    static let blockSizes = [256, 512, 1024, 2048]
-    
-    // Add PKCS#7-style padding to reach target size
-    static func pad(_ data: Data, toSize targetSize: Int) -> Data {
-        guard data.count < targetSize else { return data }
-        
-        let paddingNeeded = targetSize - data.count
-        // Constrain to 255 to fit a single-byte pad length marker
-        guard paddingNeeded > 0 && paddingNeeded <= 255 else { return data }
-        
-        var padded = data
-        // PKCS#7: All pad bytes are equal to the pad length
-        padded.append(contentsOf: Array(repeating: UInt8(paddingNeeded), count: paddingNeeded))
-        return padded
-    }
-    
-    // Remove padding from data
-    static func unpad(_ data: Data) -> Data {
-        guard !data.isEmpty else { return data }
-        let last = data.last!
-        let paddingLength = Int(last)
-        // Must have at least 1 pad byte and not exceed data length
-        guard paddingLength > 0 && paddingLength <= data.count else { return data }
-        // Verify PKCS#7: all last N bytes equal to pad length
-        let start = data.count - paddingLength
-        let tail = data[start...]
-        for b in tail { if b != last { return data } }
-        return Data(data[..<start])
-    }
-    
-    // Find optimal block size for data
-    static func optimalBlockSize(for dataSize: Int) -> Int {
-        // Account for encryption overhead (~16 bytes for AES-GCM tag)
-        let totalSize = dataSize + 16
-        
-        // Find smallest block that fits
-        for blockSize in blockSizes {
-            if totalSize <= blockSize {
-                return blockSize
-            }
-        }
-        
-        // For very large messages, just use the original size
-        // (will be fragmented anyway)
-        return dataSize
-    }
-}
-
-// MARK: - Message Types
-
-/// Simplified BitChat protocol message types.
-/// Reduced from 24 types to just 6 essential ones.
-/// All private communication metadata (receipts, status) is embedded in noiseEncrypted payloads.
-enum MessageType: UInt8 {
-    // Public messages (unencrypted)
-    case announce = 0x01        // "I'm here" with nickname
-    case message = 0x02         // Public chat message  
-    case leave = 0x03           // "I'm leaving"
-    
-    // Noise encryption
-    case noiseHandshake = 0x10  // Handshake (init or response determined by payload)
-    case noiseEncrypted = 0x11  // All encrypted payloads (messages, receipts, etc.)
-    
-    // Fragmentation (simplified)
-    case fragment = 0x20        // Single fragment type for large messages
-    
-    var description: String {
-        switch self {
-        case .announce: return "announce"
-        case .message: return "message"
-        case .leave: return "leave"
-        case .noiseHandshake: return "noiseHandshake"
-        case .noiseEncrypted: return "noiseEncrypted"
-        case .fragment: return "fragment"
-        }
-    }
-}
+import CoreBluetooth
+import BitFoundation
 
 // MARK: - Noise Payload Types
 
@@ -181,300 +98,25 @@ enum LazyHandshakeState {
     case failed(Error)         // Handshake failed
 }
 
-//
-
-// MARK: - Core Protocol Structures
-
-/// The core packet structure for all BitChat protocol messages.
-/// Encapsulates all data needed for routing through the mesh network,
-/// including TTL for hop limiting and optional encryption.
-/// - Note: Packets larger than BLE MTU (512 bytes) are automatically fragmented
-struct BitchatPacket: Codable {
-    let version: UInt8
-    let type: UInt8
-    let senderID: Data
-    let recipientID: Data?
-    let timestamp: UInt64
-    let payload: Data
-    var signature: Data?
-    var ttl: UInt8
-    
-    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8) {
-        self.version = 1
-        self.type = type
-        self.senderID = senderID
-        self.recipientID = recipientID
-        self.timestamp = timestamp
-        self.payload = payload
-        self.signature = signature
-        self.ttl = ttl
-    }
-    
-    // Convenience initializer for new binary format
-    init(type: UInt8, ttl: UInt8, senderID: String, payload: Data) {
-        self.version = 1
-        self.type = type
-        // Convert hex string peer ID to binary data (8 bytes)
-        var senderData = Data()
-        var tempID = senderID
-        while tempID.count >= 2 {
-            let hexByte = String(tempID.prefix(2))
-            if let byte = UInt8(hexByte, radix: 16) {
-                senderData.append(byte)
-            }
-            tempID = String(tempID.dropFirst(2))
-        }
-        self.senderID = senderData
-        self.recipientID = nil
-        self.timestamp = UInt64(Date().timeIntervalSince1970 * 1000) // milliseconds
-        self.payload = payload
-        self.signature = nil
-        self.ttl = ttl
-    }
-    
-    var data: Data? {
-        BinaryProtocol.encode(self)
-    }
-    
-    func toBinaryData(padding: Bool = true) -> Data? {
-        BinaryProtocol.encode(self, padding: padding)
-    }
-
-    // Backward-compatible helper (defaults to padded encoding)
-    func toBinaryData() -> Data? {
-        toBinaryData(padding: true)
-    }
-    
-    /// Create binary representation for signing (without signature and TTL fields)
-    /// TTL is excluded because it changes during packet relay operations
-    func toBinaryDataForSigning() -> Data? {
-        // Create a copy without signature and with fixed TTL for signing
-        // TTL must be excluded because it changes during relay
-        let unsignedPacket = BitchatPacket(
-            type: type,
-            senderID: senderID,
-            recipientID: recipientID,
-            timestamp: timestamp,
-            payload: payload,
-            signature: nil, // Remove signature for signing
-            ttl: 0 // Use fixed TTL=0 for signing to ensure relay compatibility
-        )
-        return BinaryProtocol.encode(unsignedPacket)
-    }
-    
-    static func from(_ data: Data) -> BitchatPacket? {
-        BinaryProtocol.decode(data)
-    }
-}
-
-//
-
-// MARK: - Read Receipts
-
-// Read receipt structure
-struct ReadReceipt: Codable {
-    let originalMessageID: String
-    let receiptID: String
-    var readerID: String  // Who read it
-    let readerNickname: String
-    let timestamp: Date
-    
-    init(originalMessageID: String, readerID: String, readerNickname: String) {
-        self.originalMessageID = originalMessageID
-        self.receiptID = UUID().uuidString
-        self.readerID = readerID
-        self.readerNickname = readerNickname
-        self.timestamp = Date()
-    }
-    
-    // For binary decoding
-    private init(originalMessageID: String, receiptID: String, readerID: String, readerNickname: String, timestamp: Date) {
-        self.originalMessageID = originalMessageID
-        self.receiptID = receiptID
-        self.readerID = readerID
-        self.readerNickname = readerNickname
-        self.timestamp = timestamp
-    }
-    
-    func encode() -> Data? {
-        try? JSONEncoder().encode(self)
-    }
-    
-    static func decode(from data: Data) -> ReadReceipt? {
-        try? JSONDecoder().decode(ReadReceipt.self, from: data)
-    }
-    
-    // MARK: - Binary Encoding
-    
-    func toBinaryData() -> Data {
-        var data = Data()
-        data.appendUUID(originalMessageID)
-        data.appendUUID(receiptID)
-        // ReaderID as 8-byte hex string
-        var readerData = Data()
-        var tempID = readerID
-        while tempID.count >= 2 && readerData.count < 8 {
-            let hexByte = String(tempID.prefix(2))
-            if let byte = UInt8(hexByte, radix: 16) {
-                readerData.append(byte)
-            }
-            tempID = String(tempID.dropFirst(2))
-        }
-        while readerData.count < 8 {
-            readerData.append(0)
-        }
-        data.append(readerData)
-        data.appendDate(timestamp)
-        data.appendString(readerNickname)
-        return data
-    }
-    
-    static func fromBinaryData(_ data: Data) -> ReadReceipt? {
-        // Create defensive copy
-        let dataCopy = Data(data)
-        
-        // Minimum size: 2 UUIDs (32) + readerID (8) + timestamp (8) + min nickname
-        guard dataCopy.count >= 49 else { return nil }
-        
-        var offset = 0
-        
-        guard let originalMessageID = dataCopy.readUUID(at: &offset),
-              let receiptID = dataCopy.readUUID(at: &offset) else { return nil }
-        
-        guard let readerIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
-        let readerID = readerIDData.hexEncodedString()
-        guard InputValidator.validatePeerID(readerID) else { return nil }
-        
-        guard let timestamp = dataCopy.readDate(at: &offset),
-              InputValidator.validateTimestamp(timestamp),
-              let readerNicknameRaw = dataCopy.readString(at: &offset),
-              let readerNickname = InputValidator.validateNickname(readerNicknameRaw) else { return nil }
-        
-        return ReadReceipt(originalMessageID: originalMessageID,
-                          receiptID: receiptID,
-                          readerID: readerID,
-                          readerNickname: readerNickname,
-                          timestamp: timestamp)
-    }
-}
-
-
-//
-
-
-// MARK: - Delivery Status
-
-// Delivery status for messages
-enum DeliveryStatus: Codable, Equatable {
-    case sending
-    case sent  // Left our device
-    case delivered(to: String, at: Date)  // Confirmed by recipient
-    case read(by: String, at: Date)  // Seen by recipient
-    case failed(reason: String)
-    case partiallyDelivered(reached: Int, total: Int)  // For rooms
-    
-    var displayText: String {
-        switch self {
-        case .sending:
-            return "Sending..."
-        case .sent:
-            return "Sent"
-        case .delivered(let nickname, _):
-            return "Delivered to \(nickname)"
-        case .read(let nickname, _):
-            return "Read by \(nickname)"
-        case .failed(let reason):
-            return "Failed: \(reason)"
-        case .partiallyDelivered(let reached, let total):
-            return "Delivered to \(reached)/\(total)"
-        }
-    }
-}
-
-// MARK: - Message Model
-
-/// Represents a user-visible message in the BitChat system.
-/// Handles both broadcast messages and private encrypted messages,
-/// with support for mentions, replies, and delivery tracking.
-/// - Note: This is the primary data model for chat messages
-class BitchatMessage: Codable {
-    let id: String
-    let sender: String
-    let content: String
-    let timestamp: Date
-    let isRelay: Bool
-    let originalSender: String?
-    let isPrivate: Bool
-    let recipientNickname: String?
-    let senderPeerID: String?
-    let mentions: [String]?  // Array of mentioned nicknames
-    var deliveryStatus: DeliveryStatus? // Delivery tracking
-    
-    // Cached formatted text (not included in Codable)
-    private var _cachedFormattedText: [String: AttributedString] = [:]
-    
-    func getCachedFormattedText(isDark: Bool, isSelf: Bool) -> AttributedString? {
-        return _cachedFormattedText["\(isDark)-\(isSelf)"]
-    }
-    
-    func setCachedFormattedText(_ text: AttributedString, isDark: Bool, isSelf: Bool) {
-        _cachedFormattedText["\(isDark)-\(isSelf)"] = text
-    }
-    
-    // Codable implementation
-    enum CodingKeys: String, CodingKey {
-        case id, sender, content, timestamp, isRelay, originalSender
-        case isPrivate, recipientNickname, senderPeerID, mentions, deliveryStatus
-    }
-    
-    init(id: String? = nil, sender: String, content: String, timestamp: Date, isRelay: Bool, originalSender: String? = nil, isPrivate: Bool = false, recipientNickname: String? = nil, senderPeerID: String? = nil, mentions: [String]? = nil, deliveryStatus: DeliveryStatus? = nil) {
-        self.id = id ?? UUID().uuidString
-        self.sender = sender
-        self.content = content
-        self.timestamp = timestamp
-        self.isRelay = isRelay
-        self.originalSender = originalSender
-        self.isPrivate = isPrivate
-        self.recipientNickname = recipientNickname
-        self.senderPeerID = senderPeerID
-        self.mentions = mentions
-        self.deliveryStatus = deliveryStatus ?? (isPrivate ? .sending : nil)
-    }
-}
-
-// Equatable conformance for BitchatMessage
-extension BitchatMessage: Equatable {
-    static func == (lhs: BitchatMessage, rhs: BitchatMessage) -> Bool {
-        return lhs.id == rhs.id &&
-               lhs.sender == rhs.sender &&
-               lhs.content == rhs.content &&
-               lhs.timestamp == rhs.timestamp &&
-               lhs.isRelay == rhs.isRelay &&
-               lhs.originalSender == rhs.originalSender &&
-               lhs.isPrivate == rhs.isPrivate &&
-               lhs.recipientNickname == rhs.recipientNickname &&
-               lhs.senderPeerID == rhs.senderPeerID &&
-               lhs.mentions == rhs.mentions &&
-               lhs.deliveryStatus == rhs.deliveryStatus
-    }
-}
-
 // MARK: - Delegate Protocol
 
 protocol BitchatDelegate: AnyObject {
     func didReceiveMessage(_ message: BitchatMessage)
-    func didConnectToPeer(_ peerID: String)
-    func didDisconnectFromPeer(_ peerID: String)
-    func didUpdatePeerList(_ peers: [String])
-    
+    func didConnectToPeer(_ peerID: PeerID)
+    func didDisconnectFromPeer(_ peerID: PeerID)
+    func didUpdatePeerList(_ peers: [PeerID])
+
     // Optional method to check if a fingerprint belongs to a favorite peer
     func isFavorite(fingerprint: String) -> Bool
-    
+
     func didUpdateMessageDeliveryStatus(_ messageID: String, status: DeliveryStatus)
 
     // Low-level events for better separation of concerns
-    func didReceiveNoisePayload(from peerID: String, type: NoisePayloadType, payload: Data, timestamp: Date)
-    func didReceivePublicMessage(from peerID: String, nickname: String, content: String, timestamp: Date)
+    func didReceiveNoisePayload(from peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date)
+
+    // Bluetooth state updates for user notifications
+    func didUpdateBluetoothState(_ state: CBManagerState)
+    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?)
 }
 
 // Provide default implementation to make it effectively optional
@@ -487,45 +129,11 @@ extension BitchatDelegate {
         // Default empty implementation
     }
 
-    func didReceiveNoisePayload(from peerID: String, type: NoisePayloadType, payload: Data, timestamp: Date) {
+    func didReceiveNoisePayload(from peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date) {
         // Default empty implementation
     }
 
-    func didReceivePublicMessage(from peerID: String, nickname: String, content: String, timestamp: Date) {
+    func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?) {
         // Default empty implementation
     }
 }
-
-// MARK: - Noise Payload Helpers
-
-/// Helper to create typed Noise payloads
-struct NoisePayload {
-    let type: NoisePayloadType
-    let data: Data
-    
-    /// Encode payload with type prefix
-    func encode() -> Data {
-        var encoded = Data()
-        encoded.append(type.rawValue)
-        encoded.append(data)
-        return encoded
-    }
-    
-    /// Decode payload from data
-    static func decode(_ data: Data) -> NoisePayload? {
-        // Ensure we have at least 1 byte for the type
-        guard !data.isEmpty else {
-            return nil
-        }
-        
-        // Safely get the first byte
-        let firstByte = data[data.startIndex]
-        guard let type = NoisePayloadType(rawValue: firstByte) else {
-            return nil
-        }
-        
-        // Create a proper Data copy (not a subsequence) for thread safety
-        let payloadData = data.count > 1 ? Data(data.dropFirst()) : Data()
-        return NoisePayload(type: type, data: payloadData)
-    }
-}

bitchat/Protocols/Geohash.swift

@@ -10,6 +10,14 @@ enum Geohash {
         return map
     }()
 
+    /// Validates a geohash string for building-level precision (8 characters).
+    /// - Parameter geohash: The geohash string to validate
+    /// - Returns: true if valid 8-character base32 geohash, false otherwise
+    static func isValidBuildingGeohash(_ geohash: String) -> Bool {
+        guard geohash.count == 8 else { return false }
+        return geohash.lowercased().allSatisfy { base32Map[$0] != nil }
+    }
+
     /// Encodes the provided coordinates into a geohash string.
     /// - Parameters:
     ///   - latitude: Latitude in degrees (-90...90)
@@ -111,4 +119,57 @@ enum Geohash {
         }
         return (latInterval.0, latInterval.1, lonInterval.0, lonInterval.1)
     }
+
+    /// Returns all 8 neighboring geohash cells at the same precision.
+    /// - Parameter geohash: Base32 geohash string.
+    /// - Returns: Array of 8 neighboring geohashes (N, NE, E, SE, S, SW, W, NW order).
+    static func neighbors(of geohash: String) -> [String] {
+        guard !geohash.isEmpty else { return [] }
+
+        let precision = geohash.count
+        let bounds = decodeBounds(geohash)
+        let center = decodeCenter(geohash)
+
+        // Calculate cell dimensions
+        let latHeight = bounds.latMax - bounds.latMin
+        let lonWidth = bounds.lonMax - bounds.lonMin
+
+        // Helper to wrap longitude around ±180
+        func wrapLongitude(_ lon: Double) -> Double {
+            var wrapped = lon
+            while wrapped > 180.0 { wrapped -= 360.0 }
+            while wrapped < -180.0 { wrapped += 360.0 }
+            return wrapped
+        }
+
+        // Helper to clamp latitude to ±90
+        func clampLatitude(_ lat: Double) -> Double {
+            return max(-90.0, min(90.0, lat))
+        }
+
+        // Calculate 8 neighbor centers
+        let neighbors: [(lat: Double, lon: Double)] = [
+            (center.lat + latHeight, center.lon),                    // N
+            (center.lat + latHeight, center.lon + lonWidth),         // NE
+            (center.lat, center.lon + lonWidth),                     // E
+            (center.lat - latHeight, center.lon + lonWidth),         // SE
+            (center.lat - latHeight, center.lon),                    // S
+            (center.lat - latHeight, center.lon - lonWidth),         // SW
+            (center.lat, center.lon - lonWidth),                     // W
+            (center.lat + latHeight, center.lon - lonWidth)          // NW
+        ]
+
+        // Encode each neighbor, handling boundary conditions
+        return neighbors.compactMap { neighbor in
+            let lat = clampLatitude(neighbor.lat)
+            let lon = wrapLongitude(neighbor.lon)
+
+            // Skip if we've crossed a pole (latitude clamped to boundary)
+            if (neighbor.lat > 90.0 || neighbor.lat < -90.0) {
+                return nil
+            }
+
+            return encode(latitude: lat, longitude: lon, precision: precision)
+        }
+    }
 }

bitchat/Protocols/LocationChannel.swift

@@ -2,6 +2,7 @@ import Foundation
 
 /// Levels of location channels mapped to geohash precisions.
 enum GeohashChannelLevel: CaseIterable, Codable, Equatable {
+    case building
     case block
     case neighborhood
     case city
@@ -11,6 +12,7 @@ enum GeohashChannelLevel: CaseIterable, Codable, Equatable {
     /// Geohash length used for this level.
     var precision: Int {
         switch self {
+        case .building: return 8
         case .block: return 7
         case .neighborhood: return 6
         case .city: return 5
@@ -21,20 +23,28 @@ enum GeohashChannelLevel: CaseIterable, Codable, Equatable {
 
     var displayName: String {
         switch self {
-        case .block: return "Block"
-        case .neighborhood: return "Neighborhood"
-        case .city: return "City"
-        case .province: return "Province"
-        case .region: return "Region"
+        case .building:
+            return String(localized: "location_levels.building", comment: "Name for building-level location channel")
+        case .block:
+            return String(localized: "location_levels.block", comment: "Name for block-level location channel")
+        case .neighborhood:
+            return String(localized: "location_levels.neighborhood", comment: "Name for neighborhood-level location channel")
+        case .city:
+            return String(localized: "location_levels.city", comment: "Name for city-level location channel")
+        case .province:
+            return String(localized: "location_levels.province", comment: "Name for province-level location channel")
+        case .region:
+            return String(localized: "location_levels.region", comment: "Name for region-level location channel")
+        }
     }
 }
-}
 // Backward-compatible Codable for renamed cases
 extension GeohashChannelLevel {
     init(from decoder: Decoder) throws {
         let container = try decoder.singleValueContainer()
         if let raw = try? container.decode(String.self) {
             switch raw {
+            case "building": self = .building
             case "block": self = .block
             case "neighborhood": self = .neighborhood
             case "city": self = .city
@@ -46,6 +56,7 @@ extension GeohashChannelLevel {
             }
         } else if let precision = try? container.decode(Int.self) {
             switch precision {
+            case 8: self = .building
             case 7: self = .block
             case 6: self = .neighborhood
             case 5: self = .city
@@ -61,6 +72,7 @@ extension GeohashChannelLevel {
     func encode(to encoder: Encoder) throws {
         var container = encoder.singleValueContainer()
         switch self {
+        case .building: try container.encode("building")
         case .block: try container.encode("block")
         case .neighborhood: try container.encode("neighborhood")
         case .city: try container.encode("city")
@@ -104,4 +116,18 @@ enum ChannelID: Equatable, Codable {
         case .location(let ch): return ch.geohash
         }
     }
+    
+    var isMesh: Bool {
+        switch self {
+        case .mesh:     true
+        case .location: false
+        }
+    }
+    
+    var isLocation: Bool {
+        switch self {
+        case .mesh:     false
+        case .location: true
+        }
+    }
 }

bitchat/Protocols/Packets.swift

@@ -6,11 +6,13 @@ struct AnnouncementPacket {
     let nickname: String
     let noisePublicKey: Data            // Noise static public key (Curve25519.KeyAgreement)
     let signingPublicKey: Data          // Ed25519 public key for signing
+    let directNeighbors: [Data]?        // 8-byte peer IDs
 
     private enum TLVType: UInt8 {
         case nickname = 0x01
         case noisePublicKey = 0x02
         case signingPublicKey = 0x03
+        case directNeighbors = 0x04
     }
 
     func encode() -> Data? {
@@ -35,6 +37,16 @@ struct AnnouncementPacket {
         data.append(TLVType.signingPublicKey.rawValue)
         data.append(UInt8(signingPublicKey.count))
         data.append(signingPublicKey)
+        
+        // TLV for direct neighbors (optional)
+        if let neighbors = directNeighbors, !neighbors.isEmpty {
+            let neighborsData = neighbors.prefix(10).reduce(Data()) { $0 + $1 }
+            if !neighborsData.isEmpty && neighborsData.count % 8 == 0 {
+                data.append(TLVType.directNeighbors.rawValue)
+                data.append(UInt8(neighborsData.count))
+                data.append(neighborsData)
+            }
+        }
 
         return data
     }
@@ -44,6 +56,7 @@ struct AnnouncementPacket {
         var nickname: String?
         var noisePublicKey: Data?
         var signingPublicKey: Data?
+        var directNeighbors: [Data]?
 
         while offset + 2 <= data.count {
             let typeRaw = data[offset]
@@ -63,6 +76,17 @@ struct AnnouncementPacket {
                     noisePublicKey = Data(value)
                 case .signingPublicKey:
                     signingPublicKey = Data(value)
+                case .directNeighbors:
+                    if length > 0 && length % 8 == 0 {
+                        var neighbors = [Data]()
+                        let count = length / 8
+                        for i in 0..<count {
+                            let start = value.startIndex + i * 8
+                            let end = start + 8
+                            neighbors.append(Data(value[start..<end]))
+                        }
+                        directNeighbors = neighbors
+                    }
                 }
             } else {
                 // Unknown TLV; skip (tolerant decoder for forward compatibility)
@@ -74,7 +98,8 @@ struct AnnouncementPacket {
         return AnnouncementPacket(
             nickname: nickname,
             noisePublicKey: noisePublicKey,
-            signingPublicKey: signingPublicKey
+            signingPublicKey: signingPublicKey,
+            directNeighbors: directNeighbors
         )
     }
 }

bitchat/Protocols/PeerID.swift

@@ -1,14 +0,0 @@
-import Foundation
-import CryptoKit
-
-// MARK: - Peer ID Utilities
-
-struct PeerIDUtils {
-    /// Derive the stable 16-hex peer ID from a Noise static public key
-    static func derivePeerID(fromPublicKey publicKey: Data) -> String {
-        let digest = SHA256.hash(data: publicKey)
-        let hex = digest.map { String(format: "%02x", $0) }.joined()
-        return String(hex.prefix(16))
-    }
-}
-

bitchat/Services/AutocompleteService.swift

@@ -9,7 +9,7 @@
 import Foundation
 
 /// Manages autocomplete functionality for chat
-class AutocompleteService {
+final class AutocompleteService {
     private let mentionRegex = try? NSRegularExpression(pattern: "@([\\p{L}0-9_]*)$", options: [])
     private let commandRegex = try? NSRegularExpression(pattern: "^/([a-z]*)$", options: [])
     

bitchat/Services/BLE/MimeType.swift

@@ -0,0 +1,212 @@
+//
+// MimeType.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import UniformTypeIdentifiers
+
+// MARK: - Extensions for missing UTTypes
+
+extension UTType {
+    static let webP = UTType(importedAs: "image/webp")
+    static let aac  = UTType(importedAs: "audio/aac")
+    static let m4a  = UTType(importedAs: "audio/m4a")
+    static let ogg  = UTType(importedAs: "audio/ogg")
+}
+
+// MARK: - MimeType Enum
+
+enum MimeType: CaseIterable, Hashable {
+    case jpeg
+    case jpg
+    case png
+    case gif
+    case webp
+    case mp4Audio
+    case m4a
+    case aac
+    case mpeg
+    case mp3
+    case wav
+    case xWav
+    case ogg
+    case pdf
+    case octetStream
+
+    var utType: UTType {
+        switch self {
+        case .jpeg, .jpg:   .jpeg
+        case .png:          .png
+        case .gif:          .gif
+        case .webp:         .webP
+        case .aac:          .aac
+        case .m4a:          .m4a
+        case .mp4Audio:     .mpeg4Audio
+        case .mp3, .mpeg:   .mp3
+        case .wav, .xWav:   .wav
+        case .ogg:          .ogg
+        case .pdf:          .pdf
+        case .octetStream:  .data
+        }
+    }
+    
+    var category: Category {
+        switch self {
+        case .jpeg, .jpg, .png, .gif, .webp:
+            return .image
+        case .aac, .m4a, .mp4Audio, .mpeg, .mp3, .wav, .xWav, .ogg:
+            return .audio
+        case .pdf, .octetStream:
+            return .file
+        }
+    }
+
+
+    var mimeString: String {
+        switch self {
+        case .jpeg, .jpg:   "image/jpeg"
+        case .png:          "image/png"
+        case .gif:          "image/gif"
+        case .webp:         "image/webp"
+        case .mp4Audio:     "audio/mp4"
+        case .m4a:          "audio/m4a"
+        case .aac:          "audio/aac"
+        case .mpeg:         "audio/mpeg"
+        case .mp3:          "audio/mp3"
+        case .wav:          "audio/wav"
+        case .xWav:         "audio/x-wav"
+        case .ogg:          "audio/ogg"
+        case .pdf:          "application/pdf"
+        case .octetStream:  "application/octet-stream"
+        }
+    }
+    
+    var defaultExtension: String {
+        switch self {
+        case .jpeg, .jpg:           "jpg"
+        case .png:                  "png"
+        case .webp:                 "webp"
+        case .gif:                  "gif"
+        case .mp4Audio, .m4a, .aac: "m4a"
+        case .mpeg, .mp3:           "mp3"
+        case .wav, .xWav:           "wav"
+        case .ogg:                  "ogg"
+        case .pdf:                  "pdf"
+        case .octetStream:          "bin"
+        }
+    }
+
+    static var allowed: Set<MimeType> = [
+        .jpeg, .jpg, .png, .gif, .webp,
+        .mp4Audio, .m4a, .aac, .mpeg, .mp3,
+        .wav, .xWav, .ogg,
+        .pdf, .octetStream
+    ]
+
+    var isAllowed: Bool {
+        Self.allowed.contains(self)
+    }
+
+    // MARK: - Byte signature validation
+    func matches(data: Data) -> Bool {
+        guard !data.isEmpty else { return false }
+
+        // Generic type → skip validation
+        if self == .octetStream { return true }
+
+        switch self {
+        case .jpeg, .jpg:
+            return data.count >= 3 && data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF
+
+        case .png:
+            return data.count >= 8 &&
+                   data[0] == 0x89 && data[1] == 0x50 && data[2] == 0x4E && data[3] == 0x47 &&
+                   data[4] == 0x0D && data[5] == 0x0A && data[6] == 0x1A && data[7] == 0x0A
+
+        case .gif:
+            return data.count >= 6 && data[0] == 0x47 && data[1] == 0x49 && data[2] == 0x46 &&
+                   data[3] == 0x38 && (data[4] == 0x37 || data[4] == 0x39) && data[5] == 0x61
+
+        case .webp:
+            return data.count >= 12 &&
+                   data[0] == 0x52 && data[1] == 0x49 && data[2] == 0x46 && data[3] == 0x46 &&
+                   data[8] == 0x57 && data[9] == 0x45 && data[10] == 0x42 && data[11] == 0x50
+
+        case .m4a, .mp4Audio, .aac:
+            // AVAudioRecorder output varies by platform - be lenient
+            // Security: size already capped + sandboxed execution
+            return data.count > 100
+
+        case .mpeg, .mp3:
+            if data.count >= 3 && data[0] == 0x49 && data[1] == 0x44 && data[2] == 0x33 {
+                return true // ID3 header
+            }
+            return data.count >= 2 && data[0] == 0xFF && (data[1] & 0xE0) == 0xE0
+
+        case .wav, .xWav:
+            return data.count >= 12 &&
+                   data[0] == 0x52 && data[1] == 0x49 && data[2] == 0x46 && data[3] == 0x46 &&
+                   data[8] == 0x57 && data[9] == 0x41 && data[10] == 0x56 && data[11] == 0x45
+
+        case .ogg:
+            return data.count >= 4 &&
+                   data[0] == 0x4F && data[1] == 0x67 && data[2] == 0x67 && data[3] == 0x53
+
+        case .pdf:
+            return data.count >= 4 &&
+                   data[0] == 0x25 && data[1] == 0x50 && data[2] == 0x44 && data[3] == 0x46
+
+        default:
+            return false
+        }
+    }
+
+    // MARK: - Convenience Initializers
+
+    init?(_ mimeString: String?) {
+        guard let mimeString else { return nil }
+        
+        let normalized = mimeString.lowercased()
+
+        // Direct match with our canonical list
+        if let match = MimeType.allCases.first(where: { $0.mimeString == normalized }) {
+            self = match
+            return
+        }
+
+        // Let UTType normalize aliases like "image/jpg", "audio/x-wav", etc.
+        if let type = UTType(mimeType: normalized),
+           let match = MimeType.allCases.first(where: { type.conforms(to: $0.utType) }) {
+            self = match
+            return
+        }
+
+        return nil
+    }
+}
+
+extension MimeType {
+    enum Category: String {
+        case audio, image, file
+
+        /// Ends with a space
+        var messagePrefix: String {
+            switch self {
+            case .audio: "[voice] "
+            case .image: "[image] "
+            case .file: "[file] "
+            }
+        }
+
+        var mediaDir: String {
+            switch self {
+            case .audio: "voicenotes"
+            case .image: "images"
+            case .file: "files"
+            }
+        }
+    }
+}

bitchat/Services/CommandProcessor.swift

@@ -7,6 +7,7 @@
 //
 
 import Foundation
+import BitFoundation
 
 /// Result of command processing
 enum CommandResult {
@@ -15,15 +16,54 @@ enum CommandResult {
     case handled  // Command handled, no message needed
 }
 
+/// Simple struct for geo participant info used by CommandProcessor
+struct CommandGeoParticipant {
+    let id: String        // pubkey hex (lowercased)
+    let displayName: String
+}
+
+/// Protocol defining what CommandProcessor needs from its context.
+/// This breaks the circular dependency between CommandProcessor and ChatViewModel.
+@MainActor
+protocol CommandContextProvider: AnyObject {
+    // MARK: - State Properties
+    var nickname: String { get }
+    var selectedPrivateChatPeer: PeerID? { get }
+    var blockedUsers: Set<String> { get }
+    var privateChats: [PeerID: [BitchatMessage]] { get set }
+    var idBridge: NostrIdentityBridge { get }
+
+    // MARK: - Peer Lookup
+    func getPeerIDForNickname(_ nickname: String) -> PeerID?
+    func getVisibleGeoParticipants() -> [CommandGeoParticipant]
+    func nostrPubkeyForDisplayName(_ displayName: String) -> String?
+
+    // MARK: - Chat Actions
+    func startPrivateChat(with peerID: PeerID)
+    func sendPrivateMessage(_ content: String, to peerID: PeerID)
+    func clearCurrentPublicTimeline()
+    func sendPublicRaw(_ content: String)
+
+    // MARK: - System Messages
+    func addLocalPrivateSystemMessage(_ content: String, to peerID: PeerID)
+    func addPublicSystemMessage(_ content: String)
+
+    // MARK: - Favorites
+    func toggleFavorite(peerID: PeerID)
+    func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool)
+}
+
 /// Processes chat commands in a focused, efficient way
 @MainActor
-class CommandProcessor {
-    weak var chatViewModel: ChatViewModel?
+final class CommandProcessor {
+    weak var contextProvider: CommandContextProvider?
     weak var meshService: Transport?
-    
-    init(chatViewModel: ChatViewModel? = nil, meshService: Transport? = nil) {
-        self.chatViewModel = chatViewModel
+    private let identityManager: SecureIdentityStateManagerProtocol
+
+    init(contextProvider: CommandContextProvider? = nil, meshService: Transport? = nil, identityManager: SecureIdentityStateManagerProtocol) {
+        self.contextProvider = contextProvider
         self.meshService = meshService
+        self.identityManager = identityManager
     }
     
     /// Process a command string
@@ -40,7 +80,7 @@ class CommandProcessor {
             case .location: return true
             }
         }()
-        let inGeoDM = (chatViewModel?.selectedPrivateChatPeer?.hasPrefix("nostr_") == true)
+        let inGeoDM = contextProvider?.selectedPrivateChatPeer?.isGeoDM == true
 
         switch cmd {
         case "/m", "/msg":
@@ -50,9 +90,9 @@ class CommandProcessor {
         case "/clear":
             return handleClear()
         case "/hug":
-            return handleEmote(args, action: "hugs", emoji: "🫂")
+            return handleEmote(args, command: "hug", action: "hugs", emoji: "🫂")
         case "/slap":
-            return handleEmote(args, action: "slaps", emoji: "🐟", suffix: " around a bit with a large trout")
+            return handleEmote(args, command: "slap", action: "slaps", emoji: "🐟", suffix: " around a bit with a large trout")
         case "/block":
             return handleBlock(args)
         case "/unblock":
@@ -63,14 +103,11 @@ class CommandProcessor {
         case "/unfav":
             if inGeoPublic || inGeoDM { return .error(message: "favorites are only for mesh peers in #mesh") }
             return handleFavorite(args, add: false)
-        //
-        case "/help", "/h":
-            return .error(message: "unknown command: \(cmd)")
         default:
             return .error(message: "unknown command: \(cmd)")
         }
     }
-    
+
     // MARK: - Command Handlers
     
     private func handleMessage(_ args: String) -> CommandResult {
@@ -82,15 +119,15 @@ class CommandProcessor {
         let targetName = String(parts[0])
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
-        guard let peerID = chatViewModel?.getPeerIDForNickname(nickname) else {
+        guard let peerID = contextProvider?.getPeerIDForNickname(nickname) else {
             return .error(message: "'\(nickname)' not found")
         }
-        
-        chatViewModel?.startPrivateChat(with: peerID)
-        
+
+        contextProvider?.startPrivateChat(with: peerID)
+
         if parts.count > 1 {
             let message = String(parts[1])
-            chatViewModel?.sendPrivateMessage(message, to: peerID)
+            contextProvider?.sendPrivateMessage(message, to: peerID)
         }
         
         return .success(message: "started private chat with \(nickname)")
@@ -101,9 +138,9 @@ class CommandProcessor {
         switch LocationChannelManager.shared.selectedChannel {
         case .location(let ch):
             // Geohash context: show visible geohash participants (exclude self)
-            guard let vm = chatViewModel else { return .success(message: "nobody around") }
-            let myHex = (try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash))?.publicKeyHex.lowercased()
-            let people = vm.visibleGeohashPeople().filter { person in
+            guard let vm = contextProvider else { return .success(message: "nobody around") }
+            let myHex = (try? vm.idBridge.deriveIdentity(forGeohash: ch.geohash))?.publicKeyHex.lowercased()
+            let people = vm.getVisibleGeoParticipants().filter { person in
                 if let me = myHex { return person.id.lowercased() != me }
                 return true
             }
@@ -121,35 +158,35 @@ class CommandProcessor {
     }
     
     private func handleClear() -> CommandResult {
-        if let peerID = chatViewModel?.selectedPrivateChatPeer {
-            chatViewModel?.privateChats[peerID]?.removeAll()
+        if let peerID = contextProvider?.selectedPrivateChatPeer {
+            contextProvider?.privateChats[peerID]?.removeAll()
         } else {
-            chatViewModel?.clearCurrentPublicTimeline()
+            contextProvider?.clearCurrentPublicTimeline()
         }
         return .handled
     }
     
-    private func handleEmote(_ args: String, action: String, emoji: String, suffix: String = "") -> CommandResult {
-        let targetName = args.trimmingCharacters(in: .whitespaces)
+    private func handleEmote(_ args: String, command: String, action: String, emoji: String, suffix: String = "") -> CommandResult {
+        let targetName = args.trimmed
         guard !targetName.isEmpty else {
-            return .error(message: "usage: /\(action) <nickname>")
+            return .error(message: "usage: /\(command) <nickname>")
         }
         
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
-        guard let targetPeerID = chatViewModel?.getPeerIDForNickname(nickname),
-              let myNickname = chatViewModel?.nickname else {
-            return .error(message: "cannot \(action) \(nickname): not found")
+        guard let targetPeerID = contextProvider?.getPeerIDForNickname(nickname),
+              let myNickname = contextProvider?.nickname else {
+            return .error(message: "cannot \(command) \(nickname): not found")
         }
         
         let emoteContent = "* \(emoji) \(myNickname) \(action) \(nickname)\(suffix) *"
         
-        if chatViewModel?.selectedPrivateChatPeer != nil {
+        if contextProvider?.selectedPrivateChatPeer != nil {
             // In private chat
             if let peerNickname = meshService?.peerNickname(peerID: targetPeerID) {
                 let personalMessage = "* \(emoji) \(myNickname) \(action) you\(suffix) *"
-                meshService?.sendPrivateMessage(personalMessage, to: targetPeerID, 
-                                               recipientNickname: peerNickname, 
+                meshService?.sendPrivateMessage(personalMessage, to: targetPeerID,
+                                               recipientNickname: peerNickname,
                                                messageID: UUID().uuidString)
                 // Also add a local system message so the sender sees a natural-language confirmation
                 let pastAction: String = {
@@ -160,24 +197,24 @@ class CommandProcessor {
                     }
                 }()
                 let localText = "\(emoji) you \(pastAction) \(nickname)\(suffix)"
-                chatViewModel?.addLocalPrivateSystemMessage(localText, to: targetPeerID)
+                contextProvider?.addLocalPrivateSystemMessage(localText, to: targetPeerID)
             }
         } else {
             // In public chat: send to active public channel (mesh or geohash)
-            chatViewModel?.sendPublicRaw(emoteContent)
+            contextProvider?.sendPublicRaw(emoteContent)
             let publicEcho = "\(emoji) \(myNickname) \(action) \(nickname)\(suffix)"
-            chatViewModel?.addPublicSystemMessage(publicEcho)
+            contextProvider?.addPublicSystemMessage(publicEcho)
         }
         
         return .handled
     }
     
     private func handleBlock(_ args: String) -> CommandResult {
-        let targetName = args.trimmingCharacters(in: .whitespaces)
+        let targetName = args.trimmed
         
         if targetName.isEmpty {
             // List blocked users (mesh) and geohash (Nostr) blocks
-            let meshBlocked = chatViewModel?.blockedUsers ?? []
+            let meshBlocked = contextProvider?.blockedUsers ?? []
             var blockedNicknames: [String] = []
             if let peers = meshService?.getPeerNicknames() {
                 for (peerID, nickname) in peers {
@@ -189,10 +226,10 @@ class CommandProcessor {
             }
 
             // Geohash blocked names (prefer visible display names; fallback to #suffix)
-            let geoBlocked = Array(SecureIdentityStateManager.shared.getBlockedNostrPubkeys())
+            let geoBlocked = Array(identityManager.getBlockedNostrPubkeys())
             var geoNames: [String] = []
-            if let vm = chatViewModel {
-                let visible = vm.visibleGeohashPeople()
+            if let vm = contextProvider {
+                let visible = vm.getVisibleGeoParticipants()
                 let visibleIndex = Dictionary(uniqueKeysWithValues: visible.map { ($0.id.lowercased(), $0.displayName) })
                 for pk in geoBlocked {
                     if let name = visibleIndex[pk.lowercased()] {
@@ -211,16 +248,16 @@ class CommandProcessor {
         
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
-        if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
+        if let peerID = contextProvider?.getPeerIDForNickname(nickname),
            let fingerprint = meshService?.getFingerprint(for: peerID) {
-            if SecureIdentityStateManager.shared.isBlocked(fingerprint: fingerprint) {
+            if identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is already blocked")
             }
             // Block the user (mesh/noise identity)
-            if var identity = SecureIdentityStateManager.shared.getSocialIdentity(for: fingerprint) {
+            if var identity = identityManager.getSocialIdentity(for: fingerprint) {
                 identity.isBlocked = true
                 identity.isFavorite = false
-                SecureIdentityStateManager.shared.updateSocialIdentity(identity)
+                identityManager.updateSocialIdentity(identity)
             } else {
                 let blockedIdentity = SocialIdentity(
                     fingerprint: fingerprint,
@@ -231,16 +268,16 @@ class CommandProcessor {
                     isBlocked: true,
                     notes: nil
                 )
-                SecureIdentityStateManager.shared.updateSocialIdentity(blockedIdentity)
+                identityManager.updateSocialIdentity(blockedIdentity)
             }
             return .success(message: "blocked \(nickname). you will no longer receive messages from them")
         }
         // Mesh lookup failed; try geohash (Nostr) participant by display name
-        if let pub = chatViewModel?.nostrPubkeyForDisplayName(nickname) {
-            if SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: pub) {
+        if let pub = contextProvider?.nostrPubkeyForDisplayName(nickname) {
+            if identityManager.isNostrBlocked(pubkeyHexLowercased: pub) {
                 return .success(message: "\(nickname) is already blocked")
             }
-            SecureIdentityStateManager.shared.setNostrBlocked(pub, isBlocked: true)
+            identityManager.setNostrBlocked(pub, isBlocked: true)
             return .success(message: "blocked \(nickname) in geohash chats")
         }
         
@@ -248,42 +285,42 @@ class CommandProcessor {
     }
     
     private func handleUnblock(_ args: String) -> CommandResult {
-        let targetName = args.trimmingCharacters(in: .whitespaces)
+        let targetName = args.trimmed
         guard !targetName.isEmpty else {
             return .error(message: "usage: /unblock <nickname>")
         }
         
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
-        if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
+        if let peerID = contextProvider?.getPeerIDForNickname(nickname),
            let fingerprint = meshService?.getFingerprint(for: peerID) {
-            if !SecureIdentityStateManager.shared.isBlocked(fingerprint: fingerprint) {
+            if !identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is not blocked")
             }
-            SecureIdentityStateManager.shared.setBlocked(fingerprint, isBlocked: false)
+            identityManager.setBlocked(fingerprint, isBlocked: false)
             return .success(message: "unblocked \(nickname)")
         }
         // Try geohash unblock
-        if let pub = chatViewModel?.nostrPubkeyForDisplayName(nickname) {
-            if !SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: pub) {
+        if let pub = contextProvider?.nostrPubkeyForDisplayName(nickname) {
+            if !identityManager.isNostrBlocked(pubkeyHexLowercased: pub) {
                 return .success(message: "\(nickname) is not blocked")
             }
-            SecureIdentityStateManager.shared.setNostrBlocked(pub, isBlocked: false)
+            identityManager.setNostrBlocked(pub, isBlocked: false)
             return .success(message: "unblocked \(nickname) in geohash chats")
         }
         return .error(message: "cannot unblock \(nickname): not found")
     }
     
     private func handleFavorite(_ args: String, add: Bool) -> CommandResult {
-        let targetName = args.trimmingCharacters(in: .whitespaces)
+        let targetName = args.trimmed
         guard !targetName.isEmpty else {
             return .error(message: "usage: /\(add ? "fav" : "unfav") <nickname>")
         }
         
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
-        guard let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-              let noisePublicKey = Data(hexString: peerID) else {
+        guard let peerID = contextProvider?.getPeerIDForNickname(nickname),
+              let noisePublicKey = Data(hexString: peerID.id) else {
             return .error(message: "can't find peer: \(nickname)")
         }
         
@@ -295,33 +332,18 @@ class CommandProcessor {
                 peerNickname: nickname
             )
             
-            chatViewModel?.toggleFavorite(peerID: peerID)
-            chatViewModel?.sendFavoriteNotification(to: peerID, isFavorite: true)
+            contextProvider?.toggleFavorite(peerID: peerID)
+            contextProvider?.sendFavoriteNotification(to: peerID, isFavorite: true)
             
             return .success(message: "added \(nickname) to favorites")
         } else {
             FavoritesPersistenceService.shared.removeFavorite(peerNoisePublicKey: noisePublicKey)
             
-            chatViewModel?.toggleFavorite(peerID: peerID)
-            chatViewModel?.sendFavoriteNotification(to: peerID, isFavorite: false)
+            contextProvider?.toggleFavorite(peerID: peerID)
+            contextProvider?.sendFavoriteNotification(to: peerID, isFavorite: false)
             
             return .success(message: "removed \(nickname) from favorites")
         }
     }
     
-    private func handleHelp() -> CommandResult {
-        let helpText = """
-        commands:
-        /msg @name - start private chat
-        /who - list who's online
-        /clear - clear messages
-        /hug @name - send a hug
-        /slap @name - slap with a trout
-        /fav @name - add to favorites
-        /unfav @name - remove from favorites
-        /block @name - block
-        /unblock @name - unblock
-        """
-        return .success(message: helpText)
-    }
 }

bitchat/Services/FavoritesPersistenceService.swift

@@ -1,9 +1,11 @@
+import BitLogger
+import BitFoundation
 import Foundation
 import Combine
 
 /// Manages persistent favorite relationships between peers
 @MainActor
-class FavoritesPersistenceService: ObservableObject {
+final class FavoritesPersistenceService: ObservableObject {
     
     struct FavoriteRelationship: Codable {
         let peerNoisePublicKey: Data
@@ -13,24 +15,27 @@ class FavoritesPersistenceService: ObservableObject {
         let theyFavoritedUs: Bool
         let favoritedAt: Date
         let lastUpdated: Date
+        // Track what we last sent as OUR npub to this peer, to avoid resending unless it changes
+        // Note: we do not track which npub we last sent to them; sending happens only on favorite toggle
         
         var isMutual: Bool {
             isFavorite && theyFavoritedUs
         }
     }
     
+    // We intentionally do not track when we last sent our npub; sending happens only on favorite toggle.
+
     private static let storageKey = "chat.bitchat.favorites"
     private static let keychainService = "chat.bitchat.favorites"
+    private let keychain: KeychainManagerProtocol
     
     @Published private(set) var favorites: [Data: FavoriteRelationship] = [:] // Noise pubkey -> relationship
     @Published private(set) var mutualFavorites: Set<Data> = []
     
-    private let userDefaults = UserDefaults.standard
-    private var cancellables = Set<AnyCancellable>()
-    
     static let shared = FavoritesPersistenceService()
-    
-    private init() {
+
+    init(keychain: KeychainManagerProtocol = KeychainManager()) {
+        self.keychain = keychain
         loadFavorites()
         
         // Update mutual favorites when favorites change
@@ -47,8 +52,7 @@ class FavoritesPersistenceService: ObservableObject {
         peerNostrPublicKey: String? = nil,
         peerNickname: String
     ) {
-        SecureLogger.log("⭐️ Adding favorite: \(peerNickname) (\(peerNoisePublicKey.hexEncodedString()))", 
-                        category: SecureLogger.session, level: .info)
+        SecureLogger.info("⭐️ Adding favorite: \(peerNickname) (\(peerNoisePublicKey.hexEncodedString()))", category: .session)
         
         let existing = favorites[peerNoisePublicKey]
         
@@ -64,8 +68,7 @@ class FavoritesPersistenceService: ObservableObject {
         
         // Log if this creates a mutual favorite
         if relationship.isMutual {
-            SecureLogger.log("💕 Mutual favorite relationship established with \(peerNickname)!", 
-                            category: SecureLogger.session, level: .info)
+            SecureLogger.info("💕 Mutual favorite relationship established with \(peerNickname)!", category: .session)
         }
         
         favorites[peerNoisePublicKey] = relationship
@@ -83,8 +86,7 @@ class FavoritesPersistenceService: ObservableObject {
     func removeFavorite(peerNoisePublicKey: Data) {
         guard let existing = favorites[peerNoisePublicKey] else { return }
         
-        SecureLogger.log("⭐️ Removing favorite: \(existing.peerNickname) (\(peerNoisePublicKey.hexEncodedString()))", 
-                        category: SecureLogger.session, level: .info)
+        SecureLogger.info("⭐️ Removing favorite: \(existing.peerNickname) (\(peerNoisePublicKey.hexEncodedString()))", category: .session)
         
         // If they still favorite us, keep the record but mark us as not favoriting
         if existing.theyFavoritedUs {
@@ -125,8 +127,7 @@ class FavoritesPersistenceService: ObservableObject {
         let existing = favorites[peerNoisePublicKey]
         let displayName = peerNickname ?? existing?.peerNickname ?? "Unknown"
         
-        SecureLogger.log("📨 Received favorite notification: \(displayName) \(favorited ? "favorited" : "unfavorited") us", 
-                        category: SecureLogger.session, level: .info)
+        SecureLogger.info("📨 Received favorite notification: \(displayName) \(favorited ? "favorited" : "unfavorited") us", category: .session)
         
         let relationship = FavoriteRelationship(
             peerNoisePublicKey: peerNoisePublicKey,
@@ -147,8 +148,7 @@ class FavoritesPersistenceService: ObservableObject {
             
             // Check if this creates a mutual favorite
             if relationship.isMutual {
-                SecureLogger.log("💕 Mutual favorite relationship established with \(displayName)!", 
-                                category: SecureLogger.session, level: .info)
+                SecureLogger.info("💕 Mutual favorite relationship established with \(displayName)!", category: .session)
             }
         }
         
@@ -179,136 +179,24 @@ class FavoritesPersistenceService: ObservableObject {
 
     /// Resolve favorite status by short peer ID (16-hex derived from Noise pubkey)
     /// Falls back to scanning favorites and matching on derived peer ID.
-    func getFavoriteStatus(forPeerID peerID: String) -> FavoriteRelationship? {
+    func getFavoriteStatus(forPeerID peerID: PeerID) -> FavoriteRelationship? {
         // Quick sanity: peerID should be 16 hex chars (8 bytes)
-        guard peerID.count == 16 else { return nil }
-        for (pubkey, rel) in favorites {
-            let derived = PeerIDUtils.derivePeerID(fromPublicKey: pubkey)
-            if derived == peerID { return rel }
+        guard peerID.isShort else { return nil }
+        for (pubkey, rel) in favorites where PeerID(publicKey: pubkey) == peerID {
+            return rel
         }
         return nil
     }
     
-    /// Update Nostr public key for a peer
-    func updateNostrPublicKey(for peerNoisePublicKey: Data, nostrPubkey: String) {
-        guard let existing = favorites[peerNoisePublicKey] else { return }
-        
-        let updated = FavoriteRelationship(
-            peerNoisePublicKey: existing.peerNoisePublicKey,
-            peerNostrPublicKey: nostrPubkey,
-            peerNickname: existing.peerNickname,
-            isFavorite: existing.isFavorite,
-            theyFavoritedUs: existing.theyFavoritedUs,
-            favoritedAt: existing.favoritedAt,
-            lastUpdated: Date()
-        )
-        
-        favorites[peerNoisePublicKey] = updated
-        saveFavorites()
-    }
-    
-    /// Update nickname for an existing favorite
-    func updateNickname(for peerNoisePublicKey: Data, newNickname: String) {
-        guard let existing = favorites[peerNoisePublicKey] else { return }
-        
-        // Skip if nickname hasn't changed
-        if existing.peerNickname == newNickname { return }
-        
-        // Updating nickname for favorite
-        
-        let updated = FavoriteRelationship(
-            peerNoisePublicKey: existing.peerNoisePublicKey,
-            peerNostrPublicKey: existing.peerNostrPublicKey,
-            peerNickname: newNickname,
-            isFavorite: existing.isFavorite,
-            theyFavoritedUs: existing.theyFavoritedUs,
-            favoritedAt: existing.favoritedAt,
-            lastUpdated: Date()
-        )
-        
-        favorites[peerNoisePublicKey] = updated
-        saveFavorites()
-        
-        // Notify observers
-        NotificationCenter.default.post(
-            name: .favoriteStatusChanged,
-            object: nil,
-            userInfo: ["peerPublicKey": peerNoisePublicKey]
-        )
-    }
-    
-    /// Update noise public key when peer reconnects with new ID
-    func updateNoisePublicKey(from oldKey: Data, to newKey: Data, peerNickname: String) {
-        guard let existing = favorites[oldKey] else { 
-            SecureLogger.log("⚠️ Cannot update noise key - no favorite found for \(oldKey.hexEncodedString())", 
-                            category: SecureLogger.session, level: .warning)
-            return 
-        }
-        
-        // Check if we already have a favorite with the new key
-        if favorites[newKey] != nil {
-            SecureLogger.log("⚠️ Favorite already exists with new key \(newKey.hexEncodedString()), removing old entry", 
-                            category: SecureLogger.session, level: .warning)
-            favorites.removeValue(forKey: oldKey)
-            saveFavorites()
-            return
-        }
-        
-        // Updating noise public key
-        
-        // Remove old entry
-        favorites.removeValue(forKey: oldKey)
-        
-        // Add with new key
-        let updated = FavoriteRelationship(
-            peerNoisePublicKey: newKey,
-            peerNostrPublicKey: existing.peerNostrPublicKey,
-            peerNickname: peerNickname,
-            isFavorite: existing.isFavorite,
-            theyFavoritedUs: existing.theyFavoritedUs,
-            favoritedAt: existing.favoritedAt,
-            lastUpdated: Date()
-        )
-        
-        favorites[newKey] = updated
-        saveFavorites()
-        
-        // Notify observers with both old and new keys
-        NotificationCenter.default.post(
-            name: .favoriteStatusChanged,
-            object: nil,
-            userInfo: [
-                "peerPublicKey": newKey,
-                "oldPeerPublicKey": oldKey,
-                "isKeyUpdate": true
-            ]
-        )
-    }
-    
-    /// Get all favorites (including non-mutual)
-    func getAllFavorites() -> [FavoriteRelationship] {
-        favorites.values.filter { $0.isFavorite }
-    }
-    
-    /// Get only mutual favorites
-    func getMutualFavorites() -> [FavoriteRelationship] {
-        favorites.values.filter { $0.isMutual }
-    }
-    
-    /// Get all favorite relationships (including where they favorited us)
-    func getAllRelationships() -> [FavoriteRelationship] {
-        Array(favorites.values)
-    }
-    
     /// Clear all favorites - used for panic mode
     func clearAllFavorites() {
-        SecureLogger.log("🧹 Clearing all favorites (panic mode)", category: SecureLogger.session, level: .warning)
+        SecureLogger.warning("🧹 Clearing all favorites (panic mode)", category: .session)
         
         favorites.removeAll()
         saveFavorites()
         
         // Delete from keychain directly
-        KeychainHelper.delete(
+        keychain.delete(
             key: Self.storageKey,
             service: Self.keychainService
         )
@@ -328,22 +216,23 @@ class FavoritesPersistenceService: ObservableObject {
             let data = try encoder.encode(relationships)
             
             // Store in keychain for security
-            KeychainHelper.save(
+            keychain.save(
                 key: Self.storageKey,
                 data: data,
-                service: Self.keychainService
+                service: Self.keychainService,
+                accessible: nil
             )
             
             // Successfully saved favorites
         } catch {
-            SecureLogger.log("Failed to save favorites: \(error)", category: SecureLogger.session, level: .error)
+            SecureLogger.error("Failed to save favorites: \(error)", category: .session)
         }
     }
     
     private func loadFavorites() {
         // Loading favorites from keychain
         
-        guard let data = KeychainHelper.load(
+        guard let data = keychain.load(
             key: Self.storageKey,
             service: Self.keychainService
         ) else { 
@@ -354,14 +243,12 @@ class FavoritesPersistenceService: ObservableObject {
             let decoder = JSONDecoder()
             let relationships = try decoder.decode([FavoriteRelationship].self, from: data)
             
-            SecureLogger.log("✅ Loaded \(relationships.count) favorite relationships", 
-                            category: SecureLogger.session, level: .info)
+            SecureLogger.info("✅ Loaded \(relationships.count) favorite relationships", category: .session)
             
             // Log Nostr public key info
             for relationship in relationships {
                 if relationship.peerNostrPublicKey == nil {
-                    SecureLogger.log("⚠️ No Nostr public key stored for '\(relationship.peerNickname)'", 
-                                    category: SecureLogger.session, level: .warning)
+                    SecureLogger.warning("⚠️ No Nostr public key stored for '\(relationship.peerNickname)'", category: .session)
                 }
             }
             
@@ -372,8 +259,7 @@ class FavoritesPersistenceService: ObservableObject {
             for relationship in relationships {
                 // Check for duplicates by public key (the actual unique identifier)
                 if let existing = seenPublicKeys[relationship.peerNoisePublicKey] {
-                    SecureLogger.log("⚠️ Duplicate favorite found for public key \(relationship.peerNoisePublicKey.hexEncodedString()) - nicknames: '\(existing.peerNickname)' vs '\(relationship.peerNickname)'", 
-                                    category: SecureLogger.session, level: .warning)
+                    SecureLogger.warning("⚠️ Duplicate favorite found for public key \(relationship.peerNoisePublicKey.hexEncodedString()) - nicknames: '\(existing.peerNickname)' vs '\(relationship.peerNickname)'", category: .session)
                     
                     // Keep the most recent or most complete relationship
                     if relationship.lastUpdated > existing.lastUpdated ||
@@ -414,7 +300,7 @@ class FavoritesPersistenceService: ObservableObject {
             // Log loaded relationships
             // Loaded relationships successfully
         } catch {
-            SecureLogger.log("Failed to load favorites: \(error)", category: SecureLogger.session, level: .error)
+            SecureLogger.error("Failed to load favorites: \(error)", category: .session)
         }
     }
 }

bitchat/Services/GeohashBookmarksStore.swift

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

bitchat/Services/GeohashParticipantTracker.swift

@@ -0,0 +1,162 @@
+//
+// GeohashParticipantTracker.swift
+// bitchat
+//
+// Tracks participants in geohash-based location channels.
+// This is free and unencumbered software released into the public domain.
+//
+
+import Foundation
+
+/// Represents a participant in a geohash channel
+public struct GeoPerson: Identifiable, Equatable, Sendable {
+    public let id: String        // pubkey hex (lowercased)
+    public let displayName: String
+    public let lastSeen: Date
+
+    public init(id: String, displayName: String, lastSeen: Date) {
+        self.id = id
+        self.displayName = displayName
+        self.lastSeen = lastSeen
+    }
+}
+
+/// Protocol for resolving display names and checking block status
+@MainActor
+public protocol GeohashParticipantContext: AnyObject {
+    /// Returns display name for a Nostr pubkey (e.g., "alice#a1b2" or "anon#c3d4")
+    func displayNameForPubkey(_ pubkeyHex: String) -> String
+    /// Returns true if the pubkey is blocked
+    func isBlocked(_ pubkeyHexLowercased: String) -> Bool
+}
+
+/// Tracks participants across multiple geohash channels
+@MainActor
+public final class GeohashParticipantTracker: ObservableObject {
+
+    /// Activity cutoff duration (defaults to 5 minutes)
+    public let activityCutoff: TimeInterval
+
+    /// Per-geohash participant map: [geohash: [pubkeyHex: lastSeen]]
+    private var participants: [String: [String: Date]] = [:]
+
+    /// Currently visible people for the active geohash
+    @Published public private(set) var visiblePeople: [GeoPerson] = []
+
+    /// The currently active geohash (if any)
+    private var activeGeohash: String?
+
+    /// Context for display name resolution and block checking
+    private weak var context: GeohashParticipantContext?
+
+    /// Timer for periodic refresh
+    private var refreshTimer: Timer?
+
+    public init(activityCutoff: TimeInterval = -300) { // default 5 minutes
+        self.activityCutoff = activityCutoff
+    }
+
+    /// Configure with a context provider
+    public func configure(context: GeohashParticipantContext) {
+        self.context = context
+    }
+
+    /// Set the currently active geohash
+    public func setActiveGeohash(_ geohash: String?) {
+        activeGeohash = geohash
+        if geohash == nil {
+            visiblePeople = []
+        } else {
+            refresh()
+        }
+    }
+
+    /// Record activity from a participant in the current active geohash
+    public func recordParticipant(pubkeyHex: String) {
+        guard let gh = activeGeohash else { return }
+        recordParticipant(pubkeyHex: pubkeyHex, geohash: gh)
+    }
+
+    /// Record activity from a participant in a specific geohash
+    public func recordParticipant(pubkeyHex: String, geohash: String) {
+        let key = pubkeyHex.lowercased()
+        var map = participants[geohash] ?? [:]
+        map[key] = Date()
+        participants[geohash] = map
+        
+        // Always notify observers that state has changed so counts in UI update
+        objectWillChange.send()
+
+        // Only refresh visible list if this geohash is currently active
+        if activeGeohash == geohash {
+            refresh()
+        }
+    }
+
+    /// Remove a participant from all geohashes (used when blocking)
+    public func removeParticipant(pubkeyHex: String) {
+        let key = pubkeyHex.lowercased()
+        for (gh, var map) in participants {
+            map.removeValue(forKey: key)
+            participants[gh] = map
+        }
+        refresh()
+    }
+
+    /// Get participant count for a specific geohash
+    public func participantCount(for geohash: String) -> Int {
+        let cutoff = Date().addingTimeInterval(activityCutoff)
+        let map = participants[geohash] ?? [:]
+        return map.values.filter { $0 >= cutoff }.count
+    }
+
+    /// Get the visible people list for the active geohash (read-only query)
+    public func getVisiblePeople() -> [GeoPerson] {
+        guard let gh = activeGeohash, let context = context else { return [] }
+        let cutoff = Date().addingTimeInterval(activityCutoff)
+        let map = (participants[gh] ?? [:])
+            .filter { $0.value >= cutoff }
+            .filter { !context.isBlocked($0.key) }
+
+        return map
+            .map { (pub, seen) in
+                GeoPerson(id: pub, displayName: context.displayNameForPubkey(pub), lastSeen: seen)
+            }
+            .sorted { $0.lastSeen > $1.lastSeen }
+    }
+
+    /// Refresh the visible people list
+    public func refresh() {
+        visiblePeople = getVisiblePeople()
+    }
+
+    /// Start the periodic refresh timer
+    public func startRefreshTimer(interval: TimeInterval = 30.0) {
+        stopRefreshTimer()
+        refreshTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
+            Task { @MainActor in
+                self?.refresh()
+            }
+        }
+    }
+
+    /// Stop the periodic refresh timer
+    public func stopRefreshTimer() {
+        refreshTimer?.invalidate()
+        refreshTimer = nil
+    }
+
+    /// Clear all participant data
+    public func clear() {
+        participants.removeAll()
+        visiblePeople = []
+    }
+
+    /// Clear participant data for a specific geohash
+    public func clear(geohash: String) {
+        participants.removeValue(forKey: geohash)
+        if activeGeohash == geohash {
+            visiblePeople = []
+        }
+    }
+}

bitchat/Services/GeohashPresenceService.swift

@@ -0,0 +1,264 @@
+//
+// GeohashPresenceService.swift
+// bitchat
+//
+// Manages the broadcasting of ephemeral presence heartbeats (Kind 20001)
+// to geohash location channels.
+//
+// This is free and unencumbered software released into the public domain.
+//
+
+import Foundation
+import Combine
+import BitLogger
+import Tor
+
+protocol GeohashPresenceTimerProtocol: AnyObject {
+    var isValid: Bool { get }
+    func invalidate()
+}
+
+private final class GeohashPresenceTimerAdapter: GeohashPresenceTimerProtocol {
+    private let base: Timer
+
+    init(base: Timer) {
+        self.base = base
+    }
+
+    var isValid: Bool { base.isValid }
+
+    func invalidate() {
+        base.invalidate()
+    }
+}
+
+/// Service that coordinates the broadcasting of presence heartbeats.
+///
+/// Behavior:
+/// - Monitors location changes via LocationStateManager
+/// - Broadcasts Kind 20001 events to low-precision geohash channels
+/// - Uses randomized timing (40-80s loop) and decorrelated bursts
+/// - Respects privacy by NOT broadcasting to Neighborhood/Block/Building levels
+@MainActor
+final class GeohashPresenceService: ObservableObject {
+    static let shared = GeohashPresenceService()
+
+    private var subscriptions = Set<AnyCancellable>()
+    private var heartbeatTimer: GeohashPresenceTimerProtocol?
+    private let availableChannelsProvider: () -> [GeohashChannel]
+    private let locationChanges: AnyPublisher<[GeohashChannel], Never>
+    private let torReadyPublisher: AnyPublisher<Void, Never>
+    private let torIsReady: () -> Bool
+    private let torIsForeground: () -> Bool
+    private let deriveIdentity: (String) throws -> NostrIdentity
+    private let relayLookup: (String, Int) -> [String]
+    private let relaySender: (NostrEvent, [String]) -> Void
+    private let sleeper: (UInt64) async -> Void
+    private let scheduleTimer: (TimeInterval, @escaping () -> Void) -> GeohashPresenceTimerProtocol
+    
+    // MARK: - Constants
+
+    // Loop interval range in seconds
+    private let loopMinInterval: TimeInterval
+    private let loopMaxInterval: TimeInterval
+    
+    // Per-broadcast decorrelation delay range in seconds
+    private let burstMinDelay: TimeInterval
+    private let burstMaxDelay: TimeInterval
+
+    // Privacy: Only broadcast to these levels
+    private let allowedPrecisions: Set<Int> = [
+        GeohashChannelLevel.region.precision,    // 2
+        GeohashChannelLevel.province.precision,  // 4
+        GeohashChannelLevel.city.precision       // 5
+    ]
+
+    private init() {
+        let idBridge = NostrIdentityBridge()
+        self.availableChannelsProvider = { LocationStateManager.shared.availableChannels }
+        self.locationChanges = LocationStateManager.shared.$availableChannels.eraseToAnyPublisher()
+        self.torReadyPublisher = NotificationCenter.default.publisher(for: .TorDidBecomeReady)
+            .map { _ in () }
+            .eraseToAnyPublisher()
+        self.torIsReady = { TorManager.shared.isReady }
+        self.torIsForeground = { TorManager.shared.isForeground() }
+        self.deriveIdentity = { try idBridge.deriveIdentity(forGeohash: $0) }
+        self.relayLookup = { geohash, count in
+            GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: count)
+        }
+        self.relaySender = { event, relays in
+            NostrRelayManager.shared.sendEvent(event, to: relays)
+        }
+        self.sleeper = { nanoseconds in
+            try? await Task.sleep(nanoseconds: nanoseconds)
+        }
+        self.scheduleTimer = { interval, action in
+            GeohashPresenceTimerAdapter(
+                base: Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { _ in
+                    action()
+                }
+            )
+        }
+        self.loopMinInterval = 40.0
+        self.loopMaxInterval = 80.0
+        self.burstMinDelay = 2.0
+        self.burstMaxDelay = 5.0
+        setupObservers()
+    }
+
+    internal init(
+        availableChannelsProvider: @escaping () -> [GeohashChannel],
+        locationChanges: AnyPublisher<[GeohashChannel], Never>,
+        torReadyPublisher: AnyPublisher<Void, Never>,
+        torIsReady: @escaping () -> Bool,
+        torIsForeground: @escaping () -> Bool,
+        deriveIdentity: @escaping (String) throws -> NostrIdentity,
+        relayLookup: @escaping (String, Int) -> [String],
+        relaySender: @escaping (NostrEvent, [String]) -> Void,
+        sleeper: @escaping (UInt64) async -> Void = { nanoseconds in try? await Task.sleep(nanoseconds: nanoseconds) },
+        scheduleTimer: @escaping (TimeInterval, @escaping () -> Void) -> GeohashPresenceTimerProtocol = { interval, action in
+            GeohashPresenceTimerAdapter(
+                base: Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { _ in
+                    action()
+                }
+            )
+        },
+        loopMinInterval: TimeInterval = 40.0,
+        loopMaxInterval: TimeInterval = 80.0,
+        burstMinDelay: TimeInterval = 2.0,
+        burstMaxDelay: TimeInterval = 5.0
+    ) {
+        self.availableChannelsProvider = availableChannelsProvider
+        self.locationChanges = locationChanges
+        self.torReadyPublisher = torReadyPublisher
+        self.torIsReady = torIsReady
+        self.torIsForeground = torIsForeground
+        self.deriveIdentity = deriveIdentity
+        self.relayLookup = relayLookup
+        self.relaySender = relaySender
+        self.sleeper = sleeper
+        self.scheduleTimer = scheduleTimer
+        self.loopMinInterval = loopMinInterval
+        self.loopMaxInterval = loopMaxInterval
+        self.burstMinDelay = burstMinDelay
+        self.burstMaxDelay = burstMaxDelay
+        setupObservers()
+    }
+    
+    /// Start the service (safe to call multiple times)
+    func start() {
+        SecureLogger.info("Presence: service starting...", category: .session)
+        scheduleNextHeartbeat()
+    }
+
+    private func setupObservers() {
+        // Monitor location channel changes
+        locationChanges
+            .dropFirst()
+            .sink { [weak self] _ in
+                self?.handleLocationChange()
+            }
+            .store(in: &subscriptions)
+
+        // Monitor Tor readiness to kick off heartbeat if it was stalled
+        torReadyPublisher
+            .sink { [weak self] _ in
+                self?.handleConnectivityChange()
+            }
+            .store(in: &subscriptions)
+    }
+
+    func handleLocationChange() {
+        // When location changes, we trigger an immediate (but slightly delayed) heartbeat
+        // to announce presence in the new zone, then reset the loop.
+        SecureLogger.debug("Presence: location changed, scheduling update", category: .session)
+        heartbeatTimer?.invalidate()
+        
+        // Small delay to allow location state to settle
+        heartbeatTimer = scheduleTimer(5.0) { [weak self] in
+            Task { @MainActor [weak self] in
+                self?.performHeartbeat()
+            }
+        }
+    }
+    
+    func handleConnectivityChange() {
+        SecureLogger.debug("Presence: connectivity restored, triggering heartbeat", category: .session)
+        // If we were waiting for network, do it now
+        if heartbeatTimer == nil || !heartbeatTimer!.isValid {
+            scheduleNextHeartbeat()
+        }
+    }
+
+    func scheduleNextHeartbeat() {
+        heartbeatTimer?.invalidate()
+        let interval = TimeInterval.random(in: loopMinInterval...loopMaxInterval)
+        heartbeatTimer = scheduleTimer(interval) { [weak self] in
+            Task { @MainActor [weak self] in
+                self?.performHeartbeat()
+            }
+        }
+    }
+
+    func performHeartbeat() {
+        // Always schedule next loop first ensures continuity even if this one fails/skips
+        defer { scheduleNextHeartbeat() }
+
+        // 1. Check preconditions
+        guard torIsReady() else {
+            SecureLogger.debug("Presence: skipping heartbeat (Tor not ready)", category: .session)
+            return
+        }
+        
+        // App must be active (or at least we shouldn't broadcast if in background, usually)
+        if !torIsForeground() {
+            return
+        }
+
+        // 2. Get channels
+        let channels = availableChannelsProvider()
+        guard !channels.isEmpty else { return }
+
+        // 3. Filter and broadcast
+        // We use Task + sleep for decorrelation to allow the main runloop to proceed
+        for channel in channels {
+            // Check privacy restriction
+            if !self.allowedPrecisions.contains(channel.geohash.count) {
+                continue
+            }
+            
+            // Launch independent task for each channel's delay
+            Task { @MainActor in
+                // Random delay for decorrelation
+                let delay = TimeInterval.random(in: self.burstMinDelay...self.burstMaxDelay)
+                let nanoseconds = UInt64(delay * 1_000_000_000)
+                await self.sleeper(nanoseconds)
+                
+                self.broadcastPresence(for: channel.geohash)
+            }
+        }
+    }
+
+    func broadcastPresence(for geohash: String) {
+        do {
+            guard let identity = try? deriveIdentity(geohash) else {
+                return
+            }
+            
+            let event = try NostrProtocol.createGeohashPresenceEvent(
+                geohash: geohash,
+                senderIdentity: identity
+            )
+            
+            // Send via RelayManager
+            let targetRelays = relayLookup(geohash, TransportConfig.nostrGeoRelayCount)
+            
+            if !targetRelays.isEmpty {
+                relaySender(event, targetRelays)
+                SecureLogger.debug("Presence: sent heartbeat for \(geohash) (pub=\(identity.publicKeyHex.prefix(6))...)", category: .session)
+            }
+        } catch {
+            SecureLogger.error("Presence: failed to create event for \(geohash): \(error)", category: .session)
+        }
+    }
+}

bitchat/Services/KeychainManager.swift

@@ -6,54 +6,22 @@
 // For more information, see <https://unlicense.org>
 //
 
+import BitLogger
+import BitFoundation
 import Foundation
 import Security
-import os.log
 
-class KeychainManager {
-    static let shared = KeychainManager()
-    
+final class KeychainManager: KeychainManagerProtocol {
     // Use consistent service name for all keychain items
-    private let service = "chat.bitchat"
-    private let appGroup = "group.chat.bitchat"
-    
-    private init() {}
-    
-    
-    private func isSandboxed() -> Bool {
-        #if os(macOS)
-        // More robust sandbox detection using multiple methods
-        
-        // Method 1: Check environment variable (can be spoofed)
-        let environment = ProcessInfo.processInfo.environment
-        let hasEnvVar = environment["APP_SANDBOX_CONTAINER_ID"] != nil
-        
-        // Method 2: Check if we can access a path outside sandbox
-        let homeDir = FileManager.default.homeDirectoryForCurrentUser
-        let testPath = homeDir.appendingPathComponent("../../../tmp/bitchat_sandbox_test_\(UUID().uuidString)")
-        let canWriteOutsideSandbox = FileManager.default.createFile(atPath: testPath.path, contents: nil, attributes: nil)
-        if canWriteOutsideSandbox {
-            try? FileManager.default.removeItem(at: testPath)
-        }
-        
-        // Method 3: Check container path
-        let containerPath = FileManager.default.urls(for: .libraryDirectory, in: .userDomainMask).first?.path ?? ""
-        let hasContainerPath = containerPath.contains("/Containers/")
-        
-        // If any method indicates sandbox, we consider it sandboxed
-        return hasEnvVar || !canWriteOutsideSandbox || hasContainerPath
-        #else
-        // iOS is always sandboxed
-        return true
-        #endif
-    }
+    private let service = BitchatApp.bundleID
+    private let appGroup = "group.\(BitchatApp.bundleID)"
     
     // MARK: - Identity Keys
     
     func saveIdentityKey(_ keyData: Data, forKey key: String) -> Bool {
         let fullKey = "identity_\(key)"
         let result = saveData(keyData, forKey: fullKey)
-        SecureLogger.logKeyOperation("save", keyType: key, success: result)
+        SecureLogger.logKeyOperation(.save, keyType: key, success: result)
         return result
     }
     
@@ -64,10 +32,184 @@ class KeychainManager {
     
     func deleteIdentityKey(forKey key: String) -> Bool {
         let result = delete(forKey: "identity_\(key)")
-        SecureLogger.logKeyOperation("delete", keyType: key, success: result)
+        SecureLogger.logKeyOperation(.delete, keyType: key, success: result)
         return result
     }
-    
+
+    // MARK: - BCH-01-009: Methods with Proper Error Classification
+
+    /// Get identity key with detailed result for proper error handling
+    /// Distinguishes between missing keys (expected) and critical failures
+    func getIdentityKeyWithResult(forKey key: String) -> KeychainReadResult {
+        let fullKey = "identity_\(key)"
+        return retrieveDataWithResult(forKey: fullKey)
+    }
+
+    /// Save identity key with detailed result and retry logic for transient errors
+    func saveIdentityKeyWithResult(_ keyData: Data, forKey key: String) -> KeychainSaveResult {
+        let fullKey = "identity_\(key)"
+        return saveDataWithResult(keyData, forKey: fullKey)
+    }
+
+    /// Internal method to save data with detailed result and retry for transient errors
+    private func saveDataWithResult(_ data: Data, forKey key: String, retryCount: Int = 2) -> KeychainSaveResult {
+        // Delete any existing item first to ensure clean state
+        _ = delete(forKey: key)
+
+        // Build base query
+        var base: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: key,
+            kSecValueData as String: data,
+            kSecAttrService as String: service,
+            kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlocked,
+            kSecAttrLabel as String: "bitchat-\(key)"
+        ]
+        #if os(macOS)
+        base[kSecAttrSynchronizable as String] = false
+        #endif
+
+        func attempt(addAccessGroup: Bool) -> OSStatus {
+            var query = base
+            if addAccessGroup { query[kSecAttrAccessGroup as String] = appGroup }
+            return SecItemAdd(query as CFDictionary, nil)
+        }
+
+        #if os(iOS)
+        var status = attempt(addAccessGroup: true)
+        if status == -34018 { // Missing entitlement, retry without access group
+            status = attempt(addAccessGroup: false)
+        }
+        #else
+        let status = attempt(addAccessGroup: false)
+        #endif
+
+        // Classify the result
+        let result = classifySaveStatus(status)
+
+        // Log all outcomes consistently
+        switch result {
+        case .success:
+            SecureLogger.debug("Keychain save succeeded for key: \(key)", category: .keychain)
+        case .duplicateItem:
+            SecureLogger.warning("Keychain save found duplicate for key: \(key)", category: .keychain)
+        case .accessDenied:
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Keychain access denied for key: \(key)", category: .keychain)
+        case .deviceLocked:
+            SecureLogger.warning("Device locked during keychain save for key: \(key)", category: .keychain)
+        case .storageFull:
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Keychain storage full for key: \(key)", category: .keychain)
+        case .otherError(let code):
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(code)),
+                               context: "Keychain save failed for key: \(key)", category: .keychain)
+        }
+
+        // Retry transient errors with exponential backoff
+        if result.isRecoverableError && retryCount > 0 {
+            let delayMs = UInt32((3 - retryCount) * 100) // 100ms, 200ms backoff
+            usleep(delayMs * 1000)
+            SecureLogger.debug("Retrying keychain save for key: \(key), attempts remaining: \(retryCount)", category: .keychain)
+            return saveDataWithResult(data, forKey: key, retryCount: retryCount - 1)
+        }
+
+        return result
+    }
+
+    /// Internal method to retrieve data with detailed result
+    private func retrieveDataWithResult(forKey key: String) -> KeychainReadResult {
+        let base: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: key,
+            kSecAttrService as String: service,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne
+        ]
+
+        var result: AnyObject?
+        func attempt(withAccessGroup: Bool) -> OSStatus {
+            var q = base
+            if withAccessGroup { q[kSecAttrAccessGroup as String] = appGroup }
+            return SecItemCopyMatching(q as CFDictionary, &result)
+        }
+
+        #if os(iOS)
+        var status = attempt(withAccessGroup: true)
+        if status == -34018 { status = attempt(withAccessGroup: false) }
+        #else
+        let status = attempt(withAccessGroup: false)
+        #endif
+
+        // Classify the result
+        let readResult = classifyReadStatus(status, data: result as? Data)
+
+        // Log all outcomes consistently
+        switch readResult {
+        case .success:
+            SecureLogger.debug("Keychain read succeeded for key: \(key)", category: .keychain)
+        case .itemNotFound:
+            // Expected case - no logging needed for missing keys
+            break
+        case .accessDenied:
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Keychain access denied for key: \(key)", category: .keychain)
+        case .deviceLocked:
+            SecureLogger.warning("Device locked during keychain read for key: \(key)", category: .keychain)
+        case .authenticationFailed:
+            SecureLogger.warning("Authentication failed for keychain read of key: \(key)", category: .keychain)
+        case .otherError(let code):
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(code)),
+                               context: "Keychain read failed for key: \(key)", category: .keychain)
+        }
+
+        return readResult
+    }
+
+    /// Classify keychain read status into meaningful categories
+    private func classifyReadStatus(_ status: OSStatus, data: Data?) -> KeychainReadResult {
+        switch status {
+        case errSecSuccess:
+            if let data = data {
+                return .success(data)
+            }
+            return .otherError(status)
+        case errSecItemNotFound:
+            return .itemNotFound
+        case errSecInteractionNotAllowed:
+            // Device is locked or in a state that doesn't allow keychain access
+            return .deviceLocked
+        case errSecAuthFailed:
+            return .authenticationFailed
+        case -34018: // errSecMissingEntitlement
+            return .accessDenied
+        case errSecNotAvailable:
+            return .accessDenied
+        default:
+            return .otherError(status)
+        }
+    }
+
+    /// Classify keychain save status into meaningful categories
+    private func classifySaveStatus(_ status: OSStatus) -> KeychainSaveResult {
+        switch status {
+        case errSecSuccess:
+            return .success
+        case errSecDuplicateItem:
+            return .duplicateItem
+        case errSecInteractionNotAllowed:
+            return .deviceLocked
+        case -34018: // errSecMissingEntitlement
+            return .accessDenied
+        case errSecNotAvailable:
+            return .accessDenied
+        case errSecDiskFull:
+            return .storageFull
+        default:
+            return .otherError(status)
+        }
+    }
+
     // MARK: - Generic Operations
     
     private func save(_ value: String, forKey key: String) -> Bool {
@@ -113,9 +255,9 @@ class KeychainManager {
 
         if status == errSecSuccess { return true }
         if status == -34018 && !triedWithoutGroup {
-            SecureLogger.logError(NSError(domain: "Keychain", code: -34018), context: "Missing keychain entitlement", category: SecureLogger.keychain)
+            SecureLogger.error(NSError(domain: "Keychain", code: -34018), context: "Missing keychain entitlement", category: .keychain)
         } else if status != errSecDuplicateItem {
-            SecureLogger.logError(NSError(domain: "Keychain", code: Int(status)), context: "Error saving to keychain", category: SecureLogger.keychain)
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)), context: "Error saving to keychain", category: .keychain)
         }
         return false
     }
@@ -151,7 +293,7 @@ class KeychainManager {
 
         if status == errSecSuccess { return result as? Data }
         if status == -34018 {
-            SecureLogger.logError(NSError(domain: "Keychain", code: -34018), context: "Missing keychain entitlement", category: SecureLogger.keychain)
+            SecureLogger.error(NSError(domain: "Keychain", code: -34018), context: "Missing keychain entitlement", category: .keychain)
         }
         return nil
     }
@@ -198,7 +340,7 @@ class KeychainManager {
     
     // Delete ALL keychain data for panic mode
     func deleteAllKeychainData() -> Bool {
-        SecureLogger.log("Panic mode - deleting all keychain data", category: SecureLogger.security, level: .warning)
+        SecureLogger.warning("Panic mode - deleting all keychain data", category: .security)
         
         var totalDeleted = 0
         
@@ -261,7 +403,7 @@ class KeychainManager {
                     let deleteStatus = SecItemDelete(deleteQuery as CFDictionary)
                     if deleteStatus == errSecSuccess {
                         totalDeleted += 1
-                        SecureLogger.log("Deleted keychain item: \(account) from \(service)", category: SecureLogger.keychain, level: .info)
+                        SecureLogger.info("Deleted keychain item: \(account) from \(service)", category: .keychain)
                     }
                 }
             }
@@ -275,6 +417,7 @@ class KeychainManager {
             "com.bitchat.deviceidentity", 
             "com.bitchat.noise.identity",
             "chat.bitchat.passwords",
+            "chat.bitchat.nostr",
             "bitchat.keychain",
             "bitchat",
             "com.bitchat"
@@ -303,7 +446,7 @@ class KeychainManager {
             totalDeleted += 1
         }
         
-        SecureLogger.log("Panic mode cleanup completed. Total items deleted: \(totalDeleted)", category: SecureLogger.keychain, level: .warning)
+        SecureLogger.warning("Panic mode cleanup completed. Total items deleted: \(totalDeleted)", category: .keychain)
         
         return totalDeleted > 0
     }
@@ -311,7 +454,7 @@ class KeychainManager {
     // MARK: - Security Utilities
     
     /// Securely clear sensitive data from memory
-    static func secureClear(_ data: inout Data) {
+    func secureClear(_ data: inout Data) {
         _ = data.withUnsafeMutableBytes { bytes in
             // Use volatile memset to prevent compiler optimization
             memset_s(bytes.baseAddress, bytes.count, 0, bytes.count)
@@ -320,7 +463,7 @@ class KeychainManager {
     }
     
     /// Securely clear sensitive string from memory
-    static func secureClear(_ string: inout String) {
+    func secureClear(_ string: inout String) {
         // Convert to mutable data and clear
         if var data = string.data(using: .utf8) {
             secureClear(&data)
@@ -329,9 +472,54 @@ class KeychainManager {
     }
     
     // MARK: - Debug
-    
+
     func verifyIdentityKeyExists() -> Bool {
         let key = "identity_noiseStaticKey"
         return retrieveData(forKey: key) != nil
     }
+
+    // MARK: - Generic Data Storage (consolidated from KeychainHelper)
+
+    /// Save data with a custom service name
+    func save(key: String, data: Data, service customService: String, accessible: CFString?) {
+        var query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: customService,
+            kSecAttrAccount as String: key,
+            kSecValueData as String: data
+        ]
+        if let accessible = accessible {
+            query[kSecAttrAccessible as String] = accessible
+        }
+
+        SecItemDelete(query as CFDictionary)
+        SecItemAdd(query as CFDictionary, nil)
+    }
+
+    /// Load data from a custom service
+    func load(key: String, service customService: String) -> Data? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: customService,
+            kSecAttrAccount as String: key,
+            kSecReturnData as String: true
+        ]
+
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+
+        guard status == errSecSuccess else { return nil }
+        return result as? Data
+    }
+
+    /// Delete data from a custom service
+    func delete(key: String, service customService: String) {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: customService,
+            kSecAttrAccount as String: key
+        ]
+
+        SecItemDelete(query as CFDictionary)
+    }
 }

bitchat/Services/LocationChannelManager.swift

@@ -1,298 +0,0 @@
-import Foundation
-import Combine
-
-#if os(iOS) || os(macOS)
-import CoreLocation
-
-/// Manages location permissions, one-shot location retrieval, and computing geohash channels.
-/// Not main-actor isolated to satisfy CLLocationManagerDelegate in Swift 6; state updates hop to MainActor.
-final class LocationChannelManager: NSObject, CLLocationManagerDelegate, ObservableObject {
-    static let shared = LocationChannelManager()
-
-    enum PermissionState: Equatable {
-        case notDetermined
-        case denied
-        case restricted
-        case authorized
-    }
-
-    private let cl = CLLocationManager()
-    private let geocoder = CLGeocoder()
-    private var lastLocation: CLLocation?
-    private var refreshTimer: Timer?
-    private let userDefaultsKey = "locationChannel.selected"
-    private let teleportedStoreKey = "locationChannel.teleportedSet"
-    private var isGeocoding: Bool = false
-
-    // Published state for UI bindings
-    @Published private(set) var permissionState: PermissionState = .notDetermined
-    @Published private(set) var availableChannels: [GeohashChannel] = []
-    @Published private(set) var selectedChannel: ChannelID = .mesh
-    // True when the current location channel was selected via manual teleport
-    @Published var teleported: Bool = false
-    @Published private(set) var locationNames: [GeohashChannelLevel: String] = [:]
-
-    // Persisted set of geohashes that were selected via teleport
-    private var teleportedSet: Set<String> = []
-
-    private override init() {
-        super.init()
-        cl.delegate = self
-        cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
-        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters // meters; we're not tracking continuously
-        // Load selection
-        if let data = UserDefaults.standard.data(forKey: userDefaultsKey),
-           let channel = try? JSONDecoder().decode(ChannelID.self, from: data) {
-            selectedChannel = channel
-        }
-        // Load persisted teleported set
-        if let data = UserDefaults.standard.data(forKey: teleportedStoreKey),
-           let arr = try? JSONDecoder().decode([String].self, from: data) {
-            teleportedSet = Set(arr)
-        }
-        // Do not eagerly mark teleported on startup; wait for location to compute regional set.
-        // This avoids showing teleported for in-region channels during cold start.
-        let status: CLAuthorizationStatus
-        if #available(iOS 14.0, macOS 11.0, *) {
-            status = cl.authorizationStatus
-        } else {
-            status = CLLocationManager.authorizationStatus()
-        }
-        updatePermissionState(from: status)
-        // If we don't have location authorization at startup, fall back to persisted teleport state
-        switch status {
-        case .authorizedAlways, .authorizedWhenInUse, .authorized:
-            break // will compute from location
-        default:
-            if case .location(let ch) = selectedChannel {
-                teleported = teleportedSet.contains(ch.geohash)
-            }
-        }
-    }
-
-    // MARK: - Public API
-    func enableLocationChannels() {
-        let status: CLAuthorizationStatus
-        if #available(iOS 14.0, macOS 11.0, *) {
-            status = cl.authorizationStatus
-        } else {
-            status = CLLocationManager.authorizationStatus()
-        }
-        switch status {
-        case .notDetermined:
-            cl.requestWhenInUseAuthorization()
-        case .restricted:
-            Task { @MainActor in self.permissionState = .restricted }
-        case .denied:
-            Task { @MainActor in self.permissionState = .denied }
-        case .authorizedAlways, .authorizedWhenInUse, .authorized:
-            Task { @MainActor in self.permissionState = .authorized }
-            requestOneShotLocation()
-        @unknown default:
-            Task { @MainActor in self.permissionState = .restricted }
-        }
-    }
-
-    func refreshChannels() {
-        if permissionState == .authorized {
-            requestOneShotLocation()
-        }
-    }
-
-    /// Begin continuous, distance-filtered updates while the channel sheet is visible.
-    /// Uses a 21m filter (configurable) to only refresh on meaningful movement.
-    func beginLiveRefresh(interval: TimeInterval = TransportConfig.locationLiveRefreshInterval) {
-        guard permissionState == .authorized else { return }
-        // Stop any previous polling timer
-        refreshTimer?.invalidate()
-        refreshTimer = nil
-        // Tighten accuracy and distance filter for live view
-        cl.desiredAccuracy = kCLLocationAccuracyNearestTenMeters
-        cl.distanceFilter = TransportConfig.locationDistanceFilterLiveMeters
-        // Start continuous updates
-        cl.startUpdatingLocation()
-        // Request an immediate fix to populate UI without waiting for movement
-        requestOneShotLocation()
-    }
-
-    /// Stop continuous refreshes when selector UI is dismissed.
-    func endLiveRefresh() {
-        refreshTimer?.invalidate()
-        refreshTimer = nil
-        cl.stopUpdatingLocation()
-        // Restore more relaxed defaults for background/idle state
-        cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
-        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters
-    }
-
-    func select(_ channel: ChannelID) {
-        Task { @MainActor in
-            self.selectedChannel = channel
-            if let data = try? JSONEncoder().encode(channel) {
-                UserDefaults.standard.set(data, forKey: self.userDefaultsKey)
-            }
-            // Update teleported flag based on persisted state for immediate UI behavior
-            switch channel {
-            case .mesh:
-                self.teleported = false
-            case .location(let ch):
-                // If this geohash is in our current regional set, do NOT mark teleported.
-                let inRegional = self.availableChannels.contains { $0.geohash == ch.geohash }
-                if inRegional {
-                    self.teleported = false
-                    // Clear persisted teleport for this geohash to keep future selections clean
-                    if self.teleportedSet.contains(ch.geohash) {
-                        self.teleportedSet.remove(ch.geohash)
-                        if let data = try? JSONEncoder().encode(Array(self.teleportedSet)) {
-                            UserDefaults.standard.set(data, forKey: self.teleportedStoreKey)
-                        }
-                    }
-                } else {
-                    // Fall back to persisted mark (set by deep link or manual teleport)
-                    self.teleported = self.teleportedSet.contains(ch.geohash)
-                }
-            }
-        }
-    }
-
-    // Mark or unmark a geohash as teleported in persistence and update current flag if relevant
-    func markTeleported(for geohash: String, _ flag: Bool) {
-        if flag { teleportedSet.insert(geohash) } else { teleportedSet.remove(geohash) }
-        if let data = try? JSONEncoder().encode(Array(teleportedSet)) {
-            UserDefaults.standard.set(data, forKey: teleportedStoreKey)
-        }
-        if case .location(let ch) = selectedChannel, ch.geohash == geohash {
-            Task { @MainActor in self.teleported = flag }
-        }
-    }
-
-    // MARK: - CoreLocation
-    private func requestOneShotLocation() {
-        cl.requestLocation()
-    }
-
-    // iOS < 14
-    func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
-        updatePermissionState(from: status)
-        if case .authorized = permissionState {
-            requestOneShotLocation()
-        }
-    }
-
-    // iOS 14+ / macOS 11+
-    @available(iOS 14.0, macOS 11.0, *)
-    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
-        updatePermissionState(from: manager.authorizationStatus)
-        if case .authorized = permissionState {
-            requestOneShotLocation()
-        }
-    }
-
-    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
-        guard let loc = locations.last else { return }
-        lastLocation = loc
-        computeChannels(from: loc.coordinate)
-        reverseGeocodeIfNeeded(location: loc)
-    }
-
-    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
-        // Surface as denied/restricted if relevant; otherwise keep previous state
-        SecureLogger.log("LocationChannelManager: location error: \(error.localizedDescription)",
-                         category: SecureLogger.session, level: .error)
-    }
-
-    // MARK: - Helpers
-    private func updatePermissionState(from status: CLAuthorizationStatus) {
-        let newState: PermissionState
-        switch status {
-        case .notDetermined: newState = .notDetermined
-        case .restricted: newState = .restricted
-        case .denied: newState = .denied
-        case .authorizedAlways, .authorizedWhenInUse, .authorized: newState = .authorized
-        @unknown default: newState = .restricted
-        }
-        Task { @MainActor in self.permissionState = newState }
-    }
-
-    private func computeChannels(from coord: CLLocationCoordinate2D) {
-        let levels = GeohashChannelLevel.allCases
-        var result: [GeohashChannel] = []
-        for level in levels {
-            let gh = Geohash.encode(latitude: coord.latitude, longitude: coord.longitude, precision: level.precision)
-            result.append(GeohashChannel(level: level, geohash: gh))
-        }
-        Task { @MainActor in
-            self.availableChannels = result
-            // Recompute teleported status based on whether the selected geohash is in our regional set
-            switch self.selectedChannel {
-            case .mesh:
-                self.teleported = false
-            case .location(let ch):
-                // Membership check using freshly computed regional channels; avoids precision/rename drift
-                let inRegional = result.contains { $0.geohash == ch.geohash }
-                if inRegional {
-                    self.teleported = false
-                    // Clear persisted teleport flag if present
-                    if self.teleportedSet.contains(ch.geohash) {
-                        self.teleportedSet.remove(ch.geohash)
-                        if let data = try? JSONEncoder().encode(Array(self.teleportedSet)) {
-                            UserDefaults.standard.set(data, forKey: self.teleportedStoreKey)
-                        }
-                    }
-                } else {
-                    self.teleported = true
-                }
-            }
-        }
-    }
-
-    private func reverseGeocodeIfNeeded(location: CLLocation) {
-        // Always cancel previous to keep latest fresh while user moves
-        geocoder.cancelGeocode()
-        isGeocoding = true
-        geocoder.reverseGeocodeLocation(location) { [weak self] placemarks, error in
-            guard let self = self else { return }
-            self.isGeocoding = false
-            if let pm = placemarks?.first {
-                let names = self.namesByLevel(from: pm)
-                Task { @MainActor in self.locationNames = names }
-            }
-        }
-    }
-
-    private func namesByLevel(from pm: CLPlacemark) -> [GeohashChannelLevel: String] {
-        var dict: [GeohashChannelLevel: String] = [:]
-        // Region (country)
-        if let country = pm.country, !country.isEmpty {
-            dict[.region] = country
-        }
-        // Province (state/province or county)
-        if let admin = pm.administrativeArea, !admin.isEmpty {
-            dict[.province] = admin
-        } else if let subAdmin = pm.subAdministrativeArea, !subAdmin.isEmpty {
-            dict[.province] = subAdmin
-        }
-        // City (locality)
-        if let locality = pm.locality, !locality.isEmpty {
-            dict[.city] = locality
-        } else if let subAdmin = pm.subAdministrativeArea, !subAdmin.isEmpty {
-            dict[.city] = subAdmin
-        } else if let admin = pm.administrativeArea, !admin.isEmpty {
-            dict[.city] = admin
-        }
-        // Neighborhood
-        if let subLocality = pm.subLocality, !subLocality.isEmpty {
-            dict[.neighborhood] = subLocality
-        } else if let locality = pm.locality, !locality.isEmpty {
-            dict[.neighborhood] = locality
-        }
-        // Block: reuse neighborhood/locality granularity without exposing street level
-        if let subLocality = pm.subLocality, !subLocality.isEmpty {
-            dict[.block] = subLocality
-        } else if let locality = pm.locality, !locality.isEmpty {
-            dict[.block] = locality
-        }
-        return dict
-    }
-}
-#endif

bitchat/Services/LocationNotesManager.swift

@@ -0,0 +1,256 @@
+import BitLogger
+import Foundation
+
+/// Dependencies for location notes, allowing tests to stub relay/identity behavior.
+struct LocationNotesDependencies {
+    typealias RelayLookup = @MainActor (_ geohash: String, _ count: Int) -> [String]
+    typealias Subscribe = @MainActor (_ filter: NostrFilter, _ id: String, _ relays: [String], _ handler: @escaping (NostrEvent) -> Void, _ onEOSE: (() -> Void)?) -> Void
+    typealias Unsubscribe = @MainActor (_ id: String) -> Void
+    typealias SendEvent = @MainActor (_ event: NostrEvent, _ relayUrls: [String]) -> Void
+
+    var relayLookup: RelayLookup
+    var subscribe: Subscribe
+    var unsubscribe: Unsubscribe
+    var sendEvent: SendEvent
+    var deriveIdentity: (_ geohash: String) throws -> NostrIdentity
+    var now: () -> Date
+    
+    private static let idBridge = NostrIdentityBridge()
+
+    static let live = LocationNotesDependencies(
+        relayLookup: { geohash, count in
+            GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: count)
+        },
+        subscribe: { filter, id, relays, handler, onEOSE in
+            NostrRelayManager.shared.subscribe(
+                filter: filter,
+                id: id,
+                relayUrls: relays,
+                handler: handler,
+                onEOSE: onEOSE
+            )
+        },
+        unsubscribe: { id in
+            NostrRelayManager.shared.unsubscribe(id: id)
+        },
+        sendEvent: { event, relays in
+            NostrRelayManager.shared.sendEvent(event, to: relays)
+        },
+        deriveIdentity: { geohash in
+            try idBridge.deriveIdentity(forGeohash: geohash)
+        },
+        now: { Date() }
+    )
+}
+
+/// Persistent location notes (Nostr kind 1) scoped to a building-level geohash (precision 8).
+/// Subscribes to and publishes notes for a given geohash and provides a send API.
+@MainActor
+final class LocationNotesManager: ObservableObject {
+    enum State: Equatable {
+        case idle
+        case loading
+        case ready
+        case noRelays
+    }
+
+    struct Note: Identifiable, Equatable {
+        let id: String
+        let pubkey: String
+        let content: String
+        let createdAt: Date
+        let nickname: String?
+
+        var displayName: String {
+            let suffix = String(pubkey.suffix(4))
+            if let nick = nickname?.trimmedOrNilIfEmpty {
+                return "\(nick)#\(suffix)"
+            }
+            return "anon#\(suffix)"
+        }
+    }
+
+    @Published private(set) var notes: [Note] = [] // reverse-chron sorted
+    @Published private(set) var geohash: String
+    @Published private(set) var initialLoadComplete: Bool = false
+    @Published private(set) var state: State = .loading
+    @Published private(set) var errorMessage: String?
+    private var subscriptionID: String?
+    private var noteIDs = Set<String>() // O(1) duplicate detection
+    private let dependencies: LocationNotesDependencies
+    private let maxNotesInMemory = 500 // Defensive cap (relay limit is 200)
+
+    private enum Strings {
+        static let noRelays = String(localized: "location_notes.error.no_relays", comment: "Shown when no geo relays are available near the selected location")
+
+        static func failedToSend(_ detail: String) -> String {
+            String(
+                format: String(localized: "location_notes.error.failed_to_send", comment: "Shown when a location note fails to send"),
+                locale: .current,
+                detail
+            )
+        }
+    }
+
+    init(geohash: String, dependencies: LocationNotesDependencies = .live) {
+        let norm = geohash.lowercased()
+        self.geohash = norm
+        self.dependencies = dependencies
+        // Validate geohash (building-level precision: 8 chars)
+        if !Geohash.isValidBuildingGeohash(norm) {
+            SecureLogger.warning("LocationNotesManager: invalid geohash '\(norm)' (expected 8 valid base32 chars)", category: .session)
+        }
+        subscribe()
+    }
+
+    func setGeohash(_ newGeohash: String) {
+        let norm = newGeohash.lowercased()
+        guard norm != geohash else { return }
+        // Validate geohash (building-level precision: 8 chars)
+        guard Geohash.isValidBuildingGeohash(norm) else {
+            SecureLogger.warning("LocationNotesManager: rejecting invalid geohash '\(norm)' (expected 8 valid base32 chars)", category: .session)
+            return
+        }
+        if let sub = subscriptionID {
+            dependencies.unsubscribe(sub)
+            subscriptionID = nil
+        }
+        // Set loading state before clearing to prevent empty state flicker
+        state = .loading
+        initialLoadComplete = false
+        errorMessage = nil
+        geohash = norm
+        notes.removeAll()
+        noteIDs.removeAll()
+        subscribe()
+    }
+
+    func refresh() {
+        if let sub = subscriptionID {
+            dependencies.unsubscribe(sub)
+            subscriptionID = nil
+        }
+        // Set loading state before clearing to prevent empty state flicker
+        state = .loading
+        initialLoadComplete = false
+        errorMessage = nil
+        notes.removeAll()
+        noteIDs.removeAll()
+        subscribe()
+    }
+
+    func clearError() {
+        errorMessage = nil
+    }
+
+    private func subscribe() {
+        state = .loading
+        errorMessage = nil
+        if let sub = subscriptionID {
+            dependencies.unsubscribe(sub)
+            subscriptionID = nil
+        }
+        let subID = "locnotes-\(geohash)-\(UUID().uuidString.prefix(8))"
+        let relays = dependencies.relayLookup(geohash, TransportConfig.nostrGeoRelayCount)
+        guard !relays.isEmpty else {
+            subscriptionID = nil
+            initialLoadComplete = true
+            state = .noRelays
+            errorMessage = Strings.noRelays
+            SecureLogger.warning("LocationNotesManager: no geo relays for geohash=\(geohash)", category: .session)
+            return
+        }
+
+        subscriptionID = subID
+        initialLoadComplete = false
+
+        // Subscribe to center + 8 neighbors (± 1 grid)
+        let neighbors = Geohash.neighbors(of: geohash)
+        let allGeohashes = [geohash] + neighbors
+        let filter = NostrFilter.geohashNotes(allGeohashes, since: nil, limit: 200)
+
+        // Build a set of valid geohashes for tag matching (includes all 9 cells)
+        let validGeohashes = Set(allGeohashes.map { $0.lowercased() })
+
+        dependencies.subscribe(filter, subID, relays, { [weak self] event in
+            guard let self = self else { return }
+            guard event.kind == NostrProtocol.EventKind.textNote.rawValue else { return }
+            // Ensure matching tag - accept any of our 9 geohashes
+            guard event.tags.contains(where: { tag in
+                tag.count >= 2 && tag[0].lowercased() == "g" && validGeohashes.contains(tag[1].lowercased())
+            }) else { return }
+            guard !self.noteIDs.contains(event.id) else { return }
+            self.noteIDs.insert(event.id)
+            let nick = event.tags.first(where: { $0.first?.lowercased() == "n" && $0.count >= 2 })?.dropFirst().first
+            let ts = Date(timeIntervalSince1970: TimeInterval(event.created_at))
+            let note = Note(id: event.id, pubkey: event.pubkey, content: event.content, createdAt: ts, nickname: nick)
+            self.notes.append(note)
+            self.notes.sort { $0.createdAt > $1.createdAt }
+            self.enforceMemoryCap()
+            self.state = .ready
+        }, { [weak self] in
+            guard let self = self else { return }
+            self.initialLoadComplete = true
+            if self.state != .noRelays {
+                self.state = .ready
+            }
+        })
+    }
+
+    /// Send a location note for the current geohash using the per-geohash identity.
+    func send(content: String, nickname: String) {
+        guard let trimmed = content.trimmedOrNilIfEmpty else { return }
+        let relays = dependencies.relayLookup(geohash, TransportConfig.nostrGeoRelayCount)
+        guard !relays.isEmpty else {
+            state = .noRelays
+            errorMessage = Strings.noRelays
+            SecureLogger.warning("LocationNotesManager: send blocked, no geo relays for geohash=\(geohash)", category: .session)
+            return
+        }
+        do {
+            let id = try dependencies.deriveIdentity(geohash)
+            let event = try NostrProtocol.createGeohashTextNote(
+                content: trimmed,
+                geohash: geohash,
+                senderIdentity: id,
+                nickname: nickname
+            )
+            dependencies.sendEvent(event, relays)
+            // Optimistic local-echo
+            let echo = Note(
+                id: event.id,
+                pubkey: id.publicKeyHex,
+                content: trimmed,
+                createdAt: Date(timeIntervalSince1970: TimeInterval(event.created_at)),
+                nickname: nickname
+            )
+            self.noteIDs.insert(event.id)
+            self.notes.insert(echo, at: 0)
+            self.enforceMemoryCap()
+            self.state = .ready
+            self.errorMessage = nil
+        } catch {
+            SecureLogger.error("LocationNotesManager: failed to send note: \(error)", category: .session)
+            errorMessage = Strings.failedToSend(error.localizedDescription)
+        }
+    }
+
+    /// Enforces defensive memory cap on notes array (keeps newest).
+    private func enforceMemoryCap() {
+        if notes.count > maxNotesInMemory {
+            let removed = notes.count - maxNotesInMemory
+            notes = Array(notes.prefix(maxNotesInMemory))
+            SecureLogger.debug("LocationNotesManager: trimmed \(removed) old notes (cap: \(maxNotesInMemory))", category: .session)
+        }
+    }
+
+    /// Explicitly cancel subscription and release resources.
+    func cancel() {
+        if let sub = subscriptionID {
+            dependencies.unsubscribe(sub)
+            subscriptionID = nil
+        }
+        state = .idle
+        errorMessage = nil
+    }
+}

bitchat/Services/LocationStateManager.swift

@@ -0,0 +1,630 @@
+import BitLogger
+import Foundation
+import Combine
+
+#if os(iOS) || os(macOS)
+import CoreLocation
+
+protocol LocationStateManaging: AnyObject {
+    var delegate: CLLocationManagerDelegate? { get set }
+    var desiredAccuracy: CLLocationAccuracy { get set }
+    var distanceFilter: CLLocationDistance { get set }
+    var authorizationStatus: CLAuthorizationStatus { get }
+    func requestWhenInUseAuthorization()
+    func requestLocation()
+    func startUpdatingLocation()
+    func stopUpdatingLocation()
+}
+
+protocol LocationStateGeocoding: AnyObject {
+    func cancelGeocode()
+    func reverseGeocodeLocation(
+        _ location: CLLocation,
+        completionHandler: @escaping ([CLPlacemark]?, Error?) -> Void
+    )
+}
+
+private final class CLLocationManagerAdapter: NSObject, LocationStateManaging {
+    private let base = CLLocationManager()
+
+    var delegate: CLLocationManagerDelegate? {
+        get { base.delegate }
+        set { base.delegate = newValue }
+    }
+
+    var desiredAccuracy: CLLocationAccuracy {
+        get { base.desiredAccuracy }
+        set { base.desiredAccuracy = newValue }
+    }
+
+    var distanceFilter: CLLocationDistance {
+        get { base.distanceFilter }
+        set { base.distanceFilter = newValue }
+    }
+
+    var authorizationStatus: CLAuthorizationStatus {
+        base.authorizationStatus
+    }
+
+    func requestWhenInUseAuthorization() {
+        base.requestWhenInUseAuthorization()
+    }
+
+    func requestLocation() {
+        base.requestLocation()
+    }
+
+    func startUpdatingLocation() {
+        base.startUpdatingLocation()
+    }
+
+    func stopUpdatingLocation() {
+        base.stopUpdatingLocation()
+    }
+}
+
+private final class CLGeocoderAdapter: LocationStateGeocoding {
+    private let base = CLGeocoder()
+
+    func cancelGeocode() {
+        base.cancelGeocode()
+    }
+
+    func reverseGeocodeLocation(
+        _ location: CLLocation,
+        completionHandler: @escaping ([CLPlacemark]?, Error?) -> Void
+    ) {
+        base.reverseGeocodeLocation(location, completionHandler: completionHandler)
+    }
+}
+
+/// Unified manager for location-based channel state including:
+/// - CoreLocation permissions and one-shot location retrieval
+/// - Geohash channel computation from coordinates
+/// - Channel selection and teleport state
+/// - Bookmark persistence and friendly name resolution
+///
+/// Consolidates LocationChannelManager + GeohashBookmarksStore into a single source of truth.
+final class LocationStateManager: NSObject, CLLocationManagerDelegate, ObservableObject {
+    static let shared = LocationStateManager()
+
+    // MARK: - Permission State
+
+    enum PermissionState: Equatable {
+        case notDetermined
+        case denied
+        case restricted
+        case authorized
+    }
+
+    // MARK: - Private Properties (CoreLocation)
+
+    private let cl: LocationStateManaging
+    private let geocoder: LocationStateGeocoding
+    private var lastLocation: CLLocation?
+    private var refreshTimer: Timer?
+    private var isGeocoding: Bool = false
+
+    // MARK: - Persistence Keys
+
+    private let selectedChannelKey = "locationChannel.selected"
+    private let teleportedStoreKey = "locationChannel.teleportedSet"
+    private let bookmarksKey = "locationChannel.bookmarks"
+    private let bookmarkNamesKey = "locationChannel.bookmarkNames"
+
+    // MARK: - Published State (Channel)
+
+    @Published private(set) var permissionState: PermissionState = .notDetermined
+    @Published private(set) var availableChannels: [GeohashChannel] = []
+    @Published private(set) var selectedChannel: ChannelID = .mesh
+    @Published var teleported: Bool = false
+    @Published private(set) var locationNames: [GeohashChannelLevel: String] = [:]
+
+    // MARK: - Published State (Bookmarks)
+
+    @Published private(set) var bookmarks: [String] = []
+    @Published private(set) var bookmarkNames: [String: String] = [:]
+
+    // MARK: - Private State
+
+    private var teleportedSet: Set<String> = []
+    private var bookmarkMembership: Set<String> = []
+    private var resolvingNames: Set<String> = []
+    private let storage: UserDefaults
+
+    /// Returns true if running in test environment
+    private static var isRunningTests: Bool {
+        let env = ProcessInfo.processInfo.environment
+        return NSClassFromString("XCTestCase") != nil ||
+               env["XCTestConfigurationFilePath"] != nil ||
+               env["XCTestBundlePath"] != nil ||
+               env["GITHUB_ACTIONS"] != nil ||
+               env["CI"] != nil
+    }
+
+    // MARK: - Initialization
+
+    private override init() {
+        self.storage = .standard
+        self.cl = CLLocationManagerAdapter()
+        self.geocoder = CLGeocoderAdapter()
+        super.init()
+
+        // Skip CoreLocation setup in test environments
+        guard !Self.isRunningTests else {
+            loadPersistedState()
+            return
+        }
+
+        cl.delegate = self
+        cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
+        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters
+
+        loadPersistedState()
+        initializePermissionState()
+    }
+
+    /// Internal initializer for testing with custom storage
+    init(storage: UserDefaults) {
+        self.storage = storage
+        self.cl = CLLocationManagerAdapter()
+        self.geocoder = CLGeocoderAdapter()
+        super.init()
+        loadPersistedState()
+    }
+
+    internal init(
+        storage: UserDefaults,
+        locationManager: LocationStateManaging,
+        geocoder: LocationStateGeocoding,
+        shouldInitializeCoreLocation: Bool
+    ) {
+        self.storage = storage
+        self.cl = locationManager
+        self.geocoder = geocoder
+        super.init()
+        loadPersistedState()
+        guard shouldInitializeCoreLocation else { return }
+        cl.delegate = self
+        cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
+        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters
+        initializePermissionState()
+    }
+
+    private func loadPersistedState() {
+        // Load selected channel
+        if let data = storage.data(forKey: selectedChannelKey),
+           let channel = try? JSONDecoder().decode(ChannelID.self, from: data) {
+            selectedChannel = channel
+        }
+
+        // Load teleported set
+        if let data = storage.data(forKey: teleportedStoreKey),
+           let arr = try? JSONDecoder().decode([String].self, from: data) {
+            teleportedSet = Set(arr)
+        }
+
+        // Load bookmarks
+        if let data = storage.data(forKey: bookmarksKey),
+           let arr = try? JSONDecoder().decode([String].self, from: data) {
+            var seen = Set<String>()
+            var list: [String] = []
+            for raw in arr {
+                let gh = Self.normalizeGeohash(raw)
+                guard !gh.isEmpty, !seen.contains(gh) else { continue }
+                seen.insert(gh)
+                list.append(gh)
+            }
+            bookmarks = list
+            bookmarkMembership = seen
+        }
+
+        // Load bookmark names
+        if let data = storage.data(forKey: bookmarkNamesKey),
+           let dict = try? JSONDecoder().decode([String: String].self, from: data) {
+            bookmarkNames = dict
+        }
+    }
+
+    private func initializePermissionState() {
+        let status = cl.authorizationStatus
+        updatePermissionState(from: status)
+
+        // Fall back to persisted teleport state if no location authorization
+        switch status {
+        case .authorizedAlways, .authorizedWhenInUse, .authorized:
+            break
+        case .notDetermined, .restricted, .denied:
+            fallthrough
+        @unknown default:
+            if case .location(let ch) = selectedChannel {
+                teleported = teleportedSet.contains(ch.geohash)
+            }
+        }
+    }
+
+    // MARK: - Public API (Permissions & Location)
+
+    func enableLocationChannels() {
+        let status = cl.authorizationStatus
+        switch status {
+        case .notDetermined:
+            cl.requestWhenInUseAuthorization()
+        case .restricted:
+            Task { @MainActor in self.permissionState = .restricted }
+        case .denied:
+            Task { @MainActor in self.permissionState = .denied }
+        case .authorizedAlways, .authorizedWhenInUse, .authorized:
+            Task { @MainActor in self.permissionState = .authorized }
+            requestOneShotLocation()
+        @unknown default:
+            Task { @MainActor in self.permissionState = .restricted }
+        }
+    }
+
+    func refreshChannels() {
+        if permissionState == .authorized {
+            requestOneShotLocation()
+        }
+    }
+
+    func beginLiveRefresh(interval: TimeInterval = TransportConfig.locationLiveRefreshInterval) {
+        guard permissionState == .authorized else { return }
+        refreshTimer?.invalidate()
+        refreshTimer = nil
+        cl.desiredAccuracy = kCLLocationAccuracyNearestTenMeters
+        cl.distanceFilter = TransportConfig.locationDistanceFilterLiveMeters
+        cl.startUpdatingLocation()
+        requestOneShotLocation()
+    }
+
+    func endLiveRefresh() {
+        refreshTimer?.invalidate()
+        refreshTimer = nil
+        cl.stopUpdatingLocation()
+        cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
+        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters
+    }
+
+    // MARK: - Public API (Channel Selection)
+
+    func select(_ channel: ChannelID) {
+        Task { @MainActor in
+            self.selectedChannel = channel
+            if let data = try? JSONEncoder().encode(channel) {
+                self.storage.set(data, forKey: self.selectedChannelKey)
+            }
+
+            switch channel {
+            case .mesh:
+                self.teleported = false
+            case .location(let ch):
+                let inRegional = self.availableChannels.contains { $0.geohash == ch.geohash }
+                if inRegional {
+                    self.teleported = false
+                    if self.teleportedSet.contains(ch.geohash) {
+                        self.teleportedSet.remove(ch.geohash)
+                        self.persistTeleportedSet()
+                    }
+                } else {
+                    self.teleported = self.teleportedSet.contains(ch.geohash)
+                }
+            }
+        }
+    }
+
+    func markTeleported(for geohash: String, _ flag: Bool) {
+        if flag {
+            teleportedSet.insert(geohash)
+        } else {
+            teleportedSet.remove(geohash)
+        }
+        persistTeleportedSet()
+        if case .location(let ch) = selectedChannel, ch.geohash == geohash {
+            Task { @MainActor in self.teleported = flag }
+        }
+    }
+
+    // MARK: - Public API (Bookmarks)
+
+    func isBookmarked(_ geohash: String) -> Bool {
+        bookmarkMembership.contains(Self.normalizeGeohash(geohash))
+    }
+
+    func toggleBookmark(_ geohash: String) {
+        let gh = Self.normalizeGeohash(geohash)
+        if bookmarkMembership.contains(gh) {
+            removeBookmark(gh)
+        } else {
+            addBookmark(gh)
+        }
+    }
+
+    func addBookmark(_ geohash: String) {
+        let gh = Self.normalizeGeohash(geohash)
+        guard !gh.isEmpty, !bookmarkMembership.contains(gh) else { return }
+        bookmarks.insert(gh, at: 0)
+        bookmarkMembership.insert(gh)
+        persistBookmarks()
+        resolveBookmarkNameIfNeeded(for: gh)
+    }
+
+    func removeBookmark(_ geohash: String) {
+        let gh = Self.normalizeGeohash(geohash)
+        guard bookmarkMembership.contains(gh) else { return }
+        if let idx = bookmarks.firstIndex(of: gh) {
+            bookmarks.remove(at: idx)
+        }
+        bookmarkMembership.remove(gh)
+        if bookmarkNames.removeValue(forKey: gh) != nil {
+            persistBookmarkNames()
+        }
+        persistBookmarks()
+    }
+
+    // MARK: - CLLocationManagerDelegate
+
+    private func requestOneShotLocation() {
+        cl.requestLocation()
+    }
+
+    func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
+        updatePermissionState(from: status)
+        if case .authorized = permissionState {
+            requestOneShotLocation()
+        }
+    }
+
+    @available(iOS 14.0, macOS 11.0, *)
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        updatePermissionState(from: manager.authorizationStatus)
+        if case .authorized = permissionState {
+            requestOneShotLocation()
+        }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        guard let loc = locations.last else { return }
+        lastLocation = loc
+        computeChannels(from: loc.coordinate)
+        reverseGeocodeLocation(loc)
+    }
+
+    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        SecureLogger.error("LocationStateManager: location error: \(error.localizedDescription)", category: .session)
+    }
+
+    // MARK: - Private Helpers (Permission)
+
+    private func updatePermissionState(from status: CLAuthorizationStatus) {
+        let newState: PermissionState
+        switch status {
+        case .notDetermined: newState = .notDetermined
+        case .restricted: newState = .restricted
+        case .denied: newState = .denied
+        case .authorizedAlways, .authorizedWhenInUse, .authorized: newState = .authorized
+        @unknown default: newState = .restricted
+        }
+        Task { @MainActor in self.permissionState = newState }
+    }
+
+    // MARK: - Private Helpers (Channel Computation)
+
+    private func computeChannels(from coord: CLLocationCoordinate2D) {
+        let levels = GeohashChannelLevel.allCases
+        var result: [GeohashChannel] = []
+        for level in levels {
+            let gh = Geohash.encode(latitude: coord.latitude, longitude: coord.longitude, precision: level.precision)
+            result.append(GeohashChannel(level: level, geohash: gh))
+        }
+        Task { @MainActor in
+            self.availableChannels = result
+            switch self.selectedChannel {
+            case .mesh:
+                self.teleported = false
+            case .location(let ch):
+                let inRegional = result.contains { $0.geohash == ch.geohash }
+                if inRegional {
+                    self.teleported = false
+                    if self.teleportedSet.contains(ch.geohash) {
+                        self.teleportedSet.remove(ch.geohash)
+                        self.persistTeleportedSet()
+                    }
+                } else {
+                    self.teleported = true
+                }
+            }
+        }
+    }
+
+    // MARK: - Private Helpers (Geocoding)
+
+    private func reverseGeocodeLocation(_ location: CLLocation) {
+        geocoder.cancelGeocode()
+        isGeocoding = true
+        geocoder.reverseGeocodeLocation(location) { [weak self] placemarks, _ in
+            guard let self = self else { return }
+            self.isGeocoding = false
+            if let pm = placemarks?.first {
+                let names = self.locationNamesByLevel(from: pm)
+                Task { @MainActor in self.locationNames = names }
+            }
+        }
+    }
+
+    private func locationNamesByLevel(from pm: CLPlacemark) -> [GeohashChannelLevel: String] {
+        var dict: [GeohashChannelLevel: String] = [:]
+        if let country = pm.country, !country.isEmpty {
+            dict[.region] = country
+        }
+        if let admin = pm.administrativeArea, !admin.isEmpty {
+            dict[.province] = admin
+        } else if let subAdmin = pm.subAdministrativeArea, !subAdmin.isEmpty {
+            dict[.province] = subAdmin
+        }
+        if let locality = pm.locality, !locality.isEmpty {
+            dict[.city] = locality
+        } else if let subAdmin = pm.subAdministrativeArea, !subAdmin.isEmpty {
+            dict[.city] = subAdmin
+        } else if let admin = pm.administrativeArea, !admin.isEmpty {
+            dict[.city] = admin
+        }
+        if let subLocality = pm.subLocality, !subLocality.isEmpty {
+            dict[.neighborhood] = subLocality
+        } else if let locality = pm.locality, !locality.isEmpty {
+            dict[.neighborhood] = locality
+        }
+        if let subLocality = pm.subLocality, !subLocality.isEmpty {
+            dict[.block] = subLocality
+        } else if let locality = pm.locality, !locality.isEmpty {
+            dict[.block] = locality
+        }
+        if let name = pm.name, !name.isEmpty {
+            dict[.building] = name
+        } else if let thoroughfare = pm.thoroughfare, !thoroughfare.isEmpty {
+            dict[.building] = thoroughfare
+        }
+        return dict
+    }
+
+    func resolveBookmarkNameIfNeeded(for geohash: String) {
+        let gh = Self.normalizeGeohash(geohash)
+        guard !gh.isEmpty, bookmarkNames[gh] == nil, !resolvingNames.contains(gh) else { return }
+        resolvingNames.insert(gh)
+
+        if gh.count <= 2 {
+            let b = Geohash.decodeBounds(gh)
+            let pts: [CLLocation] = [
+                CLLocation(latitude: (b.latMin + b.latMax) / 2, longitude: (b.lonMin + b.lonMax) / 2),
+                CLLocation(latitude: b.latMin, longitude: b.lonMin),
+                CLLocation(latitude: b.latMin, longitude: b.lonMax),
+                CLLocation(latitude: b.latMax, longitude: b.lonMin),
+                CLLocation(latitude: b.latMax, longitude: b.lonMax)
+            ]
+            resolveCompositeAdminName(geohash: gh, points: pts)
+        } else {
+            let center = Geohash.decodeCenter(gh)
+            let loc = CLLocation(latitude: center.lat, longitude: center.lon)
+            geocoder.reverseGeocodeLocation(loc) { [weak self] placemarks, _ in
+                guard let self = self else { return }
+                defer { self.resolvingNames.remove(gh) }
+                if let pm = placemarks?.first,
+                   let name = Self.nameForGeohashLength(gh.count, from: pm),
+                   !name.isEmpty {
+                    DispatchQueue.main.async {
+                        self.bookmarkNames[gh] = name
+                        self.persistBookmarkNames()
+                    }
+                }
+            }
+        }
+    }
+
+    private func resolveCompositeAdminName(geohash gh: String, points: [CLLocation]) {
+        var uniqueAdmins: [String] = []
+        var seenAdmins = Set<String>()
+        var idx = 0
+
+        func step() {
+            if idx >= points.count {
+                let finalName: String? = {
+                    if uniqueAdmins.count >= 2 { return uniqueAdmins[0] + " and " + uniqueAdmins[1] }
+                    return uniqueAdmins.first
+                }()
+                if let finalName = finalName, !finalName.isEmpty {
+                    DispatchQueue.main.async {
+                        self.bookmarkNames[gh] = finalName
+                        self.persistBookmarkNames()
+                    }
+                }
+                self.resolvingNames.remove(gh)
+                return
+            }
+            let loc = points[idx]
+            idx += 1
+            geocoder.reverseGeocodeLocation(loc) { [weak self] placemarks, _ in
+                guard self != nil else { return }
+                if let pm = placemarks?.first {
+                    if let admin = pm.administrativeArea, !admin.isEmpty, !seenAdmins.contains(admin) {
+                        seenAdmins.insert(admin)
+                        uniqueAdmins.append(admin)
+                    } else if let country = pm.country, !country.isEmpty, !seenAdmins.contains(country) {
+                        seenAdmins.insert(country)
+                        uniqueAdmins.append(country)
+                    }
+                }
+                step()
+            }
+        }
+        step()
+    }
+
+    private static func nameForGeohashLength(_ len: Int, from pm: CLPlacemark) -> String? {
+        switch len {
+        case 0...2:
+            return pm.administrativeArea ?? pm.country
+        case 3...4:
+            return pm.administrativeArea ?? pm.subAdministrativeArea ?? pm.country
+        case 5:
+            return pm.locality ?? pm.subAdministrativeArea ?? pm.administrativeArea
+        case 6...7:
+            return pm.subLocality ?? pm.locality ?? pm.administrativeArea
+        default:
+            return pm.subLocality ?? pm.locality ?? pm.administrativeArea ?? pm.country
+        }
+    }
+
+    // MARK: - Private Helpers (Persistence)
+
+    private func persistTeleportedSet() {
+        if let data = try? JSONEncoder().encode(Array(teleportedSet)) {
+            storage.set(data, forKey: teleportedStoreKey)
+        }
+    }
+
+    private func persistBookmarks() {
+        if let data = try? JSONEncoder().encode(bookmarks) {
+            storage.set(data, forKey: bookmarksKey)
+        }
+    }
+
+    private func persistBookmarkNames() {
+        if let data = try? JSONEncoder().encode(bookmarkNames) {
+            storage.set(data, forKey: bookmarkNamesKey)
+        }
+    }
+
+    private static func normalizeGeohash(_ s: String) -> String {
+        let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
+        return s
+            .trimmed
+            .lowercased()
+            .replacingOccurrences(of: "#", with: "")
+            .filter { allowed.contains($0) }
+    }
+}
+
+// MARK: - Backward Compatibility Typealiases
+
+typealias LocationChannelManager = LocationStateManager
+typealias GeohashBookmarksStore = LocationStateManager
+
+// MARK: - Backward Compatibility Extensions
+
+extension LocationStateManager {
+    /// Backward compatibility: toggle bookmark (was GeohashBookmarksStore.toggle)
+    func toggle(_ geohash: String) {
+        toggleBookmark(geohash)
+    }
+
+    /// Backward compatibility: add bookmark (was GeohashBookmarksStore.add)
+    func add(_ geohash: String) {
+        addBookmark(geohash)
+    }
+
+    /// Backward compatibility: remove bookmark (was GeohashBookmarksStore.remove)
+    func remove(_ geohash: String) {
+        removeBookmark(geohash)
+    }
+}
+#endif

bitchat/Services/MeshTopologyTracker.swift

@@ -0,0 +1,130 @@
+import Foundation
+
+/// Tracks observed mesh topology and computes hop-by-hop routes.
+final class MeshTopologyTracker {
+    private typealias RoutingID = Data
+
+    private let queue = DispatchQueue(label: "mesh.topology", attributes: .concurrent)
+    private let hopSize = 8
+    // Directed claims: Key claims to see Value (neighbors)
+    private var claims: [RoutingID: Set<RoutingID>] = [:]
+    // Last time we received an update from a node
+    private var lastSeen: [RoutingID: Date] = [:]
+
+    // Maximum age for topology claims to be considered fresh for routing
+    // Routes computed using stale topology can fail when the network has changed
+    private static let routeFreshnessThreshold: TimeInterval = 60 // 60 seconds
+
+    func reset() {
+        queue.sync(flags: .barrier) {
+            self.claims.removeAll()
+            self.lastSeen.removeAll()
+        }
+    }
+
+    /// Update the topology with a node's self-reported neighbor list
+    func updateNeighbors(for sourceData: Data?, neighbors: [Data]) {
+        guard let source = sanitize(sourceData) else { return }
+        // Sanitize neighbors and exclude self-loops
+        let validNeighbors = Set(neighbors.compactMap { sanitize($0) }).subtracting([source])
+        
+        queue.sync(flags: .barrier) {
+            self.claims[source] = validNeighbors
+            self.lastSeen[source] = Date()
+        }
+    }
+
+    func removePeer(_ data: Data?) {
+        guard let peer = sanitize(data) else { return }
+        queue.sync(flags: .barrier) {
+            self.claims.removeValue(forKey: peer)
+            self.lastSeen.removeValue(forKey: peer)
+        }
+    }
+    
+    /// Prune nodes that haven't updated their topology in `age` seconds
+    func prune(olderThan age: TimeInterval) {
+        let deadline = Date().addingTimeInterval(-age)
+        queue.sync(flags: .barrier) {
+            let stale = self.lastSeen.filter { $0.value < deadline }
+            for (peer, _) in stale {
+                self.claims.removeValue(forKey: peer)
+                self.lastSeen.removeValue(forKey: peer)
+            }
+        }
+    }
+
+    func computeRoute(from start: Data?, to goal: Data?, maxHops: Int = 10) -> [Data]? {
+        guard let source = sanitize(start), let target = sanitize(goal) else { return nil }
+        if source == target { return [] } // Direct connection, no intermediate hops
+
+        return queue.sync {
+            let now = Date()
+            let freshnessDeadline = now.addingTimeInterval(-Self.routeFreshnessThreshold)
+
+            // BFS
+            var visited: Set<RoutingID> = [source]
+            // Queue stores paths: [Start, Hop1, Hop2, ..., Current]
+            var queuePaths: [[RoutingID]] = [[source]]
+
+            while !queuePaths.isEmpty {
+                let path = queuePaths.removeFirst()
+                // Limit path length (path contains source + maxHops + target) -> maxHops intermediate
+                // If maxHops = 10, max edges = 11, max nodes = 12.
+                if path.count > maxHops + 1 { continue }
+
+                guard let last = path.last else { continue }
+
+                // Get neighbors that 'last' claims to see
+                guard let neighbors = claims[last] else { continue }
+
+                // Check if 'last' node's topology info is fresh
+                guard let lastSeenTime = lastSeen[last], lastSeenTime > freshnessDeadline else {
+                    continue // Skip stale nodes
+                }
+
+                for neighbor in neighbors {
+                    if visited.contains(neighbor) { continue }
+
+                    // CONFIRMED EDGE CHECK:
+                    // 'last' claims 'neighbor' (checked above)
+                    // Does 'neighbor' claim 'last'?
+                    guard let neighborClaims = claims[neighbor],
+                          neighborClaims.contains(last) else {
+                        continue
+                    }
+
+                    // Check if 'neighbor' node's topology info is fresh
+                    guard let neighborSeenTime = lastSeen[neighbor], neighborSeenTime > freshnessDeadline else {
+                        continue // Skip edges to stale nodes
+                    }
+
+                    var nextPath = path
+                    nextPath.append(neighbor)
+
+                    if neighbor == target {
+                        // Return only intermediate hops
+                        // Path: [Source, I1, I2, Target] -> [I1, I2]
+                        return Array(nextPath.dropFirst().dropLast())
+                    }
+
+                    visited.insert(neighbor)
+                    queuePaths.append(nextPath)
+                }
+            }
+            return nil
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func sanitize(_ data: Data?) -> Data? {
+        guard var value = data, !value.isEmpty else { return nil }
+        if value.count > hopSize {
+            value = Data(value.prefix(hopSize))
+        } else if value.count < hopSize {
+            value.append(Data(repeating: 0, count: hopSize - value.count))
+        }
+        return value
+    }
+}

bitchat/Services/MessageDeduplicationService.swift

@@ -0,0 +1,278 @@
+//
+// MessageDeduplicationService.swift
+// bitchat
+//
+// Handles message deduplication using LRU caches.
+// This is free and unencumbered software released into the public domain.
+//
+
+import Foundation
+
+// MARK: - LRU Deduplication Cache
+
+/// Generic LRU (Least Recently Used) cache for deduplication.
+/// Uses an efficient O(1) lookup with periodic compaction.
+/// Thread-safe via @MainActor - all callers are already on main actor.
+@MainActor
+final class LRUDeduplicationCache<Value> {
+    private var map: [String: Value] = [:]
+    private var order: [String] = []
+    private var head: Int = 0
+    private let capacity: Int
+
+    /// Creates a new LRU cache with the specified capacity.
+    /// - Parameter capacity: Maximum number of entries before eviction
+    init(capacity: Int) {
+        precondition(capacity > 0, "LRU cache capacity must be positive")
+        self.capacity = capacity
+    }
+
+    /// Number of active entries in the cache
+    var count: Int {
+        order.count - head
+    }
+
+    /// Checks if a key exists in the cache
+    func contains(_ key: String) -> Bool {
+        map[key] != nil
+    }
+
+    /// Gets the value for a key, or nil if not present
+    func value(for key: String) -> Value? {
+        map[key]
+    }
+
+    /// Records a key-value pair, updating if exists or inserting if new
+    func record(_ key: String, value: Value) {
+        if map[key] == nil {
+            order.append(key)
+        }
+        map[key] = value
+        trimIfNeeded()
+    }
+
+    /// Removes a specific key from the cache
+    func remove(_ key: String) {
+        map.removeValue(forKey: key)
+        // Note: key remains in order array but will be skipped during eviction
+    }
+
+    /// Clears all entries from the cache
+    func clear() {
+        map.removeAll()
+        order.removeAll()
+        head = 0
+    }
+
+    // MARK: - Private
+
+    private func trimIfNeeded() {
+        let activeCount = order.count - head
+        guard activeCount > capacity else { return }
+
+        let overflow = activeCount - capacity
+        for _ in 0..<overflow {
+            guard let victim = popOldest() else { break }
+            map.removeValue(forKey: victim)
+        }
+    }
+
+    private func popOldest() -> String? {
+        // Skip keys that were already removed from map
+        while head < order.count {
+            let key = order[head]
+            head += 1
+
+            // Periodically compact the backing storage
+            if head >= 32 && head * 2 >= order.count {
+                order.removeFirst(head)
+                head = 0
+            }
+
+            // Only return if key is still in map
+            if map[key] != nil {
+                return key
+            }
+        }
+        return nil
+    }
+}
+
+// MARK: - Content Normalizer
+
+/// Normalizes message content for near-duplicate detection.
+enum ContentNormalizer {
+
+    /// Regex to simplify HTTP URLs by stripping query strings and fragments
+    private static let simplifyHTTPURL: NSRegularExpression = {
+        try! NSRegularExpression(
+            pattern: "https?://[^\\s?#]+(?:[?#][^\\s]*)?",
+            options: [.caseInsensitive]
+        )
+    }()
+
+    /// Normalizes content for deduplication comparison.
+    /// - Parameters:
+    ///   - content: The raw message content
+    ///   - prefixLength: Maximum characters to consider (default from TransportConfig)
+    /// - Returns: A hash-based key for comparison
+    static func normalizedKey(
+        _ content: String,
+        prefixLength: Int = TransportConfig.contentKeyPrefixLength
+    ) -> String {
+        // Lowercase for case-insensitive comparison
+        let lowered = content.lowercased()
+        let ns = lowered as NSString
+        let range = NSRange(location: 0, length: ns.length)
+
+        // Simplify URLs by stripping query/fragment
+        var simplified = ""
+        var last = 0
+        for match in simplifyHTTPURL.matches(in: lowered, options: [], range: range) {
+            if match.range.location > last {
+                simplified += ns.substring(with: NSRange(location: last, length: match.range.location - last))
+            }
+            let url = ns.substring(with: match.range)
+            if let queryIndex = url.firstIndex(where: { $0 == "?" || $0 == "#" }) {
+                simplified += String(url[..<queryIndex])
+            } else {
+                simplified += url
+            }
+            last = match.range.location + match.range.length
+        }
+        if last < ns.length {
+            simplified += ns.substring(with: NSRange(location: last, length: ns.length - last))
+        }
+
+        // Trim and collapse whitespace
+        let trimmed = simplified.trimmed
+        let collapsed = trimmed.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression)
+
+        // Take prefix and hash
+        let prefix = String(collapsed.prefix(prefixLength))
+        let hash = prefix.djb2()
+        return String(format: "h:%016llx", hash)
+    }
+}
+
+// MARK: - Message Deduplication Service
+
+/// Service that manages message deduplication using LRU caches.
+/// Provides separate caches for content-based dedup and Nostr event ID dedup.
+/// Thread-safe via @MainActor - all callers are already on main actor.
+@MainActor
+final class MessageDeduplicationService {
+
+    /// Cache for content-based near-duplicate detection
+    private let contentCache: LRUDeduplicationCache<Date>
+
+    /// Cache for Nostr event ID deduplication
+    private let nostrEventCache: LRUDeduplicationCache<Bool>
+
+    /// Cache for Nostr ACK deduplication (messageId:ackType:senderPubkey format)
+    private let nostrAckCache: LRUDeduplicationCache<Bool>
+
+    /// Creates a new deduplication service with specified capacities.
+    /// - Parameters:
+    ///   - contentCapacity: Max entries for content cache
+    ///   - nostrEventCapacity: Max entries for Nostr event cache
+    init(
+        contentCapacity: Int = TransportConfig.contentLRUCap,
+        nostrEventCapacity: Int = TransportConfig.uiProcessedNostrEventsCap
+    ) {
+        self.contentCache = LRUDeduplicationCache(capacity: contentCapacity)
+        self.nostrEventCache = LRUDeduplicationCache(capacity: nostrEventCapacity)
+        self.nostrAckCache = LRUDeduplicationCache(capacity: nostrEventCapacity)
+    }
+
+    // MARK: - Content Deduplication
+
+    /// Records content with its timestamp for near-duplicate detection.
+    /// - Parameters:
+    ///   - content: The message content
+    ///   - timestamp: When the content was received
+    func recordContent(_ content: String, timestamp: Date) {
+        let key = ContentNormalizer.normalizedKey(content)
+        contentCache.record(key, value: timestamp)
+    }
+
+    /// Records a pre-normalized content key with its timestamp.
+    /// - Parameters:
+    ///   - key: The normalized content key
+    ///   - timestamp: When the content was received
+    func recordContentKey(_ key: String, timestamp: Date) {
+        contentCache.record(key, value: timestamp)
+    }
+
+    /// Gets the timestamp for previously seen content.
+    /// - Parameter content: The message content
+    /// - Returns: The timestamp when first seen, or nil if not seen
+    func contentTimestamp(for content: String) -> Date? {
+        let key = ContentNormalizer.normalizedKey(content)
+        return contentCache.value(for: key)
+    }
+
+    /// Gets the timestamp for a pre-normalized content key.
+    /// - Parameter key: The normalized content key
+    /// - Returns: The timestamp when first seen, or nil if not seen
+    func contentTimestamp(forKey key: String) -> Date? {
+        contentCache.value(for: key)
+    }
+
+    /// Normalizes content to a deduplication key.
+    /// - Parameter content: The raw content
+    /// - Returns: A normalized hash key
+    func normalizedContentKey(_ content: String) -> String {
+        ContentNormalizer.normalizedKey(content)
+    }
+
+    // MARK: - Nostr Event Deduplication
+
+    /// Checks if a Nostr event has already been processed.
+    /// - Parameter eventId: The event ID
+    /// - Returns: true if already processed
+    func hasProcessedNostrEvent(_ eventId: String) -> Bool {
+        nostrEventCache.contains(eventId)
+    }
+
+    /// Records a Nostr event as processed.
+    /// - Parameter eventId: The event ID
+    func recordNostrEvent(_ eventId: String) {
+        nostrEventCache.record(eventId, value: true)
+    }
+
+    // MARK: - Nostr ACK Deduplication
+
+    /// Checks if a Nostr ACK has already been processed.
+    /// - Parameter ackKey: The ACK key in format "messageId:ackType:senderPubkey"
+    /// - Returns: true if already processed
+    func hasProcessedNostrAck(_ ackKey: String) -> Bool {
+        nostrAckCache.contains(ackKey)
+    }
+
+    /// Records a Nostr ACK as processed.
+    /// - Parameter ackKey: The ACK key in format "messageId:ackType:senderPubkey"
+    func recordNostrAck(_ ackKey: String) {
+        nostrAckCache.record(ackKey, value: true)
+    }
+
+    /// Creates an ACK key from components.
+    static func ackKey(messageId: String, ackType: String, senderPubkey: String) -> String {
+        "\(messageId):\(ackType):\(senderPubkey)"
+    }
+
+    // MARK: - Clear
+
+    /// Clears all caches
+    func clearAll() {
+        contentCache.clear()
+        nostrEventCache.clear()
+        nostrAckCache.clear()
+    }
+
+    /// Clears only the Nostr caches (events and ACKs)
+    func clearNostrCaches() {
+        nostrEventCache.clear()
+        nostrAckCache.clear()
+    }
+}

bitchat/Services/MessageFormattingEngine.swift

@@ -0,0 +1,472 @@
+//
+// MessageFormattingEngine.swift
+// bitchat
+//
+// Handles message text formatting, including mentions, hashtags, URLs, and tokens.
+// This is free and unencumbered software released into the public domain.
+//
+
+import BitFoundation
+import Foundation
+import SwiftUI
+
+// MARK: - Formatting Context Protocol
+
+/// Protocol defining the context needed for message formatting.
+/// Implemented by ChatViewModel to provide runtime state.
+@MainActor
+protocol MessageFormattingContext: AnyObject {
+    /// The user's current nickname
+    var nickname: String { get }
+
+    /// Determines if a message was sent by the current user
+    func isSelfMessage(_ message: BitchatMessage) -> Bool
+
+    /// Gets the color for a message's sender
+    func senderColor(for message: BitchatMessage, isDark: Bool) -> Color
+
+    /// Resolves a peer ID to a clickable URL
+    func peerURL(for peerID: PeerID) -> URL?
+}
+
+// MARK: - Formatting Engine
+
+/// Handles rich text formatting for chat messages.
+/// Extracts mentions, hashtags, URLs, Lightning invoices, and Cashu tokens.
+final class MessageFormattingEngine {
+
+    // MARK: - Precompiled Regexes
+
+    /// Precompiled regex patterns for message content parsing
+    enum Patterns {
+        static let hashtag: NSRegularExpression = {
+            try! NSRegularExpression(pattern: "#([a-zA-Z0-9_]+)", options: [])
+        }()
+
+        static let mention: NSRegularExpression = {
+            try! NSRegularExpression(pattern: "@([\\p{L}0-9_]+(?:#[a-fA-F0-9]{4})?)", options: [])
+        }()
+
+        static let cashu: NSRegularExpression = {
+            try! NSRegularExpression(pattern: "\\bcashu[AB][A-Za-z0-9._-]{40,}\\b", options: [])
+        }()
+
+        static let bolt11: NSRegularExpression = {
+            try! NSRegularExpression(pattern: "(?i)\\bln(bc|tb|bcrt)[0-9][a-z0-9]{50,}\\b", options: [])
+        }()
+
+        static let lnurl: NSRegularExpression = {
+            try! NSRegularExpression(pattern: "(?i)\\blnurl1[a-z0-9]{20,}\\b", options: [])
+        }()
+
+        static let lightningScheme: NSRegularExpression = {
+            try! NSRegularExpression(pattern: "(?i)\\blightning:[^\\s]+", options: [])
+        }()
+
+        static let linkDetector: NSDataDetector? = {
+            try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue)
+        }()
+
+        static let quickCashuPresence: NSRegularExpression = {
+            try! NSRegularExpression(pattern: "\\bcashu[AB][A-Za-z0-9._-]{40,}\\b", options: [])
+        }()
+
+        static let simplifyHTTPURL: NSRegularExpression = {
+            try! NSRegularExpression(pattern: "https?://[^\\s?#]+(?:[?#][^\\s]*)?", options: [.caseInsensitive])
+        }()
+    }
+
+    // MARK: - Match Types
+
+    /// Types of matches found in message content
+    enum MatchType: String {
+        case hashtag
+        case mention
+        case url
+        case cashu
+        case lightning
+        case bolt11
+        case lnurl
+    }
+
+    /// A match found in message content
+    struct ContentMatch {
+        let range: NSRange
+        let type: MatchType
+    }
+
+    // MARK: - Public API
+
+    /// Formats a message with rich text styling
+    @MainActor
+    static func formatMessage(
+        _ message: BitchatMessage,
+        context: MessageFormattingContext,
+        colorScheme: ColorScheme
+    ) -> AttributedString {
+        let isDark = colorScheme == .dark
+        let isSelf = context.isSelfMessage(message)
+
+        // Check cache first
+        if let cached = message.getCachedFormattedText(isDark: isDark, isSelf: isSelf) {
+            return cached
+        }
+
+        var result = AttributedString()
+        let baseColor: Color = isSelf ? .orange : context.senderColor(for: message, isDark: isDark)
+
+        // Format system messages differently
+        if message.sender == "system" {
+            result = formatSystemMessage(message, isDark: isDark)
+        } else {
+            // Format sender header
+            result = formatSenderHeader(
+                message: message,
+                baseColor: baseColor,
+                isSelf: isSelf,
+                context: context
+            )
+
+            // Format content
+            let contentResult = formatContent(
+                message.content,
+                baseColor: baseColor,
+                isSelf: isSelf,
+                isMentioned: message.mentions?.contains(context.nickname) ?? false
+            )
+            result.append(contentResult)
+
+            // Add timestamp
+            result.append(formatTimestamp(message.formattedTimestamp))
+        }
+
+        // Cache the result
+        message.setCachedFormattedText(result, isDark: isDark, isSelf: isSelf)
+
+        return result
+    }
+
+    /// Formats just the message header (sender portion)
+    @MainActor
+    static func formatHeader(
+        _ message: BitchatMessage,
+        context: MessageFormattingContext,
+        colorScheme: ColorScheme
+    ) -> AttributedString {
+        let isDark = colorScheme == .dark
+        let isSelf = context.isSelfMessage(message)
+        let baseColor: Color = isSelf ? .orange : context.senderColor(for: message, isDark: isDark)
+
+        if message.sender == "system" {
+            var style = AttributeContainer()
+            style.foregroundColor = baseColor
+            style.font = .bitchatSystem(size: 14, weight: .medium, design: .monospaced)
+            return AttributedString(message.sender).mergingAttributes(style)
+        }
+
+        return formatSenderHeader(
+            message: message,
+            baseColor: baseColor,
+            isSelf: isSelf,
+            context: context
+        )
+    }
+
+    /// Extracts mentions from message content
+    static func extractMentions(from content: String) -> [String] {
+        let nsContent = content as NSString
+        let range = NSRange(location: 0, length: nsContent.length)
+        let matches = Patterns.mention.matches(in: content, options: [], range: range)
+
+        return matches.compactMap { match -> String? in
+            guard match.numberOfRanges > 1 else { return nil }
+            let captureRange = match.range(at: 1)
+            guard let swiftRange = Range(captureRange, in: content) else { return nil }
+            return String(content[swiftRange])
+        }
+    }
+
+    /// Checks if content contains a Cashu token
+    static func containsCashuToken(_ content: String) -> Bool {
+        let nsContent = content as NSString
+        let range = NSRange(location: 0, length: nsContent.length)
+        return Patterns.quickCashuPresence.numberOfMatches(in: content, options: [], range: range) > 0
+    }
+
+    // MARK: - Private Helpers
+
+    private static func formatSystemMessage(_ message: BitchatMessage, isDark: Bool) -> AttributedString {
+        var result = AttributedString()
+
+        let content = AttributedString("* \(message.content) *")
+        var contentStyle = AttributeContainer()
+        contentStyle.foregroundColor = Color.gray
+        contentStyle.font = .bitchatSystem(size: 12, design: .monospaced).italic()
+        result.append(content.mergingAttributes(contentStyle))
+
+        // Add timestamp
+        let timestamp = AttributedString(" [\(message.formattedTimestamp)]")
+        var timestampStyle = AttributeContainer()
+        timestampStyle.foregroundColor = Color.gray.opacity(0.5)
+        timestampStyle.font = .bitchatSystem(size: 10, design: .monospaced)
+        result.append(timestamp.mergingAttributes(timestampStyle))
+
+        return result
+    }
+
+    @MainActor
+    private static func formatSenderHeader(
+        message: BitchatMessage,
+        baseColor: Color,
+        isSelf: Bool,
+        context: MessageFormattingContext
+    ) -> AttributedString {
+        var result = AttributedString()
+
+        let (baseName, suffix) = message.sender.splitSuffix()
+        var senderStyle = AttributeContainer()
+        senderStyle.foregroundColor = baseColor
+        let fontWeight: Font.Weight = isSelf ? .bold : .medium
+        senderStyle.font = .bitchatSystem(size: 14, weight: fontWeight, design: .monospaced)
+
+        // Make sender clickable
+        if let spid = message.senderPeerID, let url = context.peerURL(for: spid) {
+            senderStyle.link = url
+        }
+
+        // Build: "<@baseName#suffix> "
+        result.append(AttributedString("<@").mergingAttributes(senderStyle))
+        result.append(AttributedString(baseName).mergingAttributes(senderStyle))
+
+        if !suffix.isEmpty {
+            var suffixStyle = senderStyle
+            suffixStyle.foregroundColor = baseColor.opacity(0.6)
+            result.append(AttributedString(suffix).mergingAttributes(suffixStyle))
+        }
+
+        result.append(AttributedString("> ").mergingAttributes(senderStyle))
+
+        return result
+    }
+
+    private static func formatContent(
+        _ content: String,
+        baseColor: Color,
+        isSelf: Bool,
+        isMentioned: Bool
+    ) -> AttributedString {
+        // For very long content without special tokens, use plain formatting
+        let containsCashu = containsCashuToken(content)
+        if (content.count > 4000 || content.hasVeryLongToken(threshold: 1024)) && !containsCashu {
+            return formatPlainContent(content, baseColor: baseColor, isSelf: isSelf)
+        }
+
+        // Find all matches
+        let matches = findAllMatches(in: content)
+
+        // Build formatted content
+        var result = AttributedString()
+        var lastEnd = content.startIndex
+
+        for match in matches {
+            guard let swiftRange = Range(match.range, in: content) else { continue }
+
+            // Add text before match
+            if lastEnd < swiftRange.lowerBound {
+                let beforeText = String(content[lastEnd..<swiftRange.lowerBound])
+                result.append(formatPlainText(beforeText, baseColor: baseColor, isSelf: isSelf, isMentioned: isMentioned))
+            }
+
+            // Add styled match
+            let matchText = String(content[swiftRange])
+            result.append(formatMatch(matchText, type: match.type, baseColor: baseColor, isSelf: isSelf))
+
+            lastEnd = swiftRange.upperBound
+        }
+
+        // Add remaining text
+        if lastEnd < content.endIndex {
+            let remainingText = String(content[lastEnd...])
+            result.append(formatPlainText(remainingText, baseColor: baseColor, isSelf: isSelf, isMentioned: isMentioned))
+        }
+
+        return result
+    }
+
+    private static func findAllMatches(in content: String) -> [ContentMatch] {
+        let nsContent = content as NSString
+        let nsLen = nsContent.length
+        let fullRange = NSRange(location: 0, length: nsLen)
+
+        // Quick hints to avoid unnecessary regex work
+        let hasMentions = content.contains("@")
+        let hasHashtags = content.contains("#")
+        let hasURLs = content.contains("://") || content.contains("www.") || content.contains("http")
+        let hasLightning = content.lowercased().contains("ln") || content.lowercased().contains("lightning:")
+        let hasCashu = content.lowercased().contains("cashu")
+
+        // Collect matches
+        let mentionMatches = hasMentions ? Patterns.mention.matches(in: content, options: [], range: fullRange) : []
+        let hashtagMatches = hasHashtags ? Patterns.hashtag.matches(in: content, options: [], range: fullRange) : []
+        let urlMatches = hasURLs ? (Patterns.linkDetector?.matches(in: content, options: [], range: fullRange) ?? []) : []
+        let cashuMatches = hasCashu ? Patterns.cashu.matches(in: content, options: [], range: fullRange) : []
+        let lightningMatches = hasLightning ? Patterns.lightningScheme.matches(in: content, options: [], range: fullRange) : []
+        let bolt11Matches = hasLightning ? Patterns.bolt11.matches(in: content, options: [], range: fullRange) : []
+        let lnurlMatches = hasLightning ? Patterns.lnurl.matches(in: content, options: [], range: fullRange) : []
+
+        // Build mention ranges for overlap checking
+        let mentionRanges = mentionMatches.map { $0.range(at: 0) }
+
+        func overlapsMention(_ r: NSRange) -> Bool {
+            mentionRanges.contains { NSIntersectionRange(r, $0).length > 0 }
+        }
+
+        func isStandaloneHashtag(_ r: NSRange) -> Bool {
+            guard let swiftRange = Range(r, in: content) else { return false }
+            if swiftRange.lowerBound == content.startIndex { return true }
+            let prev = content.index(before: swiftRange.lowerBound)
+            return content[prev].isWhitespace || content[prev].isNewline
+        }
+
+        func attachedToMention(_ r: NSRange) -> Bool {
+            guard let swiftRange = Range(r, in: content), swiftRange.lowerBound > content.startIndex else { return false }
+            var i = content.index(before: swiftRange.lowerBound)
+            while true {
+                let ch = content[i]
+                if ch.isWhitespace || ch.isNewline { break }
+                if ch == "@" { return true }
+                if i == content.startIndex { break }
+                i = content.index(before: i)
+            }
+            return false
+        }
+
+        var allMatches: [ContentMatch] = []
+
+        // Add hashtags (excluding those attached to mentions)
+        for match in hashtagMatches {
+            let range = match.range(at: 0)
+            if !overlapsMention(range) && !attachedToMention(range) && isStandaloneHashtag(range) {
+                allMatches.append(ContentMatch(range: range, type: .hashtag))
+            }
+        }
+
+        // Add mentions
+        for match in mentionMatches {
+            allMatches.append(ContentMatch(range: match.range(at: 0), type: .mention))
+        }
+
+        // Add URLs
+        for match in urlMatches where !overlapsMention(match.range) {
+            allMatches.append(ContentMatch(range: match.range, type: .url))
+        }
+
+        // Add Cashu tokens
+        for match in cashuMatches where !overlapsMention(match.range(at: 0)) {
+            allMatches.append(ContentMatch(range: match.range(at: 0), type: .cashu))
+        }
+
+        // Add Lightning scheme URLs
+        for match in lightningMatches where !overlapsMention(match.range(at: 0)) {
+            allMatches.append(ContentMatch(range: match.range(at: 0), type: .lightning))
+        }
+
+        // Add bolt11/lnurl (avoiding overlaps with lightning scheme and URLs)
+        let occupied = urlMatches.map { $0.range } + lightningMatches.map { $0.range(at: 0) }
+        func overlapsOccupied(_ r: NSRange) -> Bool {
+            occupied.contains { NSIntersectionRange(r, $0).length > 0 }
+        }
+
+        for match in bolt11Matches where !overlapsMention(match.range(at: 0)) && !overlapsOccupied(match.range(at: 0)) {
+            allMatches.append(ContentMatch(range: match.range(at: 0), type: .bolt11))
+        }
+
+        for match in lnurlMatches where !overlapsMention(match.range(at: 0)) && !overlapsOccupied(match.range(at: 0)) {
+            allMatches.append(ContentMatch(range: match.range(at: 0), type: .lnurl))
+        }
+
+        // Sort by position
+        return allMatches.sorted { $0.range.location < $1.range.location }
+    }
+
+    private static func formatPlainContent(_ content: String, baseColor: Color, isSelf: Bool) -> AttributedString {
+        var style = AttributeContainer()
+        style.foregroundColor = baseColor
+        style.font = isSelf
+            ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
+            : .bitchatSystem(size: 14, design: .monospaced)
+        return AttributedString(content).mergingAttributes(style)
+    }
+
+    private static func formatPlainText(_ text: String, baseColor: Color, isSelf: Bool, isMentioned: Bool) -> AttributedString {
+        guard !text.isEmpty else { return AttributedString() }
+
+        var style = AttributeContainer()
+        style.foregroundColor = baseColor
+        style.font = isSelf
+            ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
+            : .bitchatSystem(size: 14, design: .monospaced)
+
+        if isMentioned {
+            style.font = style.font?.bold()
+        }
+
+        return AttributedString(text).mergingAttributes(style)
+    }
+
+    private static func formatMatch(_ text: String, type: MatchType, baseColor: Color, isSelf: Bool) -> AttributedString {
+        var style = AttributeContainer()
+
+        switch type {
+        case .mention:
+            // Split optional '#abcd' suffix
+            let (baseName, suffix) = text.splitSuffix()
+            var result = AttributedString()
+
+            var mentionStyle = AttributeContainer()
+            mentionStyle.foregroundColor = .blue
+            mentionStyle.font = .bitchatSystem(size: 14, weight: .semibold, design: .monospaced)
+            result.append(AttributedString(baseName).mergingAttributes(mentionStyle))
+
+            if !suffix.isEmpty {
+                var suffixStyle = mentionStyle
+                suffixStyle.foregroundColor = Color.gray.opacity(0.7)
+                result.append(AttributedString(suffix).mergingAttributes(suffixStyle))
+            }
+
+            return result
+
+        case .hashtag:
+            style.foregroundColor = .purple
+            style.font = .bitchatSystem(size: 14, weight: .medium, design: .monospaced)
+
+        case .url:
+            style.foregroundColor = .blue
+            style.font = .bitchatSystem(size: 14, design: .monospaced)
+            style.underlineStyle = .single
+            if let url = URL(string: text) {
+                style.link = url
+            }
+
+        case .cashu:
+            style.foregroundColor = .green
+            style.font = .bitchatSystem(size: 14, weight: .medium, design: .monospaced)
+            style.backgroundColor = Color.green.opacity(0.1)
+
+        case .lightning, .bolt11, .lnurl:
+            style.foregroundColor = .yellow
+            style.font = .bitchatSystem(size: 14, weight: .medium, design: .monospaced)
+            style.backgroundColor = Color.yellow.opacity(0.1)
+        }
+
+        return AttributedString(text).mergingAttributes(style)
+    }
+
+    private static func formatTimestamp(_ timestamp: String) -> AttributedString {
+        let text = AttributedString(" [\(timestamp)]")
+        var style = AttributeContainer()
+        style.foregroundColor = Color.gray.opacity(0.5)
+        style.font = .bitchatSystem(size: 10, design: .monospaced)
+        return text.mergingAttributes(style)
+    }
+}

bitchat/Services/MessageRouter.swift

@@ -1,16 +1,28 @@
+import BitLogger
+import BitFoundation
 import Foundation
 
-/// Routes messages between BLE and Nostr transports
+/// Routes messages using available transports (Mesh, Nostr, etc.)
 @MainActor
 final class MessageRouter {
-    private let mesh: Transport
-    private let nostr: NostrTransport
-    private var outbox: [String: [(content: String, nickname: String, messageID: String)]] = [:] // peerID -> queued messages
+    private let transports: [Transport]
 
-    init(mesh: Transport, nostr: NostrTransport) {
-        self.mesh = mesh
-        self.nostr = nostr
-        self.nostr.senderPeerID = mesh.myPeerID
+    // Outbox entry with timestamp for TTL-based eviction
+    private struct QueuedMessage {
+        let content: String
+        let nickname: String
+        let messageID: String
+        let timestamp: Date
+    }
+
+    private var outbox: [PeerID: [QueuedMessage]] = [:]
+
+    // Outbox limits to prevent unbounded memory growth
+    private static let maxMessagesPerPeer = 100
+    private static let messageTTLSeconds: TimeInterval = 24 * 60 * 60 // 24 hours
+
+    init(transports: [Transport]) {
+        self.transports = transports
 
         // Observe favorites changes to learn Nostr mapping and flush queued messages
         NotificationCenter.default.addObserver(
@@ -20,7 +32,7 @@ final class MessageRouter {
         ) { [weak self] note in
             guard let self = self else { return }
             if let data = note.userInfo?["peerPublicKey"] as? Data {
-                let peerID = PeerIDUtils.derivePeerID(fromPublicKey: data)
+                let peerID = PeerID(publicKey: data)
                 Task { @MainActor in
                     self.flushOutbox(for: peerID)
                 }
@@ -28,7 +40,7 @@ final class MessageRouter {
             // Handle key updates
             if let newKey = note.userInfo?["peerPublicKey"] as? Data,
                let _ = note.userInfo?["isKeyUpdate"] as? Bool {
-                let peerID = PeerIDUtils.derivePeerID(fromPublicKey: newKey)
+                let peerID = PeerID(publicKey: newKey)
                 Task { @MainActor in
                     self.flushOutbox(for: peerID)
                 }
@@ -36,97 +48,87 @@ final class MessageRouter {
         }
     }
 
-    func sendPrivate(_ content: String, to peerID: String, recipientNickname: String, messageID: String) {
-        let reachableMesh = mesh.isPeerReachable(peerID)
-        if reachableMesh {
-            SecureLogger.log("Routing PM via mesh (reachable) to \(peerID.prefix(8))… id=\(messageID.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
-            // BLEService will initiate a handshake if needed and queue the message
-            mesh.sendPrivateMessage(content, to: peerID, recipientNickname: recipientNickname, messageID: messageID)
-        } else if canSendViaNostr(peerID: peerID) {
-            SecureLogger.log("Routing PM via Nostr to \(peerID.prefix(8))… id=\(messageID.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
-            nostr.sendPrivateMessage(content, to: peerID, recipientNickname: recipientNickname, messageID: messageID)
+    // MARK: - Transport Selection
+
+    private func reachableTransport(for peerID: PeerID) -> Transport? {
+        transports.first { $0.isPeerReachable(peerID) }
+    }
+
+    private func connectedTransport(for peerID: PeerID) -> Transport? {
+        transports.first { $0.isPeerConnected(peerID) }
+    }
+
+    // MARK: - Message Sending
+
+    func sendPrivate(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String) {
+        if let transport = reachableTransport(for: peerID) {
+            SecureLogger.debug("Routing PM via \(type(of: transport)) to \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+            transport.sendPrivateMessage(content, to: peerID, recipientNickname: recipientNickname, messageID: messageID)
         } else {
-            // Queue for later (when mesh connects or Nostr mapping appears)
+            // Queue for later with timestamp for TTL tracking
             if outbox[peerID] == nil { outbox[peerID] = [] }
-            outbox[peerID]?.append((content, recipientNickname, messageID))
-            SecureLogger.log("Queued PM for \(peerID.prefix(8))… (no mesh, no Nostr mapping) id=\(messageID.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
+
+            let message = QueuedMessage(content: content, nickname: recipientNickname, messageID: messageID, timestamp: Date())
+            outbox[peerID]?.append(message)
+
+            // Enforce per-peer size limit with FIFO eviction
+            if let count = outbox[peerID]?.count, count > Self.maxMessagesPerPeer {
+                let evicted = outbox[peerID]?.removeFirst()
+                SecureLogger.warning("📤 Outbox overflow for \(peerID.id.prefix(8))… - evicted oldest message: \(evicted?.messageID.prefix(8) ?? "?")…", category: .session)
+            }
+
+            SecureLogger.debug("Queued PM for \(peerID.id.prefix(8))… (no reachable transport) id=\(messageID.prefix(8))… queue=\(outbox[peerID]?.count ?? 0)", category: .session)
         }
     }
 
-    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: String) {
-        // Prefer mesh for reachable peers; BLE will queue if handshake is needed
-        if mesh.isPeerReachable(peerID) {
-            SecureLogger.log("Routing READ ack via mesh (reachable) to \(peerID.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
-            mesh.sendReadReceipt(receipt, to: peerID)
-        } else {
-            SecureLogger.log("Routing READ ack via Nostr to \(peerID.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
-            nostr.sendReadReceipt(receipt, to: peerID)
+    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID) {
+        if let transport = reachableTransport(for: peerID) {
+            SecureLogger.debug("Routing READ ack via \(type(of: transport)) to \(peerID.id.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…", category: .session)
+            transport.sendReadReceipt(receipt, to: peerID)
+        } else if !transports.isEmpty {
+            SecureLogger.debug("No reachable transport for READ ack to \(peerID.id.prefix(8))…", category: .session)
         }
     }
 
-    func sendDeliveryAck(_ messageID: String, to peerID: String) {
-        if mesh.isPeerReachable(peerID) {
-            SecureLogger.log("Routing DELIVERED ack via mesh (reachable) to \(peerID.prefix(8))… id=\(messageID.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
-            mesh.sendDeliveryAck(for: messageID, to: peerID)
-        } else {
-            nostr.sendDeliveryAck(for: messageID, to: peerID)
+    func sendDeliveryAck(_ messageID: String, to peerID: PeerID) {
+        if let transport = reachableTransport(for: peerID) {
+            SecureLogger.debug("Routing DELIVERED ack via \(type(of: transport)) to \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+            transport.sendDeliveryAck(for: messageID, to: peerID)
         }
     }
 
-    func sendFavoriteNotification(to peerID: String, isFavorite: Bool) {
-        if mesh.isPeerConnected(peerID) {
-            mesh.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
-        } else {
-            nostr.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
+    func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool) {
+        if let transport = connectedTransport(for: peerID) {
+            transport.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
+        } else if let transport = reachableTransport(for: peerID) {
+            transport.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
         }
     }
 
     // MARK: - Outbox Management
-    private func canSendViaNostr(peerID: String) -> Bool {
-        // Two forms are supported:
-        // - 64-hex Noise public key (32 bytes)
-        // - 16-hex short peer ID (derived from Noise pubkey)
-        if peerID.count == 64, let noiseKey = Data(hexString: peerID) {
-            if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
-               fav.peerNostrPublicKey != nil {
-                return true
-            }
-        } else if peerID.count == 16 {
-            if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID),
-               fav.peerNostrPublicKey != nil {
-                return true
-            }
-        }
-        return false
-    }
 
-    func flushOutbox(for peerID: String) {
+    func flushOutbox(for peerID: PeerID) {
         guard let queued = outbox[peerID], !queued.isEmpty else { return }
-        SecureLogger.log("Flushing outbox for \(peerID.prefix(8))… count=\(queued.count)",
-                        category: SecureLogger.session, level: .debug)
-        var remaining: [(content: String, nickname: String, messageID: String)] = []
-        // Prefer mesh if connected; else try Nostr if mapping exists
-        for (content, nickname, messageID) in queued {
-            if mesh.isPeerReachable(peerID) {
-                SecureLogger.log("Outbox -> mesh for \(peerID.prefix(8))… id=\(messageID.prefix(8))…",
-                                category: SecureLogger.session, level: .debug)
-                mesh.sendPrivateMessage(content, to: peerID, recipientNickname: nickname, messageID: messageID)
-            } else if canSendViaNostr(peerID: peerID) {
-                SecureLogger.log("Outbox -> Nostr for \(peerID.prefix(8))… id=\(messageID.prefix(8))…",
-                                category: SecureLogger.session, level: .debug)
-                nostr.sendPrivateMessage(content, to: peerID, recipientNickname: nickname, messageID: messageID)
+        SecureLogger.debug("Flushing outbox for \(peerID.id.prefix(8))… count=\(queued.count)", category: .session)
+
+        let now = Date()
+        var remaining: [QueuedMessage] = []
+
+        for message in queued {
+            // Skip expired messages (TTL exceeded)
+            if now.timeIntervalSince(message.timestamp) > Self.messageTTLSeconds {
+                SecureLogger.debug("⏰ Expired queued message for \(peerID.id.prefix(8))… id=\(message.messageID.prefix(8))… (age: \(Int(now.timeIntervalSince(message.timestamp)))s)", category: .session)
+                continue
+            }
+
+            if let transport = reachableTransport(for: peerID) {
+                SecureLogger.debug("Outbox -> \(type(of: transport)) for \(peerID.id.prefix(8))… id=\(message.messageID.prefix(8))…", category: .session)
+                transport.sendPrivateMessage(message.content, to: peerID, recipientNickname: message.nickname, messageID: message.messageID)
             } else {
-                // Keep unsent items queued
-                remaining.append((content, nickname, messageID))
+                remaining.append(message)
             }
         }
-        // Persist only items we could not send
+
         if remaining.isEmpty {
             outbox.removeValue(forKey: peerID)
         } else {
@@ -137,4 +139,15 @@ final class MessageRouter {
     func flushAllOutbox() {
         for key in Array(outbox.keys) { flushOutbox(for: key) }
     }
+
+    /// Periodically clean up expired messages from all outboxes
+    func cleanupExpiredMessages() {
+        let now = Date()
+        for peerID in Array(outbox.keys) {
+            outbox[peerID]?.removeAll { now.timeIntervalSince($0.timestamp) > Self.messageTTLSeconds }
+            if outbox[peerID]?.isEmpty == true {
+                outbox.removeValue(forKey: peerID)
+            }
+        }
+    }
 }

bitchat/Services/NetworkActivationService.swift

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

bitchat/Services/NoiseEncryptionService.swift

@@ -62,7 +62,6 @@
 /// ## Integration Points
 /// - **BLEService**: Calls this service for all private messages
 /// - **ChatViewModel**: Monitors encryption status for UI indicators
-/// - **NoiseHandshakeCoordinator**: Prevents handshake race conditions
 /// - **KeychainManager**: Secure storage for identity keys
 ///
 /// ## Thread Safety
@@ -83,9 +82,11 @@
 /// - Background queue for CPU-intensive operations
 ///
 
+import BitLogger
+import BitFoundation
+import Noise
 import Foundation
 import CryptoKit
-import os.log
 
 // MARK: - Encryption Status
 
@@ -116,15 +117,30 @@ enum EncryptionStatus: Equatable {
     var description: String {
         switch self {
         case .none:
-            return "Encryption failed"
+            return String(localized: "encryption.status.failed", comment: "Status text when encryption failed")
         case .noHandshake:
-            return "Not encrypted"
+            return String(localized: "encryption.status.not_encrypted", comment: "Status text when no encryption handshake happened")
         case .noiseHandshaking:
-            return "Establishing encryption..."
+            return String(localized: "encryption.status.establishing", comment: "Status text when encryption is being established")
         case .noiseSecured:
-            return "Encrypted"
+            return String(localized: "encryption.status.secured", comment: "Status text when encryption is secured but not verified")
         case .noiseVerified:
-            return "Encrypted & Verified"
+            return String(localized: "encryption.status.verified", comment: "Status text when encryption is verified")
+        }
+    }
+
+    var accessibilityDescription: String {
+        switch self {
+        case .none:
+            return String(localized: "encryption.accessibility.failed", comment: "Accessibility text when encryption failed")
+        case .noHandshake:
+            return String(localized: "encryption.accessibility.not_encrypted", comment: "Accessibility text when encryption is not established")
+        case .noiseHandshaking:
+            return String(localized: "encryption.accessibility.establishing", comment: "Accessibility text when encryption is being established")
+        case .noiseSecured:
+            return String(localized: "encryption.accessibility.secured", comment: "Accessibility text when encryption is secured")
+        case .noiseVerified:
+            return String(localized: "encryption.accessibility.verified", comment: "Accessibility text when encryption is verified")
         }
     }
 }
@@ -135,7 +151,7 @@ enum EncryptionStatus: Equatable {
 /// Provides a high-level API for establishing secure channels between peers,
 /// handling all cryptographic operations transparently.
 /// - Important: This service maintains the device's cryptographic identity
-class NoiseEncryptionService {
+final class NoiseEncryptionService {
     // Static identity key (persistent across sessions)
     private let staticIdentityKey: Curve25519.KeyAgreement.PrivateKey
     public let staticIdentityPublicKey: Curve25519.KeyAgreement.PublicKey
@@ -148,32 +164,33 @@ class NoiseEncryptionService {
     private let sessionManager: NoiseSessionManager
     
     // Peer fingerprints (SHA256 hash of static public key)
-    private var peerFingerprints: [String: String] = [:] // peerID -> fingerprint
-    private var fingerprintToPeerID: [String: String] = [:] // fingerprint -> peerID
+    private var peerFingerprints: [PeerID: String] = [:]
+    private var fingerprintToPeerID: [String: PeerID] = [:]
     
     // Thread safety
     private let serviceQueue = DispatchQueue(label: "chat.bitchat.noise.service", attributes: .concurrent)
     
     // Security components
     private let rateLimiter = NoiseRateLimiter()
+    private let keychain: KeychainManagerProtocol
     
     // Session maintenance
     private var rekeyTimer: Timer?
     private let rekeyCheckInterval: TimeInterval = 60.0 // Check every minute
     
     // Callbacks
-    private var onPeerAuthenticatedHandlers: [((String, String) -> Void)] = [] // Array of handlers for peer authentication
-    var onHandshakeRequired: ((String) -> Void)? // peerID needs handshake
+    private var onPeerAuthenticatedHandlers: [((PeerID, String) -> Void)] = [] // Array of handlers for peer authentication
+    var onHandshakeRequired: ((PeerID) -> Void)? // peerID needs handshake
     
     // Add a handler for peer authentication
-    func addOnPeerAuthenticatedHandler(_ handler: @escaping (String, String) -> Void) {
+    func addOnPeerAuthenticatedHandler(_ handler: @escaping (PeerID, String) -> Void) {
         serviceQueue.async(flags: .barrier) { [weak self] in
             self?.onPeerAuthenticatedHandlers.append(handler)
         }
     }
     
     // Legacy support - setting this will add to the handlers array
-    var onPeerAuthenticated: ((String, String) -> Void)? {
+    var onPeerAuthenticated: ((PeerID, String) -> Void)? {
         get { nil } // Always return nil for backward compatibility
         set {
             if let handler = newValue {
@@ -182,64 +199,155 @@ class NoiseEncryptionService {
         }
     }
     
-    init() {
-        // Load or create static identity key (ONLY from keychain)
+    init(keychain: KeychainManagerProtocol) {
+        self.keychain = keychain
+
+        // BCH-01-009: Load or create static identity key with proper error handling
         let loadedKey: Curve25519.KeyAgreement.PrivateKey
-        
-        // Try to load from keychain
-        if let identityData = KeychainManager.shared.getIdentityKey(forKey: "noiseStaticKey"),
-           let key = try? Curve25519.KeyAgreement.PrivateKey(rawRepresentation: identityData) {
-            loadedKey = key
-            SecureLogger.logKeyOperation("load", keyType: "noiseStaticKey", success: true)
-        }
-        // If no identity exists, create new one
-        else {
+
+        // Try to load from keychain with proper error classification
+        let noiseKeyResult = keychain.getIdentityKeyWithResult(forKey: "noiseStaticKey")
+
+        switch noiseKeyResult {
+        case .success(let identityData):
+            if let key = try? Curve25519.KeyAgreement.PrivateKey(rawRepresentation: identityData) {
+                loadedKey = key
+                SecureLogger.logKeyOperation(.load, keyType: "noiseStaticKey", success: true)
+            } else {
+                // Data corrupted, regenerate
+                SecureLogger.warning("Noise static key data corrupted, regenerating", category: .keychain)
+                loadedKey = Self.generateAndSaveNoiseKey(keychain: keychain)
+            }
+
+        case .itemNotFound:
+            // Expected case: no key exists yet, create new one
+            loadedKey = Self.generateAndSaveNoiseKey(keychain: keychain)
+
+        case .accessDenied:
+            // Critical error - log but proceed with ephemeral key (will be lost on restart)
+            SecureLogger.error(NSError(domain: "Keychain", code: -1),
+                               context: "Keychain access denied - using ephemeral identity", category: .keychain)
+            loadedKey = Curve25519.KeyAgreement.PrivateKey()
+
+        case .deviceLocked, .authenticationFailed:
+            // Recoverable error - use ephemeral key and warn
+            SecureLogger.warning("Device locked or auth failed - using ephemeral identity until unlocked", category: .keychain)
+            loadedKey = Curve25519.KeyAgreement.PrivateKey()
+
+        case .otherError(let status):
+            // Unexpected error - log and use ephemeral key
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Unexpected keychain error - using ephemeral identity", category: .keychain)
             loadedKey = Curve25519.KeyAgreement.PrivateKey()
-            let keyData = loadedKey.rawRepresentation
-            
-            // Save to keychain
-            let saved = KeychainManager.shared.saveIdentityKey(keyData, forKey: "noiseStaticKey")
-            SecureLogger.logKeyOperation("create", keyType: "noiseStaticKey", success: saved)
         }
-        
+
         // Now assign the final value
         self.staticIdentityKey = loadedKey
         self.staticIdentityPublicKey = staticIdentityKey.publicKey
-        
-        // Load or create signing key pair
+
+        // BCH-01-009: Load or create signing key pair with proper error handling
         let loadedSigningKey: Curve25519.Signing.PrivateKey
-        
-        // Try to load from keychain
-        if let signingData = KeychainManager.shared.getIdentityKey(forKey: "ed25519SigningKey"),
-           let key = try? Curve25519.Signing.PrivateKey(rawRepresentation: signingData) {
-            loadedSigningKey = key
-            SecureLogger.logKeyOperation("load", keyType: "ed25519SigningKey", success: true)
-        }
-        // If no signing key exists, create new one
-        else {
+
+        let signingKeyResult = keychain.getIdentityKeyWithResult(forKey: "ed25519SigningKey")
+
+        switch signingKeyResult {
+        case .success(let signingData):
+            if let key = try? Curve25519.Signing.PrivateKey(rawRepresentation: signingData) {
+                loadedSigningKey = key
+                SecureLogger.logKeyOperation(.load, keyType: "ed25519SigningKey", success: true)
+            } else {
+                // Data corrupted, regenerate
+                SecureLogger.warning("Ed25519 signing key data corrupted, regenerating", category: .keychain)
+                loadedSigningKey = Self.generateAndSaveSigningKey(keychain: keychain)
+            }
+
+        case .itemNotFound:
+            // Expected case: no key exists yet, create new one
+            loadedSigningKey = Self.generateAndSaveSigningKey(keychain: keychain)
+
+        case .accessDenied:
+            // Critical error - log but proceed with ephemeral key
+            SecureLogger.error(NSError(domain: "Keychain", code: -1),
+                               context: "Keychain access denied - using ephemeral signing key", category: .keychain)
+            loadedSigningKey = Curve25519.Signing.PrivateKey()
+
+        case .deviceLocked, .authenticationFailed:
+            // Recoverable error - use ephemeral key and warn
+            SecureLogger.warning("Device locked or auth failed - using ephemeral signing key until unlocked", category: .keychain)
+            loadedSigningKey = Curve25519.Signing.PrivateKey()
+
+        case .otherError(let status):
+            // Unexpected error - log and use ephemeral key
+            SecureLogger.error(NSError(domain: "Keychain", code: Int(status)),
+                               context: "Unexpected keychain error - using ephemeral signing key", category: .keychain)
             loadedSigningKey = Curve25519.Signing.PrivateKey()
-            let keyData = loadedSigningKey.rawRepresentation
-            
-            // Save to keychain
-            let saved = KeychainManager.shared.saveIdentityKey(keyData, forKey: "ed25519SigningKey")
-            SecureLogger.logKeyOperation("create", keyType: "ed25519SigningKey", success: saved)
         }
-        
+
         // Now assign the signing keys
         self.signingKey = loadedSigningKey
         self.signingPublicKey = signingKey.publicKey
-        
+
         // Initialize session manager
-        self.sessionManager = NoiseSessionManager(localStaticKey: staticIdentityKey)
-        
+        self.sessionManager = NoiseSessionManager(localStaticKey: staticIdentityKey, keychain: keychain)
+
         // Set up session callbacks
         sessionManager.onSessionEstablished = { [weak self] peerID, remoteStaticKey in
             self?.handleSessionEstablished(peerID: peerID, remoteStaticKey: remoteStaticKey)
         }
-        
+
         // Start session maintenance timer
         startRekeyTimer()
     }
+
+    // MARK: - BCH-01-009: Key Generation Helpers with Save Verification
+
+    /// Generate and save a new Noise static key, verifying the save succeeds
+    private static func generateAndSaveNoiseKey(keychain: KeychainManagerProtocol) -> Curve25519.KeyAgreement.PrivateKey {
+        let newKey = Curve25519.KeyAgreement.PrivateKey()
+        let keyData = newKey.rawRepresentation
+
+        // Save to keychain and verify success
+        let saveResult = keychain.saveIdentityKeyWithResult(keyData, forKey: "noiseStaticKey")
+
+        switch saveResult {
+        case .success:
+            SecureLogger.logKeyOperation(.create, keyType: "noiseStaticKey", success: true)
+        case .duplicateItem:
+            // This shouldn't happen since we just tried to load, but handle it
+            SecureLogger.warning("Noise key already exists (race condition?)", category: .keychain)
+        default:
+            // Save failed - log but continue with the key (it will be ephemeral)
+            SecureLogger.error(NSError(domain: "Keychain", code: -1),
+                               context: "Failed to persist noise static key - identity will be lost on restart",
+                               category: .keychain)
+        }
+
+        return newKey
+    }
+
+    /// Generate and save a new Ed25519 signing key, verifying the save succeeds
+    private static func generateAndSaveSigningKey(keychain: KeychainManagerProtocol) -> Curve25519.Signing.PrivateKey {
+        let newKey = Curve25519.Signing.PrivateKey()
+        let keyData = newKey.rawRepresentation
+
+        // Save to keychain and verify success
+        let saveResult = keychain.saveIdentityKeyWithResult(keyData, forKey: "ed25519SigningKey")
+
+        switch saveResult {
+        case .success:
+            SecureLogger.logKeyOperation(.create, keyType: "ed25519SigningKey", success: true)
+        case .duplicateItem:
+            // This shouldn't happen since we just tried to load, but handle it
+            SecureLogger.warning("Signing key already exists (race condition?)", category: .keychain)
+        default:
+            // Save failed - log but continue with the key (it will be ephemeral)
+            SecureLogger.error(NSError(domain: "Keychain", code: -1),
+                               context: "Failed to persist signing key - identity will be lost on restart",
+                               category: .keychain)
+        }
+
+        return newKey
+    }
     
     // MARK: - Public Interface
     
@@ -255,22 +363,21 @@ class NoiseEncryptionService {
     
     /// Get our identity fingerprint
     func getIdentityFingerprint() -> String {
-        let hash = SHA256.hash(data: staticIdentityPublicKey.rawRepresentation)
-        return hash.map { String(format: "%02x", $0) }.joined()
+        staticIdentityPublicKey.rawRepresentation.sha256Fingerprint()
     }
     
     /// Get peer's public key data
-    func getPeerPublicKeyData(_ peerID: String) -> Data? {
+    func getPeerPublicKeyData(_ peerID: PeerID) -> Data? {
         return sessionManager.getRemoteStaticKey(for: peerID)?.rawRepresentation
     }
     
     /// Clear persistent identity (for panic mode)
     func clearPersistentIdentity() {
         // Clear from keychain
-        let deletedStatic = KeychainManager.shared.deleteIdentityKey(forKey: "noiseStaticKey")
-        let deletedSigning = KeychainManager.shared.deleteIdentityKey(forKey: "ed25519SigningKey")
-        SecureLogger.logKeyOperation("delete", keyType: "identity keys", success: deletedStatic && deletedSigning)
-        SecureLogger.log("Panic mode activated - identity cleared", category: SecureLogger.security, level: .warning)
+        let deletedStatic = keychain.deleteIdentityKey(forKey: "noiseStaticKey")
+        let deletedSigning = keychain.deleteIdentityKey(forKey: "ed25519SigningKey")
+        SecureLogger.logKeyOperation(.delete, keyType: "identity keys", success: deletedStatic && deletedSigning)
+        SecureLogger.warning("Panic mode activated - identity cleared", category: .security)
         // Stop rekey timer
         stopRekeyTimer()
     }
@@ -281,7 +388,7 @@ class NoiseEncryptionService {
             let signature = try signingKey.signature(for: data)
             return signature
         } catch {
-            SecureLogger.logError(error, context: "Failed to sign data", category: SecureLogger.noise)
+            SecureLogger.error(error, context: "Failed to sign data")
             return nil
         }
     }
@@ -292,7 +399,7 @@ class NoiseEncryptionService {
             let signingPublicKey = try Curve25519.Signing.PublicKey(rawRepresentation: publicKey)
             return signingPublicKey.isValidSignature(signature, for: data)
         } catch {
-            SecureLogger.logError(error, context: "Failed to verify signature", category: SecureLogger.noise)
+            SecureLogger.error(error, context: "Failed to verify signature")
             return false
         }
     }
@@ -388,21 +495,21 @@ class NoiseEncryptionService {
     // MARK: - Handshake Management
     
     /// Initiate a Noise handshake with a peer
-    func initiateHandshake(with peerID: String) throws -> Data {
+    func initiateHandshake(with peerID: PeerID) throws -> Data {
         
         // Validate peer ID
-        guard NoiseSecurityValidator.validatePeerID(peerID) else {
-            SecureLogger.logSecurityEvent(.authenticationFailed(peerID: peerID), level: .warning)
+        guard peerID.isValid else {
+            SecureLogger.warning(.authenticationFailed(peerID: peerID.id))
             throw NoiseSecurityError.invalidPeerID
         }
         
         // Check rate limit
         guard rateLimiter.allowHandshake(from: peerID) else {
-            SecureLogger.logSecurityEvent(.authenticationFailed(peerID: "Rate limited: \(peerID)"), level: .warning)
+            SecureLogger.warning(.authenticationFailed(peerID: "Rate limited: \(peerID)"))
             throw NoiseSecurityError.rateLimitExceeded
         }
         
-        SecureLogger.logSecurityEvent(.handshakeStarted(peerID: peerID))
+        SecureLogger.info(.handshakeStarted(peerID: peerID.id))
         
         // Return raw handshake data without wrapper
         // The Noise protocol handles its own message format
@@ -411,23 +518,23 @@ class NoiseEncryptionService {
     }
     
     /// Process an incoming handshake message
-    func processHandshakeMessage(from peerID: String, message: Data) throws -> Data? {
+    func processHandshakeMessage(from peerID: PeerID, message: Data) throws -> Data? {
         
         // Validate peer ID
-        guard NoiseSecurityValidator.validatePeerID(peerID) else {
-            SecureLogger.logSecurityEvent(.authenticationFailed(peerID: peerID), level: .warning)
+        guard peerID.isValid else {
+            SecureLogger.warning(.authenticationFailed(peerID: peerID.id))
             throw NoiseSecurityError.invalidPeerID
         }
         
         // Validate message size
         guard NoiseSecurityValidator.validateHandshakeMessageSize(message) else {
-            SecureLogger.logSecurityEvent(.handshakeFailed(peerID: peerID, error: "Message too large"), level: .warning)
+            SecureLogger.warning(.handshakeFailed(peerID: peerID.id, error: "Message too large"))
             throw NoiseSecurityError.messageTooLarge
         }
         
         // Check rate limit
         guard rateLimiter.allowHandshake(from: peerID) else {
-            SecureLogger.logSecurityEvent(.authenticationFailed(peerID: "Rate limited: \(peerID)"), level: .warning)
+            SecureLogger.warning(.authenticationFailed(peerID: "Rate limited: \(peerID)"))
             throw NoiseSecurityError.rateLimitExceeded
         }
         
@@ -441,19 +548,19 @@ class NoiseEncryptionService {
     }
     
     /// Check if we have an established session with a peer
-    func hasEstablishedSession(with peerID: String) -> Bool {
+    func hasEstablishedSession(with peerID: PeerID) -> Bool {
         return sessionManager.getSession(for: peerID)?.isEstablished() ?? false
     }
     
     /// Check if we have a session (established or handshaking) with a peer
-    func hasSession(with peerID: String) -> Bool {
+    func hasSession(with peerID: PeerID) -> Bool {
         return sessionManager.getSession(for: peerID) != nil
     }
     
     // MARK: - Encryption/Decryption
     
     /// Encrypt data for a specific peer
-    func encrypt(_ data: Data, for peerID: String) throws -> Data {
+    func encrypt(_ data: Data, for peerID: PeerID) throws -> Data {
         // Validate message size
         guard NoiseSecurityValidator.validateMessageSize(data) else {
             throw NoiseSecurityError.messageTooLarge
@@ -475,7 +582,7 @@ class NoiseEncryptionService {
     }
     
     /// Decrypt data from a specific peer
-    func decrypt(_ data: Data, from peerID: String) throws -> Data {
+    func decrypt(_ data: Data, from peerID: PeerID) throws -> Data {
         // Validate message size
         guard NoiseSecurityValidator.validateMessageSize(data) else {
             throw NoiseSecurityError.messageTooLarge
@@ -497,38 +604,37 @@ class NoiseEncryptionService {
     // MARK: - Peer Management
     
     /// Get fingerprint for a peer
-    func getPeerFingerprint(_ peerID: String) -> String? {
+    func getPeerFingerprint(_ peerID: PeerID) -> String? {
         return serviceQueue.sync {
             return peerFingerprints[peerID]
         }
     }
-    
-    /// Get peer ID for a fingerprint
-    func getPeerID(for fingerprint: String) -> String? {
-        return serviceQueue.sync {
-            return fingerprintToPeerID[fingerprint]
-        }
-    }
-    
-    /// Remove a peer session
-    func removePeer(_ peerID: String) {
-        sessionManager.removeSession(for: peerID)
-        
+
+    func clearEphemeralStateForPanic() {
+        sessionManager.removeAllSessions()
         serviceQueue.sync(flags: .barrier) {
-            if let fingerprint = peerFingerprints[peerID] {
+            peerFingerprints.removeAll()
+            fingerprintToPeerID.removeAll()
+        }
+        rateLimiter.resetAll()
+    }
+
+    /// Clear session for a specific peer (e.g., on decryption failure to allow re-handshake)
+    func clearSession(for peerID: PeerID) {
+        sessionManager.removeSession(for: peerID)
+        serviceQueue.sync(flags: .barrier) {
+            if let fingerprint = peerFingerprints.removeValue(forKey: peerID) {
                 fingerprintToPeerID.removeValue(forKey: fingerprint)
             }
-            peerFingerprints.removeValue(forKey: peerID)
         }
-        
-        SecureLogger.logSecurityEvent(.sessionExpired(peerID: peerID))
+        SecureLogger.debug("🔓 Cleared Noise session for \(peerID)", category: .session)
     }
     
     // MARK: - Private Helpers
     
-    private func handleSessionEstablished(peerID: String, remoteStaticKey: Curve25519.KeyAgreement.PublicKey) {
+    private func handleSessionEstablished(peerID: PeerID, remoteStaticKey: Curve25519.KeyAgreement.PublicKey) {
         // Calculate fingerprint
-        let fingerprint = calculateFingerprint(for: remoteStaticKey)
+        let fingerprint = remoteStaticKey.rawRepresentation.sha256Fingerprint()
         
         // Store fingerprint mapping
         serviceQueue.sync(flags: .barrier) {
@@ -537,7 +643,7 @@ class NoiseEncryptionService {
         }
         
         // Log security event
-        SecureLogger.logSecurityEvent(.handshakeCompleted(peerID: peerID))
+        SecureLogger.info(.handshakeCompleted(peerID: peerID.id))
         
         // Notify all handlers about authentication
         serviceQueue.async { [weak self] in
@@ -546,11 +652,6 @@ class NoiseEncryptionService {
             }
         }
     }
-    
-    private func calculateFingerprint(for publicKey: Curve25519.KeyAgreement.PublicKey) -> String {
-        let hash = SHA256.hash(data: publicKey.rawRepresentation)
-        return hash.map { String(format: "%02x", $0) }.joined()
-    }
         
     // MARK: - Session Maintenance
     
@@ -573,12 +674,12 @@ class NoiseEncryptionService {
             // Attempt to rekey the session
             do {
                 try sessionManager.initiateRekey(for: peerID)
-                SecureLogger.log("Key rotation initiated for peer: \(peerID)", category: SecureLogger.security, level: .debug)
+                SecureLogger.debug("Key rotation initiated for peer: \(peerID)", category: .security)
                 
                 // Signal that handshake is needed
                 onHandshakeRequired?(peerID)
             } catch {
-                SecureLogger.logError(error, context: "Failed to initiate rekey for peer: \(peerID)", category: SecureLogger.session)
+                SecureLogger.error(error, context: "Failed to initiate rekey for peer: \(peerID)", category: .session)
             }
         }
     }

bitchat/Services/NostrTransport.swift

@@ -1,28 +1,119 @@
+import BitLogger
+import BitFoundation
 import Foundation
 import Combine
 
 // Minimal Nostr transport conforming to Transport for offline sending
-final class NostrTransport: Transport {
+final class NostrTransport: Transport, @unchecked Sendable {
+    struct Dependencies {
+        let notificationCenter: NotificationCenter
+        let loadFavorites: @MainActor () -> [Data: FavoritesPersistenceService.FavoriteRelationship]
+        let favoriteStatusForNoiseKey: @MainActor (Data) -> FavoritesPersistenceService.FavoriteRelationship?
+        let favoriteStatusForPeerID: @MainActor (PeerID) -> FavoritesPersistenceService.FavoriteRelationship?
+        let currentIdentity: @MainActor () throws -> NostrIdentity?
+        let registerPendingGiftWrap: @MainActor (String) -> Void
+        let sendEvent: @MainActor (NostrEvent) -> Void
+        let scheduleAfter: @Sendable (TimeInterval, @escaping @Sendable () -> Void) -> Void
+
+        static func live(idBridge: NostrIdentityBridge) -> Dependencies {
+            Dependencies(
+                notificationCenter: .default,
+                loadFavorites: { FavoritesPersistenceService.shared.favorites },
+                favoriteStatusForNoiseKey: { FavoritesPersistenceService.shared.getFavoriteStatus(for: $0) },
+                favoriteStatusForPeerID: { FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: $0) },
+                currentIdentity: { try idBridge.getCurrentNostrIdentity() },
+                registerPendingGiftWrap: { NostrRelayManager.registerPendingGiftWrap(id: $0) },
+                sendEvent: { NostrRelayManager.shared.sendEvent($0) },
+                scheduleAfter: { delay, action in
+                    DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: action)
+                }
+            )
+        }
+    }
+
+    // Provide BLE short peer ID for BitChat embedding
+    var senderPeerID = PeerID(str: "")
+
+    // Throttle READ receipts to avoid relay rate limits
+    private struct QueuedRead {
+        let receipt: ReadReceipt
+        let peerID: PeerID
+    }
+    private var readQueue: [QueuedRead] = []
+    private var isSendingReadAcks = false
+    private let readAckInterval: TimeInterval = TransportConfig.nostrReadAckInterval
+    private let keychain: KeychainManagerProtocol
+    private let idBridge: NostrIdentityBridge
+    private let dependencies: Dependencies
+    private var favoriteStatusObserver: NSObjectProtocol?
+
+    // Reachability Cache (thread-safe)
+    private var reachablePeers: Set<PeerID> = []
+    private let queue = DispatchQueue(label: "nostr.transport.state", attributes: .concurrent)
+
+    @MainActor
+    init(
+        keychain: KeychainManagerProtocol,
+        idBridge: NostrIdentityBridge,
+        dependencies: Dependencies? = nil
+    ) {
+        self.keychain = keychain
+        self.idBridge = idBridge
+        self.dependencies = dependencies ?? .live(idBridge: idBridge)
+        
+        setupObservers()
+        
+        // Synchronously warm the cache to avoid startup race
+        let favorites = self.dependencies.loadFavorites()
+        let reachable = favorites.values
+            .filter { $0.peerNostrPublicKey != nil }
+            .map { PeerID(publicKey: $0.peerNoisePublicKey) }
+            
+        queue.sync(flags: .barrier) {
+            self.reachablePeers = Set(reachable)
+        }
+    }
+
+    deinit {
+        if let favoriteStatusObserver {
+            dependencies.notificationCenter.removeObserver(favoriteStatusObserver)
+        }
+    }
+
+    private func setupObservers() {
+        favoriteStatusObserver = dependencies.notificationCenter.addObserver(
+            forName: .favoriteStatusChanged,
+            object: nil,
+            queue: nil
+        ) { [weak self] _ in
+            self?.refreshReachablePeers()
+        }
+    }
+
+    private func refreshReachablePeers() {
+        Task { @MainActor in
+            let favorites = dependencies.loadFavorites()
+            let reachable = favorites.values
+                .filter { $0.peerNostrPublicKey != nil }
+                .map { PeerID(publicKey: $0.peerNoisePublicKey) }
+            
+            self.queue.async(flags: .barrier) { [weak self] in
+                self?.reachablePeers = Set(reachable)
+            }
+        }
+    }
+
+    // MARK: - Transport Protocol Conformance
+
     weak var delegate: BitchatDelegate?
     weak var peerEventsDelegate: TransportPeerEventsDelegate?
+
     var peerSnapshotPublisher: AnyPublisher<[TransportPeerSnapshot], Never> {
         Just([]).eraseToAnyPublisher()
     }
     func currentPeerSnapshots() -> [TransportPeerSnapshot] { [] }
 
-    // Provide BLE short peer ID for BitChat embedding
-    var senderPeerID: String = ""
-
-    // Throttle READ receipts to avoid relay rate limits
-    private struct QueuedRead {
-        let receipt: ReadReceipt
-        let peerID: String
-    }
-    private var readQueue: [QueuedRead] = []
-    private var isSendingReadAcks = false
-    private let readAckInterval: TimeInterval = TransportConfig.nostrReadAckInterval
-
-    var myPeerID: String { senderPeerID }
+    var myPeerID: PeerID { senderPeerID }
     var myNickname: String { "" }
     func setNickname(_ nickname: String) { /* not used for Nostr */ }
 
@@ -30,220 +121,205 @@ final class NostrTransport: Transport {
     func stopServices() { /* no-op */ }
     func emergencyDisconnectAll() { /* no-op */ }
 
-    func isPeerConnected(_ peerID: String) -> Bool { false }
-    func isPeerReachable(_ peerID: String) -> Bool { false }
-    func peerNickname(peerID: String) -> String? { nil }
-    func getPeerNicknames() -> [String : String] { [:] }
+    func isPeerConnected(_ peerID: PeerID) -> Bool { false }
+    
+    func isPeerReachable(_ peerID: PeerID) -> Bool {
+        queue.sync {
+            // Check if exact match
+            if reachablePeers.contains(peerID) { return true }
+            // Check for short ID match
+            if peerID.isShort {
+                return reachablePeers.contains(where: { $0.toShort() == peerID })
+            }
+            return false
+        }
+    }
+    
+    func peerNickname(peerID: PeerID) -> String? { nil }
+    func getPeerNicknames() -> [PeerID : String] { [:] }
 
-    func getFingerprint(for peerID: String) -> String? { nil }
-    func getNoiseSessionState(for peerID: String) -> LazyHandshakeState { .none }
-    func triggerHandshake(with peerID: String) { /* no-op */ }
+    func getFingerprint(for peerID: PeerID) -> String? { nil }
+    func getNoiseSessionState(for peerID: PeerID) -> LazyHandshakeState { .none }
+    func triggerHandshake(with peerID: PeerID) { /* no-op */ }
+    
     // Nostr does not use Noise sessions here; return a cached placeholder to avoid reallocation
-    private static var cachedNoiseService: NoiseEncryptionService = {
-        NoiseEncryptionService()
-    }()
-    func getNoiseService() -> NoiseEncryptionService { Self.cachedNoiseService }
+    private static var cachedNoiseService: NoiseEncryptionService?
+    func getNoiseService() -> NoiseEncryptionService {
+        if let noiseService = Self.cachedNoiseService {
+            return noiseService
+        }
+        let noiseService = NoiseEncryptionService(keychain: keychain)
+        Self.cachedNoiseService = noiseService
+        return noiseService
+    }
 
     // Public broadcast not supported over Nostr here
     func sendMessage(_ content: String, mentions: [String]) { /* no-op */ }
 
-    func sendPrivateMessage(_ content: String, to peerID: String, recipientNickname: String, messageID: String) {
+    func sendPrivateMessage(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String) {
         Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
-            SecureLogger.log("NostrTransport: preparing PM to \(recipientNpub.prefix(16))… for peerID \(peerID.prefix(8))… id=\(messageID.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
-            // Convert recipient npub -> hex (x-only)
-            let recipientHex: String
-            do {
-                let (hrp, data) = try Bech32.decode(recipientNpub)
-                guard hrp == "npub" else {
-                    SecureLogger.log("NostrTransport: recipient key not npub (hrp=\(hrp))", category: SecureLogger.session, level: .error)
-                    return
-                }
-                recipientHex = data.hexEncodedString()
-            } catch {
-                SecureLogger.log("NostrTransport: failed to decode npub -> hex: \(error)", category: SecureLogger.session, level: .error)
-                return
-            }
+            guard let recipientNpub = resolveRecipientNpub(for: peerID),
+                  let recipientHex = npubToHex(recipientNpub),
+                  let senderIdentity = try? dependencies.currentIdentity() else { return }
+            SecureLogger.debug("NostrTransport: preparing PM to \(recipientNpub.prefix(16))… id=\(messageID.prefix(8))…", category: .session)
             guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
-                SecureLogger.log("NostrTransport: failed to embed PM packet", category: SecureLogger.session, level: .error)
+                SecureLogger.error("NostrTransport: failed to embed PM packet", category: .session)
                 return
             }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
-                SecureLogger.log("NostrTransport: failed to build Nostr event for PM", category: SecureLogger.session, level: .error)
-                return
-            }
-            SecureLogger.log("NostrTransport: sending PM giftWrap id=\(event.id.prefix(16))…",
-                            category: SecureLogger.session, level: .debug)
-            NostrRelayManager.shared.sendEvent(event)
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: senderIdentity)
         }
     }
 
-    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: String) {
+    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID) {
         // Enqueue and process with throttling to avoid relay rate limits
-        readQueue.append(QueuedRead(receipt: receipt, peerID: peerID))
-        processReadQueueIfNeeded()
-    }
-
-    private func processReadQueueIfNeeded() {
-        guard !isSendingReadAcks else { return }
-        guard !readQueue.isEmpty else { return }
-        isSendingReadAcks = true
-        sendNextReadAck()
-    }
-
-    private func sendNextReadAck() {
-        guard !readQueue.isEmpty else { isSendingReadAcks = false; return }
-        let item = readQueue.removeFirst()
-        Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: item.peerID) else { scheduleNextReadAck(); return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { scheduleNextReadAck(); return }
-            SecureLogger.log("NostrTransport: preparing READ ack for id=\(item.receipt.originalMessageID.prefix(8))… to \(recipientNpub.prefix(16))…",
-                            category: SecureLogger.session, level: .debug)
-            // Convert recipient npub -> hex
-            let recipientHex: String
-            do {
-                let (hrp, data) = try Bech32.decode(recipientNpub)
-                guard hrp == "npub" else { scheduleNextReadAck(); return }
-                recipientHex = data.hexEncodedString()
-            } catch { scheduleNextReadAck(); return }
-            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .readReceipt, messageID: item.receipt.originalMessageID, recipientPeerID: item.peerID, senderPeerID: senderPeerID) else {
-                SecureLogger.log("NostrTransport: failed to embed READ ack", category: SecureLogger.session, level: .error)
-                scheduleNextReadAck(); return
-            }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: ack, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
-                SecureLogger.log("NostrTransport: failed to build Nostr event for READ ack", category: SecureLogger.session, level: .error)
-                scheduleNextReadAck(); return
-            }
-            SecureLogger.log("NostrTransport: sending READ ack giftWrap id=\(event.id.prefix(16))…",
-                            category: SecureLogger.session, level: .debug)
-            NostrRelayManager.shared.sendEvent(event)
-            scheduleNextReadAck()
+        // Use barrier to synchronize access to readQueue
+        queue.async(flags: .barrier) { [weak self] in
+            self?.readQueue.append(QueuedRead(receipt: receipt, peerID: peerID))
+            self?.processReadQueueIfNeeded()
         }
     }
 
-    private func scheduleNextReadAck() {
-        DispatchQueue.main.asyncAfter(deadline: .now() + readAckInterval) { [weak self] in
-            guard let self = self else { return }
-            self.isSendingReadAcks = false
-            self.processReadQueueIfNeeded()
-        }
-    }
-
-    func sendFavoriteNotification(to peerID: String, isFavorite: Bool) {
+    func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool) {
         Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
+            guard let recipientNpub = resolveRecipientNpub(for: peerID),
+                  let recipientHex = npubToHex(recipientNpub),
+                  let senderIdentity = try? dependencies.currentIdentity() else { return }
             let content = isFavorite ? "[FAVORITED]:\(senderIdentity.npub)" : "[UNFAVORITED]:\(senderIdentity.npub)"
-            SecureLogger.log("NostrTransport: preparing FAVORITE(\(isFavorite)) to \(recipientNpub.prefix(16))…",
-                            category: SecureLogger.session, level: .debug)
-            // Convert recipient npub -> hex
-            let recipientHex: String
-            do {
-                let (hrp, data) = try Bech32.decode(recipientNpub)
-                guard hrp == "npub" else { return }
-                recipientHex = data.hexEncodedString()
-            } catch { return }
+            SecureLogger.debug("NostrTransport: preparing FAVORITE(\(isFavorite)) to \(recipientNpub.prefix(16))…", category: .session)
             guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: UUID().uuidString, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
-                SecureLogger.log("NostrTransport: failed to embed favorite notification", category: SecureLogger.session, level: .error)
+                SecureLogger.error("NostrTransport: failed to embed favorite notification", category: .session)
                 return
             }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
-                SecureLogger.log("NostrTransport: failed to build Nostr event for favorite notification", category: SecureLogger.session, level: .error)
-                return
-            }
-            SecureLogger.log("NostrTransport: sending favorite giftWrap id=\(event.id.prefix(16))…",
-                            category: SecureLogger.session, level: .debug)
-            NostrRelayManager.shared.sendEvent(event)
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: senderIdentity)
         }
     }
 
-    // MARK: - Helpers
-    @MainActor
-    private func resolveRecipientNpub(for peerID: String) -> String? {
-        if let noiseKey = Data(hexString: peerID),
-           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
-           let npub = fav.peerNostrPublicKey {
-            return npub
-        }
-        if peerID.count == 16,
-           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID),
-           let npub = fav.peerNostrPublicKey {
-            return npub
-        }
-        return nil
-    }
-
     func sendBroadcastAnnounce() { /* no-op for Nostr */ }
-    func sendDeliveryAck(for messageID: String, to peerID: String) {
+    func sendDeliveryAck(for messageID: String, to peerID: PeerID) {
         Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
-            SecureLogger.log("NostrTransport: preparing DELIVERED ack for id=\(messageID.prefix(8))… to \(recipientNpub.prefix(16))…",
-                            category: SecureLogger.session, level: .debug)
-            let recipientHex: String
-            do {
-                let (hrp, data) = try Bech32.decode(recipientNpub)
-                guard hrp == "npub" else { return }
-                recipientHex = data.hexEncodedString()
-            } catch { return }
+            guard let recipientNpub = resolveRecipientNpub(for: peerID),
+                  let recipientHex = npubToHex(recipientNpub),
+                  let senderIdentity = try? dependencies.currentIdentity() else { return }
+            SecureLogger.debug("NostrTransport: preparing DELIVERED ack id=\(messageID.prefix(8))…", category: .session)
             guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .delivered, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
-                SecureLogger.log("NostrTransport: failed to embed DELIVERED ack", category: SecureLogger.session, level: .error)
+                SecureLogger.error("NostrTransport: failed to embed DELIVERED ack", category: .session)
                 return
             }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: ack, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
-                SecureLogger.log("NostrTransport: failed to build Nostr event for DELIVERED ack", category: SecureLogger.session, level: .error)
-                return
-            }
-            SecureLogger.log("NostrTransport: sending DELIVERED ack giftWrap id=\(event.id.prefix(16))…",
-                            category: SecureLogger.session, level: .debug)
-            NostrRelayManager.shared.sendEvent(event)
+            sendWrappedMessage(content: ack, recipientHex: recipientHex, senderIdentity: senderIdentity)
         }
     }
+}
 
-    // MARK: - Geohash ACK helpers
+// MARK: - Geohash Helpers
+
+extension NostrTransport {
+
+    // MARK: Geohash ACK helpers
     func sendDeliveryAckGeohash(for messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
         Task { @MainActor in
-            SecureLogger.log("GeoDM: send DELIVERED -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
+            SecureLogger.debug("GeoDM: send DELIVERED mid=\(messageID.prefix(8))…", category: .session)
             guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID) else { return }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: identity) else { return }
-            NostrRelayManager.registerPendingGiftWrap(id: event.id)
-            NostrRelayManager.shared.sendEvent(event)
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: identity, registerPending: true)
         }
     }
 
     func sendReadReceiptGeohash(_ messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
         Task { @MainActor in
-            SecureLogger.log("GeoDM: send READ -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
+            SecureLogger.debug("GeoDM: send READ mid=\(messageID.prefix(8))…", category: .session)
             guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID) else { return }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: identity) else { return }
-            NostrRelayManager.registerPendingGiftWrap(id: event.id)
-            NostrRelayManager.shared.sendEvent(event)
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: identity, registerPending: true)
         }
     }
 
-    // MARK: - Geohash DMs (per-geohash identity)
+    // MARK: Geohash DMs (per-geohash identity)
     func sendPrivateMessageGeohash(content: String, toRecipientHex recipientHex: String, from identity: NostrIdentity, messageID: String) {
         Task { @MainActor in
             guard !recipientHex.isEmpty else { return }
-            SecureLogger.log("GeoDM: send PM -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…",
-                            category: SecureLogger.session, level: .debug)
-            // Build embedded BitChat packet without recipient peer ID
+            SecureLogger.debug("GeoDM: send PM mid=\(messageID.prefix(8))…", category: .session)
             guard let embedded = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(content: content, messageID: messageID, senderPeerID: senderPeerID) else {
-                SecureLogger.log("NostrTransport: failed to embed geohash PM packet", category: SecureLogger.session, level: .error)
+                SecureLogger.error("NostrTransport: failed to embed geohash PM packet", category: .session)
                 return
             }
-            guard let event = try? NostrProtocol.createPrivateMessage(content: embedded, recipientPubkey: recipientHex, senderIdentity: identity) else {
-                SecureLogger.log("NostrTransport: failed to build Nostr event for geohash PM", category: SecureLogger.session, level: .error)
-                return
-            }
-            SecureLogger.log("NostrTransport: sending geohash PM giftWrap id=\(event.id.prefix(16))…",
-                            category: SecureLogger.session, level: .debug)
-            NostrRelayManager.registerPendingGiftWrap(id: event.id)
-            NostrRelayManager.shared.sendEvent(event)
+            sendWrappedMessage(content: embedded, recipientHex: recipientHex, senderIdentity: identity, registerPending: true)
         }
     }
 }
+
+// MARK: - Private Helpers
+
+extension NostrTransport {
+    /// Converts npub bech32 string to hex pubkey
+    @MainActor
+    private func npubToHex(_ npub: String) -> String? {
+        do {
+            let (hrp, data) = try Bech32.decode(npub)
+            guard hrp == "npub" else { return nil }
+            return data.hexEncodedString()
+        } catch {
+            SecureLogger.error("NostrTransport: failed to decode npub -> hex: \(error)", category: .session)
+            return nil
+        }
+    }
+
+    /// Creates and sends a gift-wrapped private message event
+    @MainActor
+    private func sendWrappedMessage(content: String, recipientHex: String, senderIdentity: NostrIdentity, registerPending: Bool = false) {
+        guard let event = try? NostrProtocol.createPrivateMessage(content: content, recipientPubkey: recipientHex, senderIdentity: senderIdentity) else {
+            SecureLogger.error("NostrTransport: failed to build Nostr event", category: .session)
+            return
+        }
+        if registerPending {
+            dependencies.registerPendingGiftWrap(event.id)
+        }
+        dependencies.sendEvent(event)
+    }
+
+    /// Must be called within a barrier on `queue`
+    private func processReadQueueIfNeeded() {
+        guard !isSendingReadAcks else { return }
+        guard !readQueue.isEmpty else { return }
+        isSendingReadAcks = true
+        let item = readQueue.removeFirst()
+        sendReadAckItem(item)
+    }
+
+    /// Sends a single read ack item (called after extraction from queue within barrier)
+    private func sendReadAckItem(_ item: QueuedRead) {
+        Task { @MainActor in
+            defer { scheduleNextReadAck() }
+            guard let recipientNpub = resolveRecipientNpub(for: item.peerID),
+                  let recipientHex = npubToHex(recipientNpub),
+                  let senderIdentity = try? dependencies.currentIdentity() else { return }
+            SecureLogger.debug("NostrTransport: preparing READ ack id=\(item.receipt.originalMessageID.prefix(8))…", category: .session)
+            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .readReceipt, messageID: item.receipt.originalMessageID, recipientPeerID: item.peerID, senderPeerID: senderPeerID) else {
+                SecureLogger.error("NostrTransport: failed to embed READ ack", category: .session)
+                return
+            }
+            sendWrappedMessage(content: ack, recipientHex: recipientHex, senderIdentity: senderIdentity)
+        }
+    }
+
+    private func scheduleNextReadAck() {
+        dependencies.scheduleAfter(readAckInterval) { [weak self] in
+            self?.queue.async(flags: .barrier) { [weak self] in
+                self?.isSendingReadAcks = false
+                self?.processReadQueueIfNeeded()
+            }
+        }
+    }
+
+    @MainActor
+    private func resolveRecipientNpub(for peerID: PeerID) -> String? {
+        if let noiseKey = Data(hexString: peerID.id),
+           let fav = dependencies.favoriteStatusForNoiseKey(noiseKey),
+           let npub = fav.peerNostrPublicKey {
+            return npub
+        }
+        if peerID.id.count == 16,
+           let fav = dependencies.favoriteStatusForPeerID(peerID),
+           let npub = fav.peerNostrPublicKey {
+            return npub
+        }
+        return nil
+    }
+}

bitchat/Services/NotificationService.swift

@@ -6,6 +6,7 @@
 // For more information, see <https://unlicense.org>
 //
 
+import BitFoundation
 import Foundation
 import UserNotifications
 #if os(iOS)
@@ -14,13 +15,103 @@ import UIKit
 import AppKit
 #endif
 
-class NotificationService {
+protocol NotificationAuthorizing {
+    func requestAuthorization(
+        options: UNAuthorizationOptions,
+        completionHandler: @escaping (Bool, Error?) -> Void
+    )
+}
+
+protocol NotificationRequestDelivering {
+    func add(_ request: UNNotificationRequest)
+}
+
+private final class NotificationCenterAuthorizerAdapter: NotificationAuthorizing {
+    private let center: UNUserNotificationCenter
+
+    init(center: UNUserNotificationCenter) {
+        self.center = center
+    }
+
+    func requestAuthorization(
+        options: UNAuthorizationOptions,
+        completionHandler: @escaping (Bool, Error?) -> Void
+    ) {
+        center.requestAuthorization(options: options, completionHandler: completionHandler)
+    }
+}
+
+private final class NotificationCenterRequestDelivererAdapter: NotificationRequestDelivering {
+    private let center: UNUserNotificationCenter
+
+    init(center: UNUserNotificationCenter) {
+        self.center = center
+    }
+
+    func add(_ request: UNNotificationRequest) {
+        Task {
+            try? await center.add(request)
+        }
+    }
+}
+
+private struct NoopNotificationAuthorizer: NotificationAuthorizing {
+    func requestAuthorization(
+        options: UNAuthorizationOptions,
+        completionHandler: @escaping (Bool, Error?) -> Void
+    ) {
+        completionHandler(false, nil)
+    }
+}
+
+private struct NoopNotificationRequestDeliverer: NotificationRequestDelivering {
+    func add(_ request: UNNotificationRequest) {}
+}
+
+final class NotificationService {
     static let shared = NotificationService()
-    
-    private init() {}
-    
+
+    private let isRunningTestsProvider: () -> Bool
+    private let authorizer: NotificationAuthorizing
+    private let requestDeliverer: NotificationRequestDelivering
+
+    /// Returns true if running in test environment (XCTest, Swift Testing, or CI)
+    private var isRunningTests: Bool {
+        isRunningTestsProvider()
+    }
+
+    private init() {
+        self.isRunningTestsProvider = {
+            let env = ProcessInfo.processInfo.environment
+            return NSClassFromString("XCTestCase") != nil ||
+                   env["XCTestConfigurationFilePath"] != nil ||
+                   env["XCTestBundlePath"] != nil ||
+                   env["GITHUB_ACTIONS"] != nil ||
+                   env["CI"] != nil
+        }
+        if isRunningTestsProvider() {
+            self.authorizer = NoopNotificationAuthorizer()
+            self.requestDeliverer = NoopNotificationRequestDeliverer()
+        } else {
+            let center = UNUserNotificationCenter.current()
+            self.authorizer = NotificationCenterAuthorizerAdapter(center: center)
+            self.requestDeliverer = NotificationCenterRequestDelivererAdapter(center: center)
+        }
+    }
+
+    internal init(
+        isRunningTestsProvider: @escaping () -> Bool,
+        authorizer: NotificationAuthorizing,
+        requestDeliverer: NotificationRequestDelivering
+    ) {
+        self.isRunningTestsProvider = isRunningTestsProvider
+        self.authorizer = authorizer
+        self.requestDeliverer = requestDeliverer
+    }
+
     func requestAuthorization() {
-        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+        guard !isRunningTests else { return }
+        authorizer.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
             if granted {
                 // Permission granted
             } else {
@@ -29,28 +120,31 @@ class NotificationService {
         }
     }
     
-    func sendLocalNotification(title: String, body: String, identifier: String, userInfo: [String: Any]? = nil) {
-        // For now, skip app state check entirely to avoid thread issues
-        // The NotificationDelegate will handle foreground presentation
-        DispatchQueue.main.async {
-            let content = UNMutableNotificationContent()
-            content.title = title
-            content.body = body
-            content.sound = .default
-            if let userInfo = userInfo {
-                content.userInfo = userInfo
-            }
-            
-            let request = UNNotificationRequest(
-                identifier: identifier,
-                content: content,
-                trigger: nil // Deliver immediately
-            )
-            
-            UNUserNotificationCenter.current().add(request) { _ in
-                // Notification added
-            }
+    func sendLocalNotification(
+        title: String,
+        body: String,
+        identifier: String,
+        userInfo: [String: Any]? = nil,
+        interruptionLevel: UNNotificationInterruptionLevel = .active
+    ) {
+        guard !isRunningTests else { return }
+        let content = UNMutableNotificationContent()
+        content.title = title
+        content.body = body
+        content.sound = .default
+        content.interruptionLevel = interruptionLevel
+
+        if let userInfo = userInfo {
+            content.userInfo = userInfo
         }
+
+        let request = UNNotificationRequest(
+            identifier: identifier,
+            content: content,
+            trigger: nil // Deliver immediately
+        )
+
+        requestDeliverer.add(request)
     }
     
     func sendMentionNotification(from sender: String, message: String) {
@@ -61,35 +155,15 @@ class NotificationService {
         sendLocalNotification(title: title, body: body, identifier: identifier)
     }
     
-    func sendPrivateMessageNotification(from sender: String, message: String, peerID: String) {
-        let title = "🔒 private message from \(sender)"
+    func sendPrivateMessageNotification(from sender: String, message: String, peerID: PeerID) {
+        let title = "🔒 DM from \(sender)"
         let body = message
         let identifier = "private-\(UUID().uuidString)"
-        let userInfo = ["peerID": peerID, "senderName": sender]
+        let userInfo = ["peerID": peerID.id, "senderName": sender]
         
         sendLocalNotification(title: title, body: body, identifier: identifier, userInfo: userInfo)
     }
     
-    func sendFavoriteOnlineNotification(nickname: String) {
-        // Send directly without checking app state for favorites
-        DispatchQueue.main.async {
-            let content = UNMutableNotificationContent()
-            content.title = "⭐ \(nickname) is online!"
-            content.body = "wanna get in there?"
-            content.sound = .default
-            
-            let request = UNNotificationRequest(
-                identifier: "favorite-online-\(UUID().uuidString)",
-                content: content,
-                trigger: nil
-            )
-            
-            UNUserNotificationCenter.current().add(request) { _ in
-                // Notification added
-            }
-        }
-    }
-    
     // Geohash public chat notification with deep link to a specific geohash
     func sendGeohashActivityNotification(geohash: String, titlePrefix: String = "#", bodyPreview: String) {
         let title = "\(titlePrefix)\(geohash)"
@@ -102,26 +176,14 @@ class NotificationService {
     func sendNetworkAvailableNotification(peerCount: Int) {
         let title = "👥 bitchatters nearby!"
         let body = peerCount == 1 ? "1 person around" : "\(peerCount) people around"
-        let identifier = "network-available-\(Date().timeIntervalSince1970)"
-        
-        // For network notifications, we want to show them even in foreground
-        // No app state check - let the notification delegate handle presentation
-        DispatchQueue.main.async {
-            let content = UNMutableNotificationContent()
-            content.title = title
-            content.body = body
-            content.sound = .default
-            content.interruptionLevel = .timeSensitive  // Make it more prominent
-            
-            let request = UNNotificationRequest(
-                identifier: identifier,
-                content: content,
-                trigger: nil // Deliver immediately
-            )
-            
-            UNUserNotificationCenter.current().add(request) { _ in
-                // Notification added
-            }
-        }
+        // Fixed identifier so iOS updates the existing notification instead of creating new ones
+        let identifier = "network-available"
+
+        sendLocalNotification(
+            title: title,
+            body: body,
+            identifier: identifier,
+            interruptionLevel: .timeSensitive
+        )
     }
 }

bitchat/Services/NotificationStreamAssembler.swift

@@ -0,0 +1,144 @@
+//
+// NotificationStreamAssembler.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import BitLogger
+import BitFoundation
+import Foundation
+
+struct NotificationStreamAssembler {
+    private var buffer = Data()
+    private var pendingFrameStartedAt: DispatchTime?
+    private var pendingFrameExpectedLength: Int = 0
+
+    private mutating func resetState() {
+        buffer.removeAll(keepingCapacity: false)
+        pendingFrameStartedAt = nil
+        pendingFrameExpectedLength = 0
+    }
+
+    mutating func append(_ chunk: Data) -> (frames: [Data], droppedPrefixes: [UInt8], reset: Bool) {
+        guard !chunk.isEmpty else { return ([], [], false) }
+
+        buffer.append(chunk)
+
+        var frames: [Data] = []
+        var dropped: [UInt8] = []
+        var didReset = false
+        let now = DispatchTime.now()
+        let maxFrameLength = TransportConfig.bleNotificationAssemblerHardCapBytes
+        let minimumFramePrefix = BinaryProtocol.v1HeaderSize + BinaryProtocol.senderIDSize
+
+        if buffer.count > TransportConfig.bleNotificationAssemblerHardCapBytes {
+            SecureLogger.error("❌ Notification assembler overflow (\(buffer.count) bytes); dropping partial frame", category: .session)
+            resetState()
+            return ([], [], true)
+        }
+
+        while buffer.count >= minimumFramePrefix {
+            guard let version = buffer.first else { break }
+            guard version == 1 || version == 2 else {
+                dropped.append(buffer.removeFirst())
+                pendingFrameStartedAt = nil
+                pendingFrameExpectedLength = 0
+                continue
+            }
+
+            guard let headerSize = BinaryProtocol.headerSize(for: version) else {
+                dropped.append(buffer.removeFirst())
+                pendingFrameStartedAt = nil
+                pendingFrameExpectedLength = 0
+                continue
+            }
+            let framePrefix = headerSize + BinaryProtocol.senderIDSize
+            guard buffer.count >= framePrefix else { break }
+
+            let flagsIndex = buffer.startIndex + BinaryProtocol.Offsets.flags
+            guard flagsIndex < buffer.endIndex else { break }
+            let flags = buffer[flagsIndex]
+            let hasRecipient = (flags & BinaryProtocol.Flags.hasRecipient) != 0
+            let hasSignature = (flags & BinaryProtocol.Flags.hasSignature) != 0
+            let isCompressed = (flags & BinaryProtocol.Flags.isCompressed) != 0
+            let hasRoute = (version >= 2) && (flags & BinaryProtocol.Flags.hasRoute) != 0
+
+            let lengthOffset = 12
+            let payloadLength: Int
+            if version == 2 {
+                let lengthIndex = buffer.startIndex + lengthOffset
+                payloadLength =
+                    (Int(buffer[lengthIndex]) << 24) |
+                    (Int(buffer[lengthIndex + 1]) << 16) |
+                    (Int(buffer[lengthIndex + 2]) << 8) |
+                    Int(buffer[lengthIndex + 3])
+            } else {
+                let lengthIndex = buffer.startIndex + lengthOffset
+                payloadLength = (Int(buffer[lengthIndex]) << 8) | Int(buffer[lengthIndex + 1])
+            }
+
+            var frameLength = framePrefix + payloadLength
+            if hasRecipient { frameLength += BinaryProtocol.recipientIDSize }
+            if hasSignature { frameLength += BinaryProtocol.signatureSize }
+            
+            if hasRoute {
+                let routeCountOffset = framePrefix + (hasRecipient ? BinaryProtocol.recipientIDSize : 0)
+                let routeCountIndex = buffer.startIndex + routeCountOffset
+                guard buffer.count > routeCountOffset else { break }
+                let routeCount = Int(buffer[routeCountIndex])
+                frameLength += 1 + (routeCount * BinaryProtocol.senderIDSize)
+            }
+            
+            if isCompressed {
+                let rawLengthFieldBytes = (version == 2) ? 4 : 2
+                if payloadLength < rawLengthFieldBytes {
+                    SecureLogger.error("❌ Invalid compressed payload length (\(payloadLength))", category: .session)
+                    resetState()
+                    didReset = true
+                    break
+                }
+            }
+
+            guard frameLength > 0, frameLength <= maxFrameLength else {
+                SecureLogger.error("❌ Notification frame length \(frameLength) invalid (cap=\(maxFrameLength)); resetting stream", category: .session)
+                resetState()
+                didReset = true
+                break
+            }
+
+            if buffer.count < frameLength {
+                let remaining = frameLength - buffer.count
+                if pendingFrameStartedAt == nil || frameLength != pendingFrameExpectedLength {
+                    pendingFrameStartedAt = now
+                    pendingFrameExpectedLength = frameLength
+                } else if let started = pendingFrameStartedAt {
+                    let elapsed = now.uptimeNanoseconds - started.uptimeNanoseconds
+                    let threshold = UInt64(TransportConfig.bleAssemblerStallResetMs) * 1_000_000
+                    if elapsed >= threshold {
+                        SecureLogger.debug("📉 Resetting notification assembler after waiting \(remaining)B for \(TransportConfig.bleAssemblerStallResetMs)ms", category: .session)
+                        resetState()
+                        didReset = true
+                    } else {
+                        SecureLogger.debug("⌛ Waiting for remaining \(remaining)B to complete BLE frame", category: .session)
+                    }
+                }
+                break
+            }
+
+            pendingFrameStartedAt = nil
+            pendingFrameExpectedLength = 0
+
+            let frame = Data(buffer.prefix(frameLength))
+            frames.append(frame)
+            buffer.removeFirst(frameLength)
+        }
+
+        if !buffer.isEmpty, buffer.allSatisfy({ $0 == 0 }) {
+            resetState()
+        }
+
+        return (frames, dropped, didReset)
+    }
+}

bitchat/Services/PrivateChatManager.swift

@@ -6,31 +6,187 @@
 // This is free and unencumbered software released into the public domain.
 //
 
+import BitLogger
+import BitFoundation
 import Foundation
 import SwiftUI
 
 /// Manages all private chat functionality
-class PrivateChatManager: ObservableObject {
-    @Published var privateChats: [String: [BitchatMessage]] = [:]
-    @Published var selectedPeer: String? = nil
-    @Published var unreadMessages: Set<String> = []
-    
+final class PrivateChatManager: ObservableObject {
+    @Published var privateChats: [PeerID: [BitchatMessage]] = [:]
+    @Published var selectedPeer: PeerID? = nil
+    @Published var unreadMessages: Set<PeerID> = []
+
     private var selectedPeerFingerprint: String? = nil
     var sentReadReceipts: Set<String> = []  // Made accessible for ChatViewModel
-    
+
     weak var meshService: Transport?
     // Route acks/receipts via MessageRouter (chooses mesh or Nostr)
     weak var messageRouter: MessageRouter?
-    
+    // Peer service for looking up peer info during consolidation
+    weak var unifiedPeerService: UnifiedPeerService?
+
     init(meshService: Transport? = nil) {
         self.meshService = meshService
     }
 
     // Cap for messages stored per private chat
     private let privateChatCap = TransportConfig.privateChatCap
+
+    // MARK: - Message Consolidation
+
+    /// Consolidates messages from different peer ID representations into a single chat.
+    /// This ensures messages from stable Noise keys and temporary Nostr peer IDs are merged.
+    /// - Parameters:
+    ///   - peerID: The target peer ID to consolidate messages into
+    ///   - peerNickname: The peer's display name (lowercased for matching)
+    ///   - persistedReadReceipts: The persisted read receipts set from ChatViewModel (UserDefaults-backed)
+    /// - Returns: True if any unread messages were found during consolidation
+    @MainActor
+    func consolidateMessages(for peerID: PeerID, peerNickname: String, persistedReadReceipts: Set<String>) -> Bool {
+        guard let meshService = meshService else { return false }
+        var hasUnreadMessages = false
+
+        // 1. Consolidate from stable Noise key (64-char hex)
+        if let peer = unifiedPeerService?.getPeer(by: peerID) {
+            let noiseKeyHex = PeerID(hexData: peer.noisePublicKey)
+
+            if noiseKeyHex != peerID, let nostrMessages = privateChats[noiseKeyHex], !nostrMessages.isEmpty {
+                if privateChats[peerID] == nil {
+                    privateChats[peerID] = []
+                }
+
+                let existingMessageIds = Set(privateChats[peerID]?.map { $0.id } ?? [])
+                for message in nostrMessages {
+                    if !existingMessageIds.contains(message.id) {
+                        // Update senderPeerID for correct read receipts
+                        let updatedMessage = BitchatMessage(
+                            id: message.id,
+                            sender: message.sender,
+                            content: message.content,
+                            timestamp: message.timestamp,
+                            isRelay: message.isRelay,
+                            originalSender: message.originalSender,
+                            isPrivate: message.isPrivate,
+                            recipientNickname: message.recipientNickname,
+                            senderPeerID: message.senderPeerID == meshService.myPeerID ? meshService.myPeerID : peerID,
+                            mentions: message.mentions,
+                            deliveryStatus: message.deliveryStatus
+                        )
+                        privateChats[peerID]?.append(updatedMessage)
+
+                        // Check for recent unread messages (< 60s, not sent by us, not already read)
+                        // Use persistedReadReceipts to correctly identify already-read messages after app restart
+                        if message.senderPeerID != meshService.myPeerID {
+                            let messageAge = Date().timeIntervalSince(message.timestamp)
+                            if messageAge < 60 && !persistedReadReceipts.contains(message.id) {
+                                hasUnreadMessages = true
+                            }
+                        }
+                    }
+                }
+
+                privateChats[peerID]?.sort { $0.timestamp < $1.timestamp }
+
+                if hasUnreadMessages {
+                    unreadMessages.insert(peerID)
+                } else if unreadMessages.contains(noiseKeyHex) {
+                    unreadMessages.remove(noiseKeyHex)
+                }
+
+                privateChats.removeValue(forKey: noiseKeyHex)
+            }
+        }
+
+        // 2. Consolidate from temporary Nostr peer IDs (nostr_* prefixed)
+        let normalizedNickname = peerNickname.lowercased()
+        var tempPeerIDsToConsolidate: [PeerID] = []
+
+        for (storedPeerID, messages) in privateChats {
+            if storedPeerID.isGeoDM && storedPeerID != peerID {
+                let nicknamesMatch = messages.allSatisfy { $0.sender.lowercased() == normalizedNickname }
+                if nicknamesMatch && !messages.isEmpty {
+                    tempPeerIDsToConsolidate.append(storedPeerID)
+                }
+            }
+        }
+
+        if !tempPeerIDsToConsolidate.isEmpty {
+            if privateChats[peerID] == nil {
+                privateChats[peerID] = []
+            }
+
+            let existingMessageIds = Set(privateChats[peerID]?.map { $0.id } ?? [])
+            var consolidatedCount = 0
+            var hadUnreadTemp = false
+
+            for tempPeerID in tempPeerIDsToConsolidate {
+                if unreadMessages.contains(tempPeerID) {
+                    hadUnreadTemp = true
+                }
+
+                if let tempMessages = privateChats[tempPeerID] {
+                    for message in tempMessages {
+                        if !existingMessageIds.contains(message.id) {
+                            let updatedMessage = BitchatMessage(
+                                id: message.id,
+                                sender: message.sender,
+                                content: message.content,
+                                timestamp: message.timestamp,
+                                isRelay: message.isRelay,
+                                originalSender: message.originalSender,
+                                isPrivate: message.isPrivate,
+                                recipientNickname: message.recipientNickname,
+                                senderPeerID: peerID,
+                                mentions: message.mentions,
+                                deliveryStatus: message.deliveryStatus
+                            )
+                            privateChats[peerID]?.append(updatedMessage)
+                            consolidatedCount += 1
+                        }
+                    }
+                    privateChats.removeValue(forKey: tempPeerID)
+                    unreadMessages.remove(tempPeerID)
+                }
+            }
+
+            if hadUnreadTemp {
+                unreadMessages.insert(peerID)
+                hasUnreadMessages = true
+                SecureLogger.debug("📬 Transferred unread status from temp peer IDs to \(peerID)", category: .session)
+            }
+
+            if consolidatedCount > 0 {
+                privateChats[peerID]?.sort { $0.timestamp < $1.timestamp }
+                SecureLogger.info("📥 Consolidated \(consolidatedCount) Nostr messages from temporary peer IDs to \(peerNickname)", category: .session)
+            }
+        }
+
+        return hasUnreadMessages
+    }
+
+    /// Syncs the read receipt tracking between manager and view model for sent messages
+    @MainActor
+    func syncReadReceiptsForSentMessages(peerID: PeerID, nickname: String, externalReceipts: inout Set<String>) {
+        guard let messages = privateChats[peerID] else { return }
+
+        for message in messages {
+            if message.sender == nickname {
+                if let status = message.deliveryStatus {
+                    switch status {
+                    case .read, .delivered:
+                        externalReceipts.insert(message.id)
+                        sentReadReceipts.insert(message.id)
+                    case .failed, .partiallyDelivered, .sending, .sent:
+                        break
+                    }
+                }
+            }
+        }
+    }
     
     /// Start a private chat with a peer
-    func startChat(with peerID: String) {
+    func startChat(with peerID: PeerID) {
         selectedPeer = peerID
         
         // Store fingerprint for persistence across reconnections
@@ -52,109 +208,33 @@ class PrivateChatManager: ObservableObject {
         selectedPeer = nil
         selectedPeerFingerprint = nil
     }
-    
-    /// Send a private message
-    func sendMessage(_ content: String, to peerID: String) {
-        guard let meshService = meshService,
-              let peerNickname = meshService.peerNickname(peerID: peerID) else {
-            return
-        }
-        
-        let messageID = UUID().uuidString
-        
-        // Create local message
-        let message = BitchatMessage(
-            id: messageID,
-            sender: meshService.myNickname,
-            content: content,
-            timestamp: Date(),
-            isRelay: false,
-            originalSender: nil,
-            isPrivate: true,
-            recipientNickname: peerNickname,
-            senderPeerID: meshService.myPeerID,
-            mentions: nil,
-            deliveryStatus: .sending
-        )
-        
-        // Add to chat
-        if privateChats[peerID] == nil { privateChats[peerID] = [] }
-        privateChats[peerID]?.append(message)
-        // Enforce per-chat cap on local append
-        if var arr = privateChats[peerID], arr.count > privateChatCap {
-            let remove = arr.count - privateChatCap
-            arr.removeFirst(remove)
-            privateChats[peerID] = arr
-        }
-        
-        // Send via mesh service
-        meshService.sendPrivateMessage(content, to: peerID, recipientNickname: peerNickname, messageID: messageID)
-    }
-    
-    /// Handle incoming private message
-    func handleIncomingMessage(_ message: BitchatMessage) {
-        guard let senderPeerID = message.senderPeerID else { return }
-        
-        // Initialize chat if needed
-        if privateChats[senderPeerID] == nil {
-            privateChats[senderPeerID] = []
-        }
-        
-        // Deduplicate by ID: replace existing message if present, else append
-        if let idx = privateChats[senderPeerID]?.firstIndex(where: { $0.id == message.id }) {
-            privateChats[senderPeerID]?[idx] = message
-        } else {
-            privateChats[senderPeerID]?.append(message)
-        }
-
-        // Sanitize chat to avoid duplicate IDs and sort by timestamp
-        sanitizeChat(for: senderPeerID)
-        // Enforce cap after sanitize
-        if var arr = privateChats[senderPeerID], arr.count > privateChatCap {
-            let remove = arr.count - privateChatCap
-            arr.removeFirst(remove)
-            privateChats[senderPeerID] = arr
-        }
-        
-        // Mark as unread if not in this chat
-        if selectedPeer != senderPeerID {
-            unreadMessages.insert(senderPeerID)
-            
-            // Avoid notifying for messages already marked as read (dup/resubscribe cases)
-            if !sentReadReceipts.contains(message.id) {
-                NotificationService.shared.sendPrivateMessageNotification(
-                    from: message.sender,
-                    message: message.content,
-                    peerID: senderPeerID
-                )
-            }
-        } else {
-            // Send read receipt if viewing this chat
-            sendReadReceipt(for: message)
-        }
-    }
 
     /// Remove duplicate messages by ID and keep chronological order
-    func sanitizeChat(for peerID: String) {
+    func sanitizeChat(for peerID: PeerID) {
         guard let arr = privateChats[peerID] else { return }
-        var seen = Set<String>()
+        if arr.count <= 1 {
+            return
+        }
+
+        var indexByID: [String: Int] = [:]
+        indexByID.reserveCapacity(arr.count)
         var deduped: [BitchatMessage] = []
+        deduped.reserveCapacity(arr.count)
+
         for msg in arr.sorted(by: { $0.timestamp < $1.timestamp }) {
-            if !seen.contains(msg.id) {
-                seen.insert(msg.id)
-                deduped.append(msg)
+            if let existing = indexByID[msg.id] {
+                deduped[existing] = msg
             } else {
-                // Replace previous with the latest occurrence (which is later in sort)
-                if let index = deduped.firstIndex(where: { $0.id == msg.id }) {
-                    deduped[index] = msg
-                }
+                indexByID[msg.id] = deduped.count
+                deduped.append(msg)
             }
         }
+
         privateChats[peerID] = deduped
     }
     
     /// Mark messages from a peer as read
-    func markAsRead(from peerID: String) {
+    func markAsRead(from peerID: PeerID) {
         unreadMessages.remove(peerID)
         
         // Send read receipts for unread messages that haven't been sent yet
@@ -167,48 +247,6 @@ class PrivateChatManager: ObservableObject {
         }
     }
     
-    /// Update the selected peer if fingerprint matches (for reconnections)
-    func updateSelectedPeer(peers: [String: String]) {
-        guard let fingerprint = selectedPeerFingerprint else { return }
-        
-        // Find peer with matching fingerprint
-        for (peerID, _) in peers {
-            if meshService?.getFingerprint(for: peerID) == fingerprint {
-                selectedPeer = peerID
-                break
-            }
-        }
-    }
-    
-    /// Get chat messages for current context
-    func getCurrentMessages() -> [BitchatMessage] {
-        guard let peer = selectedPeer else { return [] }
-        return privateChats[peer] ?? []
-    }
-    
-    /// Clear a private chat
-    func clearChat(with peerID: String) {
-        privateChats[peerID]?.removeAll()
-    }
-    
-    /// Handle delivery acknowledgment
-    func handleDeliveryAck(messageID: String, from peerID: String) {
-        guard privateChats[peerID] != nil else { return }
-        
-        if let index = privateChats[peerID]?.firstIndex(where: { $0.id == messageID }) {
-            privateChats[peerID]?[index].deliveryStatus = .delivered(to: "recipient", at: Date())
-        }
-    }
-    
-    /// Handle read receipt
-    func handleReadReceipt(messageID: String, from peerID: String) {
-        guard privateChats[peerID] != nil else { return }
-        
-        if let index = privateChats[peerID]?.firstIndex(where: { $0.id == messageID }) {
-            privateChats[peerID]?[index].deliveryStatus = .read(by: "recipient", at: Date())
-        }
-    }
-    
     // MARK: - Private Methods
     
     private func sendReadReceipt(for message: BitchatMessage) {
@@ -222,14 +260,13 @@ class PrivateChatManager: ObservableObject {
         // Create read receipt using the simplified method
         let receipt = ReadReceipt(
             originalMessageID: message.id,
-            readerID: meshService?.myPeerID ?? "",
+            readerID: meshService?.myPeerID ?? PeerID(str: ""),
             readerNickname: meshService?.myNickname ?? ""
         )
         
         // Route via MessageRouter to avoid handshakeRequired spam when session isn't established
         if let router = messageRouter {
-            SecureLogger.log("PrivateChatManager: sending READ ack for \(message.id.prefix(8))… to \(senderPeerID.prefix(8))… via router",
-                            category: SecureLogger.session, level: .debug)
+            SecureLogger.debug("PrivateChatManager: sending READ ack for \(message.id.prefix(8))… to \(senderPeerID.id.prefix(8))… via router", category: .session)
             Task { @MainActor in
                 router.sendReadReceipt(receipt, to: senderPeerID)
             }

bitchat/Services/RelayController.swift

@@ -13,18 +13,23 @@ struct RelayController {
                        senderIsSelf: Bool,
                        isEncrypted: Bool,
                        isDirectedEncrypted: Bool,
+                       isFragment: Bool,
                        isDirectedFragment: Bool,
                        isHandshake: Bool,
                        isAnnounce: Bool,
                        degree: Int,
                        highDegreeThreshold: Int) -> RelayDecision {
+        let ttlCap = min(ttl, TransportConfig.messageTTLDefault)
+
         // Suppress obvious non-relays
-        if ttl <= 1 || senderIsSelf { return RelayDecision(shouldRelay: false, newTTL: ttl, delayMs: 0) }
+        if ttlCap <= 1 || senderIsSelf {
+            return RelayDecision(shouldRelay: false, newTTL: ttlCap, delayMs: 0)
+        }
 
         // For session-critical or directed traffic, be deterministic and reliable
         if isHandshake || isDirectedFragment || isDirectedEncrypted {
             // Always relay with no TTL cap for these types
-            let newTTL = (ttl &- 1)
+            let newTTL = ttlCap &- 1
             // Slight jitter to desynchronize without adding too much latency
             // Tighter for faster multi-hop handshakes and directed DMs
             let delayRange: ClosedRange<Int> = isHandshake ? 10...35 : 20...60
@@ -32,28 +37,27 @@ struct RelayController {
             return RelayDecision(shouldRelay: true, newTTL: newTTL, delayMs: delayMs)
         }
 
-        // Degree-aware probability to reduce floods in dense graphs (broadcast/public)
-        let baseProb: Double
-        switch degree {
-        case 0...2: baseProb = 1.0
-        case 3...4: baseProb = 0.9
-        case 5...6: baseProb = 0.7
-        case 7...9: baseProb = 0.55
-        default:    baseProb = 0.45
+        if isFragment {
+            let ttlLimit = min(ttlCap, TransportConfig.bleFragmentRelayTtlCap)
+            guard ttlLimit > 1 else {
+                return RelayDecision(shouldRelay: false, newTTL: ttlLimit, delayMs: 0)
+            }
+            let newTTL = ttlLimit &- 1
+            let delayMs = Int.random(in: TransportConfig.bleFragmentRelayMinDelayMs...TransportConfig.bleFragmentRelayMaxDelayMs)
+            return RelayDecision(shouldRelay: true, newTTL: newTTL, delayMs: delayMs)
         }
-        let prob = baseProb
-        let shouldRelay = Double.random(in: 0...1) <= prob
 
         // TTL clamping for broadcast
-        // - Dense graphs: keep very low to avoid floods
-        // - Sparse graphs: allow slightly longer reach for multi-hop discovery
-        // - Announces in sparse graphs get a bit more headroom
-        let ttlCap: UInt8 = {
-            if degree >= highDegreeThreshold { return 3 }
-            return isAnnounce ? 7 : 6
+        // - Dense graphs: keep lower but still allow multi-hop bridging
+        // - Announces get a bit more headroom
+        let ttlLimit: UInt8 = {
+            if degree >= highDegreeThreshold {
+                return max(UInt8(2), min(ttlCap, UInt8(5)))
+            }
+            let preferred = UInt8(isAnnounce ? 7 : 6)
+            return max(UInt8(2), min(ttlCap, preferred))
         }()
-        let clamped = max(1, min(ttl, ttlCap))
-        let newTTL = clamped &- 1
+        let newTTL = ttlLimit &- 1
 
         // Wider jitter window to allow duplicate suppression to win more often
         // For sparse graphs (<=2), relay quickly to avoid cancellation races
@@ -64,6 +68,6 @@ struct RelayController {
         case 6...9: delayMs = Int.random(in: 80...180)
         default:    delayMs = Int.random(in: 100...220)
         }
-        return RelayDecision(shouldRelay: shouldRelay, newTTL: newTTL, delayMs: delayMs)
+        return RelayDecision(shouldRelay: true, newTTL: newTTL, delayMs: delayMs)
     }
 }

bitchat/Services/TransferProgressManager.swift

@@ -0,0 +1,65 @@
+import Foundation
+import Combine
+
+/// Centralized progress bus for Bluetooth file transfers.
+/// Emits Combine events consumed by ChatViewModel to update UI progress indicators.
+final class TransferProgressManager {
+    static let shared = TransferProgressManager()
+
+    enum Event {
+        case started(id: String, totalFragments: Int)
+        case updated(id: String, sentFragments: Int, totalFragments: Int)
+        case completed(id: String, totalFragments: Int)
+        case cancelled(id: String, sentFragments: Int, totalFragments: Int)
+    }
+
+    private let subject = PassthroughSubject<Event, Never>()
+    private let queue = DispatchQueue(label: "com.bitchat.transfer-progress", attributes: .concurrent)
+    private var states: [String: (sent: Int, total: Int)] = [:]
+
+    var publisher: AnyPublisher<Event, Never> {
+        subject.eraseToAnyPublisher()
+    }
+
+    func start(id: String, totalFragments: Int) {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            self.states[id] = (sent: 0, total: totalFragments)
+            self.subject.send(.started(id: id, totalFragments: totalFragments))
+        }
+    }
+
+    func recordFragmentSent(id: String) {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self, var state = self.states[id] else { return }
+            state.sent = min(state.sent + 1, state.total)
+            self.states[id] = state
+            self.subject.send(.updated(id: id, sentFragments: state.sent, totalFragments: state.total))
+            if state.sent >= state.total {
+                self.states.removeValue(forKey: id)
+                self.subject.send(.completed(id: id, totalFragments: state.total))
+            }
+        }
+    }
+
+    func cancel(id: String) {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self, let state = self.states.removeValue(forKey: id) else { return }
+            self.subject.send(.cancelled(id: id, sentFragments: state.sent, totalFragments: state.total))
+        }
+    }
+
+    func reset(id: String) {
+        queue.async(flags: .barrier) { [weak self] in
+            self?.states.removeValue(forKey: id)
+        }
+    }
+
+    func snapshot(id: String) -> (sent: Int, total: Int)? {
+        var result: (sent: Int, total: Int)?
+        queue.sync {
+            result = states[id]
+        }
+        return result
+    }
+}

bitchat/Services/Transport.swift

@@ -1,10 +1,11 @@
+import BitFoundation
 import Foundation
 import Combine
 
 /// Abstract transport interface used by ChatViewModel and services.
 /// BLEService implements this protocol; a future Nostr transport can too.
 struct TransportPeerSnapshot: Equatable, Hashable {
-    let id: String
+    let peerID: PeerID
     let nickname: String
     let isConnected: Bool
     let noisePublicKey: Data?
@@ -12,13 +13,17 @@ struct TransportPeerSnapshot: Equatable, Hashable {
 }
 
 protocol Transport: AnyObject {
-    // Peer events (preferred over publishers for UI)
-    var peerEventsDelegate: TransportPeerEventsDelegate? { get set }
     // Event sink
     var delegate: BitchatDelegate? { get set }
+    // Peer events (preferred over publishers for UI)
+    var peerEventsDelegate: TransportPeerEventsDelegate? { get set }
+    
+    // Peer snapshots (for non-UI services)
+    var peerSnapshotPublisher: AnyPublisher<[TransportPeerSnapshot], Never> { get }
+    func currentPeerSnapshots() -> [TransportPeerSnapshot]
 
     // Identity
-    var myPeerID: String { get }
+    var myPeerID: PeerID { get }
     var myNickname: String { get }
     func setNickname(_ nickname: String)
 
@@ -28,37 +33,51 @@ protocol Transport: AnyObject {
     func emergencyDisconnectAll()
 
     // Connectivity and peers
-    func isPeerConnected(_ peerID: String) -> Bool
-    func isPeerReachable(_ peerID: String) -> Bool
-    func peerNickname(peerID: String) -> String?
-    func getPeerNicknames() -> [String: String]
+    func isPeerConnected(_ peerID: PeerID) -> Bool
+    func isPeerReachable(_ peerID: PeerID) -> Bool
+    func peerNickname(peerID: PeerID) -> String?
+    func getPeerNicknames() -> [PeerID: String]
 
     // Protocol utilities
-    func getFingerprint(for peerID: String) -> String?
-    func getNoiseSessionState(for peerID: String) -> LazyHandshakeState
-    func triggerHandshake(with peerID: String)
+    func getFingerprint(for peerID: PeerID) -> String?
+    func getNoiseSessionState(for peerID: PeerID) -> LazyHandshakeState
+    func triggerHandshake(with peerID: PeerID)
     func getNoiseService() -> NoiseEncryptionService
 
     // Messaging
     func sendMessage(_ content: String, mentions: [String])
-    func sendPrivateMessage(_ content: String, to peerID: String, recipientNickname: String, messageID: String)
-    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: String)
-    func sendFavoriteNotification(to peerID: String, isFavorite: Bool)
+    func sendMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date)
+    func sendPrivateMessage(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String)
+    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID)
+    func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool)
     func sendBroadcastAnnounce()
-    func sendDeliveryAck(for messageID: String, to peerID: String)
+    func sendDeliveryAck(for messageID: String, to peerID: PeerID)
+    func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String)
+    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String)
+    func cancelTransfer(_ transferId: String)
 
     // QR verification (optional for transports)
-    func sendVerifyChallenge(to peerID: String, noiseKeyHex: String, nonceA: Data)
-    func sendVerifyResponse(to peerID: String, noiseKeyHex: String, nonceA: Data)
+    func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
+    func sendVerifyResponse(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
 
-    // Peer snapshots (for non-UI services)
-    var peerSnapshotPublisher: AnyPublisher<[TransportPeerSnapshot], Never> { get }
-    func currentPeerSnapshots() -> [TransportPeerSnapshot]
+    // Pending file management (BCH-01-002: files held in memory until user accepts)
+    func acceptPendingFile(id: String) -> URL?
+    func declinePendingFile(id: String)
 }
 
 extension Transport {
-    func sendVerifyChallenge(to peerID: String, noiseKeyHex: String, nonceA: Data) {}
-    func sendVerifyResponse(to peerID: String, noiseKeyHex: String, nonceA: Data) {}
+    func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {}
+    func sendVerifyResponse(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {}
+    func sendFileBroadcast(_ packet: BitchatFilePacket, transferId: String) {}
+    func sendFilePrivate(_ packet: BitchatFilePacket, to peerID: PeerID, transferId: String) {}
+    func cancelTransfer(_ transferId: String) {}
+
+    func sendMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date) {
+        sendMessage(content, mentions: mentions)
+    }
+
+    func acceptPendingFile(id: String) -> URL? { nil }
+    func declinePendingFile(id: String) {}
 }
 
 protocol TransportPeerEventsDelegate: AnyObject {

bitchat/Services/TransportConfig.swift

@@ -8,6 +8,10 @@ enum TransportConfig {
     static let messageTTLDefault: UInt8 = 7                 // Default TTL for mesh flooding
     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
+    static let bleFragmentRelayMinDelayMs: Int = 8          // Faster forwarding for media fragments
+    static let bleFragmentRelayMaxDelayMs: Int = 25         // Upper jitter bound for fragment relays
+    static let bleFragmentRelayTtlCap: UInt8 = 5            // Clamp fragment TTL to contain floods
 
     // UI / Storage Caps
     static let privateChatCap: Int = 1337
@@ -17,6 +21,7 @@ enum TransportConfig {
 
     // Timers
     static let networkResetGraceSeconds: TimeInterval = 600 // 10 minutes
+    static let networkNotificationCooldownSeconds: TimeInterval = 300 // 5 minutes
     static let basePublicFlushInterval: TimeInterval = 0.08  // ~12.5 fps batching
 
     // BLE duty/announce/connect
@@ -30,13 +35,19 @@ enum TransportConfig {
     static let bleDynamicRSSIThresholdDefault: Int = -90
     static let bleConnectionCandidatesMax: Int = 100
     static let blePendingWriteBufferCapBytes: Int = 1_000_000
-    static let blePendingNotificationsCapCount: Int = 20
+    static let bleNotificationAssemblerHardCapBytes: Int = 8 * 1024 * 1024
+    static let bleAssemblerStallResetMs: Int = 250
+    static let blePendingNotificationsCapCount: Int = 128
+    static let bleNotificationRetryDelayMs: Int = 25
+    static let bleNotificationRetryMaxAttempts: Int = 80
 
     // Nostr
     static let nostrReadAckInterval: TimeInterval = 0.35 // ~3 per second
 
     // UI thresholds
     static let uiLateInsertThreshold: TimeInterval = 15.0
+    // Geohash public chats are more sensitive to ordering; use a tighter threshold
+    static let uiLateInsertThresholdGeo: TimeInterval = 0.0
     static let uiProcessedNostrEventsCap: Int = 2000
     static let uiChannelInactivityThresholdSeconds: TimeInterval = 9 * 60
     
@@ -60,6 +71,7 @@ enum TransportConfig {
     static let uiAnimationMediumSeconds: TimeInterval = 0.2
     static let uiAnimationSidebarSeconds: TimeInterval = 0.25
     static let uiRecentCutoffFiveMinutesSeconds: TimeInterval = 5 * 60
+    static let uiMeshEmptyConfirmationSeconds: TimeInterval = 30.0
 
     // BLE maintenance & thresholds
     static let bleMaintenanceInterval: TimeInterval = 5.0
@@ -85,11 +97,12 @@ enum TransportConfig {
     // Keep scanning fully ON when we saw traffic very recently
     static let bleRecentTrafficForceScanSeconds: TimeInterval = 10.0
     static let bleThreadSleepWriteShortDelaySeconds: TimeInterval = 0.05
-    static let bleExpectedWritePerFragmentMs: Int = 8
-    static let bleExpectedWriteMaxMs: Int = 2000
-    // Faster fragment pacing; use slightly tighter spacing for directed trains
-    static let bleFragmentSpacingMs: Int = 5
-    static let bleFragmentSpacingDirectedMs: Int = 4
+    static let bleExpectedWritePerFragmentMs: Int = 20
+    static let bleExpectedWriteMaxMs: Int = 5000
+    // Fragment pacing: Conservative spacing to prevent BLE buffer overflow
+    // Aggressive pacing causes packet loss; needs 25-30ms between fragments for reliable delivery
+    static let bleFragmentSpacingMs: Int = 30
+    static let bleFragmentSpacingDirectedMs: Int = 25
     static let bleAnnounceIntervalSeconds: TimeInterval = 4.0
     static let bleDutyOnDurationDense: TimeInterval = 3.0
     static let bleDutyOffDurationDense: TimeInterval = 15.0
@@ -101,7 +114,7 @@ enum TransportConfig {
     // Location
     static let locationDistanceFilterMeters: Double = 1000
     // Live (channel sheet open) distance threshold for meaningful updates
-    static let locationDistanceFilterLiveMeters: Double = 21.0
+    static let locationDistanceFilterLiveMeters: Double = 10.0
     static let locationLiveRefreshInterval: TimeInterval = 5.0
 
     // Notifications (geohash)
@@ -120,9 +133,6 @@ enum TransportConfig {
     static let nostrShortKeyDisplayLength: Int = 8
     static let nostrConvKeyPrefixLength: Int = 16
 
-    // Compression
-    static let compressionThresholdBytes: Int = 100
-
     // Message deduplication
     static let messageDedupMaxAgeSeconds: TimeInterval = 300
     static let messageDedupMaxCount: Int = 1000
@@ -139,6 +149,9 @@ enum TransportConfig {
 
     // Geo relay directory
     static let geoRelayFetchIntervalSeconds: TimeInterval = 60 * 60 * 24
+    static let geoRelayRefreshCheckIntervalSeconds: TimeInterval = 60 * 60
+    static let geoRelayRetryInitialSeconds: TimeInterval = 60
+    static let geoRelayRetryMaxSeconds: TimeInterval = 60 * 60
 
     // BLE operational delays
     static let bleInitialAnnounceDelaySeconds: TimeInterval = 0.6
@@ -148,6 +161,14 @@ enum TransportConfig {
     static let blePostAnnounceDelaySeconds: TimeInterval = 0.4
     static let bleForceAnnounceMinIntervalSeconds: TimeInterval = 0.15
 
+    // BCH-01-004: Rate-limiting for subscription-triggered announces
+    // Prevents rapid enumeration attacks by rate-limiting announce responses
+    static let bleSubscriptionRateLimitMinSeconds: TimeInterval = 2.0       // Minimum interval between announces per central
+    static let bleSubscriptionRateLimitBackoffFactor: Double = 2.0          // Exponential backoff multiplier
+    static let bleSubscriptionRateLimitMaxBackoffSeconds: TimeInterval = 30.0  // Maximum backoff period
+    static let bleSubscriptionRateLimitWindowSeconds: TimeInterval = 60.0   // Window for tracking subscription attempts
+    static let bleSubscriptionRateLimitMaxAttempts: Int = 5                 // Max attempts before extended cooldown
+
     // Store-and-forward for directed packets at relays
     static let bleDirectedSpoolWindowSeconds: TimeInterval = 15.0
 
@@ -186,7 +207,21 @@ enum TransportConfig {
     static let uiWindowStepCount: Int = 200
 
     // Share extension
-    static let uiShareExtensionDismissDelaySeconds: TimeInterval = 0.3
+    static let uiShareExtensionDismissDelaySeconds: TimeInterval = 2.0
     static let uiShareAcceptWindowSeconds: TimeInterval = 30.0
     static let uiMigrationCutoffSeconds: TimeInterval = 24 * 60 * 60
+
+    // Gossip Sync Configuration
+    static let syncSeenCapacity: Int = 1000
+    static let syncGCSMaxBytes: Int = 400
+    static let syncGCSTargetFpr: Double = 0.01
+    static let syncMaxMessageAgeSeconds: TimeInterval = 900
+    static let syncMaintenanceIntervalSeconds: TimeInterval = 30.0
+    static let syncStalePeerCleanupIntervalSeconds: TimeInterval = 60.0
+    static let syncStalePeerTimeoutSeconds: TimeInterval = 60.0
+    static let syncFragmentCapacity: Int = 600
+    static let syncFileTransferCapacity: Int = 200
+    static let syncFragmentIntervalSeconds: TimeInterval = 30.0
+    static let syncFileTransferIntervalSeconds: TimeInterval = 60.0
+    static let syncMessageIntervalSeconds: TimeInterval = 15.0
 }

bitchat/Services/UnifiedPeerService.swift

@@ -6,35 +6,44 @@
 //  This is free and unencumbered software released into the public domain.
 //
 
+import BitLogger
+import BitFoundation
 import Foundation
 import Combine
 import SwiftUI
-import CryptoKit
 
 /// Single source of truth for peer state, combining mesh connectivity and favorites
 @MainActor
-class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
+final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     
     // MARK: - Published Properties
     
     @Published private(set) var peers: [BitchatPeer] = []
-    @Published private(set) var connectedPeerIDs: Set<String> = []
+    @Published private(set) var connectedPeerIDs: Set<PeerID> = []
     @Published private(set) var favorites: [BitchatPeer] = []
     @Published private(set) var mutualFavorites: [BitchatPeer] = []
     
     // MARK: - Private Properties
     
-    private var peerIndex: [String: BitchatPeer] = [:]
-    private var fingerprintCache: [String: String] = [:]  // peerID -> fingerprint
+    private var peerIndex: [PeerID: BitchatPeer] = [:]
+    private var fingerprintCache: [PeerID: String] = [:]
     private let meshService: Transport
+    private let idBridge: NostrIdentityBridge
+    private let identityManager: SecureIdentityStateManagerProtocol
     weak var messageRouter: MessageRouter?
     private let favoritesService = FavoritesPersistenceService.shared
     private var cancellables = Set<AnyCancellable>()
     
     // MARK: - Initialization
     
-    init(meshService: Transport) {
+    init(
+        meshService: Transport,
+        idBridge: NostrIdentityBridge,
+        identityManager: SecureIdentityStateManagerProtocol
+    ) {
         self.meshService = meshService
+        self.idBridge = idBridge
+        self.identityManager = identityManager
         
         // Subscribe to changes from both services
         setupSubscriptions()
@@ -75,12 +84,12 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         let favorites = favoritesService.favorites
         
         var enrichedPeers: [BitchatPeer] = []
-        var connected: Set<String> = []
-        var addedPeerIDs: Set<String> = []
+        var connected: Set<PeerID> = []
+        var addedPeerIDs: Set<PeerID> = []
         
         // Phase 1: Add all mesh peers (connected and reachable)
         for peerInfo in meshPeers {
-            let peerID = peerInfo.id
+            let peerID = peerInfo.peerID
             guard peerID != meshService.myPeerID else { continue }  // Never add self
             
             let peer = buildPeerFromMesh(
@@ -101,7 +110,7 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         
         // Phase 2: Add offline favorites that we actively favorite
         for (favoriteKey, favorite) in favorites where favorite.isFavorite {
-            let peerID = favoriteKey.hexEncodedString()
+            let peerID = PeerID(hexData: favoriteKey)
             
             // Skip if already added (connected peer)
             if addedPeerIDs.contains(peerID) { continue }
@@ -135,10 +144,10 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         // Phase 4: Build subsets and indices
         var favoritesList: [BitchatPeer] = []
         var mutualsList: [BitchatPeer] = []
-        var newIndex: [String: BitchatPeer] = [:]
+        var newIndex: [PeerID: BitchatPeer] = [:]
         
         for peer in enrichedPeers {
-            newIndex[peer.id] = peer
+            newIndex[peer.peerID] = peer
             
             if peer.isFavorite {
                 favoritesList.append(peer)
@@ -174,7 +183,7 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         // Determine reachability based on lastSeen and identity trust
         let now = Date()
         let fingerprint = peerInfo.noisePublicKey?.sha256Fingerprint()
-        let isVerified = fingerprint.map { SecureIdentityStateManager.shared.isVerified(fingerprint: $0) } ?? false
+        let isVerified = fingerprint.map { identityManager.isVerified(fingerprint: $0) } ?? false
         let isFav = peerInfo.noisePublicKey.flatMap { favorites[$0]?.isFavorite } ?? false
         let retention: TimeInterval = (isVerified || isFav) ? TransportConfig.bleReachabilityRetentionVerifiedSeconds : TransportConfig.bleReachabilityRetentionUnverifiedSeconds
         // A peer is reachable if we recently saw them AND we are attached to the mesh
@@ -182,7 +191,7 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         let isReachable = peerInfo.isConnected ? true : (withinRetention && meshAttached)
 
         var peer = BitchatPeer(
-            id: peerInfo.id,
+            peerID: peerInfo.peerID,
             noisePublicKey: peerInfo.noisePublicKey ?? Data(),
             nickname: peerInfo.nickname,
             lastSeen: peerInfo.lastSeen,
@@ -195,31 +204,6 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
            let favoriteStatus = favorites[noiseKey] {
             peer.favoriteStatus = favoriteStatus
             peer.nostrPublicKey = favoriteStatus.peerNostrPublicKey
-        } else {
-            // Check by nickname for reconnected peers
-            let favoriteByNickname = favorites.values.first { 
-                $0.peerNickname == peerInfo.nickname 
-            }
-            
-            if let favorite = favoriteByNickname,
-               let noiseKey = peerInfo.noisePublicKey {
-                SecureLogger.log(
-                    "🔄 Found favorite for '\(peerInfo.nickname)' by nickname, updating noise key",
-                    category: SecureLogger.session,
-                    level: .debug
-                )
-                
-                // Update the favorite's key in persistence
-                favoritesService.updateNoisePublicKey(
-                    from: favorite.peerNoisePublicKey,
-                    to: noiseKey,
-                    peerNickname: peerInfo.nickname
-                )
-                
-                // Get updated favorite
-                peer.favoriteStatus = favoritesService.getFavoriteStatus(for: noiseKey)
-                peer.nostrPublicKey = peer.favoriteStatus?.peerNostrPublicKey ?? favorite.peerNostrPublicKey
-            }
         }
         
         return peer
@@ -227,10 +211,10 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     
     private func buildPeerFromFavorite(
         favorite: FavoritesPersistenceService.FavoriteRelationship,
-        peerID: String
+        peerID: PeerID
     ) -> BitchatPeer {
         var peer = BitchatPeer(
-            id: peerID,
+            peerID: peerID,
             noisePublicKey: favorite.peerNoisePublicKey,
             nickname: favorite.peerNickname,
             lastSeen: favorite.lastUpdated,
@@ -247,32 +231,27 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     // MARK: - Public Methods
     
     /// Get peer by ID
-    func getPeer(by id: String) -> BitchatPeer? {
-        return peerIndex[id]
+    func getPeer(by peerID: PeerID) -> BitchatPeer? {
+        return peerIndex[peerID]
     }
     
     /// Get peer ID for nickname
-    func getPeerID(for nickname: String) -> String? {
+    func getPeerID(for nickname: String) -> PeerID? {
         for peer in peers {
             if peer.displayName == nickname || peer.nickname == nickname {
-                return peer.id
+                return peer.peerID
             }
         }
         return nil
     }
     
-    /// Check if peer is online
-    func isOnline(_ peerID: String) -> Bool {
-        return connectedPeerIDs.contains(peerID)
-    }
-    
     /// Check if peer is blocked
-    func isBlocked(_ peerID: String) -> Bool {
+    func isBlocked(_ peerID: PeerID) -> Bool {
         // Get fingerprint
         guard let fingerprint = getFingerprint(for: peerID) else { return false }
         
         // Check SecureIdentityStateManager for block status
-        if let identity = SecureIdentityStateManager.shared.getSocialIdentity(for: fingerprint) {
+        if let identity = identityManager.getSocialIdentity(for: fingerprint) {
             return identity.isBlocked
         }
         
@@ -280,10 +259,9 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     }
     
     /// Toggle favorite status
-    func toggleFavorite(_ peerID: String) {
-        guard let peer = getPeer(by: peerID) else { 
-            SecureLogger.log("⚠️ Cannot toggle favorite - peer not found: \(peerID)", 
-                           category: SecureLogger.session, level: .warning)
+    func toggleFavorite(_ peerID: PeerID) {
+        guard let peer = getPeer(by: peerID) else {
+            SecureLogger.warning("⚠️ Cannot toggle favorite - peer not found: \(peerID)", category: .session)
             return 
         }
         
@@ -293,15 +271,13 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         var actualNickname = peer.nickname
         
         // Debug logging to understand the issue
-        SecureLogger.log("🔍 Toggle favorite - peer.nickname: '\(peer.nickname)', peer.displayName: '\(peer.displayName)', peerID: \(peerID)", 
-                       category: SecureLogger.session, level: .debug)
+        SecureLogger.debug("🔍 Toggle favorite - peer.nickname: '\(peer.nickname)', peer.displayName: '\(peer.displayName)', peerID: \(peerID)", category: .session)
         
         if actualNickname.isEmpty {
             // Try to get from mesh service's current peer list
             if let meshPeerNickname = meshService.peerNickname(peerID: peerID) {
                 actualNickname = meshPeerNickname
-                SecureLogger.log("🔍 Got nickname from mesh service: '\(actualNickname)'", 
-                               category: SecureLogger.session, level: .debug)
+                SecureLogger.debug("🔍 Got nickname from mesh service: '\(actualNickname)'", category: .session)
             }
         }
         
@@ -316,7 +292,7 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
             var peerNostrKey = peer.nostrPublicKey
             if peerNostrKey == nil {
                 // Try to get from NostrIdentityBridge association
-                peerNostrKey = NostrIdentityBridge.getNostrPublicKey(for: peer.noisePublicKey)
+                peerNostrKey = idBridge.getNostrPublicKey(for: peer.noisePublicKey)
             }
             
             // Add favorite
@@ -328,8 +304,7 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         }
         
         // Log the final nickname being saved
-        SecureLogger.log("⭐️ Toggled favorite for '\(finalNickname)' (peerID: \(peerID), was: \(wasFavorite), now: \(!wasFavorite))",
-                       category: SecureLogger.session, level: .debug)
+        SecureLogger.debug("⭐️ Toggled favorite for '\(finalNickname)' (peerID: \(peerID), was: \(wasFavorite), now: \(!wasFavorite))", category: .session)
         
         // Send favorite notification to the peer via router (mesh or Nostr)
         if let router = messageRouter {
@@ -348,39 +323,7 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         }
     }
     
-    /// Toggle blocked status
-    func toggleBlocked(_ peerID: String) {
-        guard let fingerprint = getFingerprint(for: peerID) else { return }
-        
-        // Get or create social identity
-        var identity = SecureIdentityStateManager.shared.getSocialIdentity(for: fingerprint)
-            ?? SocialIdentity(
-                fingerprint: fingerprint,
-                localPetname: nil,
-                claimedNickname: getPeer(by: peerID)?.displayName ?? "Unknown",
-                trustLevel: .unknown,
-                isFavorite: false,
-                isBlocked: false,
-                notes: nil
-            )
-        
-        // Toggle blocked status
-        identity.isBlocked = !identity.isBlocked
-        
-        // Can't be both favorite and blocked
-        if identity.isBlocked {
-            identity.isFavorite = false
-            // Also remove from favorites service
-            if let peer = getPeer(by: peerID) {
-                favoritesService.removeFavorite(peerNoisePublicKey: peer.noisePublicKey)
-            }
-        }
-        
-        SecureIdentityStateManager.shared.updateSocialIdentity(identity)
-    }
-    
-    /// Get fingerprint for peer ID
-    func getFingerprint(for peerID: String) -> String? {
+    func getFingerprint(for peerID: PeerID) -> String? {
         // Check cache first
         if let cached = fingerprintCache[peerID] {
             return cached
@@ -405,23 +348,13 @@ class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     // MARK: - Compatibility Methods (for easy migration)
     
     var allPeers: [BitchatPeer] { peers }
-    var connectedPeers: [String] { Array(connectedPeerIDs) }
-    var favoritePeers: Set<String> { 
-        Set(favorites.compactMap { getFingerprint(for: $0.id) })
+    var connectedPeers: Set<PeerID> { connectedPeerIDs }
+    var favoritePeers: Set<String> {
+        Set(favorites.compactMap { getFingerprint(for: $0.peerID) })
     }
     var blockedUsers: Set<String> {
         Set(peers.compactMap { peer in
-            isBlocked(peer.id) ? getFingerprint(for: peer.id) : nil
+            isBlocked(peer.peerID) ? getFingerprint(for: peer.peerID) : nil
         })
     }
 }
-
-// MARK: - Helper Extensions
-
-extension Data {
-    func sha256Fingerprint() -> String {
-        // Implementation matches existing fingerprint generation in NoiseEncryptionService
-        let hash = SHA256.hash(data: self)
-        return hash.map { String(format: "%02x", $0) }.joined()
-    }
-}

bitchat/Services/VerificationService.swift

@@ -1,5 +1,4 @@
 import Foundation
-import CryptoKit
 
 /// QR verification scaffolding: schema, signing, and basic challenge/response helpers.
 final class VerificationService {
@@ -95,7 +94,7 @@ final class VerificationService {
                                     nickname: payload.nickname,
                                     ts: payload.ts,
                                     nonceB64: payload.nonceB64,
-                                    sigHex: sig.map { String(format: "%02x", $0) }.joined())
+                                    sigHex: sig.hexEncodedString())
         let out = signed.toURLString()
         Cache.last = (nickname, npub, Date(), out)
         return out

bitchat/Sync/GCSFilter.swift

@@ -0,0 +1,237 @@
+import Foundation
+import CryptoKit
+
+// Golomb-Coded Set (GCS) filter utilities for sync.
+// Hashing:
+//  - Packet ID is 16 bytes (see PacketIdUtil). For GCS mapping, use h64 = first 8 bytes of SHA-256 over the 16-byte ID.
+//  - Map to [1, M) by computing (h64 % M) and remapping 0 -> 1 to avoid zero-length deltas.
+// Encoding (v1):
+//  - Sort mapped values ascending; encode deltas (first is v0, then vi - v{i-1}) as positive integers x >= 1.
+//  - Golomb-Rice with parameter P: q = (x - 1) >> P encoded as unary (q ones then a zero), then write P-bit remainder r = (x - 1) & ((1<<P)-1).
+//  - Bitstream is MSB-first within each byte.
+enum GCSFilter {
+    struct Params { let p: Int; let m: UInt32; let data: Data }
+
+    // Derive P from FPR (~ 1 / 2^P)
+    static func deriveP(targetFpr: Double) -> Int {
+        let f = max(0.000001, min(0.25, targetFpr))
+        // ceil(log2(1/f))
+        let p = Int(ceil(log2(1.0 / f)))
+        return max(1, p)
+    }
+
+    // Estimate max elements that fit in size bytes: bits per element ~= P + 2 (approx)
+    static func estimateMaxElements(sizeBytes: Int, p: Int) -> Int {
+        let bits = max(8, sizeBytes * 8)
+        let per = max(3, p + 2)
+        return max(1, bits / per)
+    }
+
+    static func buildFilter(ids: [Data], maxBytes: Int, targetFpr: Double) -> Params {
+        let p = deriveP(targetFpr: targetFpr)
+        guard !ids.isEmpty else {
+            return Params(p: p, m: 1, data: Data())
+        }
+
+        let cap = estimateMaxElements(sizeBytes: maxBytes, p: p)
+        let selected = Array(ids.prefix(cap))
+        let range = max(1, hashRange(count: selected.count, p: p))
+        let modulo = UInt64(range)
+
+        var mapped = selected
+            .map { h64($0) }
+            .map { mapHash($0, modulo: modulo) }
+            .sorted()
+        mapped = normalizeMappedValues(mapped, modulo: modulo)
+
+        if mapped.isEmpty {
+            return Params(p: p, m: range, data: Data())
+        }
+
+        var encoded = encode(sorted: mapped, p: p)
+        var trimmedCount = mapped.count
+
+        while encoded.count > maxBytes && trimmedCount > 0 {
+            if trimmedCount == 1 {
+                mapped.removeAll()
+                encoded = Data()
+                break
+            }
+            trimmedCount = max(1, (trimmedCount * 9) / 10)
+            mapped = Array(mapped.prefix(trimmedCount))
+            encoded = encode(sorted: mapped, p: p)
+        }
+
+        return Params(p: p, m: range, data: encoded)
+    }
+
+    static func decodeToSortedSet(p: Int, m: UInt32, data: Data) -> [UInt64] {
+        var values: [UInt64] = []
+        let reader = BitReader(data)
+        var acc: UInt64 = 0
+        while true {
+            guard let q = reader.readUnary() else { break }
+            guard let r = reader.readBits(count: p) else { break }
+            let x = (UInt64(q) << UInt64(p)) + UInt64(r) + 1
+            acc &+= x
+            if acc >= UInt64(m) { break }
+            values.append(acc)
+        }
+        return values
+    }
+
+    static func contains(sortedValues: [UInt64], candidate: UInt64) -> Bool {
+        var lo = 0
+        var hi = sortedValues.count - 1
+        while lo <= hi {
+            let mid = (lo + hi) >> 1
+            let v = sortedValues[mid]
+            if v == candidate { return true }
+            if v < candidate { lo = mid + 1 } else { hi = mid - 1 }
+        }
+        return false
+    }
+
+    static func bucket(for id: Data, modulus m: UInt32) -> UInt64 {
+        let modulo = UInt64(max(1, m))
+        guard modulo > 1 else { return 0 }
+        return mapHash(h64(id), modulo: modulo)
+    }
+
+    private static func h64(_ id16: Data) -> UInt64 {
+        var hasher = SHA256()
+        hasher.update(data: id16)
+        let d = hasher.finalize()
+        let db = Data(d)
+        var x: UInt64 = 0
+        let take = min(8, db.count)
+        for i in 0..<take { x = (x << 8) | UInt64(db[i]) }
+        return x & 0x7fff_ffff_ffff_ffff
+    }
+
+    private static func hashRange(count: Int, p: Int) -> UInt32 {
+        guard count > 0 else { return 1 }
+        if p >= 64 { return UInt32.max }
+        let multiplier = UInt64(1) << UInt64(p)
+        let (product, overflow) = UInt64(count).multipliedReportingOverflow(by: multiplier)
+        if overflow { return UInt32.max }
+        if product == 0 { return 1 }
+        return product > UInt64(UInt32.max) ? UInt32.max : UInt32(product)
+    }
+
+    private static func mapHash(_ hash: UInt64, modulo: UInt64) -> UInt64 {
+        guard modulo > 1 else { return 0 }
+        let value = hash % modulo
+        if value == 0 { return 1 }
+        return value
+    }
+
+    private static func normalizeMappedValues(_ values: [UInt64], modulo: UInt64) -> [UInt64] {
+        guard modulo > 1 else { return [] }
+        guard !values.isEmpty else { return [] }
+        var result: [UInt64] = []
+        result.reserveCapacity(values.count)
+        var last: UInt64 = 0
+        for value in values {
+            let normalized = min(value, modulo - 1)
+            if normalized > last {
+                result.append(normalized)
+                last = normalized
+            }
+        }
+        return result
+    }
+
+    private static func encode(sorted: [UInt64], p: Int) -> Data {
+        let writer = BitWriter()
+        var prev: UInt64 = 0
+        let mask: UInt64 = (p >= 64) ? ~0 : ((1 << UInt64(p)) - 1)
+        for v in sorted {
+            let delta = v &- prev
+            prev = v
+            let x = delta
+            let q = (x &- 1) >> UInt64(p)
+            let r = (x &- 1) & mask
+            // unary q ones then zero
+            if q > 0 { writer.writeOnes(count: Int(q)) }
+            writer.writeBit(0)
+            writer.writeBits(value: r, count: p)
+        }
+        return writer.toData()
+    }
+
+    // MARK: - Bit helpers (MSB-first)
+    private final class BitWriter {
+        private var buf = Data()
+        private var cur: UInt8 = 0
+        private var nbits: Int = 0
+        func writeBit(_ bit: Int) { // 0 or 1
+            cur = UInt8((Int(cur) << 1) | (bit & 1))
+            nbits += 1
+            if nbits == 8 {
+                buf.append(cur)
+                cur = 0; nbits = 0
+            }
+        }
+        func writeOnes(count: Int) {
+            guard count > 0 else { return }
+            for _ in 0..<count { writeBit(1) }
+        }
+        func writeBits(value: UInt64, count: Int) {
+            guard count > 0 else { return }
+            for i in stride(from: count - 1, through: 0, by: -1) {
+                let bit = Int((value >> UInt64(i)) & 1)
+                writeBit(bit)
+            }
+        }
+        func toData() -> Data {
+            if nbits > 0 {
+                let rem = UInt8(Int(cur) << (8 - nbits))
+                buf.append(rem)
+                cur = 0; nbits = 0
+            }
+            return buf
+        }
+    }
+
+    private final class BitReader {
+        private let data: Data
+        private var idx: Int = 0
+        private var cur: UInt8 = 0
+        private var left: Int = 0
+        init(_ data: Data) {
+            self.data = data
+            if !data.isEmpty {
+                cur = data[0]
+                left = 8
+            }
+        }
+        func readBit() -> Int? {
+            if idx >= data.count { return nil }
+            let bit = (Int(cur) >> 7) & 1
+            cur = UInt8((Int(cur) << 1) & 0xFF)
+            left -= 1
+            if left == 0 {
+                idx += 1
+                if idx < data.count { cur = data[idx]; left = 8 }
+            }
+            return bit
+        }
+        func readUnary() -> Int? {
+            var q = 0
+            while true {
+                guard let b = readBit() else { return nil }
+                if b == 1 { q += 1 } else { break }
+            }
+            return q
+        }
+        func readBits(count: Int) -> UInt64? {
+            var v: UInt64 = 0
+            for _ in 0..<count {
+                guard let b = readBit() else { return nil }
+                v = (v << 1) | UInt64(b)
+            }
+            return v
+        }
+    }
+}

bitchat/Sync/GossipSyncManager.swift

@@ -0,0 +1,462 @@
+import Foundation
+import BitLogger
+import BitFoundation
+
+// Gossip-based sync manager using on-demand GCS filters
+final class GossipSyncManager {
+    protocol Delegate: AnyObject {
+        func sendPacket(_ packet: BitchatPacket)
+        func sendPacket(to peerID: PeerID, packet: BitchatPacket)
+        func signPacketForBroadcast(_ packet: BitchatPacket) -> BitchatPacket
+        func getConnectedPeers() -> [PeerID]
+    }
+
+    private struct PacketStore {
+        private(set) var packets: [String: BitchatPacket] = [:]
+        private(set) var order: [String] = []
+
+        mutating func insert(idHex: String, packet: BitchatPacket, capacity: Int) {
+            guard capacity > 0 else { return }
+            if packets[idHex] != nil {
+                packets[idHex] = packet
+                return
+            }
+            packets[idHex] = packet
+            order.append(idHex)
+            while order.count > capacity {
+                let victim = order.removeFirst()
+                packets.removeValue(forKey: victim)
+            }
+        }
+
+        func allPackets(isFresh: (BitchatPacket) -> Bool) -> [BitchatPacket] {
+            order.compactMap { key in
+                guard let packet = packets[key], isFresh(packet) else { return nil }
+                return packet
+            }
+        }
+
+        mutating func remove(where shouldRemove: (BitchatPacket) -> Bool) {
+            var nextOrder: [String] = []
+            for key in order {
+                guard let packet = packets[key] else { continue }
+                if shouldRemove(packet) {
+                    packets.removeValue(forKey: key)
+                } else {
+                    nextOrder.append(key)
+                }
+            }
+            order = nextOrder
+        }
+
+        mutating func removeExpired(isFresh: (BitchatPacket) -> Bool) {
+            remove { !isFresh($0) }
+        }
+    }
+
+    private struct SyncSchedule {
+        let types: SyncTypeFlags
+        let interval: TimeInterval
+        var lastSent: Date
+    }
+
+    struct Config {
+        var seenCapacity: Int = 1000          // max packets per sync (cap across types)
+        var gcsMaxBytes: Int = 400           // filter size budget (128..1024)
+        var gcsTargetFpr: Double = 0.01      // 1%
+        var maxMessageAgeSeconds: TimeInterval = 900  // 15 min - discard older messages
+        var maintenanceIntervalSeconds: TimeInterval = 30.0
+        var stalePeerCleanupIntervalSeconds: TimeInterval = 60.0
+        var stalePeerTimeoutSeconds: TimeInterval = 60.0
+        var fragmentCapacity: Int = 600
+        var fileTransferCapacity: Int = 200
+        var fragmentSyncIntervalSeconds: TimeInterval = 30.0
+        var fileTransferSyncIntervalSeconds: TimeInterval = 60.0
+        var messageSyncIntervalSeconds: TimeInterval = 15.0
+    }
+
+    private let myPeerID: PeerID
+    private let config: Config
+    private let requestSyncManager: RequestSyncManager
+    weak var delegate: Delegate?
+
+    // Storage: broadcast packets by type, and latest announce per sender
+    private var messages = PacketStore()
+    private var fragments = PacketStore()
+    private var fileTransfers = PacketStore()
+    private var latestAnnouncementByPeer: [PeerID: (id: String, packet: BitchatPacket)] = [:]
+
+    // Timer
+    private var periodicTimer: DispatchSourceTimer?
+    private let queue = DispatchQueue(label: "mesh.sync", qos: .utility)
+    private var lastStalePeerCleanup: Date = .distantPast
+    private var syncSchedules: [SyncSchedule] = []
+
+    init(myPeerID: PeerID, config: Config = Config(), requestSyncManager: RequestSyncManager) {
+        self.myPeerID = myPeerID
+        self.config = config
+        self.requestSyncManager = requestSyncManager
+        var schedules: [SyncSchedule] = []
+        if config.seenCapacity > 0 && config.messageSyncIntervalSeconds > 0 {
+            schedules.append(SyncSchedule(types: .publicMessages, interval: config.messageSyncIntervalSeconds, lastSent: .distantPast))
+        }
+        if config.fragmentCapacity > 0 && config.fragmentSyncIntervalSeconds > 0 {
+            schedules.append(SyncSchedule(types: .fragment, interval: config.fragmentSyncIntervalSeconds, lastSent: .distantPast))
+        }
+        if config.fileTransferCapacity > 0 && config.fileTransferSyncIntervalSeconds > 0 {
+            schedules.append(SyncSchedule(types: .fileTransfer, interval: config.fileTransferSyncIntervalSeconds, lastSent: .distantPast))
+        }
+        syncSchedules = schedules
+    }
+
+    func start() {
+        stop()
+        let timer = DispatchSource.makeTimerSource(queue: queue)
+        let interval = max(0.1, config.maintenanceIntervalSeconds)
+        timer.schedule(deadline: .now() + interval, repeating: interval, leeway: .seconds(1))
+        timer.setEventHandler { [weak self] in
+            self?.performPeriodicMaintenance()
+        }
+        timer.resume()
+        periodicTimer = timer
+    }
+
+    func stop() {
+        periodicTimer?.cancel(); periodicTimer = nil
+    }
+
+    func scheduleInitialSyncToPeer(_ peerID: PeerID, delaySeconds: TimeInterval = 5.0) {
+        queue.asyncAfter(deadline: .now() + delaySeconds) { [weak self] in
+            guard let self = self else { return }
+            self.sendRequestSync(to: peerID, types: .publicMessages)
+            if self.config.fragmentCapacity > 0 && self.config.fragmentSyncIntervalSeconds > 0 {
+                self.queue.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+                    self?.sendRequestSync(to: peerID, types: .fragment)
+                }
+            }
+            if self.config.fileTransferCapacity > 0 && self.config.fileTransferSyncIntervalSeconds > 0 {
+                self.queue.asyncAfter(deadline: .now() + 1.0) { [weak self] in
+                    self?.sendRequestSync(to: peerID, types: .fileTransfer)
+                }
+            }
+        }
+    }
+
+    func onPublicPacketSeen(_ packet: BitchatPacket) {
+        queue.async { [weak self] in
+            self?._onPublicPacketSeen(packet)
+        }
+    }
+
+    // Helper to check if a packet is within the age threshold
+    private func isPacketFresh(_ packet: BitchatPacket) -> Bool {
+        let nowMs = UInt64(Date().timeIntervalSince1970 * 1000)
+        let ageThresholdMs = UInt64(config.maxMessageAgeSeconds * 1000)
+
+        // If current time is less than threshold, accept all (handle clock issues gracefully)
+        guard nowMs >= ageThresholdMs else { return true }
+
+        let cutoffMs = nowMs - ageThresholdMs
+        return packet.timestamp >= cutoffMs
+    }
+
+    private func isAnnouncementFresh(_ packet: BitchatPacket) -> Bool {
+        guard config.stalePeerTimeoutSeconds > 0 else { return true }
+        let nowMs = UInt64(Date().timeIntervalSince1970 * 1000)
+        let timeoutMs = UInt64(config.stalePeerTimeoutSeconds * 1000)
+        guard nowMs >= timeoutMs else { return true }
+        let cutoffMs = nowMs - timeoutMs
+        return packet.timestamp >= cutoffMs
+    }
+
+    private func _onPublicPacketSeen(_ packet: BitchatPacket) {
+        guard let messageType = MessageType(rawValue: packet.type) else { return }
+        let isBroadcastRecipient: Bool = {
+            guard let r = packet.recipientID else { return true }
+            return r.count == 8 && r.allSatisfy { $0 == 0xFF }
+        }()
+
+        switch messageType {
+        case .announce:
+            guard isPacketFresh(packet) else { return }
+            guard isAnnouncementFresh(packet) else {
+                let sender = PeerID(hexData: packet.senderID)
+                removeState(for: sender)
+                return
+            }
+            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+            let sender = PeerID(hexData: packet.senderID)
+            latestAnnouncementByPeer[sender] = (id: idHex, packet: packet)
+        case .message:
+            guard isBroadcastRecipient else { return }
+            guard isPacketFresh(packet) else { return }
+            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+            messages.insert(idHex: idHex, packet: packet, capacity: max(1, config.seenCapacity))
+        case .fragment:
+            guard isBroadcastRecipient else { return }
+            guard isPacketFresh(packet) else { return }
+            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+            fragments.insert(idHex: idHex, packet: packet, capacity: max(1, config.fragmentCapacity))
+        case .fileTransfer:
+            guard isBroadcastRecipient else { return }
+            guard isPacketFresh(packet) else { return }
+            let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+            fileTransfers.insert(idHex: idHex, packet: packet, capacity: max(1, config.fileTransferCapacity))
+        default:
+            break
+        }
+    }
+
+    private func sendPeriodicSync(for types: SyncTypeFlags) {
+        // Unicast sync to connected peers to allow RSR attribution
+        if let connectedPeers = delegate?.getConnectedPeers(), !connectedPeers.isEmpty {
+            SecureLogger.debug("Sending periodic sync to \(connectedPeers.count) connected peers", category: .sync)
+            for peerID in connectedPeers {
+                sendRequestSync(to: peerID, types: types)
+            }
+        } else {
+            // Fallback to broadcast (discovery phase)
+            sendRequestSync(for: types)
+        }
+    }
+
+    private func sendRequestSync(for types: SyncTypeFlags) {
+        let payload = buildGcsPayload(for: types)
+        let pkt = BitchatPacket(
+            type: MessageType.requestSync.rawValue,
+            senderID: Data(hexString: myPeerID.id) ?? Data(),
+            recipientID: nil, // broadcast
+            timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
+            payload: payload,
+            signature: nil,
+            ttl: 0 // local-only
+        )
+        let signed = delegate?.signPacketForBroadcast(pkt) ?? pkt
+        delegate?.sendPacket(signed)
+    }
+
+    private func sendRequestSync(to peerID: PeerID, types: SyncTypeFlags) {
+        // Register the request for RSR validation
+        requestSyncManager.registerRequest(to: peerID)
+        
+        let payload = buildGcsPayload(for: types)
+        var recipient = Data()
+        var temp = peerID.id
+        while temp.count >= 2 && recipient.count < 8 {
+            let hexByte = String(temp.prefix(2))
+            if let b = UInt8(hexByte, radix: 16) { recipient.append(b) }
+            temp = String(temp.dropFirst(2))
+        }
+        let pkt = BitchatPacket(
+            type: MessageType.requestSync.rawValue,
+            senderID: Data(hexString: myPeerID.id) ?? Data(),
+            recipientID: recipient,
+            timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
+            payload: payload,
+            signature: nil,
+            ttl: 0 // local-only
+        )
+        let signed = delegate?.signPacketForBroadcast(pkt) ?? pkt
+        delegate?.sendPacket(to: peerID, packet: signed)
+    }
+
+    func handleRequestSync(from peerID: PeerID, request: RequestSyncPacket) {
+        queue.async { [weak self] in
+            self?._handleRequestSync(from: peerID, request: request)
+        }
+    }
+
+    private func _handleRequestSync(from peerID: PeerID, request: RequestSyncPacket) {
+        let requestedTypes = (request.types ?? .publicMessages)
+        // Decode GCS into sorted set and prepare membership checker
+        let sorted = GCSFilter.decodeToSortedSet(p: request.p, m: request.m, data: request.data)
+        func mightContain(_ id: Data) -> Bool {
+            let bucket = GCSFilter.bucket(for: id, modulus: request.m)
+            return GCSFilter.contains(sortedValues: sorted, candidate: bucket)
+        }
+
+        if requestedTypes.contains(.announce) {
+            for (_, pair) in latestAnnouncementByPeer {
+                let (idHex, pkt) = pair
+                guard isPacketFresh(pkt) else { continue }
+                let idBytes = Data(hexString: idHex) ?? Data()
+                if !mightContain(idBytes) {
+                    var toSend = pkt
+                    toSend.ttl = 0
+                    toSend.isRSR = true // Mark as solicited response
+                    delegate?.sendPacket(to: peerID, packet: toSend)
+                }
+            }
+        }
+
+        if requestedTypes.contains(.message) {
+            let toSendMsgs = messages.allPackets(isFresh: isPacketFresh)
+            for pkt in toSendMsgs {
+                let idBytes = PacketIdUtil.computeId(pkt)
+                if !mightContain(idBytes) {
+                    var toSend = pkt
+                    toSend.ttl = 0
+                    toSend.isRSR = true // Mark as solicited response
+                    delegate?.sendPacket(to: peerID, packet: toSend)
+                }
+            }
+        }
+
+        if requestedTypes.contains(.fragment) {
+            let frags = fragments.allPackets(isFresh: isPacketFresh)
+            for pkt in frags {
+                let idBytes = PacketIdUtil.computeId(pkt)
+                if !mightContain(idBytes) {
+                    var toSend = pkt
+                    toSend.ttl = 0
+                    toSend.isRSR = true // Mark as solicited response
+                    delegate?.sendPacket(to: peerID, packet: toSend)
+                }
+            }
+        }
+
+        if requestedTypes.contains(.fileTransfer) {
+            let files = fileTransfers.allPackets(isFresh: isPacketFresh)
+            for pkt in files {
+                let idBytes = PacketIdUtil.computeId(pkt)
+                if !mightContain(idBytes) {
+                    var toSend = pkt
+                    toSend.ttl = 0
+                    toSend.isRSR = true // Mark as solicited response
+                    delegate?.sendPacket(to: peerID, packet: toSend)
+                }
+            }
+        }
+    }
+
+    // Build REQUEST_SYNC payload using current candidates and GCS params
+    private func buildGcsPayload(for types: SyncTypeFlags) -> Data {
+        var candidates: [BitchatPacket] = []
+        if types.contains(.announce) {
+            for (_, pair) in latestAnnouncementByPeer where isPacketFresh(pair.packet) {
+                candidates.append(pair.packet)
+            }
+        }
+        if types.contains(.message) {
+            candidates.append(contentsOf: messages.allPackets(isFresh: isPacketFresh))
+        }
+        if types.contains(.fragment) {
+            candidates.append(contentsOf: fragments.allPackets(isFresh: isPacketFresh))
+        }
+        if types.contains(.fileTransfer) {
+            candidates.append(contentsOf: fileTransfers.allPackets(isFresh: isPacketFresh))
+        }
+        if candidates.isEmpty {
+            let p = GCSFilter.deriveP(targetFpr: config.gcsTargetFpr)
+            let req = RequestSyncPacket(p: p, m: 1, data: Data(), types: types)
+            return req.encode()
+        }
+
+        // Sort by timestamp desc
+        candidates.sort { $0.timestamp > $1.timestamp }
+
+        let p = GCSFilter.deriveP(targetFpr: config.gcsTargetFpr)
+        let nMax = GCSFilter.estimateMaxElements(sizeBytes: config.gcsMaxBytes, p: p)
+        let cap: Int
+        if types == .fragment {
+            cap = max(1, config.fragmentCapacity)
+        } else if types == .fileTransfer {
+            cap = max(1, config.fileTransferCapacity)
+        } else {
+            cap = max(1, config.seenCapacity)
+        }
+        let takeN = min(candidates.count, min(nMax, cap))
+        if takeN <= 0 {
+            let req = RequestSyncPacket(p: p, m: 1, data: Data(), types: types)
+            return req.encode()
+        }
+        let ids: [Data] = candidates.prefix(takeN).map { PacketIdUtil.computeId($0) }
+        let params = GCSFilter.buildFilter(ids: ids, maxBytes: config.gcsMaxBytes, targetFpr: config.gcsTargetFpr)
+        let req = RequestSyncPacket(p: params.p, m: params.m, data: params.data, types: types)
+        return req.encode()
+    }
+
+    // Periodic cleanup of expired messages and announcements
+    private func cleanupExpiredMessages() {
+        // Remove expired announcements
+        latestAnnouncementByPeer = latestAnnouncementByPeer.filter { _, pair in
+            isPacketFresh(pair.packet)
+        }
+
+        messages.removeExpired(isFresh: isPacketFresh)
+        fragments.removeExpired(isFresh: isPacketFresh)
+        fileTransfers.removeExpired(isFresh: isPacketFresh)
+    }
+
+    private func performPeriodicMaintenance(now: Date = Date()) {
+        cleanupExpiredMessages()
+        cleanupStaleAnnouncementsIfNeeded(now: now)
+        requestSyncManager.cleanup() // Cleanup expired sync requests
+        
+        for index in syncSchedules.indices {
+            guard syncSchedules[index].interval > 0 else { continue }
+            if syncSchedules[index].lastSent == .distantPast || now.timeIntervalSince(syncSchedules[index].lastSent) >= syncSchedules[index].interval {
+                syncSchedules[index].lastSent = now
+                sendPeriodicSync(for: syncSchedules[index].types)
+            }
+        }
+    }
+
+    private func cleanupStaleAnnouncementsIfNeeded(now: Date) {
+        guard now.timeIntervalSince(lastStalePeerCleanup) >= config.stalePeerCleanupIntervalSeconds else {
+            return
+        }
+        lastStalePeerCleanup = now
+        cleanupStaleAnnouncements(now: now)
+    }
+
+    private func cleanupStaleAnnouncements(now: Date) {
+        let timeoutMs = UInt64(config.stalePeerTimeoutSeconds * 1000)
+        let nowMs = UInt64(now.timeIntervalSince1970 * 1000)
+        guard nowMs >= timeoutMs else { return }
+        let cutoff = nowMs - timeoutMs
+        let stalePeerIDs = latestAnnouncementByPeer.compactMap { peerID, pair in
+            pair.packet.timestamp < cutoff ? peerID : nil
+        }
+        guard !stalePeerIDs.isEmpty else { return }
+        for peerKey in stalePeerIDs {
+            removeState(for: peerKey)
+        }
+    }
+
+    // Explicit removal hook for LEAVE/stale peer
+    func removeAnnouncementForPeer(_ peerID: PeerID) {
+        queue.async { [weak self] in
+            self?.removeState(for: peerID)
+        }
+    }
+
+    private func removeState(for peerID: PeerID) {
+        _ = latestAnnouncementByPeer.removeValue(forKey: peerID)
+        messages.remove { PeerID(hexData: $0.senderID) == peerID }
+        fragments.remove { PeerID(hexData: $0.senderID) == peerID }
+        fileTransfers.remove { PeerID(hexData: $0.senderID) == peerID }
+    }
+}
+
+#if DEBUG
+extension GossipSyncManager {
+    func _performMaintenanceSynchronously(now: Date = Date()) {
+        queue.sync {
+            performPeriodicMaintenance(now: now)
+        }
+    }
+
+    func _hasAnnouncement(for peerID: PeerID) -> Bool {
+        queue.sync {
+            latestAnnouncementByPeer[peerID] != nil
+        }
+    }
+
+    func _messageCount(for peerID: PeerID) -> Int {
+        queue.sync {
+            messages.allPackets { _ in true }.filter { PeerID(hexData: $0.senderID) == peerID }.count
+        }
+    }
+}
+#endif

bitchat/Sync/PacketIdUtil.swift

@@ -0,0 +1,18 @@
+import struct BitFoundation.BitchatPacket
+import Foundation
+import CryptoKit
+
+// Deterministic packet ID used for gossip sync membership
+// ID = first 16 bytes of SHA-256 over: [type | senderID | timestamp | payload]
+enum PacketIdUtil {
+    static func computeId(_ packet: BitchatPacket) -> Data {
+        var hasher = SHA256()
+        hasher.update(data: Data([packet.type]))
+        hasher.update(data: packet.senderID)
+        var tsBE = packet.timestamp.bigEndian
+        withUnsafeBytes(of: &tsBE) { raw in hasher.update(data: Data(raw)) }
+        hasher.update(data: packet.payload)
+        let digest = hasher.finalize()
+        return Data(digest.prefix(16))
+    }
+}

bitchat/Sync/RequestSyncManager.swift

@@ -0,0 +1,86 @@
+//
+// RequestSyncManager.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+import BitLogger
+import BitFoundation
+
+/// Manages outgoing sync requests and validates incoming responses.
+///
+/// Allows attributing RSR (Request-Sync Response) packets to specific peers
+/// that we have actively requested sync from.
+final class RequestSyncManager {
+    
+    private let queue = DispatchQueue(label: "request.sync.manager", attributes: .concurrent)
+    private var pendingRequests: [PeerID: TimeInterval] = [:]
+    private let responseWindow: TimeInterval
+    private let now: () -> TimeInterval
+    
+    init(
+        responseWindow: TimeInterval = 30.0,
+        now: @escaping () -> TimeInterval = { Date().timeIntervalSince1970 }
+    ) {
+        self.responseWindow = responseWindow
+        self.now = now
+    }
+    
+    /// Register that we are sending a sync request to a peer.
+    /// - Parameter peerID: The peer we are requesting sync from
+    func registerRequest(to peerID: PeerID) {
+        let now = self.now()
+        queue.async(flags: .barrier) {
+            SecureLogger.debug("Registering sync request to \(peerID.id.prefix(8))…", category: .sync)
+            self.pendingRequests[peerID] = now
+        }
+    }
+    
+    /// Check if a packet from a peer is a valid response to a sync request.
+    ///
+    /// - Parameters:
+    ///   - peerID: The sender of the packet
+    ///   - isRSR: Whether the packet is marked as a Request-Sync Response
+    /// - Returns: true if we have a pending request for this peer and the window is open
+    func isValidResponse(from peerID: PeerID, isRSR: Bool) -> Bool {
+        guard isRSR else { return false }
+        
+        return queue.sync {
+            guard let requestTime = pendingRequests[peerID] else {
+                SecureLogger.warning("Received unsolicited RSR packet from \(peerID.id.prefix(8))…", category: .security)
+                return false
+            }
+            
+            let now = self.now()
+            if now - requestTime > responseWindow {
+                SecureLogger.warning("Received RSR packet from \(peerID.id.prefix(8))… outside of response window", category: .security)
+                // We don't remove here because we might receive multiple packets for one request
+                return false
+            }
+            
+            return true
+        }
+    }
+    
+    /// Periodic cleanup of expired requests
+    func cleanup() {
+        let now = self.now()
+        queue.async(flags: .barrier) {
+            let originalCount = self.pendingRequests.count
+            self.pendingRequests = self.pendingRequests.filter { _, timestamp in
+                now - timestamp <= self.responseWindow
+            }
+            let removed = originalCount - self.pendingRequests.count
+            if removed > 0 {
+                SecureLogger.debug("Cleaned up \(removed) expired sync requests", category: .sync)
+            }
+        }
+    }
+
+    var debugPendingRequestCount: Int {
+        queue.sync { pendingRequests.count }
+    }
+}

bitchat/Sync/SyncTypeFlags.swift

@@ -0,0 +1,105 @@
+import BitFoundation
+import Foundation
+
+/// Bitfield describing which message types are covered by a REQUEST_SYNC round.
+/// Matches the Android mapping (bit index -> message type).
+struct SyncTypeFlags: OptionSet {
+    let rawValue: UInt64
+
+    init(rawValue: UInt64) {
+        self.rawValue = rawValue & 0x00FF_FFFF_FFFF_FFFF // Trim to max 8 bytes
+    }
+
+    private static func bitIndex(for type: MessageType) -> Int? {
+        switch type {
+        case .announce: return 0
+        case .message: return 1
+        case .leave: return 2
+        case .noiseHandshake: return 3
+        case .noiseEncrypted: return 4
+        case .fragment: return 5
+        case .requestSync: return 6
+        case .fileTransfer: return 7
+        }
+    }
+
+    private static func type(forBit index: Int) -> MessageType? {
+        switch index {
+        case 0: return .announce
+        case 1: return .message
+        case 2: return .leave
+        case 3: return .noiseHandshake
+        case 4: return .noiseEncrypted
+        case 5: return .fragment
+        case 6: return .requestSync
+        case 7: return .fileTransfer
+        default:
+            return nil
+        }
+    }
+
+    static let announce = SyncTypeFlags(messageTypes: [.announce])
+    static let message = SyncTypeFlags(messageTypes: [.message])
+    static let fragment = SyncTypeFlags(messageTypes: [.fragment])
+    static let fileTransfer = SyncTypeFlags(messageTypes: [.fileTransfer])
+
+    static let publicMessages = SyncTypeFlags(messageTypes: [.announce, .message])
+
+    init(messageTypes: [MessageType]) {
+        var raw: UInt64 = 0
+        for type in messageTypes {
+            guard let bit = SyncTypeFlags.bitIndex(for: type) else { continue }
+            raw |= (1 << UInt64(bit))
+        }
+        self.init(rawValue: raw)
+    }
+
+    func contains(_ type: MessageType) -> Bool {
+        guard let bit = SyncTypeFlags.bitIndex(for: type) else { return false }
+        return contains(SyncTypeFlags(rawValue: 1 << UInt64(bit)))
+    }
+
+    func union(_ other: SyncTypeFlags) -> SyncTypeFlags {
+        SyncTypeFlags(rawValue: rawValue | other.rawValue)
+    }
+
+    func intersection(_ other: SyncTypeFlags) -> SyncTypeFlags {
+        SyncTypeFlags(rawValue: rawValue & other.rawValue)
+    }
+
+    func toMessageTypes() -> [MessageType] {
+        guard rawValue != 0 else { return [] }
+        var types: [MessageType] = []
+        for bit in 0..<64 {
+            guard (rawValue & (1 << UInt64(bit))) != 0 else { continue }
+            if let type = SyncTypeFlags.type(forBit: bit) {
+                types.append(type)
+            }
+        }
+        return types
+    }
+
+    func toData() -> Data? {
+        guard rawValue != 0 else { return nil }
+        var value = rawValue
+        var bytes: [UInt8] = []
+        while value > 0 && bytes.count < 8 {
+            bytes.append(UInt8(value & 0xFF))
+            value >>= 8
+        }
+        while let last = bytes.last, last == 0 {
+            bytes.removeLast()
+        }
+        guard !bytes.isEmpty, bytes.count <= 8 else { return nil }
+        return Data(bytes)
+    }
+
+    static func decode(_ data: Data) -> SyncTypeFlags? {
+        guard (1...8).contains(data.count) else { return nil }
+        var raw: UInt64 = 0
+        for (index, byte) in data.enumerated() {
+            raw |= UInt64(byte) << UInt64(index * 8)
+        }
+        return SyncTypeFlags(rawValue: raw)
+    }
+}

bitchat/Utils/Color+Peer.swift

@@ -0,0 +1,37 @@
+//
+// Color+Peer.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import SwiftUI
+
+extension Color {
+    private static var peerColorCache: [String: Color] = [:]
+    
+    init(peerSeed: String, isDark: Bool) {
+        let cacheKey = peerSeed + (isDark ? "|dark" : "|light")
+        if let cached = Self.peerColorCache[cacheKey] {
+            self = cached
+        }
+        let h = peerSeed.djb2()
+        var hue = Double(h % 1000) / 1000.0
+        let orange = 30.0 / 360.0
+        if abs(hue - orange) < TransportConfig.uiColorHueAvoidanceDelta {
+            hue = fmod(hue + TransportConfig.uiColorHueOffset, 1.0)
+        }
+        let sRand = Double((h >> 17) & 0x3FF) / 1023.0
+        let bRand = Double((h >> 27) & 0x3FF) / 1023.0
+        let sBase: Double = isDark ? 0.80 : 0.70
+        let sRange: Double = 0.20
+        let bBase: Double = isDark ? 0.75 : 0.45
+        let bRange: Double = isDark ? 0.16 : 0.14
+        let saturation = min(1.0, max(0.50, sBase + (sRand - 0.5) * sRange))
+        let brightness = min(1.0, max(0.35, bBase + (bRand - 0.5) * bRange))
+        let c = Color(hue: hue, saturation: saturation, brightness: brightness)
+        Self.peerColorCache[cacheKey] = c
+        self = c
+    }
+}