Delete SpamFilterService - remove 184 lines of unused code

SpamFilterService was disabled on Oct 7 because rate limits broke normal
conversation (3 msg capacity, 0.5/sec refill = 1 msg per 2 seconds).

Only the near-duplicate detection was being used, so:
- Deleted SpamFilterService.swift (222 lines)
- Moved near-dup LRU cache inline to ChatViewModel (40 lines)
- Removed unused rate limiter config constants (6 lines)

Net: -184 lines, clearer code, same functionality

Services: 6 → 5 (SpamFilter removed)
Build time: 6.10s (was 6.21s)
Tests: 23/23 passing

.cache/clang/ModuleCache/Swift-207X6UTF85MUY.swiftmodule

@@ -0,0 +1,12 @@
+---
+path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/Swift.swiftmodule/arm64e-apple-macos.swiftmodule'
+dependencies:
+  - mtime:           1757258659000000000
+    path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/Swift.swiftmodule/arm64e-apple-macos.swiftmodule'
+    size:            14166264
+  - mtime:           1754189697000000000
+    path:            'usr/lib/swift/Swift.swiftmodule/arm64e-apple-macos.swiftinterface'
+    size:            2261306
+    sdk_relative:    true
+version:         1
+...

.cache/clang/ModuleCache/SwiftOnoneSupport-3W234PQLRG1JJ.swiftmodule

@@ -0,0 +1,16 @@
+---
+path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/SwiftOnoneSupport.swiftmodule/arm64e-apple-macos.swiftmodule'
+dependencies:
+  - mtime:           1757258662000000000
+    path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/SwiftOnoneSupport.swiftmodule/arm64e-apple-macos.swiftmodule'
+    size:            18068
+  - mtime:           1754189697000000000
+    path:            'usr/lib/swift/Swift.swiftmodule/arm64e-apple-macos.swiftinterface'
+    size:            2261306
+    sdk_relative:    true
+  - mtime:           1754191141000000000
+    path:            'usr/lib/swift/SwiftOnoneSupport.swiftmodule/arm64e-apple-macos.swiftinterface'
+    size:            1224
+    sdk_relative:    true
+version:         1
+...

.cache/clang/ModuleCache/_Concurrency-IW47C06QYY26.swiftmodule

@@ -0,0 +1,16 @@
+---
+path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/_Concurrency.swiftmodule/arm64e-apple-macos.swiftmodule'
+dependencies:
+  - mtime:           1757258669000000000
+    path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/_Concurrency.swiftmodule/arm64e-apple-macos.swiftmodule'
+    size:            699544
+  - mtime:           1754189697000000000
+    path:            'usr/lib/swift/Swift.swiftmodule/arm64e-apple-macos.swiftinterface'
+    size:            2261306
+    sdk_relative:    true
+  - mtime:           1754192470000000000
+    path:            'usr/lib/swift/_Concurrency.swiftmodule/arm64e-apple-macos.swiftinterface'
+    size:            364219
+    sdk_relative:    true
+version:         1
+...

.cache/clang/ModuleCache/_StringProcessing-1C2ZFCSIKDXY1.swiftmodule

@@ -0,0 +1,16 @@
+---
+path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/_StringProcessing.swiftmodule/arm64e-apple-macos.swiftmodule'
+dependencies:
+  - mtime:           1757258664000000000
+    path:            '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx/prebuilt-modules/26.0/_StringProcessing.swiftmodule/arm64e-apple-macos.swiftmodule'
+    size:            83568
+  - mtime:           1754189697000000000
+    path:            'usr/lib/swift/Swift.swiftmodule/arm64e-apple-macos.swiftinterface'
+    size:            2261306
+    sdk_relative:    true
+  - mtime:           1754192532000000000
+    path:            'usr/lib/swift/_StringProcessing.swiftmodule/arm64e-apple-macos.swiftinterface'
+    size:            24507
+    sdk_relative:    true
+version:         1
+...

.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/swift-tests.yml

@@ -0,0 +1,27 @@
+name: Build & Test
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test:
+    name: Run Swift Tests
+    runs-on: macos-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Set up Swift
+        uses: swift-actions/setup-swift@v2
+
+      - name: Build the package
+        run: swift build
+
+      - name: Run Tests
+        run: swift test --parallel

.gitignore

@@ -9,9 +9,6 @@ plans/
 CLAUDE.md
 AGENTS.md
 
-## User settings
-xcuserdata/
-
 ## compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9)
 *.xcscmblueprint
 *.xccheckout
@@ -57,7 +54,8 @@ iOSInjectionProject/
 
 ## Xcode project
 *.xcodeproj/project.xcworkspace/
-*.xcodeproj/xcshareddata/
+## Xcode User settings
+xcuserdata/
 
 ## Python
 __pycache__/
@@ -75,3 +73,6 @@ TestResult.xcresult/
 *.xcresult/
 build.log
 *.log
+
+# Local configs
+Local.xcconfig

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,11 @@
+MARKETING_VERSION = 1.4.4
+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

Justfile

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

Package.swift

@@ -4,8 +4,9 @@ import PackageDescription
 
 let package = Package(
     name: "bitchat",
+    defaultLocalization: "en",
     platforms: [
-        .iOS(.v16),
+        .iOS(.v17),
         .macOS(.v13)
     ],
     products: [
@@ -15,13 +16,17 @@ let package = Package(
         ),
     ],
     dependencies:[
-        .package(url: "https://github.com/21-DOT-DEV/swift-secp256k1", exact: "0.21.1"),
+        .package(path: "localPackages/Tor"),
+        .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: "BitLogger", package: "BitLogger"),
+                .product(name: "Tor", package: "Tor")
             ],
             path: "bitchat",
             exclude: [
@@ -30,7 +35,22 @@ let package = Package(
                 "bitchat.entitlements",
                 "bitchat-macOS.entitlements",
                 "LaunchScreen.storyboard"
+            ],
+            resources: [
+                .process("Localizable.xcstrings")
             ]
         ),
+        .testTarget(
+            name: "bitchatTests",
+            dependencies: ["bitchat"],
+            path: "bitchatTests",
+            exclude: [
+                "Info.plist",
+                "README.md"
+            ],
+            resources: [
+                .process("Localization")
+            ]
+        )
     ]
 )

README.md

@@ -9,7 +9,7 @@ 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.
+> 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](https://www.noiseprotocol.org) for identity and encryption. Public local chat (the main feature) has no security concerns.
 
 ## License
 
@@ -22,7 +22,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 +94,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 = "-DBITCHAT_DEV_ALLOW_CLEARNET"
+            value = ""
+            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/AppIconDebug.appiconset/Contents.json

@@ -0,0 +1,38 @@
+{
+  "images" : [
+    {
+      "filename" : "image-1024.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "dark"
+        }
+      ],
+      "filename" : "image-1024 1.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "tinted"
+        }
+      ],
+      "filename" : "image-1024 2.png",
+      "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,11 +6,15 @@
 // For more information, see <https://unlicense.org>
 //
 
+import Tor
 import SwiftUI
 import UserNotifications
 
 @main
 struct BitchatApp: App {
+    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
@@ -54,8 +58,8 @@ struct BitchatApp: App {
                     #elseif os(macOS)
                     appDelegate.chatViewModel = chatViewModel
                     #endif
-                    // Spin up Tor early; all internet will gate on Tor 100%
-                    TorManager.shared.startIfNeeded()
+                    // Initialize network activation policy; will start Tor/Nostr only when allowed
+                    NetworkActivationService.shared.start()
                     // Check for shared content
                     checkForSharedContent()
                 }
@@ -67,7 +71,7 @@ struct BitchatApp: App {
                     switch newPhase {
                     case .background:
                         // Keep BLE mesh running in background; BLEService adapts scanning automatically
-                        // Optionally nudge Tor to dormant to save power
+                        // Always send Tor to dormant on background for a clean restart later.
                         TorManager.shared.setAppForeground(false)
                         TorManager.shared.goDormantOnBackground()
                         // Stop geohash sampling while backgrounded
@@ -84,18 +88,22 @@ struct BitchatApp: App {
                         // On initial cold launch, Tor was just started in onAppear.
                         // Skip the deterministic restart the first time we become active.
                         if didHandleInitialActive && didEnterBackground {
-                            TorManager.shared.ensureRunningOnForeground()
+                            if TorManager.shared.isAutoStartAllowed() && !TorManager.shared.isReady {
+                                TorManager.shared.ensureRunningOnForeground()
+                            }
                         } else {
                             didHandleInitialActive = true
                         }
                         didEnterBackground = false
-                        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()
+                        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()
@@ -130,7 +138,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
         }
         

bitchat/Identity/IdentityModels.swift

@@ -87,7 +87,7 @@ import Foundation
 /// 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 +158,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,6 +90,7 @@
 /// - Advanced conflict resolution
 ///
 
+import BitLogger
 import Foundation
 import CryptoKit
 
@@ -102,7 +103,7 @@ protocol SecureIdentityStateManagerProtocol {
     
     // MARK: Cryptographic Identities
     func upsertCryptographicIdentity(fingerprint: String, noisePublicKey: Data, signingPublicKey: Data?, claimedNickname: String?)
-    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: String) -> [CryptographicIdentity]
+    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: PeerID) -> [CryptographicIdentity]
     func updateSocialIdentity(_ identity: SocialIdentity)
     
     // MARK: Favorites Management
@@ -120,12 +121,12 @@ protocol SecureIdentityStateManagerProtocol {
     func getBlockedNostrPubkeys() -> Set<String>
     
     // MARK: Ephemeral Session Management
-    func registerEphemeralSession(peerID: String, handshakeState: HandshakeState)
-    func updateHandshakeState(peerID: String, state: HandshakeState)
+    func registerEphemeralSession(peerID: PeerID, handshakeState: HandshakeState)
+    func updateHandshakeState(peerID: PeerID, state: HandshakeState)
     
     // MARK: Cleanup
     func clearAllIdentityData()
-    func removeEphemeralSession(peerID: String)
+    func removeEphemeralSession(peerID: PeerID)
     
     // MARK: Verification
     func setVerified(fingerprint: String, verified: Bool)
@@ -142,7 +143,7 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     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()
     
@@ -320,11 +321,11 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     }
 
     /// 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) }
+            guard peerID.isShort else { return [] }
+            return cryptographicIdentities.values.filter { $0.fingerprint.hasPrefix(peerID.id) }
         }
     }
     
@@ -454,7 +455,7 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     
     // 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,
@@ -464,7 +465,7 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
         }
     }
     
-    func updateHandshakeState(peerID: String, state: HandshakeState) {
+    func updateHandshakeState(peerID: PeerID, state: HandshakeState) {
         queue.async(flags: .barrier) {
             self.ephemeralSessions[peerID]?.handshakeState = state
             
@@ -492,7 +493,7 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
         }
     }
     
-    func removeEphemeralSession(peerID: String) {
+    func removeEphemeralSession(peerID: PeerID) {
         queue.async(flags: .barrier) {
             self.ephemeralSessions.removeValue(forKey: peerID)
         }

bitchat/Models/BitchatMessage.swift

@@ -0,0 +1,369 @@
+//
+// BitchatMessage.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+/// 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
+final 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: PeerID?
+    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: PeerID? = 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)
+    }
+}
+
+// MARK: - Equatable Conformance
+
+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: - Binary encoding
+
+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 peerData = senderPeerID?.id.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
+    }
+    
+    convenience init?(_ data: Data) {
+        // 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: PeerID?
+        if hasSenderPeerID && offset < dataCopy.count {
+            let length = Int(dataCopy[offset]); offset += 1
+            if offset + length <= dataCopy.count {
+                senderPeerID = PeerID(data: dataCopy[offset..<offset+length])
+                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
+                        }
+                    }
+                }
+            }
+        }
+        
+        self.init(
+            id: id,
+            sender: sender,
+            content: content,
+            timestamp: timestamp,
+            isRelay: isRelay,
+            originalSender: originalSender,
+            isPrivate: isPrivate,
+            recipientNickname: recipientNickname,
+            senderPeerID: senderPeerID,
+            mentions: mentions
+        )
+    }
+}
+
+// MARK: - Helpers
+
+extension BitchatMessage {
+    
+    private static let timestampFormatter: DateFormatter = {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "HH:mm:ss"
+        return formatter
+    }()
+    
+    var formattedTimestamp: String {
+        Self.timestampFormatter.string(from: timestamp)
+    }
+}
+
+// MARK: - System Message Factory
+
+extension BitchatMessage {
+    /// Creates a system message with default values
+    static func system(_ content: String, timestamp: Date = Date()) -> BitchatMessage {
+        return BitchatMessage(
+            sender: "system",
+            content: content,
+            timestamp: timestamp,
+            isRelay: false
+        )
+    }
+}
+
+extension Array where Element == BitchatMessage {
+    /// Filters out empty ones and deduplicate by ID while preserving order (from oldest to newest)
+    func cleanedAndDeduped() -> [Element] {
+        let arr = filter { $0.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false }
+        guard arr.count > 1 else {
+            return arr
+        }
+        var seen = Set<String>()
+        var dedup: [BitchatMessage] = []
+        for m in arr.sorted(by: { $0.timestamp < $1.timestamp }) {
+            if !seen.contains(m.id) {
+                dedup.append(m)
+                seen.insert(m.id)
+            }
+        }
+        return dedup
+    }
+}

bitchat/Models/BitchatPacket.swift

@@ -0,0 +1,91 @@
+//
+// BitchatPacket.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+/// 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: PeerID, payload: Data) {
+        self.version = 1
+        self.type = type
+        // Convert hex string peer ID to binary data (8 bytes)
+        var senderData = Data()
+        var tempID = senderID.id
+        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)
+    }
+}

bitchat/Models/BitchatPeer.swift

@@ -2,8 +2,8 @@ import Foundation
 import CoreBluetooth
 
 /// 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 +51,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 +73,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 +93,6 @@ struct BitchatPeer: Identifiable, Equatable {
     }
     
     static func == (lhs: BitchatPeer, rhs: BitchatPeer) -> Bool {
-        lhs.id == rhs.id
+        lhs.peerID == rhs.peerID
     }
 }
-
-//

bitchat/Models/GeoPerson.swift

@@ -0,0 +1,16 @@
+//
+// GeoPerson.swift
+// bitchat
+//
+// Model representing a participant in a geohash channel
+// This is free and unencumbered software released into the public domain.
+//
+
+import Foundation
+
+/// Represents a person participating in a geohash-based location channel
+struct GeoPerson: Identifiable, Equatable {
+    let id: String        // pubkey hex (lowercased)
+    let displayName: String
+    let lastSeen: Date
+}

bitchat/Models/MessagePadding.swift

@@ -0,0 +1,61 @@
+//
+// MessagePadding.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+/// 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
+    }
+}

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/PeerID.swift

@@ -0,0 +1,212 @@
+//
+// PeerID.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+struct PeerID: Equatable, Hashable {
+    enum Prefix: String, CaseIterable {
+        /// When no prefix is provided
+        case empty = ""
+        /// `"mesh:"`
+        case mesh = "mesh:"
+        /// `"name:"`
+        case name = "name:"
+        /// `"noise:"` (+ 64 characters hex)
+        case noise = "noise:"
+        /// `"nostr_"` (+ 16 characters hex)
+        case geoDM = "nostr_"
+        /// `"nostr:"` (+ 8 characters hex)
+        case geoChat = "nostr:"
+    }
+    
+    let prefix: Prefix
+    
+    /// Returns the actual value without any prefix
+    let bare: String
+    
+    /// Returns the full `id` value by combining `(prefix + bare)`
+    var id: String { prefix.rawValue + bare }
+    
+    // Private so the callers have to go through a convenience init
+    private init(prefix: Prefix, bare: any StringProtocol) {
+        self.prefix = prefix
+        self.bare = String(bare)
+    }
+}
+
+// MARK: - Convenience Inits
+
+extension PeerID {
+    /// Convenience init to create GeoDM PeerID by appending `"nostr_"` to the first 16 characters of `pubKey`
+    init(nostr_ pubKey: String) {
+        self.init(prefix: .geoDM, bare: pubKey.prefix(TransportConfig.nostrConvKeyPrefixLength))
+    }
+    
+    /// Convenience init to create GeoChat PeerID by appending `"nostr:"` to the first 8 characters of `pubKey`
+    init(nostr pubKey: String) {
+        self.init(prefix: .geoChat, bare: pubKey.prefix(TransportConfig.nostrShortKeyDisplayLength))
+    }
+    
+    /// Convenience init to create PeerID from String/Substring by splitting it into prefix and bare parts
+    init(str: any StringProtocol) {
+        if let prefix = Prefix.allCases.first(where: { $0 != .empty && str.hasPrefix($0.rawValue) }) {
+            self.init(prefix: prefix, bare: String(str).dropFirst(prefix.rawValue.count))
+        } else {
+            self.init(prefix: .empty, bare: str)
+        }
+    }
+    
+    /// Convenience init to handle `Optional<String>`
+    init?(str: (any StringProtocol)?) {
+        guard let str else { return nil }
+        self.init(str: str)
+    }
+    
+    /// Convenience init to create PeerID by converting Data to String
+    init?(data: Data) {
+        self.init(str: String(data: data, encoding: .utf8))
+    }
+    
+    /// Convenience init to "hide" hex-encoding implementation detail
+    init(hexData: Data) {
+        self.init(str: hexData.hexEncodedString())
+    }
+}
+
+// MARK: - Noise Public Key Helpers
+
+extension PeerID {
+    /// Derive the stable 16-hex peer ID from a Noise static public key
+    init(publicKey: Data) {
+        self.init(str: publicKey.sha256Fingerprint().prefix(16))
+    }
+    
+    /// Returns a 16-hex short peer ID derived from a 64-hex Noise public key if needed
+    func toShort() -> PeerID {
+        if let noiseKey {
+            return PeerID(publicKey: noiseKey)
+        }
+        return self
+    }
+}
+
+// MARK: - Codable
+
+extension PeerID: Codable {
+    init(from decoder: any Decoder) throws {
+        self.init(str: try decoder.singleValueContainer().decode(String.self))
+    }
+    
+    func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(id)
+    }
+}
+
+// MARK: - Helpers
+
+extension PeerID {
+    var isEmpty: Bool {
+        id.isEmpty
+    }
+    
+    /// Returns true if `id` starts with "`nostr:`"
+    var isGeoChat: Bool {
+        prefix == .geoChat
+    }
+    
+    /// Returns true if `id` starts with "`nostr_`"
+    var isGeoDM: Bool {
+        prefix == .geoDM
+    }
+    
+    func toPercentEncoded() -> String {
+        id.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? id
+    }
+}
+
+// MARK: - Validation
+
+extension PeerID {
+    private enum Constants {
+        static let maxIDLength = 64
+        static let hexIDLength = 16 // 8 bytes = 16 hex chars
+    }
+    
+    /// Validates a peer ID from any source (short 16-hex, full 64-hex, or internal alnum/-/_ up to 64)
+    var isValid: Bool {
+        if prefix != .empty {
+            return PeerID(str: bare).isValid
+        }
+        
+        // Accept short routing IDs (exact 16-hex) or Full Noise key hex (exact 64-hex)
+        if isShort || isNoiseKeyHex {
+            return true
+        }
+        
+        // If length equals short or full but isn't valid hex, reject
+        if id.count == Constants.hexIDLength || id.count == Constants.maxIDLength {
+            return false
+        }
+        
+        // Internal format: alphanumeric + dash/underscore up to 63 (not 16 or 64)
+        let validCharset = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-_"))
+        return !id.isEmpty &&
+                id.count < Constants.maxIDLength &&
+                id.rangeOfCharacter(from: validCharset.inverted) == nil
+    }
+    
+    /// Short routing IDs (exact 16-hex)
+    var isShort: Bool {
+        bare.count == Constants.hexIDLength && Data(hexString: bare) != nil
+    }
+    
+    /// Full Noise key hex (exact 64-hex)
+    var isNoiseKeyHex: Bool {
+        noiseKey != nil
+    }
+    
+    /// Full Noise key (exact 64-hex) as Data
+    var noiseKey: Data? {
+        guard bare.count == Constants.maxIDLength else { return nil }
+        return Data(hexString: bare)
+    }
+}
+
+// MARK: - Comparable
+
+extension PeerID: Comparable {
+    static func < (lhs: PeerID, rhs: PeerID) -> Bool {
+        lhs.id < rhs.id
+    }
+}
+
+// MARK: - String Interop Helpers
+
+// MARK: CustomStringConvertible
+
+extension PeerID: CustomStringConvertible {
+    /// So it returns the actual `id` like before even inside another String
+    var description: String {
+        id
+    }
+}
+
+// MARK: Custom Equatable w/ String & Optionality
+
+// PeerID <> String
+extension Optional where Wrapped == PeerID {
+    static func ==(lhs: Optional<Wrapped>, rhs: Optional<String>) -> Bool   { lhs?.id == rhs }
+    static func !=(lhs: Optional<Wrapped>, rhs: Optional<String>) -> Bool   { lhs?.id != rhs }
+}
+
+// String <> PeerID
+extension Optional where Wrapped == String {
+    static func ==(lhs: Optional<Wrapped>, rhs: Optional<PeerID>) -> Bool   { lhs == rhs?.id }
+    static func !=(lhs: Optional<Wrapped>, rhs: Optional<PeerID>) -> Bool   { lhs != rhs?.id }
+}

bitchat/Models/ReadReceipt.swift

@@ -0,0 +1,95 @@
+//
+// ReadReceipt.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+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 PeerID(str: 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,63 @@
+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
+
+    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)
+        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
+
+        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
+            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)
+    }
+}

bitchat/Noise/NoiseHandshakeCoordinator.swift

@@ -1,357 +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
-final 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.warning("Forcing new handshake with \(remotePeerID) - previous stuck in initiating", category: .handshake)
-                            return true
-                        }
-                    default:
-                        break
-                    }
-                }
-                
-                SecureLogger.debug("Already in active handshake with \(remotePeerID), state: \(state)", category: .handshake)
-                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.info("Recording handshake initiation with \(peerID), attempt \(attempt)", category: .handshake)
-        }
-    }
-    
-    /// Record that we're responding to a handshake
-    func recordHandshakeResponse(peerID: String) {
-        handshakeQueue.async(flags: .barrier) {
-            self.handshakeStates[peerID] = .responding(since: Date())
-            SecureLogger.info("Recording handshake response to \(peerID)", category: .handshake)
-        }
-    }
-    
-    /// Record successful handshake completion
-    func recordHandshakeSuccess(peerID: String) {
-        handshakeQueue.async(flags: .barrier) {
-            self.handshakeStates[peerID] = .established(since: Date())
-            SecureLogger.info("Handshake successfully established with \(peerID)", category: .handshake)
-        }
-    }
-    
-    /// 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.warning("Handshake failed with \(peerID): \(reason), canRetry: \(canRetry)", category: .handshake)
-        }
-    }
-    
-    /// 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.debug("Rejecting handshake from \(remotePeerID) - already established", category: .handshake)
-                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.warning("Accepting handshake from \(remotePeerID) despite being initiator (race condition recovery)", category: .handshake)
-                    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.debug("Reset handshake state for \(peerID)", category: .handshake)
-        }
-    }
-    
-    /// 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.warning("Found stale handshake state for \(peerID): \(state)", category: .handshake)
-                }
-            }
-            
-            // 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.info("Removing old established session for \(peerID) to maintain session limit", category: .handshake)
-                }
-            }
-            
-            // Clean up stale states
-            for peerID in stalePeerIDs {
-                handshakeStates.removeValue(forKey: peerID)
-            }
-            
-            if !stalePeerIDs.isEmpty {
-                SecureLogger.info("Cleaned up \(stalePeerIDs.count) stale handshake states", category: .handshake)
-            }
-            
-            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.debug("=== Handshake States ===", category: .handshake)
-            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.debug("  \(peerID): \(stateDesc)", category: .handshake)
-            }
-            SecureLogger.debug("========================", category: .handshake)
-        }
-    }
-    
-    /// Clear all handshake states - used during panic mode
-    func clearAllHandshakeStates() {
-        handshakeQueue.async(flags: .barrier) {
-            SecureLogger.warning("Clearing all handshake states for panic mode", category: .handshake)
-            self.handshakeStates.removeAll()
-            self.processedHandshakeMessages.removeAll()
-        }
-    }
-}

bitchat/Noise/NoiseProtocol.swift

@@ -77,6 +77,7 @@
 /// - Noise Specification: http://www.noiseprotocol.org/noise.html
 ///
 
+import BitLogger
 import Foundation
 import CryptoKit
 
@@ -396,7 +397,7 @@ final class NoiseSymmetricState {
         if nameData.count <= 32 {
             self.hash = nameData + Data(repeating: 0, count: 32 - nameData.count)
         } else {
-            self.hash = Data(SHA256.hash(data: nameData))
+            self.hash = nameData.sha256Hash()
         }
         self.chainingKey = self.hash
     }
@@ -409,7 +410,7 @@ final class NoiseSymmetricState {
     }
     
     func mixHash(_ data: Data) {
-        hash = Data(SHA256.hash(data: hash + data))
+        hash = (hash + data).sha256Hash()
     }
     
     func mixKeyAndHash(_ inputKeyMaterial: Data) {

bitchat/Noise/NoiseSecurityConsiderations.swift

@@ -6,8 +6,8 @@
 // For more information, see <https://unlicense.org>
 //
 
+import BitLogger
 import Foundation
-import CryptoKit
 
 // MARK: - Security Constants
 
@@ -52,11 +52,6 @@ struct NoiseSecurityValidator {
     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
@@ -136,8 +131,8 @@ final class SecureNoiseSession: NoiseSession {
 // MARK: - Rate Limiter
 
 final class NoiseRateLimiter {
-    private var handshakeTimestamps: [String: [Date]] = [:] // peerID -> timestamps
-    private var messageTimestamps: [String: [Date]] = [:] // peerID -> timestamps
+    private var handshakeTimestamps: [PeerID: [Date]] = [:]
+    private var messageTimestamps: [PeerID: [Date]] = [:]
     
     // Global rate limiting
     private var globalHandshakeTimestamps: [Date] = []
@@ -145,7 +140,7 @@ final class NoiseRateLimiter {
     
     private let queue = DispatchQueue(label: "chat.bitchat.noise.ratelimit", attributes: .concurrent)
     
-    func allowHandshake(from peerID: String) -> Bool {
+    func allowHandshake(from peerID: PeerID) -> Bool {
         return queue.sync(flags: .barrier) {
             let now = Date()
             let oneMinuteAgo = now.addingTimeInterval(-60)
@@ -174,7 +169,7 @@ final class NoiseRateLimiter {
         }
     }
     
-    func allowMessage(from peerID: String) -> Bool {
+    func allowMessage(from peerID: PeerID) -> Bool {
         return queue.sync(flags: .barrier) {
             let now = Date()
             let oneSecondAgo = now.addingTimeInterval(-1)
@@ -203,12 +198,21 @@ final class NoiseRateLimiter {
         }
     }
     
-    func reset(for peerID: String) {
+    func reset(for peerID: PeerID) {
         queue.async(flags: .barrier) {
             self.handshakeTimestamps.removeValue(forKey: peerID)
             self.messageTimestamps.removeValue(forKey: peerID)
         }
     }
+
+    func resetAll() {
+        queue.async(flags: .barrier) {
+            self.handshakeTimestamps.removeAll()
+            self.messageTimestamps.removeAll()
+            self.globalHandshakeTimestamps.removeAll()
+            self.globalMessageTimestamps.removeAll()
+        }
+    }
 }
 
 // MARK: - Security Errors

bitchat/Noise/NoiseSession.swift

@@ -6,35 +6,12 @@
 // For more information, see <https://unlicense.org>
 //
 
+import BitLogger
 import Foundation
 import CryptoKit
 
-// 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 peerID: PeerID
     let role: NoiseRole
     private let keychain: KeychainManagerProtocol
     private var state: NoiseSessionState = .uninitialized
@@ -54,7 +31,7 @@ class NoiseSession {
     private let sessionQueue = DispatchQueue(label: "chat.bitchat.noise.session", attributes: .concurrent)
     
     init(
-        peerID: String,
+        peerID: PeerID,
         role: NoiseRole,
         keychain: KeychainManagerProtocol,
         localStaticKey: Curve25519.KeyAgreement.PrivateKey,
@@ -140,7 +117,7 @@ class NoiseSession {
                 handshakeState = nil // Clear handshake state
                 
                 SecureLogger.debug("NoiseSession[\(peerID)]: Handshake complete (no response needed), transitioning to established")
-                SecureLogger.info(.handshakeCompleted(peerID: peerID))
+                SecureLogger.info(.handshakeCompleted(peerID: peerID.id))
                 
                 return nil
             } else {
@@ -166,7 +143,7 @@ class NoiseSession {
                     handshakeState = nil // Clear handshake state
                     
                     SecureLogger.debug("NoiseSession[\(peerID)]: Handshake complete after writing response, transitioning to established")
-                    SecureLogger.info(.handshakeCompleted(peerID: peerID))
+                    SecureLogger.info(.handshakeCompleted(peerID: peerID.id))
                 }
                 
                 return response
@@ -251,240 +228,8 @@ class NoiseSession {
             handshakeHash = nil
             
             if wasEstablished {
-                SecureLogger.info(.sessionExpired(peerID: peerID))
+                SecureLogger.info(.sessionExpired(peerID: peerID.id))
             }
         }
     }
 }
-
-// MARK: - Session Manager
-
-final class NoiseSessionManager {
-    private var sessions: [String: NoiseSession] = [:]
-    private let localStaticKey: Curve25519.KeyAgreement.PrivateKey
-    private let keychain: KeychainManagerProtocol
-    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, keychain: KeychainManagerProtocol) {
-        self.localStaticKey = localStaticKey
-        self.keychain = keychain
-    }
-    
-    // MARK: - Session Management
-    
-    func createSession(for peerID: String, role: NoiseRole) -> NoiseSession {
-        return managerQueue.sync(flags: .barrier) {
-            let session = SecureNoiseSession(
-                peerID: peerID,
-                role: role,
-                keychain: keychain,
-                localStaticKey: localStaticKey
-            )
-            sessions[peerID] = session
-            return session
-        }
-    }
-    
-    func getSession(for peerID: 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.info(.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,
-                keychain: keychain,
-                localStaticKey: localStaticKey
-            )
-            sessions[peerID] = session
-            
-            do {
-                let handshakeData = try session.startHandshake()
-                return handshakeData
-            } catch {
-                // Clean up failed session
-                _ = sessions.removeValue(forKey: peerID)
-                SecureLogger.error(.handshakeFailed(peerID: peerID, error: error.localizedDescription))
-                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.info("Accepting handshake from \(peerID) despite existing session - peer likely cleared their session", category: .session)
-                    _ = 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,
-                    keychain: keychain,
-                    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.error(.handshakeFailed(peerID: peerID, error: error.localizedDescription))
-                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/Noise/NoiseSessionError.swift

@@ -0,0 +1,15 @@
+//
+// NoiseSessionError.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+enum NoiseSessionError: Error {
+    case invalidState
+    case notEstablished
+    case sessionNotFound
+    case handshakeFailed(Error)
+    case alreadyEstablished
+}

bitchat/Noise/NoiseSessionManager.swift

@@ -0,0 +1,239 @@
+//
+// NoiseSessionManager.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import BitLogger
+import CryptoKit
+import Foundation
+
+final class NoiseSessionManager {
+    private var sessions: [PeerID: NoiseSession] = [:]
+    private let localStaticKey: Curve25519.KeyAgreement.PrivateKey
+    private let keychain: KeychainManagerProtocol
+    private let managerQueue = DispatchQueue(label: "chat.bitchat.noise.manager", attributes: .concurrent)
+    
+    // Callbacks
+    var onSessionEstablished: ((PeerID, Curve25519.KeyAgreement.PublicKey) -> Void)?
+    var onSessionFailed: ((PeerID, Error) -> Void)?
+    
+    init(localStaticKey: Curve25519.KeyAgreement.PrivateKey, keychain: KeychainManagerProtocol) {
+        self.localStaticKey = localStaticKey
+        self.keychain = keychain
+    }
+    
+    // MARK: - Session Management
+    
+    func createSession(for peerID: PeerID, role: NoiseRole) -> NoiseSession {
+        return managerQueue.sync(flags: .barrier) {
+            let session = SecureNoiseSession(
+                peerID: peerID,
+                role: role,
+                keychain: keychain,
+                localStaticKey: localStaticKey
+            )
+            sessions[peerID] = session
+            return session
+        }
+    }
+    
+    func getSession(for peerID: PeerID) -> NoiseSession? {
+        return managerQueue.sync {
+            return sessions[peerID]
+        }
+    }
+    
+    func removeSession(for peerID: PeerID) {
+        managerQueue.sync(flags: .barrier) {
+            if let session = sessions[peerID] {
+                if session.isEstablished() {
+                    SecureLogger.info(.sessionExpired(peerID: peerID.id))
+                }
+                // Clear sensitive data before removing
+                session.reset()
+            }
+            _ = sessions.removeValue(forKey: peerID)
+        }
+    }
+
+    func removeAllSessions() {
+        managerQueue.sync(flags: .barrier) {
+            for (_, session) in sessions {
+                session.reset()
+            }
+            sessions.removeAll()
+        }
+    }
+    
+    func getEstablishedSessions() -> [PeerID: NoiseSession] {
+        return managerQueue.sync {
+            return sessions.filter { $0.value.isEstablished() }
+        }
+    }
+    
+    // MARK: - Handshake Helpers
+    
+    func initiateHandshake(with peerID: PeerID) 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,
+                keychain: keychain,
+                localStaticKey: localStaticKey
+            )
+            sessions[peerID] = session
+            
+            do {
+                let handshakeData = try session.startHandshake()
+                return handshakeData
+            } catch {
+                // Clean up failed session
+                _ = sessions.removeValue(forKey: peerID)
+                SecureLogger.error(.handshakeFailed(peerID: peerID.id, error: error.localizedDescription))
+                throw error
+            }
+        }
+    }
+    
+    func handleIncomingHandshake(from peerID: PeerID, 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.info("Accepting handshake from \(peerID) despite existing session - peer likely cleared their session", category: .session)
+                    _ = 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,
+                    keychain: keychain,
+                    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.error(.handshakeFailed(peerID: peerID.id, error: error.localizedDescription))
+                throw error
+            }
+        }
+    }
+    
+    // MARK: - Encryption/Decryption
+    
+    func encrypt(_ plaintext: Data, for peerID: PeerID) throws -> Data {
+        guard let session = getSession(for: peerID) else {
+            throw NoiseSessionError.sessionNotFound
+        }
+        
+        return try session.encrypt(plaintext)
+    }
+    
+    func decrypt(_ ciphertext: Data, from peerID: PeerID) throws -> Data {
+        guard let session = getSession(for: peerID) else {
+            throw NoiseSessionError.sessionNotFound
+        }
+        
+        return try session.decrypt(ciphertext)
+    }
+    
+    // MARK: - Key Management
+    
+    func getRemoteStaticKey(for peerID: PeerID) -> Curve25519.KeyAgreement.PublicKey? {
+        return getSession(for: peerID)?.getRemoteStaticPublicKey()
+    }
+    
+    func getHandshakeHash(for peerID: PeerID) -> Data? {
+        return getSession(for: peerID)?.getHandshakeHash()
+    }
+    
+    // MARK: - Session Rekeying
+    
+    func getSessionsNeedingRekey() -> [(peerID: PeerID, needsRekey: Bool)] {
+        return managerQueue.sync {
+            var needingRekey: [(peerID: PeerID, 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: PeerID) throws {
+        // Remove old session
+        removeSession(for: peerID)
+        
+        // Initiate new handshake
+        _ = try initiateHandshake(with: peerID)
+    }
+}

bitchat/Noise/NoiseSessionState.swift

@@ -0,0 +1,13 @@
+//
+// NoiseSessionState.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+enum NoiseSessionState: Equatable {
+    case uninitialized
+    case handshaking
+    case established
+}

bitchat/Nostr/GeoRelayDirectory.swift

@@ -1,4 +1,6 @@
+import BitLogger
 import Foundation
+import Tor
 
 /// Directory of online Nostr relays with approximate GPS locations, used for geohash routing.
 @MainActor

bitchat/Nostr/NostrEmbeddedBitChat.swift

@@ -100,7 +100,7 @@ struct NostrEmbeddedBitChat {
         if let maybeData = Data(hexString: recipientPeerID) {
             if maybeData.count == 32 {
                 // Treat as Noise static public key; derive peerID from fingerprint
-                return PeerIDUtils.derivePeerID(fromPublicKey: maybeData)
+                return PeerID(publicKey: maybeData).id
             } else if maybeData.count == 8 {
                 // Already an 8-byte peer ID
                 return recipientPeerID

bitchat/Nostr/NostrIdentity.swift

@@ -150,13 +150,31 @@ struct NostrIdentityBridge {
     
     /// Clear all Nostr identity associations and current identity
     static func clearAllAssociations() {
-        // Delete current Nostr identity
-        KeychainHelper.delete(key: currentIdentityKey, service: keychainService)
-        KeychainHelper.delete(key: deviceSeedKey, service: keychainService)
-        
-        // 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
+        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)
@@ -208,10 +226,7 @@ struct NostrIdentityBridge {
             }
         }
         // 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))
+        let fallback = (seed + msg).sha256Hash()
         return try NostrIdentity(privateKeyData: fallback)
     }
 }

bitchat/Nostr/NostrProtocol.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import CryptoKit
 import P256K
@@ -123,6 +124,28 @@ struct NostrProtocol {
         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?.trimmingCharacters(in: .whitespacesAndNewlines), !nickname.isEmpty {
+            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
     
@@ -498,10 +521,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,6 +1,8 @@
+import BitLogger
 import Foundation
 import Network
 import Combine
+import Tor
 
 /// Manages WebSocket connections to Nostr relays
 @MainActor
@@ -34,10 +36,14 @@ final class NostrRelayManager: ObservableObject {
         "wss://nostr21.com"
         // For local testing, you can add: "ws://localhost:8080"
     ]
+    private static let defaultRelaySet = Set(defaultRelays)
     
     @Published private(set) var relays: [Relay] = []
     @Published private(set) var isConnected = false
     
+    private var allowDefaultRelays: Bool = false
+    private var hasMutualFavorites: Bool = false
+    private var hasLocationPermission: Bool = false
     private var connections: [String: URLSessionWebSocketTask] = [:]
     private var subscriptions: [String: Set<String>] = [:] // relay URL -> active subscription IDs
     private var pendingSubscriptions: [String: [String: String]] = [:] // relay URL -> (subscription id -> encoded REQ JSON)
@@ -45,6 +51,14 @@ final class NostrRelayManager: ObservableObject {
     // 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.
@@ -56,6 +70,8 @@ final class NostrRelayManager: ObservableObject {
     private let messageQueueLock = NSLock()
     private let encoder = JSONEncoder()
     private let decoder = JSONDecoder()
+    private var networkService: NetworkActivationService { NetworkActivationService.shared }
+    private var shouldUseTor: Bool { networkService.userTorEnabled }
     
     // Exponential backoff configuration
     private let initialBackoffInterval: TimeInterval = TransportConfig.nostrRelayInitialBackoffSeconds
@@ -69,27 +85,68 @@ final class NostrRelayManager: ObservableObject {
     private var connectionGeneration: Int = 0
     
     init() {
-        // Initialize with default relays
-        self.relays = Self.defaultRelays.map { Relay(url: $0) }
+        hasMutualFavorites = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
+        hasLocationPermission = LocationChannelManager.shared.permissionState == .authorized
+        applyDefaultRelayPolicy(force: true)
         // Deterministic JSON shape for outbound requests
         self.encoder.outputFormatting = .sortedKeys
+        FavoritesPersistenceService.shared.$mutualFavorites
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] favorites in
+                guard let self = self else { return }
+                self.hasMutualFavorites = !favorites.isEmpty
+                self.applyDefaultRelayPolicy()
+            }
+            .store(in: &cancellables)
+        LocationChannelManager.shared.$permissionState
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] state in
+                guard let self = self else { return }
+                let authorized = (state == .authorized)
+                if authorized == self.hasLocationPermission { return }
+                self.hasLocationPermission = authorized
+                self.applyDefaultRelayPolicy()
+            }
+            .store(in: &cancellables)
     }
-    
+
+    deinit {
+        // Clean up timers and active connections
+        reconnectionTimer?.invalidate()
+        for (_, tracker) in eoseTrackers {
+            tracker.timer?.invalidate()
+        }
+        for (_, task) in connections {
+            task.cancel(with: .goingAway, reason: nil)
+        }
+        cancellables.removeAll()
+        SecureLogger.debug("NostrRelayManager deinitialized", category: .session)
+    }
+
     /// Connect to all configured relays
     func connect() {
-        // Ensure Tor is started early and wait for readiness off-main; then hop back to connect.
-        Task.detached {
-            let ready = await TorManager.shared.awaitReady()
-            await MainActor.run {
-                if !ready {
-                    SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
-                    return
-                }
-                SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
-                for relay in self.relays {
-                    self.connectToRelay(relay.url)
+        // Global network policy gate
+        guard networkService.activationAllowed else { return }
+        if shouldUseTor {
+            // Ensure Tor is started early and wait for readiness off-main; then hop back to connect.
+            Task.detached {
+                let ready = await TorManager.shared.awaitReady()
+                await MainActor.run {
+                    if !ready {
+                        SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
+                        return
+                    }
+                    SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
+                    for relay in self.relays {
+                        self.connectToRelay(relay.url)
+                    }
                 }
             }
+        } else {
+            SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (direct)", category: .session)
+            for relay in self.relays {
+                connectToRelay(relay.url)
+            }
         }
     }
     
@@ -108,7 +165,11 @@ final class NostrRelayManager: ObservableObject {
     
     /// Ensure connections exist to the given relay URLs (idempotent).
     func ensureConnections(to relayUrls: [String]) {
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        // Global network policy gate
+        guard networkService.activationAllowed else { return }
+        let targets = allowedRelayList(from: relayUrls)
+        guard !targets.isEmpty else { return }
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer until Tor is fully ready; avoid queuing connection attempts early
             Task.detached { [weak self] in
                 guard let self = self else { return }
@@ -117,20 +178,21 @@ final class NostrRelayManager: ObservableObject {
             }
             return
         }
-        let existing = Set(relays.map { $0.url })
-        for url in Set(relayUrls) {
-            if !existing.contains(url) {
-                relays.append(Relay(url: url))
-            }
-            if connections[url] == nil {
-                connectToRelay(url)
-            }
+        var existing = Set(relays.map { $0.url })
+        for url in targets where !existing.contains(url) {
+            relays.append(Relay(url: url))
+            existing.insert(url)
+        }
+        for url in targets where connections[url] == nil {
+            connectToRelay(url)
         }
     }
 
     /// Send an event to specified relays (or all if none specified)
     func sendEvent(_ event: NostrEvent, to relayUrls: [String]? = nil) {
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        // Global network policy gate
+        guard networkService.activationAllowed else { return }
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer sends until Tor is ready to avoid premature queueing
             Task.detached { [weak self] in
                 guard let self = self else { return }
@@ -139,7 +201,9 @@ final class NostrRelayManager: ObservableObject {
             }
             return
         }
-        let targetRelays = relayUrls ?? Self.defaultRelays
+        let requestedRelays = relayUrls ?? Self.defaultRelays
+        let targetRelays = allowedRelayList(from: requestedRelays)
+        guard !targetRelays.isEmpty else { return }
         ensureConnections(to: targetRelays)
 
         // Attempt immediate send to relays with active connections; queue the rest
@@ -201,8 +265,11 @@ final 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 networkService.activationAllowed else { return }
         // Coalesce rapid duplicate subscribe requests only if a handler already exists
         let now = Date()
         if messageHandlers[id] != nil {
@@ -211,7 +278,7 @@ final class NostrRelayManager: ObservableObject {
             }
         }
         subscribeCoalesce[id] = now
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer subscription setup until Tor is ready; avoid queuing subs early
             Task.detached { [weak self] in
                 guard let self = self else { return }
@@ -239,17 +306,38 @@ final class NostrRelayManager: ObservableObject {
             
             // Target specific relays if provided; else default. Filter permanently failed relays.
             let baseUrls = relayUrls ?? Self.defaultRelays
-            let urls = baseUrls.filter { !isPermanentlyFailed($0) }
+            let candidateUrls = baseUrls.filter { !isPermanentlyFailed($0) }
+            let urls = allowedRelayList(from: candidateUrls)
             // Always queue subscriptions; sending happens when a relay reports connected
             let existingSet = Set(relays.map { $0.url })
             for url in urls where !existingSet.contains(url) {
                 relays.append(Relay(url: url))
             }
-            for url in urls {
+            for url in candidateUrls {
                 var map = self.pendingSubscriptions[url] ?? [:]
                 map[id] = messageString
                 self.pendingSubscriptions[url] = map
             }
+            // Initialize EOSE tracking if requested
+            if let onEOSE = onEOSE {
+                if urls.isEmpty {
+                    onEOSE()
+                } else {
+                    var tracker = EOSETracker(pendingRelays: Set(urls), callback: onEOSE, timer: nil)
+                    // Fallback timeout to avoid hanging if a relay never sends EOSE
+                    tracker.timer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
+                        Task { @MainActor in
+                            guard let self = self else { return }
+                            if let t = self.eoseTrackers[id] {
+                                t.timer?.invalidate()
+                                self.eoseTrackers.removeValue(forKey: id)
+                                onEOSE()
+                            }
+                        }
+                    }
+                    eoseTrackers[id] = tracker
+                }
+            }
             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)
@@ -263,6 +351,55 @@ final class NostrRelayManager: ObservableObject {
             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 networkService.activationAllowed {
+                ensureConnections(to: Self.defaultRelays)
+            }
+        } else {
+            for url in Self.defaultRelays {
+                if let connection = connections[url] {
+                    connection.cancel(with: .goingAway, reason: nil)
+                }
+                connections.removeValue(forKey: url)
+                subscriptions.removeValue(forKey: url)
+            }
+            messageQueueLock.lock()
+            for index in (0..<messageQueue.count).reversed() {
+                var item = messageQueue[index]
+                item.pendingRelays.subtract(Self.defaultRelaySet)
+                if item.pendingRelays.isEmpty {
+                    messageQueue.remove(at: index)
+                } else {
+                    messageQueue[index] = item
+                }
+            }
+            messageQueueLock.unlock()
+            relays.removeAll { Self.defaultRelaySet.contains($0.url) }
+            updateConnectionStatus()
+        }
+    }
+
+    private func allowedRelayList(from urls: [String]) -> [String] {
+        var seen = Set<String>()
+        var result: [String] = []
+        for url in urls {
+            if !allowDefaultRelays && Self.defaultRelaySet.contains(url) { continue }
+            if seen.insert(url).inserted {
+                result.append(url)
+            }
+        }
+        return result
+    }
     
     /// Unsubscribe from a subscription
     func unsubscribe(id: String) {
@@ -291,13 +428,15 @@ final class NostrRelayManager: ObservableObject {
     // MARK: - Private Methods
     
     private func connectToRelay(_ urlString: String) {
+        // Global network policy gate
+        guard networkService.activationAllowed else { return }
         guard let url = URL(string: urlString) else { 
             SecureLogger.warning("Invalid relay URL: \(urlString)", category: .session)
             return 
         }
 
         // Avoid initiating connections while app is backgrounded; we'll reconnect on foreground
-        if TorManager.shared.torEnforced && !TorManager.shared.isForeground() {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isForeground() {
             return
         }
         
@@ -312,7 +451,7 @@ final class NostrRelayManager: ObservableObject {
         // Attempting to connect to Nostr relay via the proxied session
         
         // If Tor is enforced but not ready, delay connection until it is.
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             Task.detached { [weak self] in
                 guard let self = self else { return }
                 let ready = await TorManager.shared.awaitReady()
@@ -418,9 +557,17 @@ final class NostrRelayManager: ObservableObject {
             } else {
                 SecureLogger.warning("⚠️ No handler for subscription \(subId)", category: .session)
             }
-        case .eose:
-            // No-op for now
-            break
+        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 .ok(let eventId, let success, let reason):
             if success {
                 _ = Self.pendingGiftWrapIDs.remove(eventId)
@@ -489,6 +636,13 @@ final class NostrRelayManager: ObservableObject {
     }
     
     private func handleDisconnection(relayUrl: String, error: Error) {
+        // If networking is disallowed, do not schedule reconnection
+        if !networkService.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)
@@ -755,6 +909,16 @@ struct NostrFilter: Encodable {
         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
+    }
 }
 
 // Dynamic coding key for tag filters

bitchat/Protocols/BinaryEncodingUtils.swift

@@ -197,7 +197,7 @@ extension Data {
         offset += 16
         
         // Convert 16 bytes to UUID string format
-        let uuid = uuidData.map { String(format: "%02x", $0) }.joined()
+        let uuid = uuidData.hexEncodedString()
         
         // Insert hyphens at proper positions: 8-4-4-4-12
         var result = ""

bitchat/Protocols/BinaryProtocol.swift

@@ -328,236 +328,3 @@ struct BinaryProtocol {
         }
     }
 }
-
-// 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/BitchatProtocol.swift

@@ -59,61 +59,7 @@
 ///
 
 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
-    }
-}
+import CoreBluetooth
 
 // MARK: - Message Types
 
@@ -125,6 +71,7 @@ enum MessageType: UInt8 {
     case announce = 0x01        // "I'm here" with nickname
     case message = 0x02         // Public chat message  
     case leave = 0x03           // "I'm leaving"
+    case requestSync = 0x21     // GCS filter-based sync request (local-only)
     
     // Noise encryption
     case noiseHandshake = 0x10  // Handshake (init or response determined by payload)
@@ -138,6 +85,7 @@ enum MessageType: UInt8 {
         case .announce: return "announce"
         case .message: return "message"
         case .leave: return "leave"
+        case .requestSync: return "requestSync"
         case .noiseHandshake: return "noiseHandshake"
         case .noiseEncrypted: return "noiseEncrypted"
         case .fragment: return "fragment"
@@ -181,191 +129,10 @@ 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 {
+enum DeliveryStatus: Codable, Equatable, Hashable {
     case sending
     case sent  // Left our device
     case delivered(to: String, at: Date)  // Confirmed by recipient
@@ -391,90 +158,25 @@ enum DeliveryStatus: Codable, Equatable {
     }
 }
 
-// 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
-final 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)
 }
 
 // Provide default implementation to make it effectively optional
@@ -487,45 +189,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) {
         // 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)

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")

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/ColorPaletteService.swift

@@ -0,0 +1,328 @@
+//
+// ColorPaletteService.swift
+// bitchat
+//
+// Manages consistent color assignment for peers using minimal-distance algorithm
+// This is free and unencumbered software released into the public domain.
+//
+
+import Foundation
+import SwiftUI
+
+/// Service that assigns consistent, visually distinct colors to peers
+/// Uses a minimal-distance hue assignment algorithm to maximize color separation
+final class ColorPaletteService {
+
+    // MARK: - Palette State
+
+    private var peerPaletteLight: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+    private var peerPaletteDark: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+    private var peerPaletteSeeds: [String: String] = [:] // peerID -> seed used
+
+    private var nostrPaletteLight: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+    private var nostrPaletteDark: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+    private var nostrPaletteSeeds: [String: String] = [:] // pubkey -> seed used
+
+    // MARK: - Configuration
+
+    private let slotCount: Int
+    private let avoidCenter: Double // Hue to avoid (typically orange for self)
+    private let avoidDelta: Double
+    private let saturationDark: Double
+    private let saturationLight: Double
+    private let baseBrightnessDark: Double
+    private let baseBrightnessLight: Double
+    private let ringDeltaDark: Double
+    private let ringDeltaLight: Double
+
+    // MARK: - Initialization
+
+    init(
+        slotCount: Int = max(8, TransportConfig.uiPeerPaletteSlots),
+        avoidCenter: Double = 30.0 / 360.0, // Orange hue
+        avoidDelta: Double = TransportConfig.uiColorHueAvoidanceDelta,
+        saturationDark: Double = 0.80,
+        saturationLight: Double = 0.70,
+        baseBrightnessDark: Double = 0.75,
+        baseBrightnessLight: Double = 0.45,
+        ringDeltaDark: Double = TransportConfig.uiPeerPaletteRingBrightnessDeltaDark,
+        ringDeltaLight: Double = TransportConfig.uiPeerPaletteRingBrightnessDeltaLight
+    ) {
+        self.slotCount = slotCount
+        self.avoidCenter = avoidCenter
+        self.avoidDelta = avoidDelta
+        self.saturationDark = saturationDark
+        self.saturationLight = saturationLight
+        self.baseBrightnessDark = baseBrightnessDark
+        self.baseBrightnessLight = baseBrightnessLight
+        self.ringDeltaDark = ringDeltaDark
+        self.ringDeltaLight = ringDeltaLight
+    }
+
+    // MARK: - Public API
+
+    /// Get color for a mesh peer
+    func colorForMeshPeer(
+        peerID: String,
+        isDark: Bool,
+        myPeerID: String,
+        allPeers: [BitchatPeer],
+        getNoiseKeyForShortID: (String) -> String?
+    ) -> Color {
+        // Ensure palette is up to date
+        rebuildPeerPaletteIfNeeded(
+            myPeerID: myPeerID,
+            allPeers: allPeers,
+            getNoiseKeyForShortID: getNoiseKeyForShortID
+        )
+
+        let entry = (isDark ? peerPaletteDark[peerID] : peerPaletteLight[peerID])
+        let orange = Color.orange
+        if peerID == myPeerID { return orange }
+
+        let saturation: Double = isDark ? saturationDark : saturationLight
+        let baseBrightness: Double = isDark ? baseBrightnessDark : baseBrightnessLight
+        let ringDelta = isDark ? ringDeltaDark : ringDeltaLight
+
+        if let e = entry {
+            let brightness = min(1.0, max(0.0, baseBrightness + ringDelta * Double(e.ring)))
+            return Color(hue: e.hue, saturation: saturation, brightness: brightness)
+        }
+
+        // Fallback to seed color if not in palette
+        let seed = meshSeed(for: peerID, getNoiseKeyForShortID: getNoiseKeyForShortID)
+        return Color(peerSeed: seed, isDark: isDark)
+    }
+
+    /// Get color for a Nostr participant
+    func colorForNostrPubkey(
+        pubkeyHexLowercased: String,
+        isDark: Bool,
+        myNostrPubkey: String?,
+        geohashPeople: [(id: String, seed: String)]
+    ) -> Color {
+        rebuildNostrPaletteIfNeeded(
+            myNostrPubkey: myNostrPubkey,
+            geohashPeople: geohashPeople
+        )
+
+        let entry = (isDark ? nostrPaletteDark[pubkeyHexLowercased] : nostrPaletteLight[pubkeyHexLowercased])
+        if let me = myNostrPubkey, pubkeyHexLowercased == me { return .orange }
+
+        let saturation: Double = isDark ? saturationDark : saturationLight
+        let baseBrightness: Double = isDark ? baseBrightnessDark : baseBrightnessLight
+        let ringDelta = isDark ? ringDeltaDark : ringDeltaLight
+
+        if let e = entry {
+            let brightness = min(1.0, max(0.0, baseBrightness + ringDelta * Double(e.ring)))
+            return Color(hue: e.hue, saturation: saturation, brightness: brightness)
+        }
+
+        // Fallback to seed color
+        return Color(peerSeed: "nostr:" + pubkeyHexLowercased, isDark: isDark)
+    }
+
+    /// Get color for a message sender (auto-detects type)
+    func peerColor(
+        for message: BitchatMessage,
+        isDark: Bool,
+        myPeerID: String,
+        myNostrPubkey: String?,
+        nostrKeyMapping: [String: String],
+        allPeers: [BitchatPeer],
+        geohashPeople: [(id: String, seed: String)],
+        getNoiseKeyForShortID: (String) -> String?
+    ) -> Color {
+        if let spid = message.senderPeerID?.id {
+            if spid.hasPrefix("nostr:") || spid.hasPrefix("nostr_") {
+                let bare: String = {
+                    if spid.hasPrefix("nostr:") { return String(spid.dropFirst(6)) }
+                    if spid.hasPrefix("nostr_") { return String(spid.dropFirst(6)) }
+                    return spid
+                }()
+                let full = nostrKeyMapping[spid]?.lowercased() ?? bare.lowercased()
+                return colorForNostrPubkey(
+                    pubkeyHexLowercased: full,
+                    isDark: isDark,
+                    myNostrPubkey: myNostrPubkey,
+                    geohashPeople: geohashPeople
+                )
+            } else if spid.count == 16 {
+                return colorForMeshPeer(
+                    peerID: spid,
+                    isDark: isDark,
+                    myPeerID: myPeerID,
+                    allPeers: allPeers,
+                    getNoiseKeyForShortID: getNoiseKeyForShortID
+                )
+            } else {
+                return colorForMeshPeer(
+                    peerID: spid.lowercased(),
+                    isDark: isDark,
+                    myPeerID: myPeerID,
+                    allPeers: allPeers,
+                    getNoiseKeyForShortID: getNoiseKeyForShortID
+                )
+            }
+        }
+        // Fallback when we only have a display name
+        return Color(peerSeed: message.sender.lowercased(), isDark: isDark)
+    }
+
+    /// Reset all palette state (useful for testing)
+    func reset() {
+        peerPaletteLight.removeAll()
+        peerPaletteDark.removeAll()
+        peerPaletteSeeds.removeAll()
+        nostrPaletteLight.removeAll()
+        nostrPaletteDark.removeAll()
+        nostrPaletteSeeds.removeAll()
+    }
+
+    // MARK: - Private Helpers
+
+    private func meshSeed(for peerID: String, getNoiseKeyForShortID: (String) -> String?) -> String {
+        if let full = getNoiseKeyForShortID(peerID)?.lowercased() {
+            return "noise:" + full
+        }
+        return peerID.lowercased()
+    }
+
+    private func rebuildPeerPaletteIfNeeded(
+        myPeerID: String,
+        allPeers: [BitchatPeer],
+        getNoiseKeyForShortID: (String) -> String?
+    ) {
+        // Build current peer->seed map (excluding self)
+        var currentSeeds: [String: String] = [:]
+        for p in allPeers where p.peerID.id != myPeerID {
+            currentSeeds[p.peerID.id] = meshSeed(for: p.peerID.id, getNoiseKeyForShortID: getNoiseKeyForShortID)
+        }
+
+        // If seeds unchanged and palette exists for both themes, skip
+        if currentSeeds == peerPaletteSeeds,
+           peerPaletteLight.keys.count == currentSeeds.count,
+           peerPaletteDark.keys.count == currentSeeds.count {
+            return
+        }
+        peerPaletteSeeds = currentSeeds
+
+        // Generate palette
+        let mapping = assignColorsMinimalDistance(seeds: currentSeeds, previousMapping: peerPaletteLight)
+        peerPaletteLight = mapping
+        peerPaletteDark = mapping
+    }
+
+    private func rebuildNostrPaletteIfNeeded(
+        myNostrPubkey: String?,
+        geohashPeople: [(id: String, seed: String)]
+    ) {
+        // Build seeds map from currently visible geohash people (excluding self)
+        var currentSeeds: [String: String] = [:]
+        for p in geohashPeople where p.id != myNostrPubkey {
+            currentSeeds[p.id] = p.seed
+        }
+
+        if currentSeeds == nostrPaletteSeeds,
+           nostrPaletteLight.keys.count == currentSeeds.count,
+           nostrPaletteDark.keys.count == currentSeeds.count {
+            return
+        }
+        nostrPaletteSeeds = currentSeeds
+
+        let mapping = assignColorsMinimalDistance(seeds: currentSeeds, previousMapping: nostrPaletteLight)
+        nostrPaletteLight = mapping
+        nostrPaletteDark = mapping
+    }
+
+    // MARK: - Minimal-Distance Color Assignment Algorithm
+
+    private func assignColorsMinimalDistance(
+        seeds: [String: String],
+        previousMapping: [String: (slot: Int, ring: Int, hue: Double)]
+    ) -> [String: (slot: Int, ring: Int, hue: Double)] {
+        // Generate evenly spaced hue slots avoiding self-orange range
+        var slots: [Double] = []
+        for i in 0..<slotCount {
+            let hue = Double(i) / Double(slotCount)
+            if abs(hue - avoidCenter) < avoidDelta { continue }
+            slots.append(hue)
+        }
+        if slots.isEmpty {
+            // Safety: if avoidance consumed all (shouldn't happen), fall back to full slots
+            for i in 0..<slotCount { slots.append(Double(i) / Double(slotCount)) }
+        }
+
+        // Helper to compute circular distance
+        func circDist(_ a: Double, _ b: Double) -> Double {
+            let d = abs(a - b)
+            return d > 0.5 ? 1.0 - d : d
+        }
+
+        // Assign slots to peers to maximize minimal distance, deterministically
+        let peers = seeds.keys.sorted() // stable order
+
+        // Preferred slot index by seed (wrapping to available slots)
+        let prefIndex: [String: Int] = Dictionary(uniqueKeysWithValues: peers.map { id in
+            let h = (seeds[id] ?? id).djb2()
+            let idx = Int(h % UInt64(slots.count))
+            return (id, idx)
+        })
+
+        var mapping: [String: (slot: Int, ring: Int, hue: Double)] = [:]
+        var usedSlots = Set<Int>()
+        var usedHues: [Double] = []
+
+        // Keep previous assignments if still valid to minimize churn
+        for (id, entry) in previousMapping {
+            if seeds.keys.contains(id), entry.slot < slots.count { // slot index still valid
+                mapping[id] = (entry.slot, entry.ring, slots[entry.slot])
+                usedSlots.insert(entry.slot)
+                usedHues.append(slots[entry.slot])
+            }
+        }
+
+        // First ring assignment using free slots
+        let unassigned = peers.filter { mapping[$0] == nil }
+        for id in unassigned {
+            // If a preferred slot free, take it
+            let preferred = prefIndex[id] ?? 0
+            if !usedSlots.contains(preferred) && preferred < slots.count {
+                mapping[id] = (preferred, 0, slots[preferred])
+                usedSlots.insert(preferred)
+                usedHues.append(slots[preferred])
+                continue
+            }
+            // Choose free slot maximizing minimal distance to used hues
+            var bestSlot: Int? = nil
+            var bestScore: Double = -1
+            for sIdx in 0..<slots.count where !usedSlots.contains(sIdx) {
+                let hue = slots[sIdx]
+                let minDist = usedHues.isEmpty ? 1.0 : usedHues.map { circDist(hue, $0) }.min() ?? 1.0
+                // Bias toward preferred index for stability
+                let bias = 1.0 - (Double((abs(sIdx - (prefIndex[id] ?? 0)) % slots.count)) / Double(slots.count))
+                let score = minDist + 0.05 * bias
+                if score > bestScore { bestScore = score; bestSlot = sIdx }
+            }
+            if let s = bestSlot {
+                mapping[id] = (s, 0, slots[s])
+                usedSlots.insert(s)
+                usedHues.append(slots[s])
+            }
+        }
+
+        // Overflow peers: assign additional rings by reusing slots with stable preference
+        let stillUnassigned = peers.filter { mapping[$0] == nil }
+        if !stillUnassigned.isEmpty {
+            for (idx, id) in stillUnassigned.enumerated() {
+                let preferred = prefIndex[id] ?? 0
+                // Spread over slots by rotating from preferred with a golden-step
+                let goldenStep = 7 // small prime step for dispersion
+                let s = (preferred + idx * goldenStep) % slots.count
+                mapping[id] = (s, 1, slots[s])
+            }
+        }
+
+        return mapping
+    }
+}

bitchat/Services/CommandProcessor.swift

@@ -148,10 +148,10 @@ final class CommandProcessor {
         
         if chatViewModel?.selectedPrivateChatPeer != nil {
             // In private chat
-            if let peerNickname = meshService?.peerNickname(peerID: targetPeerID) {
+            if let peerNickname = meshService?.peerNickname(peerID: PeerID(str: targetPeerID)) {
                 let personalMessage = "* \(emoji) \(myNickname) \(action) you\(suffix) *"
-                meshService?.sendPrivateMessage(personalMessage, to: targetPeerID, 
-                                               recipientNickname: peerNickname, 
+                meshService?.sendPrivateMessage(personalMessage, to: PeerID(str: targetPeerID),
+                                               recipientNickname: peerNickname,
                                                messageID: UUID().uuidString)
                 // Also add a local system message so the sender sees a natural-language confirmation
                 let pastAction: String = {
@@ -214,7 +214,7 @@ final class CommandProcessor {
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
         if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-           let fingerprint = meshService?.getFingerprint(for: peerID) {
+           let fingerprint = meshService?.getFingerprint(for: PeerID(str: peerID)) {
             if identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is already blocked")
             }
@@ -258,7 +258,7 @@ final class CommandProcessor {
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
         if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-           let fingerprint = meshService?.getFingerprint(for: peerID) {
+           let fingerprint = meshService?.getFingerprint(for: PeerID(str: peerID)) {
             if !identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is not blocked")
             }

bitchat/Services/DeliveryTrackingService.swift

@@ -0,0 +1,73 @@
+//
+// DeliveryTrackingService.swift
+// bitchat
+//
+// Service for tracking message delivery and read status
+// This is free and unencumbered software released into the public domain.
+//
+
+import BitLogger
+import Foundation
+
+/// Service that manages delivery status updates for messages
+/// Prevents status downgrades (e.g., read → delivered) and maintains consistency
+final class DeliveryTrackingService {
+
+    // MARK: - Public API
+
+    /// Update delivery status for a message, preventing downgrades
+    /// - Parameters:
+    ///   - messageID: The message ID to update
+    ///   - status: The new delivery status
+    ///   - messages: Array of public messages (inout for mutation)
+    ///   - privateChats: Dictionary of private chats (inout for mutation)
+    ///   - notifyChange: Closure to trigger UI update
+    func updateStatus(
+        messageID: String,
+        status: DeliveryStatus,
+        messages: inout [BitchatMessage],
+        privateChats: inout [String: [BitchatMessage]],
+        notifyChange: @escaping () -> Void
+    ) {
+        // Update in main messages
+        if let index = messages.firstIndex(where: { $0.id == messageID }) {
+            let currentStatus = messages[index].deliveryStatus
+            if !shouldSkipUpdate(currentStatus: currentStatus, newStatus: status) {
+                messages[index].deliveryStatus = status
+            }
+        }
+
+        // Update in private chats
+        for (peerID, chatMessages) in privateChats {
+            guard let index = chatMessages.firstIndex(where: { $0.id == messageID }) else { continue }
+
+            let currentStatus = chatMessages[index].deliveryStatus
+            guard !shouldSkipUpdate(currentStatus: currentStatus, newStatus: status) else { continue }
+
+            // Update delivery status
+            privateChats[peerID]?[index].deliveryStatus = status
+        }
+
+        // Trigger UI update
+        DispatchQueue.main.async {
+            notifyChange()
+        }
+    }
+
+    // MARK: - Private Helpers
+
+    /// Check if we should skip a status update to prevent downgrades
+    private func shouldSkipUpdate(currentStatus: DeliveryStatus?, newStatus: DeliveryStatus) -> Bool {
+        guard let current = currentStatus else { return false }
+
+        // Don't downgrade from read to delivered or sent
+        switch (current, newStatus) {
+        case (.read, .delivered):
+            return true
+        case (.read, .sent):
+            return true
+        default:
+            return false
+        }
+    }
+}

bitchat/Services/FavoritesPersistenceService.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import Combine
 
@@ -44,7 +45,13 @@ final class FavoritesPersistenceService: ObservableObject {
             }
             .assign(to: &$mutualFavorites)
     }
-    
+
+    deinit {
+        // Clean up Combine subscriptions
+        cancellables.removeAll()
+        SecureLogger.debug("FavoritesPersistenceService deinitialized", category: .session)
+    }
+
     /// Add or update a favorite
     func addFavorite(
         peerNoisePublicKey: Data,
@@ -178,125 +185,15 @@ final 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.warning("⚠️ Cannot update noise key - no favorite found for \(oldKey.hexEncodedString())", category: .session)
-            return 
-        }
-        
-        // Check if we already have a favorite with the new key
-        if favorites[newKey] != nil {
-            SecureLogger.warning("⚠️ Favorite already exists with new key \(newKey.hexEncodedString()), removing old entry", category: .session)
-            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.warning("🧹 Clearing all favorites (panic mode)", category: .session)

bitchat/Services/GeohashBookmarksStore.swift

@@ -1,8 +1,7 @@
+import BitLogger
 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)
@@ -16,15 +15,22 @@ final class GeohashBookmarksStore: ObservableObject {
     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 let storage: UserDefaults
 
-    private init() {
+    init(storage: UserDefaults = .standard) {
+        self.storage = storage
         load()
     }
 
+    deinit {
+        // Cancel any pending geocoding operations
+        geocoder.cancelGeocode()
+        SecureLogger.debug("GeohashBookmarksStore deinitialized", category: .session)
+    }
+
     // MARK: - Public API
     func isBookmarked(_ geohash: String) -> Bool {
         return membership.contains(Self.normalize(geohash))
@@ -64,7 +70,7 @@ final class GeohashBookmarksStore: ObservableObject {
 
     // MARK: - Persistence
     private func load() {
-        guard let data = UserDefaults.standard.data(forKey: storeKey) else { return }
+        guard let data = storage.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>()
@@ -81,7 +87,7 @@ final class GeohashBookmarksStore: ObservableObject {
             membership = seen
         }
         // Load any saved names
-        if let namesData = UserDefaults.standard.data(forKey: namesStoreKey),
+        if let namesData = storage.data(forKey: namesStoreKey),
            let dict = try? JSONDecoder().decode([String: String].self, from: namesData) {
             bookmarkNames = dict
         }
@@ -89,13 +95,13 @@ final class GeohashBookmarksStore: ObservableObject {
 
     private func persist() {
         if let data = try? JSONEncoder().encode(bookmarks) {
-            UserDefaults.standard.set(data, forKey: storeKey)
+            storage.set(data, forKey: storeKey)
         }
     }
 
     private func persistNames() {
         if let data = try? JSONEncoder().encode(bookmarkNames) {
-            UserDefaults.standard.set(data, forKey: namesStoreKey)
+            storage.set(data, forKey: namesStoreKey)
         }
     }
 
@@ -115,7 +121,6 @@ final class GeohashBookmarksStore: ObservableObject {
         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
@@ -146,10 +151,8 @@ final class GeohashBookmarksStore: ObservableObject {
                 }
             }
         }
-        #endif
     }
 
-    #if os(iOS) || os(macOS)
     private func resolveCompositeAdminName(geohash gh: String, points: [CLLocation]) {
         var uniqueAdmins = OrderedSet<String>()
         var idx = 0
@@ -212,7 +215,6 @@ final class GeohashBookmarksStore: ObservableObject {
             return pm.subLocality ?? pm.locality ?? pm.administrativeArea ?? pm.country
         }
     }
-    #endif
 
     #if DEBUG
     /// Testing-only reset helper

bitchat/Services/GeohashParticipantsService.swift

@@ -0,0 +1,180 @@
+//
+// GeohashParticipantsService.swift
+// bitchat
+//
+// Manages tracking of participants in geohash-based location channels
+// This is free and unencumbered software released into the public domain.
+//
+
+import BitLogger
+import Foundation
+import Combine
+
+/// Service for tracking and managing participants in geohash channels
+/// Handles automatic expiration, refresh timers, and participant list management
+final class GeohashParticipantsService: ObservableObject {
+
+    // MARK: - Published Properties
+
+    @Published private(set) var geohashPeople: [GeoPerson] = []
+
+    // MARK: - Private State
+
+    private var geoParticipants: [String: [String: Date]] = [:] // geohash -> [pubkeyHex -> lastSeen]
+    private var geoParticipantsTimer: Timer? = nil
+    private var currentGeohash: String? = nil
+
+    // MARK: - Dependencies
+
+    private let identityManager: SecureIdentityStateManagerProtocol
+    private let displayNameProvider: (String) -> String
+
+    // MARK: - Configuration
+
+    private let activityWindowSeconds: TimeInterval
+    private let refreshIntervalSeconds: TimeInterval
+
+    // MARK: - Initialization
+
+    init(
+        identityManager: SecureIdentityStateManagerProtocol,
+        displayNameProvider: @escaping (String) -> String,
+        activityWindowSeconds: TimeInterval = TransportConfig.uiRecentCutoffFiveMinutesSeconds,
+        refreshIntervalSeconds: TimeInterval = 30.0
+    ) {
+        self.identityManager = identityManager
+        self.displayNameProvider = displayNameProvider
+        self.activityWindowSeconds = activityWindowSeconds
+        self.refreshIntervalSeconds = refreshIntervalSeconds
+    }
+
+    deinit {
+        // Note: deinit cannot call @MainActor methods
+        // Timer cleanup will happen automatically when service is deallocated
+        SecureLogger.debug("GeohashParticipantsService deinitialized", category: .session)
+    }
+
+    // MARK: - Public API
+
+    /// Set the current geohash being tracked (starts/stops timer accordingly)
+    func setCurrentGeohash(_ geohash: String?) {
+        if currentGeohash != geohash {
+            currentGeohash = geohash
+            refreshPeopleList()
+
+            if geohash != nil {
+                startTimer()
+            } else {
+                stopTimer()
+            }
+        }
+    }
+
+    /// Record a participant activity in the current geohash
+    func recordParticipant(pubkeyHex: String) {
+        guard let gh = currentGeohash else { return }
+        recordParticipant(pubkeyHex: pubkeyHex, geohash: gh)
+    }
+
+    /// Record a participant activity in a specific geohash
+    func recordParticipant(pubkeyHex: String, geohash: String) {
+        let key = pubkeyHex.lowercased()
+        var map = geoParticipants[geohash] ?? [:]
+        map[key] = Date()
+        geoParticipants[geohash] = map
+
+        // Only refresh list if this geohash is currently selected
+        if currentGeohash == geohash {
+            refreshPeopleList()
+        }
+    }
+
+    /// Get visible people for the current geohash (without mutating state)
+    func visiblePeople() -> [GeoPerson] {
+        guard let gh = currentGeohash else { return [] }
+        return visiblePeople(for: gh)
+    }
+
+    /// Get visible people for a specific geohash
+    func visiblePeople(for geohash: String) -> [GeoPerson] {
+        let cutoff = Date().addingTimeInterval(-activityWindowSeconds)
+        let map = (geoParticipants[geohash] ?? [:])
+            .filter { $0.value >= cutoff }
+            .filter { !identityManager.isNostrBlocked(pubkeyHexLowercased: $0.key) }
+        let people = map
+            .map { (pub, seen) in
+                GeoPerson(id: pub, displayName: displayNameProvider(pub), lastSeen: seen)
+            }
+            .sorted { $0.lastSeen > $1.lastSeen }
+        return people
+    }
+
+    /// Get participant count for a specific geohash (using activity window)
+    func participantCount(for geohash: String) -> Int {
+        let cutoff = Date().addingTimeInterval(-activityWindowSeconds)
+        let map = geoParticipants[geohash] ?? [:]
+        return map.values.filter { $0 >= cutoff }.count
+    }
+
+    /// Remove a participant from all geohashes (e.g., when blocked)
+    func removeParticipant(pubkeyHexLowercased: String) {
+        let hex = pubkeyHexLowercased.lowercased()
+        for (gh, var map) in geoParticipants {
+            map.removeValue(forKey: hex)
+            geoParticipants[gh] = map
+        }
+        refreshPeopleList()
+    }
+
+    /// Clear all participant data (for testing or reset)
+    func reset() {
+        stopTimer()
+        geoParticipants.removeAll()
+        geohashPeople.removeAll()
+        currentGeohash = nil
+    }
+
+    // MARK: - Private Helpers
+
+    private func refreshPeopleList() {
+        guard let gh = currentGeohash else {
+            geohashPeople = []
+            return
+        }
+
+        let cutoff = Date().addingTimeInterval(-activityWindowSeconds)
+        var map = geoParticipants[gh] ?? [:]
+
+        // Prune expired entries
+        map = map.filter { $0.value >= cutoff }
+
+        // Remove blocked Nostr pubkeys
+        map = map.filter { !identityManager.isNostrBlocked(pubkeyHexLowercased: $0.key) }
+
+        // Update cleaned map
+        geoParticipants[gh] = map
+
+        // Build display list
+        let people = map
+            .map { (pub, seen) in
+                GeoPerson(id: pub, displayName: displayNameProvider(pub), lastSeen: seen)
+            }
+            .sorted { $0.lastSeen > $1.lastSeen }
+
+        geohashPeople = people
+    }
+
+    private func startTimer() {
+        stopTimer()
+        geoParticipantsTimer = Timer.scheduledTimer(withTimeInterval: refreshIntervalSeconds, repeats: true) { [weak self] _ in
+            Task { @MainActor in
+                self?.refreshPeopleList()
+            }
+        }
+    }
+
+    private func stopTimer() {
+        geoParticipantsTimer?.invalidate()
+        geoParticipantsTimer = nil
+    }
+}

bitchat/Services/KeychainManager.swift

@@ -6,6 +6,7 @@
 // For more information, see <https://unlicense.org>
 //
 
+import BitLogger
 import Foundation
 import Security
 
@@ -23,8 +24,8 @@ protocol KeychainManagerProtocol {
 
 final class KeychainManager: KeychainManagerProtocol {
     // Use consistent service name for all keychain items
-    private let service = "chat.bitchat"
-    private let appGroup = "group.chat.bitchat"
+    private let service = BitchatApp.bundleID
+    private let appGroup = "group.\(BitchatApp.bundleID)"
     
     private func isSandboxed() -> Bool {
         #if os(macOS)
@@ -281,6 +282,7 @@ final class KeychainManager: KeychainManagerProtocol {
             "com.bitchat.deviceidentity", 
             "com.bitchat.noise.identity",
             "chat.bitchat.passwords",
+            "chat.bitchat.nostr",
             "bitchat.keychain",
             "bitchat",
             "com.bitchat"

bitchat/Services/LocationChannelManager.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import Combine
 
@@ -285,12 +286,18 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         } else if let locality = pm.locality, !locality.isEmpty {
             dict[.neighborhood] = locality
         }
-        // Block: reuse neighborhood/locality granularity without exposing street level
+        // Block: reuse neighborhood/locality granularity
         if let subLocality = pm.subLocality, !subLocality.isEmpty {
             dict[.block] = subLocality
         } else if let locality = pm.locality, !locality.isEmpty {
             dict[.block] = locality
         }
+        // Building: prefer place name/street/venue when available
+        if let name = pm.name, !name.isEmpty {
+            dict[.building] = name
+        } else if let thoroughfare = pm.thoroughfare, !thoroughfare.isEmpty {
+            dict[.building] = thoroughfare
+        }
         return dict
     }
 }

bitchat/Services/LocationNotesCounter.swift

@@ -0,0 +1,110 @@
+import BitLogger
+import Foundation
+
+struct LocationNotesCounterDependencies {
+    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
+
+    var relayLookup: RelayLookup
+    var subscribe: Subscribe
+    var unsubscribe: Unsubscribe
+
+    static let live = LocationNotesCounterDependencies(
+        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)
+        }
+    )
+}
+
+/// Lightweight background counter for location notes (kind 1) at building-level geohash (8 chars).
+@MainActor
+final class LocationNotesCounter: ObservableObject {
+    static let shared = LocationNotesCounter()
+
+    @Published private(set) var geohash: String? = nil
+    @Published private(set) var count: Int? = 0
+    @Published private(set) var initialLoadComplete: Bool = false
+    @Published private(set) var relayAvailable: Bool = true
+
+    private var subscriptionID: String? = nil
+    private var noteIDs = Set<String>()
+    private let dependencies: LocationNotesCounterDependencies
+
+    private init(dependencies: LocationNotesCounterDependencies = .live) {
+        self.dependencies = dependencies
+    }
+
+    init(testDependencies: LocationNotesCounterDependencies) {
+        self.dependencies = testDependencies
+    }
+
+    deinit {
+        // Note: deinit cannot call @MainActor functions
+        // Subscription cleanup will happen automatically when counter is deallocated
+        SecureLogger.debug("LocationNotesCounter deinitialized", category: .session)
+    }
+
+    func subscribe(geohash gh: String) {
+        let norm = gh.lowercased()
+        if geohash == norm, subscriptionID != nil { return }
+        // Validate geohash (building-level precision: 8 chars)
+        guard Geohash.isValidBuildingGeohash(norm) else {
+            SecureLogger.warning("LocationNotesCounter: rejecting invalid geohash '\(norm)' (expected 8 valid base32 chars)", category: .session)
+            return
+        }
+        // Unsubscribe previous without clearing count to avoid flicker
+        if let sub = subscriptionID { dependencies.unsubscribe(sub) }
+        subscriptionID = nil
+        geohash = norm
+        noteIDs.removeAll()
+        initialLoadComplete = false
+        relayAvailable = true
+
+        // Subscribe only to the building geohash (precision 8)
+        let subID = "locnotes-count-\(norm)-\(UUID().uuidString.prefix(6))"
+        let relays = dependencies.relayLookup(norm, TransportConfig.nostrGeoRelayCount)
+        guard !relays.isEmpty else {
+            relayAvailable = false
+            initialLoadComplete = true
+            count = 0
+            SecureLogger.warning("LocationNotesCounter: no geo relays for geohash=\(norm)", category: .session)
+            return
+        }
+
+        subscriptionID = subID
+        let filter = NostrFilter.geohashNotes(norm, since: nil, limit: 200)
+        dependencies.subscribe(filter, subID, relays, { [weak self] event in
+            guard let self = self else { return }
+            guard event.kind == NostrProtocol.EventKind.textNote.rawValue else { return }
+            guard event.tags.contains(where: { $0.count >= 2 && $0[0].lowercased() == "g" && $0[1].lowercased() == norm }) else { return }
+            if !self.noteIDs.contains(event.id) {
+                self.noteIDs.insert(event.id)
+                self.count = self.noteIDs.count
+            }
+        }, { [weak self] in
+            self?.initialLoadComplete = true
+        })
+    }
+
+    func cancel() {
+        if let sub = subscriptionID { dependencies.unsubscribe(sub) }
+        subscriptionID = nil
+        geohash = nil
+        count = 0
+        noteIDs.removeAll()
+        relayAvailable = true
+    }
+}

bitchat/Services/LocationNotesManager.swift

@@ -0,0 +1,253 @@
+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
+
+    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 NostrIdentityBridge.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, !nick.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+                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()
+    }
+
+    deinit {
+        // Note: deinit cannot call @MainActor functions
+        // Subscription cleanup will happen automatically when manager is deallocated
+        SecureLogger.debug("LocationNotesManager deinitialized", category: .session)
+    }
+
+    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
+        // For persistent notes, allow relays to return recent history without an aggressive time cutoff
+        let filter = NostrFilter.geohashNotes(geohash, since: nil, limit: 200)
+
+        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
+            guard event.tags.contains(where: { $0.count >= 2 && $0[0].lowercased() == "g" && $0[1].lowercased() == self.geohash }) 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) {
+        let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty 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/MessageFormattingService.swift

@@ -0,0 +1,618 @@
+//
+// MessageFormattingService.swift
+// bitchat
+//
+// Service for formatting chat messages with syntax highlighting
+// This is free and unencumbered software released into the public domain.
+//
+
+import Foundation
+import SwiftUI
+
+/// Service that formats BitchatMessages into styled AttributedStrings
+/// Handles hashtags, mentions, links, payment tokens, and more
+final class MessageFormattingService {
+
+    // MARK: - Precompiled Regexes
+
+    private enum Regexes {
+        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: [])
+        }()
+    }
+
+    // MARK: - Dependencies
+
+    private let colorPalette: ColorPaletteService
+
+    // MARK: - Initialization
+
+    init(colorPalette: ColorPaletteService) {
+        self.colorPalette = colorPalette
+    }
+
+    // MARK: - Public API
+
+    /// Format a message with full syntax highlighting (hashtags, mentions, links, payments)
+    /// This is the primary formatter used in the main chat view
+    func formatMessageAsText(
+        _ message: BitchatMessage,
+        colorScheme: ColorScheme,
+        nickname: String,
+        myPeerID: String,
+        myNostrPubkey: String?,
+        activeChannel: ChannelID,
+        nostrKeyMapping: [String: String],
+        allPeers: [BitchatPeer],
+        geohashPeople: [GeoPerson],
+        getNoiseKeyForShortID: @escaping (String) -> String?
+    ) -> AttributedString {
+        // Determine if this message was sent by self
+        let isSelf = isSelfMessage(
+            message,
+            nickname: nickname,
+            myPeerID: myPeerID,
+            myNostrPubkey: myNostrPubkey,
+            activeChannel: activeChannel
+        )
+
+        // Check cache first
+        let isDark = colorScheme == .dark
+        if let cachedText = message.getCachedFormattedText(isDark: isDark, isSelf: isSelf) {
+            return cachedText
+        }
+
+        // Not cached, format the message
+        var result = AttributedString()
+
+        let baseColor: Color = isSelf ? .orange : colorPalette.peerColor(
+            for: message,
+            isDark: isDark,
+            myPeerID: myPeerID,
+            myNostrPubkey: myNostrPubkey,
+            nostrKeyMapping: nostrKeyMapping,
+            allPeers: allPeers,
+            geohashPeople: geohashPeople.map { (id: $0.id, seed: "nostr:" + $0.id) },
+            getNoiseKeyForShortID: getNoiseKeyForShortID
+        )
+
+        if message.sender != "system" {
+            // Sender (at the beginning) with light-gray suffix styling if present
+            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: encode senderPeerID into a custom URL
+            if let spid = message.senderPeerID?.id,
+               let url = URL(string: "bitchat://user/\(spid.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? spid)") {
+                senderStyle.link = url
+            }
+
+            // Format: <@name#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))
+
+            // Process content with syntax highlighting
+            let content = message.content
+            let nsContent = content as NSString
+            let nsLen = nsContent.length
+
+            // Check for Cashu presence early to decide rendering strategy
+            let containsCashuEarly = Regexes.quickCashuPresence.numberOfMatches(
+                in: content,
+                options: [],
+                range: NSRange(location: 0, length: nsLen)
+            ) > 0
+
+            // For extremely long content, render as plain text (unless has Cashu)
+            if (content.count > 4000 || content.hasVeryLongToken(threshold: 1024)) && !containsCashuEarly {
+                var plainStyle = AttributeContainer()
+                plainStyle.foregroundColor = baseColor
+                plainStyle.font = isSelf
+                    ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
+                    : .bitchatSystem(size: 14, design: .monospaced)
+                result.append(AttributedString(content).mergingAttributes(plainStyle))
+            } else {
+                // Full syntax highlighting
+                result.append(formatContent(
+                    content,
+                    nsContent: nsContent,
+                    nsLen: nsLen,
+                    message: message,
+                    baseColor: baseColor,
+                    isSelf: isSelf,
+                    isDark: isDark,
+                    nickname: nickname,
+                    myPeerID: myPeerID,
+                    myNostrPubkey: myNostrPubkey,
+                    activeChannel: activeChannel
+                ))
+            }
+
+            // Add timestamp
+            let timestamp = AttributedString(" [\(message.formattedTimestamp)]")
+            var timestampStyle = AttributeContainer()
+            timestampStyle.foregroundColor = Color.gray.opacity(0.7)
+            timestampStyle.font = .bitchatSystem(size: 10, design: .monospaced)
+            result.append(timestamp.mergingAttributes(timestampStyle))
+        } else {
+            // System message
+            var contentStyle = AttributeContainer()
+            contentStyle.foregroundColor = Color.gray
+            let content = AttributedString("* \(message.content) *")
+            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))
+        }
+
+        // Cache the formatted text
+        message.setCachedFormattedText(result, isDark: isDark, isSelf: isSelf)
+
+        return result
+    }
+
+    /// Simpler message formatter (used in legacy contexts)
+    func formatMessage(
+        _ message: BitchatMessage,
+        colorScheme: ColorScheme,
+        nickname: String
+    ) -> AttributedString {
+        var result = AttributedString()
+
+        let isDark = colorScheme == .dark
+        let primaryColor = isDark ? Color.green : Color(red: 0, green: 0.5, blue: 0)
+
+        if message.sender == "system" {
+            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))
+        } else {
+            let sender = AttributedString("<@\(message.sender)> ")
+            var senderStyle = AttributeContainer()
+            senderStyle.foregroundColor = primaryColor
+            let fontWeight: Font.Weight = message.sender == nickname ? .bold : .medium
+            senderStyle.font = .bitchatSystem(size: 12, weight: fontWeight, design: .monospaced)
+            result.append(sender.mergingAttributes(senderStyle))
+
+            // Process content to highlight mentions
+            let contentText = message.content
+            let pattern = "@([\\p{L}0-9_]+)"
+            let regex = try? NSRegularExpression(pattern: pattern, options: [])
+            let nsContent = contentText as NSString
+            let nsLen = nsContent.length
+            let matches = regex?.matches(in: contentText, options: [], range: NSRange(location: 0, length: nsLen)) ?? []
+
+            var processedContent = AttributedString()
+            var lastEndIndex = contentText.startIndex
+
+            for match in matches {
+                if let range = Range(match.range(at: 0), in: contentText) {
+                    // Add text before mention
+                    if lastEndIndex < range.lowerBound {
+                        let beforeText = String(contentText[lastEndIndex..<range.lowerBound])
+                        if !beforeText.isEmpty {
+                            var normalStyle = AttributeContainer()
+                            normalStyle.font = .bitchatSystem(size: 14, design: .monospaced)
+                            normalStyle.foregroundColor = isDark ? Color.white : Color.black
+                            processedContent.append(AttributedString(beforeText).mergingAttributes(normalStyle))
+                        }
+                    }
+
+                    // Add the mention with highlight
+                    let mentionText = String(contentText[range])
+                    var mentionStyle = AttributeContainer()
+                    mentionStyle.font = .bitchatSystem(size: 14, weight: .semibold, design: .monospaced)
+                    mentionStyle.foregroundColor = Color.orange
+                    processedContent.append(AttributedString(mentionText).mergingAttributes(mentionStyle))
+
+                    if lastEndIndex < range.upperBound { lastEndIndex = range.upperBound }
+                }
+            }
+
+            // Add remaining text
+            if lastEndIndex < contentText.endIndex {
+                let remainingText = String(contentText[lastEndIndex...])
+                var normalStyle = AttributeContainer()
+                normalStyle.font = .bitchatSystem(size: 14, design: .monospaced)
+                normalStyle.foregroundColor = isDark ? Color.white : Color.black
+                processedContent.append(AttributedString(remainingText).mergingAttributes(normalStyle))
+            }
+
+            result.append(processedContent)
+
+            if message.isRelay, let originalSender = message.originalSender {
+                let relay = AttributedString(" (via \(originalSender))")
+                var relayStyle = AttributeContainer()
+                relayStyle.foregroundColor = primaryColor.opacity(0.7)
+                relayStyle.font = .bitchatSystem(size: 11, design: .monospaced)
+                result.append(relay.mergingAttributes(relayStyle))
+            }
+
+            // Add timestamp
+            let timestamp = AttributedString(" [\(message.formattedTimestamp)]")
+            var timestampStyle = AttributeContainer()
+            timestampStyle.foregroundColor = Color.gray.opacity(0.7)
+            timestampStyle.font = .bitchatSystem(size: 10, design: .monospaced)
+            result.append(timestamp.mergingAttributes(timestampStyle))
+        }
+
+        return result
+    }
+
+    // MARK: - Private Helpers
+
+    private func isSelfMessage(
+        _ message: BitchatMessage,
+        nickname: String,
+        myPeerID: String,
+        myNostrPubkey: String?,
+        activeChannel: ChannelID
+    ) -> Bool {
+        if let spid = message.senderPeerID?.id {
+            // In geohash channels, compare against our per-geohash nostr short ID
+            if case .location = activeChannel, spid.hasPrefix("nostr:"),
+               let myGeo = myNostrPubkey {
+                return spid == "nostr:\(myGeo.prefix(TransportConfig.nostrShortKeyDisplayLength))"
+            }
+            return spid == myPeerID
+        }
+        // Fallback by nickname
+        if message.sender == nickname { return true }
+        if message.sender.hasPrefix(nickname + "#") { return true }
+        return false
+    }
+
+    private func formatContent(
+        _ content: String,
+        nsContent: NSString,
+        nsLen: Int,
+        message: BitchatMessage,
+        baseColor: Color,
+        isSelf: Bool,
+        isDark: Bool,
+        nickname: String,
+        myPeerID: String,
+        myNostrPubkey: String?,
+        activeChannel: ChannelID
+    ) -> AttributedString {
+        // Extract all matches
+        let hasMentionsHint = content.contains("@")
+        let hasHashtagsHint = content.contains("#")
+        let hasURLHint = content.contains("://") || content.contains("www.") || content.contains("http")
+        let hasLightningHint = content.lowercased().contains("ln") || content.lowercased().contains("lightning:")
+        let hasCashuHint = content.lowercased().contains("cashu")
+
+        let hashtagMatches = hasHashtagsHint ? Regexes.hashtag.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
+        let mentionMatches = hasMentionsHint ? Regexes.mention.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
+        let urlMatches = hasURLHint ? (Regexes.linkDetector?.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) ?? []) : []
+        let cashuMatches = hasCashuHint ? Regexes.cashu.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
+        let lightningMatches = hasLightningHint ? Regexes.lightningScheme.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
+        let bolt11Matches = hasLightningHint ? Regexes.bolt11.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
+        let lnurlMatches = hasLightningHint ? Regexes.lnurl.matches(in: content, options: [], range: NSRange(location: 0, length: nsLen)) : []
+
+        // Combine and sort matches, excluding hashtags/URLs overlapping mentions
+        let mentionRanges = mentionMatches.map { $0.range(at: 0) }
+
+        func overlapsMention(_ r: NSRange) -> Bool {
+            for mr in mentionRanges {
+                if NSIntersectionRange(r, mr).length > 0 { return true }
+            }
+            return false
+        }
+
+        func attachedToMention(_ r: NSRange) -> Bool {
+            if let nsRange = Range(r, in: content), nsRange.lowerBound > content.startIndex {
+                var i = content.index(before: nsRange.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
+        }
+
+        func isStandaloneHashtag(_ r: NSRange) -> Bool {
+            guard let nsRange = Range(r, in: content) else { return false }
+            if nsRange.lowerBound == content.startIndex { return true }
+            let prev = content.index(before: nsRange.lowerBound)
+            return content[prev].isWhitespace || content[prev].isNewline
+        }
+
+        var allMatches: [(range: NSRange, type: String)] = []
+        for match in hashtagMatches where !overlapsMention(match.range(at: 0)) && !attachedToMention(match.range(at: 0)) && isStandaloneHashtag(match.range(at: 0)) {
+            allMatches.append((match.range(at: 0), "hashtag"))
+        }
+        for match in mentionMatches {
+            allMatches.append((match.range(at: 0), "mention"))
+        }
+        for match in urlMatches where !overlapsMention(match.range) {
+            allMatches.append((match.range, "url"))
+        }
+        for match in cashuMatches where !overlapsMention(match.range(at: 0)) {
+            allMatches.append((match.range(at: 0), "cashu"))
+        }
+        for match in lightningMatches where !overlapsMention(match.range(at: 0)) {
+            allMatches.append((match.range(at: 0), "lightning"))
+        }
+
+        // Exclude overlaps with lightning/url for bolt11/lnurl
+        let occupied: [NSRange] = urlMatches.map { $0.range } + lightningMatches.map { $0.range(at: 0) }
+        func overlapsOccupied(_ r: NSRange) -> Bool {
+            for or in occupied {
+                if NSIntersectionRange(r, or).length > 0 { return true }
+            }
+            return false
+        }
+        for match in bolt11Matches where !overlapsMention(match.range(at: 0)) && !overlapsOccupied(match.range(at: 0)) {
+            allMatches.append((match.range(at: 0), "bolt11"))
+        }
+        for match in lnurlMatches where !overlapsMention(match.range(at: 0)) && !overlapsOccupied(match.range(at: 0)) {
+            allMatches.append((match.range(at: 0), "lnurl"))
+        }
+        allMatches.sort { $0.range.location < $1.range.location }
+
+        // Build content with styling
+        var processedContent = AttributedString()
+        var lastEnd = content.startIndex
+        let isMentioned = message.mentions?.contains(nickname) ?? false
+
+        for (range, type) in allMatches {
+            if let nsRange = Range(range, in: content) {
+                // Add text before match
+                if lastEnd < nsRange.lowerBound {
+                    let beforeText = String(content[lastEnd..<nsRange.lowerBound])
+                    if !beforeText.isEmpty {
+                        var beforeStyle = AttributeContainer()
+                        beforeStyle.foregroundColor = baseColor
+                        beforeStyle.font = isSelf
+                            ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
+                            : .bitchatSystem(size: 14, design: .monospaced)
+                        if isMentioned {
+                            beforeStyle.font = beforeStyle.font?.bold()
+                        }
+                        processedContent.append(AttributedString(beforeText).mergingAttributes(beforeStyle))
+                    }
+                }
+
+                // Add styled match
+                let matchText = String(content[nsRange])
+                processedContent.append(formatMatch(
+                    matchText,
+                    type: type,
+                    baseColor: baseColor,
+                    isSelf: isSelf,
+                    isDark: isDark,
+                    nickname: nickname,
+                    myPeerID: myPeerID,
+                    myNostrPubkey: myNostrPubkey,
+                    activeChannel: activeChannel
+                ))
+
+                lastEnd = nsRange.upperBound
+            }
+        }
+
+        // Add remaining text after last match
+        if lastEnd < content.endIndex {
+            let remainingText = String(content[lastEnd...])
+            var remainingStyle = AttributeContainer()
+            remainingStyle.foregroundColor = baseColor
+            remainingStyle.font = isSelf
+                ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
+                : .bitchatSystem(size: 14, design: .monospaced)
+            if isMentioned {
+                remainingStyle.font = remainingStyle.font?.bold()
+            }
+            processedContent.append(AttributedString(remainingText).mergingAttributes(remainingStyle))
+        }
+
+        return processedContent
+    }
+
+    private func formatMatch(
+        _ matchText: String,
+        type: String,
+        baseColor: Color,
+        isSelf: Bool,
+        isDark: Bool,
+        nickname: String,
+        myPeerID: String,
+        myNostrPubkey: String?,
+        activeChannel: ChannelID
+    ) -> AttributedString {
+        switch type {
+        case "mention":
+            return formatMention(
+                matchText,
+                baseColor: baseColor,
+                isSelf: isSelf,
+                nickname: nickname,
+                myPeerID: myPeerID,
+                myNostrPubkey: myNostrPubkey,
+                activeChannel: activeChannel
+            )
+        case "hashtag":
+            return formatHashtag(matchText, isDark: isDark, baseColor: baseColor, activeChannel: activeChannel)
+        case "url":
+            return formatURL(matchText, baseColor: baseColor, isSelf: isSelf)
+        case "cashu", "bolt11", "lnurl", "lightning":
+            return formatPayment(matchText, type: type, baseColor: baseColor, isSelf: isSelf)
+        default:
+            return AttributedString(matchText)
+        }
+    }
+
+    private func formatMention(
+        _ matchText: String,
+        baseColor: Color,
+        isSelf: Bool,
+        nickname: String,
+        myPeerID: String,
+        myNostrPubkey: String?,
+        activeChannel: ChannelID
+    ) -> AttributedString {
+        // Split optional '#abcd' suffix and color suffix light grey
+        let (mBase, mSuffix) = matchText.splitSuffix()
+
+        // Determine if this mention targets me
+        let mySuffix: String? = {
+            if case .location = activeChannel, let myGeo = myNostrPubkey {
+                return String(myGeo.suffix(4))
+            }
+            return String(myPeerID.prefix(4))
+        }()
+
+        let isMentionToMe: Bool = {
+            if mBase == nickname {
+                if let suf = mySuffix, !mSuffix.isEmpty {
+                    return mSuffix == "#\(suf)"
+                }
+                return mSuffix.isEmpty
+            }
+            return false
+        }()
+
+        var mentionStyle = AttributeContainer()
+        mentionStyle.font = .bitchatSystem(size: 14, weight: .semibold, design: .monospaced)
+        mentionStyle.foregroundColor = isMentionToMe ? .orange : baseColor
+
+        var result = AttributedString()
+        result.append(AttributedString(mBase).mergingAttributes(mentionStyle))
+
+        if !mSuffix.isEmpty {
+            var suffixStyle = mentionStyle
+            suffixStyle.foregroundColor = (isMentionToMe ? Color.orange : baseColor).opacity(0.5)
+            result.append(AttributedString(mSuffix).mergingAttributes(suffixStyle))
+        }
+
+        return result
+    }
+
+    private func formatHashtag(
+        _ matchText: String,
+        isDark: Bool,
+        baseColor: Color,
+        activeChannel: ChannelID
+    ) -> AttributedString {
+        var hashtagStyle = AttributeContainer()
+        hashtagStyle.font = .bitchatSystem(size: 14, weight: .medium, design: .monospaced)
+
+        // Determine if this hashtag represents the active channel
+        let isActiveChannel: Bool = {
+            if matchText.count > 1 {
+                let tag = String(matchText.dropFirst()) // Remove '#'
+                switch activeChannel {
+                case .mesh:
+                    return tag.lowercased() == "mesh"
+                case .location(let ch):
+                    return tag.lowercased() == ch.geohash.lowercased()
+                }
+            }
+            return false
+        }()
+
+        if isActiveChannel {
+            // Highlight active channel hashtag in green
+            hashtagStyle.foregroundColor = isDark ? Color.green : Color(red: 0, green: 0.5, blue: 0)
+            hashtagStyle.font = .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
+        } else {
+            // Link to geohash if valid
+            if matchText.count > 1 {
+                let tag = String(matchText.dropFirst())
+                if tag.count >= 2, tag.count <= 12,
+                   tag.allSatisfy({ "0123456789bcdefghjkmnpqrstuvwxyz".contains($0) }) {
+                    if let url = URL(string: "bitchat://geohash/\(tag)") {
+                        hashtagStyle.link = url
+                    }
+                }
+            }
+            hashtagStyle.foregroundColor = baseColor.opacity(0.8)
+        }
+
+        return AttributedString(matchText).mergingAttributes(hashtagStyle)
+    }
+
+    private func formatURL(_ matchText: String, baseColor: Color, isSelf: Bool) -> AttributedString {
+        var urlStyle = AttributeContainer()
+        if let url = URL(string: matchText) {
+            urlStyle.link = url
+        }
+        urlStyle.foregroundColor = baseColor
+        urlStyle.font = isSelf
+            ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
+            : .bitchatSystem(size: 14, design: .monospaced)
+        urlStyle.underlineStyle = .single
+        return AttributedString(matchText).mergingAttributes(urlStyle)
+    }
+
+    private func formatPayment(
+        _ matchText: String,
+        type: String,
+        baseColor: Color,
+        isSelf: Bool
+    ) -> AttributedString {
+        var paymentStyle = AttributeContainer()
+        paymentStyle.foregroundColor = baseColor
+        paymentStyle.font = isSelf
+            ? .bitchatSystem(size: 14, weight: .bold, design: .monospaced)
+            : .bitchatSystem(size: 14, design: .monospaced)
+
+        // Make payment tokens tappable
+        if type == "cashu", let url = URL(string: "cashu:\(matchText)") {
+            paymentStyle.link = url
+        } else if type == "lightning" || type == "bolt11" || type == "lnurl" {
+            if let url = URL(string: matchText.lowercased().hasPrefix("lightning:") ? matchText : "lightning:\(matchText)") {
+                paymentStyle.link = url
+            }
+        }
+
+        return AttributedString(matchText).mergingAttributes(paymentStyle)
+    }
+}

bitchat/Services/MessageRouter.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 
 /// Routes messages between BLE and Nostr transports
@@ -5,7 +6,7 @@ import Foundation
 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 var outbox: [PeerID: [(content: String, nickname: String, messageID: String)]] = [:] // peerID -> queued messages
 
     init(mesh: Transport, nostr: NostrTransport) {
         self.mesh = mesh
@@ -20,7 +21,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 +29,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,44 +37,44 @@ final class MessageRouter {
         }
     }
 
-    func sendPrivate(_ content: String, to peerID: String, recipientNickname: String, messageID: String) {
+    func sendPrivate(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String) {
         let reachableMesh = mesh.isPeerReachable(peerID)
         if reachableMesh {
-            SecureLogger.debug("Routing PM via mesh (reachable) to \(peerID.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+            SecureLogger.debug("Routing PM via mesh (reachable) to \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
             // 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.debug("Routing PM via Nostr to \(peerID.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+            SecureLogger.debug("Routing PM via Nostr to \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
             nostr.sendPrivateMessage(content, to: peerID, recipientNickname: recipientNickname, messageID: messageID)
         } else {
             // Queue for later (when mesh connects or Nostr mapping appears)
             if outbox[peerID] == nil { outbox[peerID] = [] }
             outbox[peerID]?.append((content, recipientNickname, messageID))
-            SecureLogger.debug("Queued PM for \(peerID.prefix(8))… (no mesh, no Nostr mapping) id=\(messageID.prefix(8))…", category: .session)
+            SecureLogger.debug("Queued PM for \(peerID.id.prefix(8))… (no mesh, no Nostr mapping) id=\(messageID.prefix(8))…", category: .session)
         }
     }
 
-    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: String) {
+    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID) {
         // Prefer mesh for reachable peers; BLE will queue if handshake is needed
         if mesh.isPeerReachable(peerID) {
-            SecureLogger.debug("Routing READ ack via mesh (reachable) to \(peerID.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…", category: .session)
+            SecureLogger.debug("Routing READ ack via mesh (reachable) to \(peerID.id.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…", category: .session)
             mesh.sendReadReceipt(receipt, to: peerID)
         } else {
-            SecureLogger.debug("Routing READ ack via Nostr to \(peerID.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…", category: .session)
+            SecureLogger.debug("Routing READ ack via Nostr to \(peerID.id.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…", category: .session)
             nostr.sendReadReceipt(receipt, to: peerID)
         }
     }
 
-    func sendDeliveryAck(_ messageID: String, to peerID: String) {
+    func sendDeliveryAck(_ messageID: String, to peerID: PeerID) {
         if mesh.isPeerReachable(peerID) {
-            SecureLogger.debug("Routing DELIVERED ack via mesh (reachable) to \(peerID.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+            SecureLogger.debug("Routing DELIVERED ack via mesh (reachable) to \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
             mesh.sendDeliveryAck(for: messageID, to: peerID)
         } else {
             nostr.sendDeliveryAck(for: messageID, to: peerID)
         }
     }
 
-    func sendFavoriteNotification(to peerID: String, isFavorite: Bool) {
+    func sendFavoriteNotification(to peerID: PeerID, isFavorite: Bool) {
         // Route via mesh when connected; else use Nostr
         if mesh.isPeerConnected(peerID) {
             mesh.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
@@ -83,16 +84,16 @@ final class MessageRouter {
     }
 
     // MARK: - Outbox Management
-    private func canSendViaNostr(peerID: String) -> Bool {
+    private func canSendViaNostr(peerID: PeerID) -> 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 noiseKey = peerID.noiseKey {
             if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
                fav.peerNostrPublicKey != nil {
                 return true
             }
-        } else if peerID.count == 16 {
+        } else if peerID.isShort {
             if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID),
                fav.peerNostrPublicKey != nil {
                 return true
@@ -101,17 +102,17 @@ final class MessageRouter {
         return false
     }
 
-    func flushOutbox(for peerID: String) {
+    func flushOutbox(for peerID: PeerID) {
         guard let queued = outbox[peerID], !queued.isEmpty else { return }
-        SecureLogger.debug("Flushing outbox for \(peerID.prefix(8))… count=\(queued.count)", category: .session)
+        SecureLogger.debug("Flushing outbox for \(peerID.id.prefix(8))… count=\(queued.count)", category: .session)
         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.debug("Outbox -> mesh for \(peerID.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+                SecureLogger.debug("Outbox -> mesh for \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
                 mesh.sendPrivateMessage(content, to: peerID, recipientNickname: nickname, messageID: messageID)
             } else if canSendViaNostr(peerID: peerID) {
-                SecureLogger.debug("Outbox -> Nostr for \(peerID.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+                SecureLogger.debug("Outbox -> Nostr for \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
                 nostr.sendPrivateMessage(content, to: peerID, recipientNickname: nickname, messageID: messageID)
             } else {
                 // Keep unsent items queued

bitchat/Services/NetworkActivationService.swift

@@ -0,0 +1,120 @@
+import Foundation
+import BitLogger
+import Combine
+import Tor
+
+/// 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 init() {}
+
+    deinit {
+        // Clean up Combine subscriptions
+        cancellables.removeAll()
+        SecureLogger.debug("NetworkActivationService deinitialized", category: .session)
+    }
+
+    func start() {
+        guard !started else { return }
+        started = true
+
+        if let stored = UserDefaults.standard.object(forKey: torPreferenceKey) as? Bool {
+            userTorEnabled = stored
+        } else {
+            userTorEnabled = true
+        }
+
+        // Initial compute
+        let allowed = basePolicyAllowed()
+        activationAllowed = allowed
+        torAutoStartDesired = allowed && userTorEnabled
+        TorManager.shared.setAutoStartAllowed(torAutoStartDesired)
+        applyTorState(torDesired: torAutoStartDesired)
+        if allowed {
+            NostrRelayManager.shared.connect()
+        } else {
+            NostrRelayManager.shared.disconnect()
+        }
+
+        // React to location permission changes
+        LocationChannelManager.shared.$permissionState
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] _ in
+                self?.reevaluate()
+            }
+            .store(in: &cancellables)
+
+        // React to mutual favorites changes
+        FavoritesPersistenceService.shared.$mutualFavorites
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] _ in
+                self?.reevaluate()
+            }
+            .store(in: &cancellables)
+    }
+
+    func setUserTorEnabled(_ enabled: Bool) {
+        guard enabled != userTorEnabled else { return }
+        userTorEnabled = enabled
+        UserDefaults.standard.set(enabled, forKey: torPreferenceKey)
+        NotificationCenter.default.post(
+            name: .TorUserPreferenceChanged,
+            object: nil,
+            userInfo: ["enabled": enabled]
+        )
+        reevaluate()
+    }
+
+    private func reevaluate() {
+        let allowed = 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
+            TorManager.shared.setAutoStartAllowed(torDesired)
+            applyTorState(torDesired: torDesired)
+        }
+
+        if allowed {
+            if torChanged {
+                // Reset relay sockets when switching transport path (Tor ↔︎ direct)
+                NostrRelayManager.shared.disconnect()
+            }
+            NostrRelayManager.shared.connect()
+        } else if statusChanged {
+            NostrRelayManager.shared.disconnect()
+        }
+    }
+
+    private func basePolicyAllowed() -> Bool {
+        let permOK = LocationChannelManager.shared.permissionState == .authorized
+        let hasMutual = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
+        return permOK || hasMutual
+    }
+
+    private func applyTorState(torDesired: Bool) {
+        TorURLSession.shared.setProxyMode(useTor: torDesired)
+        if torDesired {
+            TorManager.shared.startIfNeeded()
+        } else {
+            TorManager.shared.shutdownCompletely()
+        }
+    }
+}

bitchat/Services/NoiseEncryptionService.swift

@@ -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,6 +82,7 @@
 /// - Background queue for CPU-intensive operations
 ///
 
+import BitLogger
 import Foundation
 import CryptoKit
 
@@ -115,15 +115,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")
         }
     }
 }
@@ -147,8 +162,8 @@ final 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)
@@ -163,7 +178,7 @@ final class NoiseEncryptionService {
     
     // Callbacks
     private var onPeerAuthenticatedHandlers: [((String, String) -> Void)] = [] // Array of handlers for peer authentication
-    var onHandshakeRequired: ((String) -> Void)? // peerID needs handshake
+    var onHandshakeRequired: ((PeerID) -> Void)? // peerID needs handshake
     
     // Add a handler for peer authentication
     func addOnPeerAuthenticatedHandler(_ handler: @escaping (String, String) -> Void) {
@@ -257,12 +272,11 @@ final 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
     }
     
@@ -390,11 +404,11 @@ final 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.warning(.authenticationFailed(peerID: peerID))
+        guard peerID.isValid else {
+            SecureLogger.warning(.authenticationFailed(peerID: peerID.id))
             throw NoiseSecurityError.invalidPeerID
         }
         
@@ -404,7 +418,7 @@ final class NoiseEncryptionService {
             throw NoiseSecurityError.rateLimitExceeded
         }
         
-        SecureLogger.info(.handshakeStarted(peerID: peerID))
+        SecureLogger.info(.handshakeStarted(peerID: peerID.id))
         
         // Return raw handshake data without wrapper
         // The Noise protocol handles its own message format
@@ -413,17 +427,17 @@ final 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.warning(.authenticationFailed(peerID: peerID))
+        guard peerID.isValid else {
+            SecureLogger.warning(.authenticationFailed(peerID: peerID.id))
             throw NoiseSecurityError.invalidPeerID
         }
         
         // Validate message size
         guard NoiseSecurityValidator.validateHandshakeMessageSize(message) else {
-            SecureLogger.warning(.handshakeFailed(peerID: peerID, error: "Message too large"))
+            SecureLogger.warning(.handshakeFailed(peerID: peerID.id, error: "Message too large"))
             throw NoiseSecurityError.messageTooLarge
         }
         
@@ -443,19 +457,19 @@ final 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
@@ -477,7 +491,7 @@ final 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
@@ -499,38 +513,26 @@ final 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] {
-                fingerprintToPeerID.removeValue(forKey: fingerprint)
-            }
-            peerFingerprints.removeValue(forKey: peerID)
+            peerFingerprints.removeAll()
+            fingerprintToPeerID.removeAll()
         }
-        
-        SecureLogger.info(.sessionExpired(peerID: peerID))
+        rateLimiter.resetAll()
     }
     
     // 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) {
@@ -539,20 +541,15 @@ final class NoiseEncryptionService {
         }
         
         // Log security event
-        SecureLogger.info(.handshakeCompleted(peerID: peerID))
+        SecureLogger.info(.handshakeCompleted(peerID: peerID.id))
         
         // Notify all handlers about authentication
         serviceQueue.async { [weak self] in
             self?.onPeerAuthenticatedHandlers.forEach { handler in
-                handler(peerID, fingerprint)
+                handler(peerID.id, fingerprint)
             }
         }
     }
-    
-    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
     

bitchat/Services/NostrTransport.swift

@@ -1,48 +1,52 @@
+import BitLogger
 import Foundation
 import Combine
 
 // Minimal Nostr transport conforming to Transport for offline sending
 final class NostrTransport: Transport {
-    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 = ""
+    var senderPeerID = PeerID(str: "")
 
     // Throttle READ receipts to avoid relay rate limits
     private struct QueuedRead {
         let receipt: ReadReceipt
-        let peerID: String
+        let peerID: PeerID
     }
     private var readQueue: [QueuedRead] = []
     private var isSendingReadAcks = false
     private let readAckInterval: TimeInterval = TransportConfig.nostrReadAckInterval
     private let keychain: KeychainManagerProtocol
 
-    var myPeerID: String { senderPeerID }
-    var myNickname: String { "" }
-    func setNickname(_ nickname: String) { /* not used for Nostr */ }
-    
     init(keychain: KeychainManagerProtocol) {
         self.keychain = keychain
     }
 
+    // MARK: - Transport Protocol Conformance
+
+    weak var delegate: BitchatDelegate?
+    weak var peerEventsDelegate: TransportPeerEventsDelegate?
+
+    var peerSnapshotPublisher: AnyPublisher<[TransportPeerSnapshot], Never> {
+        Just([]).eraseToAnyPublisher()
+    }
+    func currentPeerSnapshots() -> [TransportPeerSnapshot] { [] }
+
+    var myPeerID: PeerID { senderPeerID }
+    var myNickname: String { "" }
+    func setNickname(_ nickname: String) { /* not used for Nostr */ }
+
     func startServices() { /* no-op */ }
     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 { 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?
@@ -58,11 +62,11 @@ final class NostrTransport: Transport {
     // 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.debug("NostrTransport: preparing PM to \(recipientNpub.prefix(16))… for peerID \(peerID.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+            SecureLogger.debug("NostrTransport: preparing PM to \(recipientNpub.prefix(16))… for peerID \(peerID.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
             // Convert recipient npub -> hex (x-only)
             let recipientHex: String
             do {
@@ -76,7 +80,7 @@ final class NostrTransport: Transport {
                 SecureLogger.error("NostrTransport: failed to decode npub -> hex: \(error)", category: .session)
                 return
             }
-            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: messageID, recipientPeerID: peerID.id, senderPeerID: senderPeerID.id) else {
                 SecureLogger.error("NostrTransport: failed to embed PM packet", category: .session)
                 return
             }
@@ -89,12 +93,113 @@ final class NostrTransport: Transport {
         }
     }
 
-    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()
     }
 
+    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 }
+            let content = isFavorite ? "[FAVORITED]:\(senderIdentity.npub)" : "[UNFAVORITED]:\(senderIdentity.npub)"
+            SecureLogger.debug("NostrTransport: preparing FAVORITE(\(isFavorite)) to \(recipientNpub.prefix(16))…", category: .session)
+            // 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 }
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: UUID().uuidString, recipientPeerID: peerID.id, senderPeerID: senderPeerID.id) else {
+                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.error("NostrTransport: failed to build Nostr event for favorite notification", category: .session)
+                return
+            }
+            SecureLogger.debug("NostrTransport: sending favorite giftWrap id=\(event.id.prefix(16))…", category: .session)
+            NostrRelayManager.shared.sendEvent(event)
+        }
+    }
+
+    func sendBroadcastAnnounce() { /* no-op for Nostr */ }
+    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.debug("NostrTransport: preparing DELIVERED ack for id=\(messageID.prefix(8))… to \(recipientNpub.prefix(16))…", category: .session)
+            let recipientHex: String
+            do {
+                let (hrp, data) = try Bech32.decode(recipientNpub)
+                guard hrp == "npub" else { return }
+                recipientHex = data.hexEncodedString()
+            } catch { return }
+            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .delivered, messageID: messageID, recipientPeerID: peerID.id, senderPeerID: senderPeerID.id) else {
+                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.error("NostrTransport: failed to build Nostr event for DELIVERED ack", category: .session)
+                return
+            }
+            SecureLogger.debug("NostrTransport: sending DELIVERED ack giftWrap id=\(event.id.prefix(16))…", category: .session)
+            NostrRelayManager.shared.sendEvent(event)
+        }
+    }
+}
+
+// MARK: - Geohash Helpers
+
+extension NostrTransport {
+
+    // MARK: Geohash ACK helpers
+    func sendDeliveryAckGeohash(for messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
+        Task { @MainActor in
+            SecureLogger.debug("GeoDM: send DELIVERED -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
+            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .delivered, messageID: messageID, senderPeerID: senderPeerID.id) 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)
+        }
+    }
+
+    func sendReadReceiptGeohash(_ messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
+        Task { @MainActor in
+            SecureLogger.debug("GeoDM: send READ -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
+            guard let embedded = NostrEmbeddedBitChat.encodeAckForNostrNoRecipient(type: .readReceipt, messageID: messageID, senderPeerID: senderPeerID.id) 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)
+        }
+    }
+
+    // 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.debug("GeoDM: send PM -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
+            // Build embedded BitChat packet without recipient peer ID
+            guard let embedded = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(content: content, messageID: messageID, senderPeerID: senderPeerID.id) else {
+                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.error("NostrTransport: failed to build Nostr event for geohash PM", category: .session)
+                return
+            }
+            SecureLogger.debug("NostrTransport: sending geohash PM giftWrap id=\(event.id.prefix(16))…", category: .session)
+            NostrRelayManager.registerPendingGiftWrap(id: event.id)
+            NostrRelayManager.shared.sendEvent(event)
+        }
+    }
+}
+
+// MARK: - Private Helpers
+
+extension NostrTransport {
     private func processReadQueueIfNeeded() {
         guard !isSendingReadAcks else { return }
         guard !readQueue.isEmpty else { return }
@@ -116,7 +221,7 @@ final class NostrTransport: Transport {
                 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 {
+            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .readReceipt, messageID: item.receipt.originalMessageID, recipientPeerID: item.peerID.id, senderPeerID: senderPeerID.id) else {
                 SecureLogger.error("NostrTransport: failed to embed READ ack", category: .session)
                 scheduleNextReadAck(); return
             }
@@ -138,111 +243,18 @@ final class NostrTransport: Transport {
         }
     }
 
-    func sendFavoriteNotification(to peerID: String, isFavorite: Bool) {
-        Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
-            let content = isFavorite ? "[FAVORITED]:\(senderIdentity.npub)" : "[UNFAVORITED]:\(senderIdentity.npub)"
-            SecureLogger.debug("NostrTransport: preparing FAVORITE(\(isFavorite)) to \(recipientNpub.prefix(16))…", category: .session)
-            // 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 }
-            guard let embedded = NostrEmbeddedBitChat.encodePMForNostr(content: content, messageID: UUID().uuidString, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
-                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.error("NostrTransport: failed to build Nostr event for favorite notification", category: .session)
-                return
-            }
-            SecureLogger.debug("NostrTransport: sending favorite giftWrap id=\(event.id.prefix(16))…", category: .session)
-            NostrRelayManager.shared.sendEvent(event)
-        }
-    }
-
-    // MARK: - Helpers
     @MainActor
-    private func resolveRecipientNpub(for peerID: String) -> String? {
-        if let noiseKey = Data(hexString: peerID),
+    private func resolveRecipientNpub(for peerID: PeerID) -> String? {
+        if let noiseKey = Data(hexString: peerID.id),
            let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
            let npub = fav.peerNostrPublicKey {
             return npub
         }
-        if peerID.count == 16,
+        if peerID.id.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) {
-        Task { @MainActor in
-            guard let recipientNpub = resolveRecipientNpub(for: peerID) else { return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { return }
-            SecureLogger.debug("NostrTransport: preparing DELIVERED ack for id=\(messageID.prefix(8))… to \(recipientNpub.prefix(16))…", category: .session)
-            let recipientHex: String
-            do {
-                let (hrp, data) = try Bech32.decode(recipientNpub)
-                guard hrp == "npub" else { return }
-                recipientHex = data.hexEncodedString()
-            } catch { return }
-            guard let ack = NostrEmbeddedBitChat.encodeAckForNostr(type: .delivered, messageID: messageID, recipientPeerID: peerID, senderPeerID: senderPeerID) else {
-                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.error("NostrTransport: failed to build Nostr event for DELIVERED ack", category: .session)
-                return
-            }
-            SecureLogger.debug("NostrTransport: sending DELIVERED ack giftWrap id=\(event.id.prefix(16))…", category: .session)
-            NostrRelayManager.shared.sendEvent(event)
-        }
-    }
-
-    // MARK: - Geohash ACK helpers
-    func sendDeliveryAckGeohash(for messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
-        Task { @MainActor in
-            SecureLogger.debug("GeoDM: send DELIVERED -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.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)
-        }
-    }
-
-    func sendReadReceiptGeohash(_ messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
-        Task { @MainActor in
-            SecureLogger.debug("GeoDM: send READ -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.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)
-        }
-    }
-
-    // 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.debug("GeoDM: send PM -> recip=\(recipientHex.prefix(8))… mid=\(messageID.prefix(8))… from=\(identity.publicKeyHex.prefix(8))…", category: .session)
-            // Build embedded BitChat packet without recipient peer ID
-            guard let embedded = NostrEmbeddedBitChat.encodePMForNostrNoRecipient(content: content, messageID: messageID, senderPeerID: senderPeerID) else {
-                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.error("NostrTransport: failed to build Nostr event for geohash PM", category: .session)
-                return
-            }
-            SecureLogger.debug("NostrTransport: sending geohash PM giftWrap id=\(event.id.prefix(16))…", category: .session)
-            NostrRelayManager.registerPendingGiftWrap(id: event.id)
-            NostrRelayManager.shared.sendEvent(event)
-        }
-    }
 }

bitchat/Services/NotificationService.swift

@@ -62,7 +62,7 @@ final class NotificationService {
     }
     
     func sendPrivateMessageNotification(from sender: String, message: String, peerID: String) {
-        let title = "🔒 private message from \(sender)"
+        let title = "🔒 DM from \(sender)"
         let body = message
         let identifier = "private-\(UUID().uuidString)"
         let userInfo = ["peerID": peerID, "senderName": sender]
@@ -70,26 +70,6 @@ final class NotificationService {
         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)"

bitchat/Services/NotificationStreamAssembler.swift

@@ -0,0 +1,81 @@
+//
+// NotificationStreamAssembler.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+struct NotificationStreamAssembler {
+    private var buffer = Data()
+
+    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 reset = false
+        let maxFrameLength = TransportConfig.blePendingWriteBufferCapBytes
+
+        let minHeaderBytes = 14 // version + type + ttl + timestamp(8) + flags + length(2)
+        let minFramePrefix = minHeaderBytes + BinaryProtocol.senderIDSize
+
+        while buffer.count >= minFramePrefix {
+            guard let first = buffer.first else { break }
+            if first != 1 {
+                dropped.append(buffer.removeFirst())
+                continue
+            }
+
+            guard buffer.count >= minHeaderBytes else { break }
+
+            let headerBytes = Array(buffer.prefix(minFramePrefix))
+            guard headerBytes.count == minFramePrefix else { break }
+
+            let flags = headerBytes[11]
+            let hasRecipient = (flags & BinaryProtocol.Flags.hasRecipient) != 0
+            let hasSignature = (flags & BinaryProtocol.Flags.hasSignature) != 0
+            let payloadLen = (Int(headerBytes[12]) << 8) | Int(headerBytes[13])
+
+            var frameLength = minFramePrefix + payloadLen
+            if hasRecipient { frameLength += BinaryProtocol.recipientIDSize }
+            if hasSignature { frameLength += BinaryProtocol.signatureSize }
+
+            guard frameLength > 0, frameLength <= maxFrameLength else {
+                buffer.removeAll()
+                reset = true
+                break
+            }
+
+            if buffer.count < frameLength {
+                // Check if a new frame start exists within the incomplete buffer; if so, drop leading partial bytes.
+                if let nextStart = buffer.dropFirst().firstIndex(of: 1) {
+                    let dropCount = buffer.distance(from: buffer.startIndex, to: nextStart)
+                    if dropCount > 0 {
+                        buffer.removeFirst(dropCount)
+                        dropped.append(1) // treat as dropped partial start
+                    }
+                }
+                break
+            }
+
+            let frame = Data(buffer.prefix(frameLength))
+            frames.append(frame)
+            buffer.removeFirst(frameLength)
+        }
+
+        if !buffer.isEmpty, buffer.allSatisfy({ $0 == 0 }) {
+            buffer.removeAll(keepingCapacity: false)
+        }
+
+        return (frames, dropped, reset)
+    }
+
+    mutating func reset() {
+        buffer.removeAll(keepingCapacity: false)
+    }
+}

bitchat/Services/PrivateChatManager.swift

@@ -6,6 +6,7 @@
 // This is free and unencumbered software released into the public domain.
 //
 
+import BitLogger
 import Foundation
 import SwiftUI
 
@@ -26,6 +27,10 @@ final class PrivateChatManager: ObservableObject {
         self.meshService = meshService
     }
 
+    deinit {
+        SecureLogger.debug("PrivateChatManager deinitialized", category: .session)
+    }
+
     // Cap for messages stored per private chat
     private let privateChatCap = TransportConfig.privateChatCap
     
@@ -34,7 +39,7 @@ final class PrivateChatManager: ObservableObject {
         selectedPeer = peerID
         
         // Store fingerprint for persistence across reconnections
-        if let fingerprint = meshService?.getFingerprint(for: peerID) {
+        if let fingerprint = meshService?.getFingerprint(for: PeerID(str: peerID)) {
             selectedPeerFingerprint = fingerprint
         }
         
@@ -52,104 +57,28 @@ final 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) {
         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
     }
     
@@ -167,48 +96,6 @@ final 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,13 +109,13 @@ final class PrivateChatManager: ObservableObject {
         // Create read receipt using the simplified method
         let receipt = ReadReceipt(
             originalMessageID: message.id,
-            readerID: meshService?.myPeerID ?? "",
+            readerID: meshService?.myPeerID.id ?? "",
             readerNickname: meshService?.myNickname ?? ""
         )
         
         // Route via MessageRouter to avoid handshakeRequired spam when session isn't established
         if let router = messageRouter {
-            SecureLogger.debug("PrivateChatManager: sending READ ack for \(message.id.prefix(8))… to \(senderPeerID.prefix(8))… via router", category: .session)
+            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

@@ -18,13 +18,17 @@ struct RelayController {
                        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 +36,17 @@ 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
-        }
-        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 +57,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/Tor/TorNotifications.swift

@@ -1,6 +0,0 @@
-import Foundation
-
-extension Notification.Name {
-    static let TorDidBecomeReady = Notification.Name("TorDidBecomeReady")
-    static let TorWillRestart = Notification.Name("TorWillRestart")
-}

bitchat/Services/Transport.swift

@@ -4,7 +4,7 @@ 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 +12,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 +32,33 @@ 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 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)
 
     // QR verification (optional for transports)
-    func sendVerifyChallenge(to peerID: String, noiseKeyHex: String, nonceA: Data)
-    func sendVerifyResponse(to peerID: String, noiseKeyHex: String, nonceA: Data)
-
-    // Peer snapshots (for non-UI services)
-    var peerSnapshotPublisher: AnyPublisher<[TransportPeerSnapshot], Never> { get }
-    func currentPeerSnapshots() -> [TransportPeerSnapshot]
+    func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
+    func sendVerifyResponse(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
 }
 
 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) {}
 }
 
 protocol TransportPeerEventsDelegate: AnyObject {

bitchat/Services/TransportConfig.swift

@@ -41,12 +41,6 @@ enum TransportConfig {
     static let uiLateInsertThresholdGeo: TimeInterval = 0.0
     static let uiProcessedNostrEventsCap: Int = 2000
     static let uiChannelInactivityThresholdSeconds: TimeInterval = 9 * 60
-    
-    // UI rate limiters (token buckets)
-    static let uiSenderRateBucketCapacity: Double = 5
-    static let uiSenderRateBucketRefillPerSec: Double = 1.0
-    static let uiContentRateBucketCapacity: Double = 3
-    static let uiContentRateBucketRefillPerSec: Double = 0.5
 
     // UI sleeps/delays
     static let uiStartupInitialDelaySeconds: TimeInterval = 1.0
@@ -103,7 +97,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)
@@ -188,7 +182,7 @@ 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
 }

bitchat/Services/UnifiedPeerService.swift

@@ -6,10 +6,10 @@
 //  This is free and unencumbered software released into the public domain.
 //
 
+import BitLogger
 import Foundation
 import Combine
 import SwiftUI
-import CryptoKit
 
 /// Single source of truth for peer state, combining mesh connectivity and favorites
 @MainActor
@@ -18,14 +18,14 @@ 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 identityManager: SecureIdentityStateManagerProtocol
     weak var messageRouter: MessageRouter?
@@ -46,7 +46,17 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
             updatePeers()
         }
     }
-    
+
+    deinit {
+        // Clean up NotificationCenter observers
+        NotificationCenter.default.removeObserver(self)
+
+        // Clean up Combine subscriptions
+        cancellables.removeAll()
+
+        SecureLogger.debug("UnifiedPeerService deinitialized", category: .session)
+    }
+
     // MARK: - Setup
     
     private func setupSubscriptions() {
@@ -77,12 +87,12 @@ final 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(
@@ -103,7 +113,7 @@ final 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 }
@@ -137,10 +147,10 @@ final 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)
@@ -184,7 +194,7 @@ final 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,
@@ -204,10 +214,10 @@ final 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,
@@ -224,27 +234,22 @@ final 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? {
         for peer in peers {
             if peer.displayName == nickname || peer.nickname == nickname {
-                return peer.id
+                return peer.peerID.id
             }
         }
         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 }
         
@@ -257,8 +262,8 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     }
     
     /// Toggle favorite status
-    func toggleFavorite(_ peerID: String) {
-        guard let peer = getPeer(by: peerID) else { 
+    func toggleFavorite(_ peerID: PeerID) {
+        guard let peer = getPeer(by: peerID) else {
             SecureLogger.warning("⚠️ Cannot toggle favorite - peer not found: \(peerID)", category: .session)
             return 
         }
@@ -321,39 +326,7 @@ final 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 = identityManager.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)
-            }
-        }
-        
-        identityManager.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
@@ -378,23 +351,13 @@ final 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: [PeerID] { Array(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,256 @@
+import Foundation
+
+// 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
+    }
+
+    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
+    }
+
+    private let myPeerID: PeerID
+    private let config: Config
+    weak var delegate: Delegate?
+
+    // Storage: broadcast messages (ordered by insert), and latest announce per sender
+    private var messages: [String: BitchatPacket] = [:] // idHex -> packet
+    private var messageOrder: [String] = []
+    private var latestAnnouncementByPeer: [String: (id: String, packet: BitchatPacket)] = [:]
+
+    // Timer
+    private var periodicTimer: DispatchSourceTimer?
+    private let queue = DispatchQueue(label: "mesh.sync", qos: .utility)
+
+    init(myPeerID: PeerID, config: Config = Config()) {
+        self.myPeerID = myPeerID
+        self.config = config
+    }
+
+    func start() {
+        stop()
+        let timer = DispatchSource.makeTimerSource(queue: queue)
+        timer.schedule(deadline: .now() + 30.0, repeating: 30.0, leeway: .seconds(1))
+        timer.setEventHandler { [weak self] in
+            self?.cleanupExpiredMessages()
+            self?.sendRequestSync()
+        }
+        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
+            self?.sendRequestSync(to: peerID)
+        }
+    }
+
+    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 _onPublicPacketSeen(_ packet: BitchatPacket) {
+        let mt = MessageType(rawValue: packet.type)
+        let isBroadcastRecipient: Bool = {
+            guard let r = packet.recipientID else { return true }
+            return r.count == 8 && r.allSatisfy { $0 == 0xFF }
+        }()
+        let isBroadcastMessage = (mt == .message && isBroadcastRecipient)
+        let isAnnounce = (mt == .announce)
+        guard isBroadcastMessage || isAnnounce else { return }
+
+        // Reject expired packets to prevent ghost peers and old messages
+        guard isPacketFresh(packet) else { return }
+
+        let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+
+        if isBroadcastMessage {
+            if messages[idHex] == nil {
+                messages[idHex] = packet
+                messageOrder.append(idHex)
+                // Enforce capacity
+                let cap = max(1, config.seenCapacity)
+                while messageOrder.count > cap {
+                    let victim = messageOrder.removeFirst()
+                    messages.removeValue(forKey: victim)
+                }
+            }
+        } else if isAnnounce {
+            let sender = packet.senderID.hexEncodedString()
+            latestAnnouncementByPeer[sender] = (id: idHex, packet: packet)
+        }
+    }
+
+    private func sendRequestSync() {
+        let payload = buildGcsPayload()
+        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) {
+        let payload = buildGcsPayload()
+        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) {
+        // 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)
+        }
+
+        // 1) Announcements: send latest per peer if requester lacks them (and not expired)
+        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
+                delegate?.sendPacket(to: peerID, packet: toSend)
+            }
+        }
+
+        // 2) Broadcast messages: send all missing (and not expired)
+        let toSendMsgs = messageOrder.compactMap { messages[$0] }
+        for pkt in toSendMsgs {
+            guard isPacketFresh(pkt) else { continue }
+            let idBytes = PacketIdUtil.computeId(pkt)
+            if !mightContain(idBytes) {
+                var toSend = pkt
+                toSend.ttl = 0
+                delegate?.sendPacket(to: peerID, packet: toSend)
+            }
+        }
+    }
+
+    // Build REQUEST_SYNC payload using current candidates and GCS params
+    private func buildGcsPayload() -> Data {
+        // Collect candidates: latest announce per peer + broadcast messages (only fresh)
+        var candidates: [BitchatPacket] = []
+        candidates.reserveCapacity(latestAnnouncementByPeer.count + messageOrder.count)
+        for (_, pair) in latestAnnouncementByPeer {
+            if isPacketFresh(pair.packet) {
+                candidates.append(pair.packet)
+            }
+        }
+        for id in messageOrder {
+            if let p = messages[id], isPacketFresh(p) {
+                candidates.append(p)
+            }
+        }
+        // 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 = max(1, config.seenCapacity)
+        let takeN = min(candidates.count, min(nMax, cap))
+        if takeN <= 0 {
+            let req = RequestSyncPacket(p: p, m: 1, data: Data())
+            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)
+        return req.encode()
+    }
+
+    // Periodic cleanup of expired messages and announcements
+    private func cleanupExpiredMessages() {
+        // Remove expired announcements
+        latestAnnouncementByPeer = latestAnnouncementByPeer.filter { _, pair in
+            isPacketFresh(pair.packet)
+        }
+
+        // Remove expired messages
+        let expiredMessageIds = messages.compactMap { id, pkt in
+            isPacketFresh(pkt) ? nil : id
+        }
+        for id in expiredMessageIds {
+            messages.removeValue(forKey: id)
+            messageOrder.removeAll { $0 == id }
+        }
+    }
+
+    // Explicit removal hook for LEAVE/stale peer
+    func removeAnnouncementForPeer(_ peerID: PeerID) {
+        queue.async { [weak self] in
+            self?._removeAnnouncementForPeer(peerID)
+        }
+    }
+
+    private func _removeAnnouncementForPeer(_ peerID: PeerID) {
+        let normalizedPeerID = peerID.id.lowercased()
+        _ = latestAnnouncementByPeer.removeValue(forKey: normalizedPeerID)
+
+        // Remove messages from this peer
+        // Collect IDs to remove first to avoid concurrent modification
+        let messageIdsToRemove = messages.compactMap { (id, message) -> String? in
+            message.senderID.hexEncodedString().lowercased() == normalizedPeerID ? id : nil
+        }
+        
+        // Remove messages and update messageOrder
+        for id in messageIdsToRemove {
+            messages.removeValue(forKey: id)
+            messageOrder.removeAll { $0 == id }
+        }
+    }
+}

bitchat/Sync/PacketIdUtil.swift

@@ -0,0 +1,17 @@
+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/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
+    }
+}

bitchat/Utils/Data+SHA256.swift

@@ -0,0 +1,22 @@
+//
+//  Data+SHA256.swift
+//  bitchat
+//
+//  Created by Islam on 26/09/2025.
+//
+
+import struct Foundation.Data
+import struct CryptoKit.SHA256
+
+extension Data {
+    /// Returns the hex representation of SHA256 hash
+    func sha256Fingerprint() -> String {
+        // Implementation matches existing fingerprint generation in NoiseEncryptionService
+        sha256Hash().hexEncodedString()
+    }
+    
+    /// Returns the SHA256 hash wrapped in Data
+    func sha256Hash() -> Data {
+        Data(SHA256.hash(data: self))
+    }
+}

bitchat/Utils/Font+Bitchat.swift

@@ -0,0 +1,41 @@
+import SwiftUI
+
+/// Provides Dynamic Type aware font helpers that map existing fixed sizes onto
+/// preferred text styles so the UI scales with user accessibility settings.
+extension Font {
+    static func bitchatSystem(size: CGFloat, weight: Font.Weight = .regular, design: Font.Design = .default) -> Font {
+        let style = Font.TextStyle.bitchatPreferredStyle(for: size)
+        var font = Font.system(style, design: design)
+        if weight != .regular {
+            font = font.weight(weight)
+        }
+        return font
+    }
+}
+
+private extension Font.TextStyle {
+    static func bitchatPreferredStyle(for size: CGFloat) -> Font.TextStyle {
+        switch size {
+        case ..<11.5:
+            return .caption2
+        case ..<13.0:
+            return .caption
+        case ..<13.75:
+            return .footnote
+        case ..<15.5:
+            return .subheadline
+        case ..<17.5:
+            return .callout
+        case ..<19.5:
+            return .body
+        case ..<22.5:
+            return .title3
+        case ..<27.5:
+            return .title2
+        case ..<34.0:
+            return .title
+        default:
+            return .largeTitle
+        }
+    }
+}

bitchat/Utils/InputValidator.swift

@@ -8,52 +8,27 @@ struct InputValidator {
     
     struct Limits {
         static let maxNicknameLength = 50
-        static let maxMessageLength = 10_000
-        static let maxReasonLength = 200
-        static let maxPeerIDLength = 64
-        static let hexPeerIDLength = 16 // 8 bytes = 16 hex chars
-    }
-    
-    // MARK: - Peer ID Validation
-    
-    /// Validates a peer ID from any source (short 16-hex, full 64-hex, or internal alnum/-/_ up to 64)
-    static func validatePeerID(_ peerID: String) -> Bool {
-        // Accept short routing IDs (exact 16-hex)
-        if PeerIDResolver.isShortID(peerID) { return true }
-        // If length equals short-hex length but isn't valid hex, reject
-        if peerID.count == Limits.hexPeerIDLength { return false }
-        // Accept full Noise key hex (exact 64-hex)
-        if PeerIDResolver.isNoiseKeyHex(peerID) { return true }
-        // If length equals full key length but isn't valid hex, reject
-        if peerID.count == Limits.maxPeerIDLength { return false }
-        // Internal format: alphanumeric + dash/underscore up to 63 (not 16 or 64)
-        let validCharset = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-_"))
-        return !peerID.isEmpty &&
-               peerID.count < Limits.maxPeerIDLength &&
-               peerID.rangeOfCharacter(from: validCharset.inverted) == nil
+        // BinaryProtocol caps payload length at UInt16.max (65_535). Leave headroom
+        // for headers/padding by limiting user content to 60_000 bytes.
+        static let maxMessageLength = 60_000
     }
     
     // MARK: - String Content Validation
     
-    /// Validates and sanitizes user-provided strings (nicknames, messages)
-    static func validateUserString(_ string: String, maxLength: Int, allowNewlines: Bool = false) -> String? {
+    /// Validates and sanitizes user-provided strings used in UI
+    static func validateUserString(_ string: String, maxLength: Int) -> String? {
         // Check empty
         guard !string.isEmpty else { return nil }
-        
+
         // Trim whitespace
         let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !trimmed.isEmpty else { return nil }
-        
+
         // Check length
         guard trimmed.count <= maxLength else { return nil }
-        
-        // Remove control characters except allowed ones
-        var allowedControlChars = CharacterSet()
-        if allowNewlines {
-            allowedControlChars.insert(charactersIn: "\n\r")
-        }
-        
-        let controlChars = CharacterSet.controlCharacters.subtracting(allowedControlChars)
+
+        // Remove control characters
+        let controlChars = CharacterSet.controlCharacters
         let cleaned = trimmed.components(separatedBy: controlChars).joined()
         
         // Ensure valid UTF-8 (should already be, but double-check)
@@ -68,29 +43,14 @@ struct InputValidator {
     
     /// Validates nickname
     static func validateNickname(_ nickname: String) -> String? {
-        return validateUserString(nickname, maxLength: Limits.maxNicknameLength, allowNewlines: false)
-    }
-    
-    /// Validates message content
-    static func validateMessageContent(_ content: String) -> String? {
-        return validateUserString(content, maxLength: Limits.maxMessageLength, allowNewlines: true)
-    }
-    
-    /// Validates error/reason strings
-    static func validateReasonString(_ reason: String) -> String? {
-        return validateUserString(reason, maxLength: Limits.maxReasonLength, allowNewlines: false)
+        return validateUserString(nickname, maxLength: Limits.maxNicknameLength)
     }
     
     // MARK: - Protocol Field Validation
-    
+
     // Note: Message type validation is performed closer to decoding using
     // MessageType/NoisePayloadType enums; keeping validator free of stale lists.
-    
-    /// Validates hop count is reasonable
-    static func validateHopCount(_ hopCount: UInt8) -> Bool {
-        return hopCount <= 10 // Prevent excessive forwarding
-    }
-    
+
     /// Validates timestamp is reasonable (not too far in past or future)
     static func validateTimestamp(_ timestamp: Date) -> Bool {
         let now = Date()
@@ -98,38 +58,5 @@ struct InputValidator {
         let oneHourFromNow = now.addingTimeInterval(3600)
         return timestamp >= oneHourAgo && timestamp <= oneHourFromNow
     }
-    
-    /// Validates data size for different contexts
-    static func validateDataSize(_ data: Data, maxSize: Int) -> Bool {
-        return data.count > 0 && data.count <= maxSize
-    }
-    
-    // MARK: - Binary Data Validation
-    
-    /// Validates UUID format
-    static func validateUUID(_ uuid: String) -> Bool {
-        // Remove dashes and validate hex
-        let cleaned = uuid.replacingOccurrences(of: "-", with: "")
-        return cleaned.count == 32 && cleaned.allSatisfy { $0.isHexDigit }
-    }
-    
-    /// Validates public key data
-    static func validatePublicKey(_ keyData: Data) -> Bool {
-        // Curve25519 public keys are 32 bytes
-        return keyData.count == 32
-    }
-    
-    /// Validates signature data
-    static func validateSignature(_ signature: Data) -> Bool {
-        // Ed25519 signatures are 64 bytes
-        return signature.count == 64
-    }
-}
 
-// MARK: - Character Extensions
-
-private extension Character {
-    var isHexDigit: Bool {
-        return "0123456789abcdefABCDEF".contains(self)
-    }
 }

bitchat/Utils/PeerDisplayNameResolver.swift

@@ -4,10 +4,10 @@ import Foundation
 struct PeerDisplayNameResolver {
     /// Computes display names with a `#xxxx` suffix for connected peers when nickname collisions occur.
     /// - Parameters:
-    ///   - peers: Array of tuples (id, nickname, isConnected).
+    ///   - peers: Array of tuples (peerID, nickname, isConnected).
     ///   - selfNickname: The local user's current nickname, included in collision counts to suffix remotes matching it.
     /// - Returns: Map of peerID -> displayName.
-    static func resolve(_ peers: [(id: String, nickname: String, isConnected: Bool)], selfNickname: String) -> [String: String] {
+    static func resolve(_ peers: [(peerID: PeerID, nickname: String, isConnected: Bool)], selfNickname: String) -> [PeerID: String] {
         // Count collisions among connected peers and include our own nickname
         var counts: [String: Int] = [:]
         for p in peers where p.isConnected {
@@ -15,13 +15,13 @@ struct PeerDisplayNameResolver {
         }
         counts[selfNickname, default: 0] += 1
 
-        var result: [String: String] = [:]
+        var result: [PeerID: String] = [:]
         for p in peers {
             var name = p.nickname
             if p.isConnected, (counts[p.nickname] ?? 0) > 1 {
-                name += "#" + String(p.id.prefix(4))
+                name += "#" + String(p.peerID.id.prefix(4))
             }
-            result[p.id] = name
+            result[p.peerID] = name
         }
         return result
     }

bitchat/Utils/PeerIDResolver.swift

@@ -1,20 +0,0 @@
-import Foundation
-
-struct PeerIDResolver {
-    /// Returns a 16-hex short peer ID derived from a 64-hex Noise public key if needed
-    static func toShortID(_ id: String) -> String {
-        if id.count == 64, let data = Data(hexString: id) {
-            return PeerIDUtils.derivePeerID(fromPublicKey: data)
-        }
-        return id
-    }
-
-    static func isShortID(_ id: String) -> Bool {
-        return id.count == 16 && Data(hexString: id) != nil
-    }
-
-    static func isNoiseKeyHex(_ id: String) -> Bool {
-        return id.count == 64 && Data(hexString: id) != nil
-    }
-}
-

bitchat/Utils/String+DJB2.swift

@@ -0,0 +1,17 @@
+//
+// String+DJB2.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+extension String {
+    func djb2() -> UInt64 {
+        var hash: UInt64 = 5381
+        for b in utf8 { hash = ((hash << 5) &+ hash) &+ UInt64(b) }
+        return hash
+    }
+}

bitchat/Utils/String+Nickname.swift

@@ -0,0 +1,25 @@
+//
+// String+Nickname.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+extension String {
+    /// Split a nickname into base and a '#abcd' suffix if present
+    func splitSuffix() -> (String, String) {
+        let name = self.replacingOccurrences(of: "@", with: "")
+        guard name.count >= 5 else { return (name, "") }
+        let suffix = String(name.suffix(5))
+        if suffix.first == "#", suffix.dropFirst().allSatisfy({ c in
+            ("0"..."9").contains(String(c)) || ("a"..."f").contains(String(c)) || ("A"..."F").contains(String(c))
+        }) {
+            let base = String(name.dropLast(5))
+            return (base, suffix)
+        }
+        return (name, "")
+    }
+}

bitchat/Views/AppInfoView.swift

@@ -18,41 +18,77 @@ struct AppInfoView: View {
     
     // MARK: - Constants
     private enum Strings {
-        static let appName = "bitchat"
-        static let tagline = "sidegroupchat"
-        
+        static let appName: LocalizedStringKey = "app_info.app_name"
+        static let tagline: LocalizedStringKey = "app_info.tagline"
+
         enum Features {
-            static let title = "FEATURES"
-            static let offlineComm = ("wifi.slash", "offline communication", "works without internet using Bluetooth low energy")
-            static let encryption = ("lock.shield", "end-to-end encryption", "private messages encrypted with noise protocol")
-            static let extendedRange = ("antenna.radiowaves.left.and.right", "extended range", "messages relay through peers, going the distance")
-            static let mentions = ("at", "mentions", "use @nickname to notify specific people")
-            static let favorites = ("star.fill", "favorites", "get notified when your favorite people join")
-            static let geohash = ("number", "local channels", "geohash channels to chat with people in nearby regions over decentralized anonymous relays")
+            static let title: LocalizedStringKey = "app_info.features.title"
+            static let offlineComm = AppInfoFeatureInfo(
+                icon: "wifi.slash",
+                title: "app_info.features.offline.title",
+                description: "app_info.features.offline.description"
+            )
+            static let encryption = AppInfoFeatureInfo(
+                icon: "lock.shield",
+                title: "app_info.features.encryption.title",
+                description: "app_info.features.encryption.description"
+            )
+            static let extendedRange = AppInfoFeatureInfo(
+                icon: "antenna.radiowaves.left.and.right",
+                title: "app_info.features.extended_range.title",
+                description: "app_info.features.extended_range.description"
+            )
+            static let mentions = AppInfoFeatureInfo(
+                icon: "at",
+                title: "app_info.features.mentions.title",
+                description: "app_info.features.mentions.description"
+            )
+            static let favorites = AppInfoFeatureInfo(
+                icon: "star.fill",
+                title: "app_info.features.favorites.title",
+                description: "app_info.features.favorites.description"
+            )
+            static let geohash = AppInfoFeatureInfo(
+                icon: "number",
+                title: "app_info.features.geohash.title",
+                description: "app_info.features.geohash.description"
+            )
         }
-        
+
         enum Privacy {
-            static let title = "PRIVACY"
-            static let noTracking = ("eye.slash", "no tracking", "no servers, accounts, or data collection")
-            static let ephemeral = ("shuffle", "ephemeral identity", "new peer ID generated regularly")
-            static let panic = ("hand.raised.fill", "panic mode", "triple-tap logo to instantly clear all data")
+            static let title: LocalizedStringKey = "app_info.privacy.title"
+            static let noTracking = AppInfoFeatureInfo(
+                icon: "eye.slash",
+                title: "app_info.privacy.no_tracking.title",
+                description: "app_info.privacy.no_tracking.description"
+            )
+            static let ephemeral = AppInfoFeatureInfo(
+                icon: "shuffle",
+                title: "app_info.privacy.ephemeral.title",
+                description: "app_info.privacy.ephemeral.description"
+            )
+            static let panic = AppInfoFeatureInfo(
+                icon: "hand.raised.fill",
+                title: "app_info.privacy.panic.title",
+                description: "app_info.privacy.panic.description"
+            )
         }
-        
+
         enum HowToUse {
-            static let title = "HOW TO USE"
-            static let instructions = [
-                "• set your nickname by tapping it",
-                "• tap #mesh to change channels",
-                "• tap people icon for sidebar",
-                "• tap a peer's name to start a DM",
-                "• triple-tap chat to clear",
-                "• type / for commands"
+            static let title: LocalizedStringKey = "app_info.how_to_use.title"
+            static let instructions: [LocalizedStringKey] = [
+                "app_info.how_to_use.set_nickname",
+                "app_info.how_to_use.change_channels",
+                "app_info.how_to_use.open_sidebar",
+                "app_info.how_to_use.start_dm",
+                "app_info.how_to_use.clear_chat",
+                "app_info.how_to_use.commands"
             ]
         }
-        
+
         enum Warning {
-            static let title = "WARNING"
-            static let message = "private message security has not yet been fully audited. do not use for critical situations until this warning disappears."
+            static let title: LocalizedStringKey = "app_info.warning.title"
+            static let message: LocalizedStringKey = "app_info.warning.message"
         }
     }
     
@@ -62,7 +98,7 @@ struct AppInfoView: View {
             // Custom header for macOS
             HStack {
                 Spacer()
-                Button("DONE") {
+                Button("app_info.done") {
                     dismiss()
                 }
                 .buttonStyle(.plain)
@@ -86,10 +122,14 @@ struct AppInfoView: View {
             .navigationBarTitleDisplayMode(.inline)
             .toolbar {
                 ToolbarItem(placement: .navigationBarTrailing) {
-                    Button("close") {
-                        dismiss()
+                    Button(action: { dismiss() }) {
+                        Image(systemName: "xmark")
+                            .font(.bitchatSystem(size: 13, weight: .semibold, design: .monospaced))
+                            .foregroundColor(textColor)
+                            .frame(width: 32, height: 32)
                     }
-                    .foregroundColor(textColor)
+                    .buttonStyle(.plain)
+                    .accessibilityLabel("app_info.close")
                 }
             }
         }
@@ -102,82 +142,64 @@ struct AppInfoView: View {
             // Header
             VStack(alignment: .center, spacing: 8) {
                 Text(Strings.appName)
-                    .font(.system(size: 32, weight: .bold, design: .monospaced))
+                    .font(.bitchatSystem(size: 32, weight: .bold, design: .monospaced))
                     .foregroundColor(textColor)
                 
                 Text(Strings.tagline)
-                    .font(.system(size: 16, design: .monospaced))
+                    .font(.bitchatSystem(size: 16, design: .monospaced))
                     .foregroundColor(secondaryTextColor)
             }
             .frame(maxWidth: .infinity)
             .padding(.vertical)
             
-            // Features
-            VStack(alignment: .leading, spacing: 16) {
-                SectionHeader(Strings.Features.title)
-                
-                FeatureRow(icon: Strings.Features.offlineComm.0, 
-                          title: Strings.Features.offlineComm.1,
-                          description: Strings.Features.offlineComm.2)
-                
-                FeatureRow(icon: Strings.Features.encryption.0,
-                          title: Strings.Features.encryption.1,
-                          description: Strings.Features.encryption.2)
-                
-                FeatureRow(icon: Strings.Features.extendedRange.0,
-                          title: Strings.Features.extendedRange.1,
-                          description: Strings.Features.extendedRange.2)
-                
-                FeatureRow(icon: Strings.Features.favorites.0,
-                          title: Strings.Features.favorites.1,
-                          description: Strings.Features.favorites.2)
-                
-                FeatureRow(icon: Strings.Features.geohash.0,
-                          title: Strings.Features.geohash.1,
-                          description: Strings.Features.geohash.2)
-                
-                FeatureRow(icon: Strings.Features.mentions.0,
-                          title: Strings.Features.mentions.1,
-                          description: Strings.Features.mentions.2)
-            }
-            
-            // Privacy
-            VStack(alignment: .leading, spacing: 16) {
-                SectionHeader(Strings.Privacy.title)
-                
-                FeatureRow(icon: Strings.Privacy.noTracking.0,
-                          title: Strings.Privacy.noTracking.1,
-                          description: Strings.Privacy.noTracking.2)
-                
-                FeatureRow(icon: Strings.Privacy.ephemeral.0,
-                          title: Strings.Privacy.ephemeral.1,
-                          description: Strings.Privacy.ephemeral.2)
-                
-                FeatureRow(icon: Strings.Privacy.panic.0,
-                          title: Strings.Privacy.panic.1,
-                          description: Strings.Privacy.panic.2)
-            }
-            
             // How to Use
             VStack(alignment: .leading, spacing: 16) {
                 SectionHeader(Strings.HowToUse.title)
-                
+
                 VStack(alignment: .leading, spacing: 8) {
-                    ForEach(Strings.HowToUse.instructions, id: \.self) { instruction in
+                    ForEach(Array(Strings.HowToUse.instructions.enumerated()), id: \.offset) { _, instruction in
                         Text(instruction)
                     }
                 }
-                .font(.system(size: 14, design: .monospaced))
+                .font(.bitchatSystem(size: 14, design: .monospaced))
                 .foregroundColor(textColor)
             }
-            
+
+            // Features
+            VStack(alignment: .leading, spacing: 16) {
+                SectionHeader(Strings.Features.title)
+
+                FeatureRow(info: Strings.Features.offlineComm)
+
+                FeatureRow(info: Strings.Features.encryption)
+
+                FeatureRow(info: Strings.Features.extendedRange)
+
+                FeatureRow(info: Strings.Features.favorites)
+
+                FeatureRow(info: Strings.Features.geohash)
+
+                FeatureRow(info: Strings.Features.mentions)
+            }
+
+            // Privacy
+            VStack(alignment: .leading, spacing: 16) {
+                SectionHeader(Strings.Privacy.title)
+
+                FeatureRow(info: Strings.Privacy.noTracking)
+
+                FeatureRow(info: Strings.Privacy.ephemeral)
+
+                FeatureRow(info: Strings.Privacy.panic)
+            }
+
             // Warning
             VStack(alignment: .leading, spacing: 6) {
                 SectionHeader(Strings.Warning.title)
                     .foregroundColor(Color.red)
                 
                 Text(Strings.Warning.message)
-                    .font(.system(size: 14, design: .monospaced))
+                    .font(.bitchatSystem(size: 14, design: .monospaced))
                     .foregroundColor(Color.red)
                     .fixedSize(horizontal: false, vertical: true)
             }
@@ -193,30 +215,34 @@ struct AppInfoView: View {
     }
 }
 
+struct AppInfoFeatureInfo {
+    let icon: String
+    let title: LocalizedStringKey
+    let description: LocalizedStringKey
+}
+
 struct SectionHeader: View {
-    let title: String
+    let title: LocalizedStringKey
     @Environment(\.colorScheme) var colorScheme
     
     private var textColor: Color {
         colorScheme == .dark ? Color.green : Color(red: 0, green: 0.5, blue: 0)
     }
     
-    init(_ title: String) {
+    init(_ title: LocalizedStringKey) {
         self.title = title
     }
     
     var body: some View {
         Text(title)
-            .font(.system(size: 16, weight: .bold, design: .monospaced))
+            .font(.bitchatSystem(size: 16, weight: .bold, design: .monospaced))
             .foregroundColor(textColor)
             .padding(.top, 8)
     }
 }
 
 struct FeatureRow: View {
-    let icon: String
-    let title: String
-    let description: String
+    let info: AppInfoFeatureInfo
     @Environment(\.colorScheme) var colorScheme
     
     private var textColor: Color {
@@ -229,18 +255,18 @@ struct FeatureRow: View {
     
     var body: some View {
         HStack(alignment: .top, spacing: 12) {
-            Image(systemName: icon)
-                .font(.system(size: 20))
+            Image(systemName: info.icon)
+                .font(.bitchatSystem(size: 20))
                 .foregroundColor(textColor)
                 .frame(width: 30)
             
             VStack(alignment: .leading, spacing: 4) {
-                Text(title)
-                    .font(.system(size: 14, weight: .semibold, design: .monospaced))
+                Text(info.title)
+                    .font(.bitchatSystem(size: 14, weight: .semibold, design: .monospaced))
                     .foregroundColor(textColor)
                 
-                Text(description)
-                    .font(.system(size: 12, design: .monospaced))
+                Text(info.description)
+                    .font(.bitchatSystem(size: 12, design: .monospaced))
                     .foregroundColor(secondaryTextColor)
                     .fixedSize(horizontal: false, vertical: true)
             }
@@ -250,6 +276,16 @@ struct FeatureRow: View {
     }
 }
 
-#Preview {
+#Preview("Default") {
     AppInfoView()
 }
+
+#Preview("Dynamic Type XXL") {
+    AppInfoView()
+        .environment(\.sizeCategory, .accessibilityExtraExtraExtraLarge)
+}
+
+#Preview("Dynamic Type XS") {
+    AppInfoView()
+        .environment(\.sizeCategory, .extraSmall)
+}

bitchat/Views/Components/DeliveryStatusView.swift

@@ -0,0 +1,144 @@
+//
+// DeliveryStatusView.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import SwiftUI
+
+struct DeliveryStatusView: View {
+    @Environment(\.colorScheme) private var colorScheme
+    let status: DeliveryStatus
+
+    // MARK: - Computed Properties
+    
+    private var textColor: Color {
+        colorScheme == .dark ? Color.green : Color(red: 0, green: 0.5, blue: 0)
+    }
+    
+    private var secondaryTextColor: Color {
+        colorScheme == .dark ? Color.green.opacity(0.8) : Color(red: 0, green: 0.5, blue: 0).opacity(0.8)
+    }
+
+    private enum Strings {
+        static func delivered(to nickname: String) -> String {
+            String(
+                format: String(localized: "content.delivery.delivered_to", comment: "Tooltip for delivered private messages"),
+                locale: .current,
+                nickname
+            )
+        }
+
+        static func read(by nickname: String) -> String {
+            String(
+                format: String(localized: "content.delivery.read_by", comment: "Tooltip for read private messages"),
+                locale: .current,
+                nickname
+            )
+        }
+
+        static func failed(_ reason: String) -> String {
+            String(
+                format: String(localized: "content.delivery.failed", comment: "Tooltip for failed message delivery"),
+                locale: .current,
+                reason
+            )
+        }
+
+        static func deliveredToMembers(_ reached: Int, _ total: Int) -> String {
+            String(
+                format: String(localized: "content.delivery.delivered_members", comment: "Tooltip for partially delivered messages"),
+                locale: .current,
+                reached,
+                total
+            )
+        }
+    }
+    
+    // MARK: - Body
+    
+    var body: some View {
+        switch status {
+        case .sending:
+            Image(systemName: "circle")
+                .font(.bitchatSystem(size: 10))
+                .foregroundColor(secondaryTextColor.opacity(0.6))
+            
+        case .sent:
+            Image(systemName: "checkmark")
+                .font(.bitchatSystem(size: 10))
+                .foregroundColor(secondaryTextColor.opacity(0.6))
+            
+        case .delivered(let nickname, _):
+            HStack(spacing: -2) {
+                Image(systemName: "checkmark")
+                    .font(.bitchatSystem(size: 10))
+                Image(systemName: "checkmark")
+                    .font(.bitchatSystem(size: 10))
+            }
+            .foregroundColor(textColor.opacity(0.8))
+            .help(Strings.delivered(to: nickname))
+            
+        case .read(let nickname, _):
+            HStack(spacing: -2) {
+                Image(systemName: "checkmark")
+                    .font(.bitchatSystem(size: 10, weight: .bold))
+                Image(systemName: "checkmark")
+                    .font(.bitchatSystem(size: 10, weight: .bold))
+            }
+            .foregroundColor(Color(red: 0.0, green: 0.478, blue: 1.0))  // Bright blue
+            .help(Strings.read(by: nickname))
+            
+        case .failed(let reason):
+            Image(systemName: "exclamationmark.triangle")
+                .font(.bitchatSystem(size: 10))
+                .foregroundColor(Color.red.opacity(0.8))
+                .help(Strings.failed(reason))
+            
+        case .partiallyDelivered(let reached, let total):
+            HStack(spacing: 1) {
+                Image(systemName: "checkmark")
+                    .font(.bitchatSystem(size: 10))
+                Text(verbatim: "\(reached)/\(total)")
+                    .font(.bitchatSystem(size: 10, design: .monospaced))
+            }
+            .foregroundColor(secondaryTextColor.opacity(0.6))
+            .help(Strings.deliveredToMembers(reached, total))
+        }
+    }
+}
+
+#Preview {
+    let statuses: [DeliveryStatus] = [
+        .sending,
+        .sent,
+        .delivered(to: "John Doe", at: Date()),
+        .read(by: "Jane Doe", at: Date()),
+        .failed(reason: "Offline"),
+        .partiallyDelivered(reached: 2, total: 5)
+    ]
+    
+    List {
+        ForEach(statuses, id: \.self) { status in
+            HStack {
+                Text(status.displayText)
+                Spacer()
+                DeliveryStatusView(status: status)
+            }
+        }
+    }
+    .environment(\.colorScheme, .light)
+
+    List {
+        ForEach(statuses, id: \.self) { status in
+            HStack {
+                Text(status.displayText)
+                Spacer()
+                DeliveryStatusView(status: status)
+            }
+        }
+    }
+    .environment(\.colorScheme, .dark)
+}

bitchat/Views/Components/PaymentChipView.swift

@@ -0,0 +1,107 @@
+//
+// PaymentChipView.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import SwiftUI
+
+struct PaymentChipView: View {
+    @Environment(\.colorScheme) private var colorScheme
+    @Environment(\.openURL) private var openURL
+    
+    enum PaymentType {
+        case cashu(String)
+        case lightning(String)
+        
+        var url: URL? {
+            switch self {
+            case .cashu(let link), .lightning(let link):
+                return URL(string: link)
+            }
+        }
+        
+        var emoji: String {
+            switch self {
+            case .cashu:        "🥜"
+            case .lightning:    "⚡"
+            }
+        }
+        
+        var label: String {
+            switch self {
+            case .cashu:
+                String(localized: "content.payment.cashu", comment: "Label for Cashu payment chip")
+            case .lightning:
+                String(localized: "content.payment.lightning", comment: "Label for Lightning payment chip")
+            }
+        }
+    }
+    
+    let paymentType: PaymentType
+    
+    private var fgColor: Color {
+        colorScheme == .dark ? Color.green : Color(red: 0, green: 0.5, blue: 0)
+    }
+    private var bgColor: Color {
+        colorScheme == .dark ? Color.gray.opacity(0.18) : Color.gray.opacity(0.12)
+    }
+    private var border: Color { fgColor.opacity(0.25) }
+    
+    var body: some View {
+        Button {
+            #if os(iOS)
+            if let url = paymentType.url { openURL(url) }
+            #else
+            if let url = paymentType.url { NSWorkspace.shared.open(url) }
+            #endif
+        } label: {
+            HStack(spacing: 6) {
+                Text(paymentType.emoji)
+                Text(paymentType.label)
+                    .font(.bitchatSystem(size: 12, weight: .semibold, design: .monospaced))
+            }
+            .padding(.vertical, 6)
+            .padding(.horizontal, 12)
+            .background(
+                RoundedRectangle(cornerRadius: 12)
+                    .fill(bgColor)
+            )
+            .overlay(
+                RoundedRectangle(cornerRadius: 12)
+                    .stroke(border, lineWidth: 1)
+            )
+            .foregroundColor(fgColor)
+        }
+        .buttonStyle(.plain)
+    }
+}
+
+#Preview {
+    let cashuLink = "https://example.com/cashu"
+    let lightningLink = "https://example.com/lightning"
+    
+    List {
+        HStack {
+            PaymentChipView(paymentType: .cashu(cashuLink))
+            PaymentChipView(paymentType: .lightning(lightningLink))
+        }
+        .listRowSeparator(.hidden)
+        .listRowInsets(EdgeInsets())
+        .listRowBackground(EmptyView())
+    }
+    .environment(\.colorScheme, .light)
+
+    List {
+        HStack {
+            PaymentChipView(paymentType: .cashu(cashuLink))
+            PaymentChipView(paymentType: .lightning(lightningLink))
+        }
+        .listRowSeparator(.hidden)
+        .listRowInsets(EdgeInsets())
+        .listRowBackground(EmptyView())
+    }
+    .environment(\.colorScheme, .dark)
+}

bitchat/Views/Components/TextMessageView.swift

@@ -0,0 +1,97 @@
+//
+// TextMessageView.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import SwiftUI
+
+struct TextMessageView: View {
+    @Environment(\.colorScheme) private var colorScheme: ColorScheme
+    @EnvironmentObject private var viewModel: ChatViewModel
+    
+    let message: BitchatMessage
+    @Binding var expandedMessageIDs: Set<String>
+    
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            // Precompute heavy token scans once per row
+            let cashuLinks = message.content.extractCashuLinks()
+            let lightningLinks = message.content.extractLightningLinks()
+            HStack(alignment: .top, spacing: 0) {
+                let isLong = (message.content.count > TransportConfig.uiLongMessageLengthThreshold || message.content.hasVeryLongToken(threshold: TransportConfig.uiVeryLongTokenThreshold)) && cashuLinks.isEmpty
+                let isExpanded = expandedMessageIDs.contains(message.id)
+                Text(viewModel.formatMessageAsText(message, colorScheme: colorScheme))
+                    .fixedSize(horizontal: false, vertical: true)
+                    .lineLimit(isLong && !isExpanded ? TransportConfig.uiLongMessageLineLimit : nil)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                
+                // Delivery status indicator for private messages
+                if message.isPrivate && message.sender == viewModel.nickname,
+                   let status = message.deliveryStatus {
+                    DeliveryStatusView(status: status)
+                        .padding(.leading, 4)
+                }
+            }
+            
+            // Expand/Collapse for very long messages
+            if (message.content.count > TransportConfig.uiLongMessageLengthThreshold || message.content.hasVeryLongToken(threshold: TransportConfig.uiVeryLongTokenThreshold)) && cashuLinks.isEmpty {
+                let isExpanded = expandedMessageIDs.contains(message.id)
+                let labelKey = isExpanded ? LocalizedStringKey("content.message.show_less") : LocalizedStringKey("content.message.show_more")
+                Button(labelKey) {
+                    if isExpanded { expandedMessageIDs.remove(message.id) }
+                    else { expandedMessageIDs.insert(message.id) }
+                }
+                .font(.bitchatSystem(size: 11, weight: .medium, design: .monospaced))
+                .foregroundColor(Color.blue)
+                .padding(.top, 4)
+            }
+
+            // Render payment chips (Lightning / Cashu) with rounded background
+            if !lightningLinks.isEmpty || !cashuLinks.isEmpty {
+                HStack(spacing: 8) {
+                    ForEach(lightningLinks, id: \.self) { link in
+                        PaymentChipView(paymentType: .lightning(link))
+                    }
+                    ForEach(cashuLinks, id: \.self) { link in
+                        PaymentChipView(paymentType: .cashu(link))
+                    }
+                }
+                .padding(.top, 6)
+                .padding(.leading, 2)
+            }
+        }
+    }
+}
+
+@available(macOS 14, iOS 17, *)
+#Preview {
+    @Previewable @State var ids: Set<String> = []
+    let keychain = PreviewKeychainManager()
+    
+    Group {
+        List {
+            TextMessageView(message: .preview, expandedMessageIDs: $ids)
+                .listRowSeparator(.hidden)
+                .listRowInsets(EdgeInsets())
+                .listRowBackground(EmptyView())
+        }
+        .environment(\.colorScheme, .light)
+        
+        List {
+            TextMessageView(message: .preview, expandedMessageIDs: $ids)
+                .listRowSeparator(.hidden)
+                .listRowInsets(EdgeInsets())
+                .listRowBackground(EmptyView())
+        }
+        .environment(\.colorScheme, .dark)
+    }
+    .environmentObject(
+        ChatViewModel(
+            keychain: keychain,
+            identityManager: SecureIdentityStateManager(keychain)
+        )
+    )
+}