Add plus-minus feature to location notes (± 1 grid) (#821)

Expands location notes coverage to include 8 neighboring geohash cells,
creating a 3×3 grid around the user's current building-level location.

Changes:
- Add Geohash.neighbors() method to calculate 8 surrounding cells
- Update LocationNotesManager to subscribe to center + neighbors (9 cells total)
- Add NostrFilter.geohashNotes([String]) overload for multi-cell subscriptions
- Display '± 1' indicator in LocationNotesView header

Coverage:
- Single cell: ~38m × 19m
- 3×3 grid: ~114m × 57m total area
- Better discovery of nearby activity

Behavior:
- Subscribe: Fetches notes from all 9 cells (single efficient subscription)
- Post: Still uses center geohash only (correct privacy-preserving behavior)
- UI: Shows 'geohash ± 1' to indicate expanded coverage

Co-authored-by: jack <jackjackbits@users.noreply.github.com>

.github/workflows/swift-tests.yml

@@ -24,4 +24,4 @@ jobs:
         run: swift build
 
       - name: Run Tests
-        run: swift test --parallel --disable-swift-testing  # so it only runs xctests: https://github.com/swiftlang/swift-package-manager/issues/8529#issuecomment-2815711345
+        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__/
@@ -68,6 +66,9 @@ __pycache__/
 *.tmp
 *.temp
 
+## Cache
+.cache/
+
 # Local build results
 .Result*/
 .Result*.xcresult/

Configs/Release.xcconfig

@@ -1,4 +1,4 @@
-MARKETING_VERSION = 1.4.2
+MARKETING_VERSION = 1.4.4
 CURRENT_PROJECT_VERSION = 1
 
 IPHONEOS_DEPLOYMENT_TARGET = 16.0

Justfile

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

Package.swift

@@ -4,6 +4,7 @@ import PackageDescription
 
 let package = Package(
     name: "bitchat",
+    defaultLocalization: "en",
     platforms: [
         .iOS(.v16),
         .macOS(.v13)
@@ -15,6 +16,7 @@ let package = Package(
         ),
     ],
     dependencies:[
+        .package(path: "localPackages/Tor"),
         .package(path: "localPackages/BitLogger"),
         .package(url: "https://github.com/21-DOT-DEV/swift-secp256k1", exact: "0.21.1")
     ],
@@ -24,8 +26,7 @@ let package = Package(
             dependencies: [
                 .product(name: "P256K", package: "swift-secp256k1"),
                 .product(name: "BitLogger", package: "BitLogger"),
-                .target(name: "TorC"),
+                .product(name: "Tor", package: "Tor")
-                .target(name: "tor-nolzma")
             ],
             path: "bitchat",
             exclude: [
@@ -33,21 +34,12 @@ let package = Package(
                 "Assets.xcassets",
                 "bitchat.entitlements",
                 "bitchat-macOS.entitlements",
-                "LaunchScreen.storyboard",
+                "LaunchScreen.storyboard"
-                "Services/Tor/C/"
             ],
-            linkerSettings: [
+            resources: [
-                .linkedLibrary("z")
+                .process("Localizable.xcstrings")
             ]
         ),
-        .target(
-            name: "TorC",
-            path: "bitchat/Services/Tor/C"
-        ),
-        .binaryTarget(
-            name: "tor-nolzma",
-            path: "Frameworks/tor-nolzma.xcframework"
-        ),
         .testTarget(
             name: "bitchatTests",
             dependencies: ["bitchat"],
@@ -55,6 +47,9 @@ let package = Package(
             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
@@ -116,3 +116,10 @@ For detailed protocol documentation, see the [Technical Whitepaper](WHITEPAPER.m
 
 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/project.pbxproj

@@ -7,15 +7,14 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-		0481A35D2E6DA18600FC845E /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 0481A35C2E6DA18600FC845E /* libz.tbd */; };
-		0481A3A02E744D6300FC845E /* tor-nolzma.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0481A39F2E744D6300FC845E /* tor-nolzma.xcframework */; };
-		0481A3A12E744D6300FC845E /* tor-nolzma.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0481A39F2E744D6300FC845E /* tor-nolzma.xcframework */; };
-		048A88812E76FD18000FBCDD /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 0481A35C2E6DA18600FC845E /* libz.tbd */; };
 		17901751FD8010AFC8E750F2 /* bitchatShareExtension.appex in Embed Foundation Extensions */ = {isa = PBXBuildFile; fileRef = 61F92EBA29C47C0FCC482F1F /* bitchatShareExtension.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
 		3EE336D150427F736F32B56C /* P256K in Frameworks */ = {isa = PBXBuildFile; productRef = B1D9136AA0083366353BFA2F /* P256K */; };
 		885BBED78092484A5B069461 /* P256K in Frameworks */ = {isa = PBXBuildFile; productRef = 4EB6BA1B8464F1EA38F4E286 /* P256K */; };
 		A6E3E5702E77036A0032EA8A /* BitLogger in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3E56F2E77036A0032EA8A /* BitLogger */; };
 		A6E3E5722E7703760032EA8A /* BitLogger in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3E5712E7703760032EA8A /* BitLogger */; };
+		A6E3EA7F2E7706720032EA8A /* Tor in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3EA7E2E7706720032EA8A /* Tor */; };
+		A6E3EA812E7706A80032EA8A /* Tor in Frameworks */ = {isa = PBXBuildFile; productRef = A6E3EA802E7706A80032EA8A /* Tor */; };
+		A6F183FD2E948783006A9046 /* tor-nolzma.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = A6F183FC2E948783006A9046 /* tor-nolzma.xcframework */; };
 		E0A1B2C3D4E5F6012345678D /* relays/online_relays_gps.csv in Resources */ = {isa = PBXBuildFile; fileRef = E0A1B2C3D4E5F6012345678A /* relays/online_relays_gps.csv */; };
 		E0A1B2C3D4E5F6012345678E /* relays/online_relays_gps.csv in Resources */ = {isa = PBXBuildFile; fileRef = E0A1B2C3D4E5F6012345678A /* relays/online_relays_gps.csv */; };
 /* End PBXBuildFile section */
@@ -58,11 +57,10 @@
 
 /* Begin PBXFileReference section */
 		03C57F452B55FD0FD8F51421 /* bitchatTests_macOS.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = bitchatTests_macOS.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
-		0481A35C2E6DA18600FC845E /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; };
-		0481A39F2E744D6300FC845E /* tor-nolzma.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; path = "tor-nolzma.xcframework"; sourceTree = "<group>"; };
 		61F92EBA29C47C0FCC482F1F /* bitchatShareExtension.appex */ = {isa = PBXFileReference; explicitFileType = "wrapper.app-extension"; includeInIndex = 0; path = bitchatShareExtension.appex; sourceTree = BUILT_PRODUCTS_DIR; };
 		8F3A7C058C2C8E1A06C8CF8B /* bitchat.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = bitchat.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		96D0D41CA19EE5A772AA8434 /* bitchat.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = bitchat.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		A6F183FC2E948783006A9046 /* tor-nolzma.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; name = "tor-nolzma.xcframework"; path = "localPackages/Tor/Frameworks/tor-nolzma.xcframework"; sourceTree = "<group>"; };
 		C0DB1DE27F0AAB5092663E8E /* bitchatTests_iOS.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = bitchatTests_iOS.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 		E0A1B2C3D4E5F6012345678A /* relays/online_relays_gps.csv */ = {isa = PBXFileReference; lastKnownFileType = text; path = relays/online_relays_gps.csv; sourceTree = "<group>"; };
 /* End PBXFileReference section */
@@ -87,7 +85,6 @@
 			membershipExceptions = (
 				Info.plist,
 				LaunchScreen.storyboard,
-				Services/Tor/C/include/.gitkeep,
 			);
 			target = 0576A29205865664C0937536 /* bitchat_macOS */;
 		};
@@ -136,32 +133,22 @@
 			isa = PBXFrameworksBuildPhase;
 			files = (
 				A6E3E5722E7703760032EA8A /* BitLogger in Frameworks */,
-				048A88812E76FD18000FBCDD /* libz.tbd in Frameworks */,
-				0481A3A02E744D6300FC845E /* tor-nolzma.xcframework in Frameworks */,
 				3EE336D150427F736F32B56C /* P256K in Frameworks */,
+				A6E3EA812E7706A80032EA8A /* Tor in Frameworks */,
 			);
 		};
 		B5A5CC493FFB3D8966548140 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			files = (
+				A6F183FD2E948783006A9046 /* tor-nolzma.xcframework in Frameworks */,
 				A6E3E5702E77036A0032EA8A /* BitLogger in Frameworks */,
-				0481A35D2E6DA18600FC845E /* libz.tbd in Frameworks */,
-				0481A3A12E744D6300FC845E /* tor-nolzma.xcframework in Frameworks */,
 				885BBED78092484A5B069461 /* P256K in Frameworks */,
+				A6E3EA7F2E7706720032EA8A /* Tor in Frameworks */,
 			);
 		};
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
-		0481A3542E6D877600FC845E /* Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				0481A39F2E744D6300FC845E /* tor-nolzma.xcframework */,
-				0481A35C2E6DA18600FC845E /* libz.tbd */,
-			);
-			path = Frameworks;
-			sourceTree = "<group>";
-		};
 		18198ED912AAF495D8AF7763 = {
 			isa = PBXGroup;
 			children = (
@@ -170,8 +157,8 @@
 				A6E32D212E762EAB0032EA8A /* bitchatShareExtension */,
 				A6E32D412E762EAE0032EA8A /* bitchatTests */,
 				A6E367C92E76469E0032EA8A /* Configs */,
-				0481A3542E6D877600FC845E /* Frameworks */,
 				9F37F9F2C353B58AC809E93B /* Products */,
+				A6F183FB2E948783006A9046 /* Frameworks */,
 			);
 			sourceTree = "<group>";
 		};
@@ -187,6 +174,14 @@
 			name = Products;
 			sourceTree = "<group>";
 		};
+		A6F183FB2E948783006A9046 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				A6F183FC2E948783006A9046 /* tor-nolzma.xcframework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
 /* End PBXGroup section */
 
 /* Begin PBXNativeTarget section */
@@ -207,6 +202,7 @@
 			packageProductDependencies = (
 				B1D9136AA0083366353BFA2F /* P256K */,
 				A6E3E5712E7703760032EA8A /* BitLogger */,
+				A6E3EA802E7706A80032EA8A /* Tor */,
 			);
 			productName = bitchat_macOS;
 			productReference = 8F3A7C058C2C8E1A06C8CF8B /* bitchat.app */;
@@ -284,6 +280,7 @@
 			packageProductDependencies = (
 				4EB6BA1B8464F1EA38F4E286 /* P256K */,
 				A6E3E56F2E77036A0032EA8A /* BitLogger */,
+				A6E3EA7E2E7706720032EA8A /* Tor */,
 			);
 			productName = bitchat_iOS;
 			productReference = 96D0D41CA19EE5A772AA8434 /* bitchat.app */;
@@ -304,12 +301,27 @@
 			knownRegions = (
 				Base,
 				en,
+				es,
+				ar,
+				de,
+				fr,
+				he,
+				id,
+				it,
+				ja,
+				ne,
+				"pt-BR",
+				ru,
+				tr,
+				uk,
+				"zh-Hans",
 			);
 			mainGroup = 18198ED912AAF495D8AF7763;
 			minimizedProjectReferenceProxies = 1;
 			packageReferences = (
 				B8C407587481BBB190741C93 /* XCRemoteSwiftPackageReference "swift-secp256k1" */,
 				A6E3E56E2E77036A0032EA8A /* XCLocalSwiftPackageReference "localPackages/BitLogger" */,
+				A6E3EA7D2E7706720032EA8A /* XCLocalSwiftPackageReference "localPackages/Tor" */,
 			);
 			preferredProjectObjectVersion = 90;
 			projectDirPath = "";
@@ -498,7 +510,7 @@
 			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
 			baseConfigurationReferenceRelativePath = Debug.xcconfig;
 			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIconDebug;
 				ASSETCATALOG_COMPILER_INCLUDE_ALL_APPICON_ASSETS = YES;
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
@@ -684,7 +696,7 @@
 			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
 			baseConfigurationReferenceRelativePath = Debug.xcconfig;
 			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIconDebug;
 				ASSETCATALOG_COMPILER_INCLUDE_ALL_APPICON_ASSETS = YES;
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
@@ -867,6 +879,10 @@
 			isa = XCLocalSwiftPackageReference;
 			relativePath = localPackages/BitLogger;
 		};
+		A6E3EA7D2E7706720032EA8A /* XCLocalSwiftPackageReference "localPackages/Tor" */ = {
+			isa = XCLocalSwiftPackageReference;
+			relativePath = localPackages/Tor;
+		};
 /* End XCLocalSwiftPackageReference section */
 
 /* Begin XCRemoteSwiftPackageReference section */
@@ -894,6 +910,14 @@
 			isa = XCSwiftPackageProductDependency;
 			productName = BitLogger;
 		};
+		A6E3EA7E2E7706720032EA8A /* Tor */ = {
+			isa = XCSwiftPackageProductDependency;
+			productName = Tor;
+		};
+		A6E3EA802E7706A80032EA8A /* Tor */ = {
+			isa = XCSwiftPackageProductDependency;
+			productName = Tor;
+		};
 		B1D9136AA0083366353BFA2F /* P256K */ = {
 			isa = XCSwiftPackageProductDependency;
 			package = B8C407587481BBB190741C93 /* XCRemoteSwiftPackageReference "swift-secp256k1" */;

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

bitchat/Assets.xcassets/Contents.json

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

bitchat/BitchatApp.swift

@@ -6,6 +6,7 @@
 // For more information, see <https://unlicense.org>
 //
 
+import Tor
 import SwiftUI
 import UserNotifications
 
@@ -25,11 +26,15 @@ struct BitchatApp: App {
     @NSApplicationDelegateAdaptor(MacAppDelegate.self) var appDelegate
     #endif
     
+    private let idBridge = NostrIdentityBridge()
+    
     init() {
         let keychain = KeychainManager()
+        let idBridge = self.idBridge
         _chatViewModel = StateObject(
             wrappedValue: ChatViewModel(
                 keychain: keychain,
+                idBridge: idBridge,
                 identityManager: SecureIdentityStateManager(keychain)
             )
         )
@@ -49,7 +54,7 @@ struct BitchatApp: App {
                     VerificationService.shared.configure(with: chatViewModel.meshService.getNoiseService())
                     // Prewarm Nostr identity and QR to make first VERIFY sheet fast
                     DispatchQueue.global(qos: .utility).async {
-                        let npub = try? NostrIdentityBridge.getCurrentNostrIdentity()?.npub
+                        let npub = try? idBridge.getCurrentNostrIdentity()?.npub
                         _ = VerificationService.shared.buildMyQRString(nickname: chatViewModel.nickname, npub: npub)
                     }
                     #if os(iOS)
@@ -216,7 +221,7 @@ final class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
             // Get peer ID from userInfo
             if let peerID = userInfo["peerID"] as? String {
                 DispatchQueue.main.async {
-                    self.chatViewModel?.startPrivateChat(with: peerID)
+                    self.chatViewModel?.startPrivateChat(with: PeerID(str: peerID))
                 }
             }
         }

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

@@ -103,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
@@ -121,12 +121,12 @@ protocol SecureIdentityStateManagerProtocol {
     func getBlockedNostrPubkeys() -> Set<String>
     
     // MARK: Ephemeral Session Management
-    func registerEphemeralSession(peerID: String, handshakeState: HandshakeState)
+    func registerEphemeralSession(peerID: PeerID, handshakeState: HandshakeState)
-    func updateHandshakeState(peerID: String, state: 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)
@@ -143,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()
     
@@ -321,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 [] }
+            guard peerID.isShort else { return [] }
-            return cryptographicIdentities.values.filter { $0.fingerprint.hasPrefix(peerID) }
+            return cryptographicIdentities.values.filter { $0.fingerprint.hasPrefix(peerID.id) }
         }
     }
     
@@ -455,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,
@@ -465,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
             
@@ -493,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

@@ -21,7 +21,7 @@ final class BitchatMessage: Codable {
     let originalSender: String?
     let isPrivate: Bool
     let recipientNickname: String?
-    let senderPeerID: String?
+    let senderPeerID: PeerID?
     let mentions: [String]?  // Array of mentioned nicknames
     var deliveryStatus: DeliveryStatus? // Delivery tracking
     
@@ -42,7 +42,19 @@ final class BitchatMessage: Codable {
         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) {
+    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
@@ -151,7 +163,7 @@ extension BitchatMessage {
             data.append(recipData.prefix(255))
         }
         
-        if let senderPeerID = senderPeerID, let peerData = senderPeerID.data(using: .utf8) {
+        if let peerData = senderPeerID?.id.data(using: .utf8) {
             data.append(UInt8(min(peerData.count, 255)))
             data.append(peerData.prefix(255))
         }
@@ -264,11 +276,11 @@ extension BitchatMessage {
             }
         }
         
-        var senderPeerID: String?
+        var senderPeerID: PeerID?
         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)
+                senderPeerID = PeerID(data: dataCopy[offset..<offset+length])
                 offset += length
             }
         }

bitchat/Models/BitchatPacket.swift

@@ -34,12 +34,12 @@ struct BitchatPacket: Codable {
     }
     
     // Convenience initializer for new binary format
-    init(type: UInt8, ttl: UInt8, senderID: String, payload: Data) {
+    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
+        var tempID = senderID.id
         while tempID.count >= 2 {
             let hexByte = String(tempID.prefix(2))
             if let byte = UInt8(hexByte, radix: 16) {

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 {
+struct BitchatPeer: Equatable {
-    let id: String // Hex-encoded peer ID
+    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/PeerID.swift

@@ -0,0 +1,217 @@
+//
+// 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
+    }
+    
+    /// Returns true if the `bare` id is all hex
+    var isHex: Bool {
+        bare.allSatisfy { $0.isHexDigit }
+    }
+    
+    /// Short routing IDs (exact 16-hex)
+    var isShort: Bool {
+        bare.count == Constants.hexIDLength && isHex
+    }
+    
+    /// 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

@@ -79,7 +79,7 @@ struct ReadReceipt: Codable {
         
         guard let readerIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
         let readerID = readerIDData.hexEncodedString()
-        guard InputValidator.validatePeerID(readerID) else { return nil }
+        guard PeerID(str: readerID).isValid else { return nil }
         
         guard let timestamp = dataCopy.readDate(at: &offset),
               InputValidator.validateTimestamp(timestamp),

bitchat/Noise/NoiseHandshakeCoordinator.swift

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

@@ -397,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
     }
@@ -410,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/NoiseRateLimiter.swift

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

bitchat/Noise/NoiseSecurityConsiderations.swift

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

bitchat/Noise/NoiseSecurityConstants.swift

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

bitchat/Noise/NoiseSecurityError.swift

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

bitchat/Noise/NoiseSecurityValidator.swift

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

bitchat/Noise/NoiseSession.swift

@@ -10,32 +10,8 @@ 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
@@ -55,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,
@@ -141,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 {
@@ -167,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
@@ -220,12 +196,6 @@ class NoiseSession {
         }
     }
     
-    func getHandshakeHash() -> Data? {
-        return sessionQueue.sync {
-            return handshakeHash
-        }
-    }
-    
     func reset() {
         sessionQueue.sync(flags: .barrier) {
             let wasEstablished = state == .established
@@ -252,249 +222,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 removeAllSessions() {
-        managerQueue.sync(flags: .barrier) {
-            for (_, session) in sessions {
-                session.reset()
-            }
-            sessions.removeAll()
-        }
-    }
-    
-    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,14 @@
+//
+// NoiseSessionError.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+enum NoiseSessionError: Error, Equatable {
+    case invalidState
+    case notEstablished
+    case sessionNotFound
+    case alreadyEstablished
+}

bitchat/Noise/NoiseSessionManager.swift

@@ -0,0 +1,211 @@
+//
+// 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 getSession(for peerID: PeerID) -> NoiseSession? {
+        return managerQueue.sync {
+            return sessions[peerID]
+        }
+    }
+    
+    func removeSession(for peerID: PeerID) {
+        managerQueue.sync(flags: .barrier) {
+            if let session = sessions.removeValue(forKey: peerID) {
+                session.reset() // Clear sensitive data before removing
+            }
+        }
+    }
+
+    func removeAllSessions() {
+        managerQueue.sync(flags: .barrier) {
+            for (_, session) in sessions {
+                session.reset()
+            }
+            sessions.removeAll()
+        }
+    }
+    
+    // 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()
+    }
+    
+    // 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/Noise/SecureNoiseSession.swift

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

bitchat/Nostr/Bech32.swift

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

bitchat/Nostr/GeoRelayDirectory.swift

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

bitchat/Nostr/KeychainHelper.swift

@@ -0,0 +1,50 @@
+import Foundation
+
+protocol KeychainHelperProtocol {
+    func save(key: String, data: Data, service: String, accessible: CFString?)
+    func load(key: String, service: String) -> Data?
+    func delete(key: String, service: String)
+}
+
+/// Keychain helper for secure storage
+struct KeychainHelper: KeychainHelperProtocol {
+    func save(key: String, data: Data, service: String, accessible: CFString? = nil) {
+        var query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key,
+            kSecValueData as String: data
+        ]
+        if let accessible = accessible {
+            query[kSecAttrAccessible as String] = accessible
+        }
+        
+        SecItemDelete(query as CFDictionary)
+        SecItemAdd(query as CFDictionary, nil)
+    }
+    
+    func load(key: String, service: String) -> Data? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key,
+            kSecReturnData as String: true
+        ]
+        
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        
+        guard status == errSecSuccess else { return nil }
+        return result as? Data
+    }
+    
+    func delete(key: String, service: String) {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key
+        ]
+        
+        SecItemDelete(query as CFDictionary)
+    }
+}

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

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

bitchat/Nostr/NostrIdentityBridge.swift

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

bitchat/Nostr/NostrProtocol.swift

@@ -521,10 +521,7 @@ struct NostrEvent: Codable {
         ] as [Any]
         
         let data = try JSONSerialization.data(withJSONObject: serialized, options: [.withoutEscapingSlashes])
-        let hash = CryptoKit.SHA256.hash(data: data)
+        return (data.sha256Fingerprint(), data.sha256Hash())
-        let hashData = Data(hash)
-        let hashHex = hash.compactMap { String(format: "%02x", $0) }.joined()
-        return (hashHex, hashData)
     }
     
     func jsonString() throws -> String {

bitchat/Nostr/NostrRelayManager.swift

@@ -2,6 +2,7 @@ import BitLogger
 import Foundation
 import Network
 import Combine
+import Tor
 
 /// Manages WebSocket connections to Nostr relays
 @MainActor
@@ -41,6 +42,8 @@ final class NostrRelayManager: ObservableObject {
     @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)
@@ -82,17 +85,27 @@ final class NostrRelayManager: ObservableObject {
     private var connectionGeneration: Int = 0
     
     init() {
-        let hasMutual = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
+        hasMutualFavorites = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
-        allowDefaultRelays = hasMutual
+        hasLocationPermission = LocationChannelManager.shared.permissionState == .authorized
-        if hasMutual {
+        applyDefaultRelayPolicy(force: true)
-            self.relays = Self.defaultRelays.map { Relay(url: $0) }
-        }
         // Deterministic JSON shape for outbound requests
         self.encoder.outputFormatting = .sortedKeys
         FavoritesPersistenceService.shared.$mutualFavorites
             .receive(on: DispatchQueue.main)
             .sink { [weak self] favorites in
-                self?.updateDefaultRelayPolicy(hasMutual: !favorites.isEmpty)
+                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)
     }
@@ -326,10 +339,11 @@ final class NostrRelayManager: ObservableObject {
         }
     }
 
-    private func updateDefaultRelayPolicy(hasMutual: Bool) {
+    private func applyDefaultRelayPolicy(force: Bool = false) {
-        guard hasMutual != allowDefaultRelays else { return }
+        let shouldAllow = hasMutualFavorites || hasLocationPermission
-        allowDefaultRelays = hasMutual
+        if !force && shouldAllow == allowDefaultRelays { return }
-        if hasMutual {
+        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))
@@ -892,6 +906,16 @@ struct NostrFilter: Encodable {
         filter.limit = limit
         return filter
     }
+
+    // For location notes with neighbors: subscribe to multiple geohashes (center + neighbors)
+    static func geohashNotes(_ geohashes: [String], since: Date? = nil, limit: Int = 200) -> NostrFilter {
+        var filter = NostrFilter()
+        filter.kinds = [1]
+        filter.since = since?.timeIntervalSince1970.toInt()
+        filter.tagFilters = ["g": geohashes]
+        filter.limit = limit
+        return filter
+    }
 }
 
 // Dynamic coding key for tag filters

bitchat/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/BitchatProtocol.swift

@@ -59,6 +59,7 @@
 ///
 
 import Foundation
+import CoreBluetooth
 
 // MARK: - Message Types
 
@@ -131,7 +132,7 @@ enum LazyHandshakeState {
 // 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
@@ -161,18 +162,21 @@ enum DeliveryStatus: Codable, Equatable {
 
 protocol BitchatDelegate: AnyObject {
     func didReceiveMessage(_ message: BitchatMessage)
-    func didConnectToPeer(_ peerID: String)
+    func didConnectToPeer(_ peerID: PeerID)
-    func didDisconnectFromPeer(_ peerID: String)
+    func didDisconnectFromPeer(_ peerID: PeerID)
-    func didUpdatePeerList(_ peers: [String])
+    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 didReceiveNoisePayload(from peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date)
-    func didReceivePublicMessage(from peerID: String, nickname: String, content: String, 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
@@ -185,11 +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
     }
 }

bitchat/Protocols/Geohash.swift

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

bitchat/Protocols/LocationChannel.swift

@@ -23,15 +23,21 @@ enum GeohashChannelLevel: CaseIterable, Codable, Equatable {
 
     var displayName: String {
         switch self {
-        case .building: return "Building"
+        case .building:
-        case .block: return "Block"
+            return String(localized: "location_levels.building", comment: "Name for building-level location channel")
-        case .neighborhood: return "Neighborhood"
+        case .block:
-        case .city: return "City"
+            return String(localized: "location_levels.block", comment: "Name for block-level location channel")
-        case .province: return "Province"
+        case .neighborhood:
-        case .region: return "Region"
+            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 {

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

@@ -42,7 +42,7 @@ final class CommandProcessor {
             case .location: return true
             }
         }()
-        let inGeoDM = (chatViewModel?.selectedPrivateChatPeer?.hasPrefix("nostr_") == true)
+        let inGeoDM = chatViewModel?.selectedPrivateChatPeer?.isGeoDM == true
 
         switch cmd {
         case "/m", "/msg":
@@ -65,14 +65,11 @@ final class CommandProcessor {
         case "/unfav":
             if inGeoPublic || inGeoDM { return .error(message: "favorites are only for mesh peers in #mesh") }
             return handleFavorite(args, add: false)
-        //
-        case "/help", "/h":
-            return .error(message: "unknown command: \(cmd)")
         default:
             return .error(message: "unknown command: \(cmd)")
         }
     }
-    
+
     // MARK: - Command Handlers
     
     private func handleMessage(_ args: String) -> CommandResult {
@@ -104,7 +101,7 @@ final class CommandProcessor {
         case .location(let ch):
             // Geohash context: show visible geohash participants (exclude self)
             guard let vm = chatViewModel else { return .success(message: "nobody around") }
-            let myHex = (try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash))?.publicKeyHex.lowercased()
+            let myHex = (try? chatViewModel?.idBridge.deriveIdentity(forGeohash: ch.geohash))?.publicKeyHex.lowercased()
             let people = vm.visibleGeohashPeople().filter { person in
                 if let me = myHex { return person.id.lowercased() != me }
                 return true
@@ -150,8 +147,8 @@ final class CommandProcessor {
             // In private chat
             if let peerNickname = meshService?.peerNickname(peerID: targetPeerID) {
                 let personalMessage = "* \(emoji) \(myNickname) \(action) you\(suffix) *"
-                meshService?.sendPrivateMessage(personalMessage, to: targetPeerID, 
+                meshService?.sendPrivateMessage(personalMessage, to: targetPeerID,
-                                               recipientNickname: peerNickname, 
+                                               recipientNickname: peerNickname,
                                                messageID: UUID().uuidString)
                 // Also add a local system message so the sender sees a natural-language confirmation
                 let pastAction: String = {
@@ -285,7 +282,7 @@ final class CommandProcessor {
         let nickname = targetName.hasPrefix("@") ? String(targetName.dropFirst()) : targetName
         
         guard let peerID = chatViewModel?.getPeerIDForNickname(nickname),
-              let noisePublicKey = Data(hexString: peerID) else {
+              let noisePublicKey = Data(hexString: peerID.id) else {
             return .error(message: "can't find peer: \(nickname)")
         }
         
@@ -311,19 +308,4 @@ final class CommandProcessor {
         }
     }
     
-    private func handleHelp() -> CommandResult {
-        let helpText = """
-        commands:
-        /msg @name - start private chat
-        /who - list who's online
-        /clear - clear messages
-        /hug @name - send a hug
-        /slap @name - slap with a trout
-        /fav @name - add to favorites
-        /unfav @name - remove from favorites
-        /block @name - block
-        /unblock @name - unblock
-        """
-        return .success(message: helpText)
-    }
 }

bitchat/Services/FavoritesPersistenceService.swift

@@ -26,6 +26,7 @@ final class FavoritesPersistenceService: ObservableObject {
 
     private static let storageKey = "chat.bitchat.favorites"
     private static let keychainService = "chat.bitchat.favorites"
+    private let keychain: KeychainHelperProtocol
     
     @Published private(set) var favorites: [Data: FavoriteRelationship] = [:] // Noise pubkey -> relationship
     @Published private(set) var mutualFavorites: Set<Data> = []
@@ -35,7 +36,8 @@ final class FavoritesPersistenceService: ObservableObject {
     
     static let shared = FavoritesPersistenceService()
     
-    private init() {
+    init(keychain: KeychainHelperProtocol = KeychainHelper()) {
+        self.keychain = keychain
         loadFavorites()
         
         // Update mutual favorites when favorites change
@@ -179,125 +181,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 }
+        guard peerID.isShort else { return nil }
-        for (pubkey, rel) in favorites {
+        for (pubkey, rel) in favorites where PeerID(publicKey: pubkey) == peerID {
-            let derived = PeerIDUtils.derivePeerID(fromPublicKey: pubkey)
+            return rel
-            if derived == 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)
@@ -306,7 +198,7 @@ final class FavoritesPersistenceService: ObservableObject {
         saveFavorites()
         
         // Delete from keychain directly
-        KeychainHelper.delete(
+        keychain.delete(
             key: Self.storageKey,
             service: Self.keychainService
         )
@@ -326,10 +218,11 @@ final class FavoritesPersistenceService: ObservableObject {
             let data = try encoder.encode(relationships)
             
             // Store in keychain for security
-            KeychainHelper.save(
+            keychain.save(
                 key: Self.storageKey,
                 data: data,
-                service: Self.keychainService
+                service: Self.keychainService,
+                accessible: nil
             )
             
             // Successfully saved favorites
@@ -341,7 +234,7 @@ final class FavoritesPersistenceService: ObservableObject {
     private func loadFavorites() {
         // Loading favorites from keychain
         
-        guard let data = KeychainHelper.load(
+        guard let data = keychain.load(
             key: Self.storageKey,
             service: Self.keychainService
         ) else { 

bitchat/Services/GeohashBookmarksStore.swift

@@ -20,8 +20,11 @@ final class GeohashBookmarksStore: ObservableObject {
     private let geocoder = CLGeocoder()
     private var resolving: Set<String> = []
     #endif
+    
+    private let storage: UserDefaults
 
-    private init() {
+    init(storage: UserDefaults = .standard) {
+        self.storage = storage
         load()
     }
 
@@ -64,7 +67,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 +84,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 +92,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)
         }
     }
 
@@ -213,15 +216,4 @@ final class GeohashBookmarksStore: ObservableObject {
         }
     }
     #endif
-
-    #if DEBUG
-    /// Testing-only reset helper
-    func _resetForTesting() {
-        bookmarks.removeAll()
-        membership.removeAll()
-        bookmarkNames.removeAll()
-        persist()
-        persistNames()
-    }
-    #endif
 }

bitchat/Services/KeychainManager.swift

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

bitchat/Services/LocationNotesCounter.swift

@@ -1,53 +0,0 @@
-import Foundation
-
-/// 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
-
-    private var subscriptionID: String? = nil
-    private var noteIDs = Set<String>()
-
-    private init() {}
-
-    func subscribe(geohash gh: String) {
-        let norm = gh.lowercased()
-        if geohash == norm, subscriptionID != nil { return }
-        // Unsubscribe previous without clearing count to avoid flicker
-        if let sub = subscriptionID { NostrRelayManager.shared.unsubscribe(id: sub) }
-        subscriptionID = nil
-        geohash = norm
-        noteIDs.removeAll()
-        initialLoadComplete = false
-
-        // Subscribe only to the building geohash (precision 8)
-        let subID = "locnotes-count-\(norm)-\(UUID().uuidString.prefix(6))"
-        subscriptionID = subID
-        let filter = NostrFilter.geohashNotes(norm, since: nil, limit: 500)
-        let relays = GeoRelayDirectory.shared.closestRelays(toGeohash: norm, count: TransportConfig.nostrGeoRelayCount)
-        let relayUrls: [String]? = relays.isEmpty ? nil : relays
-        NostrRelayManager.shared.subscribe(filter: filter, id: subID, relayUrls: relayUrls, handler: { [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
-            }
-        }, onEOSE: { [weak self] in
-            self?.initialLoadComplete = true
-        })
-    }
-
-    func cancel() {
-        if let sub = subscriptionID { NostrRelayManager.shared.unsubscribe(id: sub) }
-        subscriptionID = nil
-        geohash = nil
-        count = 0
-        noteIDs.removeAll()
-    }
-}

bitchat/Services/LocationNotesManager.swift

@@ -1,10 +1,59 @@
 import BitLogger
 import Foundation
 
-/// Persistent location notes (Nostr kind 1) scoped to a street-level geohash (precision 7).
+/// Dependencies for location notes, allowing tests to stub relay/identity behavior.
+struct LocationNotesDependencies {
+    typealias RelayLookup = @MainActor (_ geohash: String, _ count: Int) -> [String]
+    typealias Subscribe = @MainActor (_ filter: NostrFilter, _ id: String, _ relays: [String], _ handler: @escaping (NostrEvent) -> Void, _ onEOSE: (() -> Void)?) -> Void
+    typealias Unsubscribe = @MainActor (_ id: String) -> Void
+    typealias SendEvent = @MainActor (_ event: NostrEvent, _ relayUrls: [String]) -> Void
+
+    var relayLookup: RelayLookup
+    var subscribe: Subscribe
+    var unsubscribe: Unsubscribe
+    var sendEvent: SendEvent
+    var deriveIdentity: (_ geohash: String) throws -> NostrIdentity
+    var now: () -> Date
+    
+    private static let idBridge = NostrIdentityBridge()
+
+    static let live = LocationNotesDependencies(
+        relayLookup: { geohash, count in
+            GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: count)
+        },
+        subscribe: { filter, id, relays, handler, onEOSE in
+            NostrRelayManager.shared.subscribe(
+                filter: filter,
+                id: id,
+                relayUrls: relays,
+                handler: handler,
+                onEOSE: onEOSE
+            )
+        },
+        unsubscribe: { id in
+            NostrRelayManager.shared.unsubscribe(id: id)
+        },
+        sendEvent: { event, relays in
+            NostrRelayManager.shared.sendEvent(event, to: relays)
+        },
+        deriveIdentity: { geohash in
+            try idBridge.deriveIdentity(forGeohash: geohash)
+        },
+        now: { Date() }
+    )
+}
+
+/// Persistent location notes (Nostr kind 1) scoped to a building-level geohash (precision 8).
 /// Subscribes to and publishes notes for a given geohash and provides a send API.
 @MainActor
 final class LocationNotesManager: ObservableObject {
+    enum State: Equatable {
+        case idle
+        case loading
+        case ready
+        case noRelays
+    }
+
     struct Note: Identifiable, Equatable {
         let id: String
         let pubkey: String
@@ -24,46 +73,127 @@ final class LocationNotesManager: ObservableObject {
     @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)
 
-    init(geohash: String) {
+    private enum Strings {
-        self.geohash = geohash.lowercased()
+        static let noRelays = String(localized: "location_notes.error.no_relays", comment: "Shown when no geo relays are available near the selected location")
+
+        static func failedToSend(_ detail: String) -> String {
+            String(
+                format: String(localized: "location_notes.error.failed_to_send", comment: "Shown when a location note fails to send"),
+                locale: .current,
+                detail
+            )
+        }
+    }
+
+    init(geohash: String, dependencies: LocationNotesDependencies = .live) {
+        let norm = geohash.lowercased()
+        self.geohash = norm
+        self.dependencies = dependencies
+        // Validate geohash (building-level precision: 8 chars)
+        if !Geohash.isValidBuildingGeohash(norm) {
+            SecureLogger.warning("LocationNotesManager: invalid geohash '\(norm)' (expected 8 valid base32 chars)", category: .session)
+        }
         subscribe()
     }
 
     func setGeohash(_ newGeohash: String) {
         let norm = newGeohash.lowercased()
         guard norm != geohash else { return }
+        // Validate geohash (building-level precision: 8 chars)
+        guard Geohash.isValidBuildingGeohash(norm) else {
+            SecureLogger.warning("LocationNotesManager: rejecting invalid geohash '\(norm)' (expected 8 valid base32 chars)", category: .session)
+            return
+        }
         if let sub = subscriptionID {
-            NostrRelayManager.shared.unsubscribe(id: sub)
+            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()
     }
 
-    private func subscribe() {
+    func refresh() {
-        let subID = "locnotes-\(geohash)-\(UUID().uuidString.prefix(8))"
+        if let sub = subscriptionID {
-        subscriptionID = subID
+            dependencies.unsubscribe(sub)
-        // For persistent notes, allow relays to return recent history without an aggressive time cutoff
+            subscriptionID = nil
-        let filter = NostrFilter.geohashNotes(geohash, since: nil, limit: 200)
+        }
-        let relays = GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: TransportConfig.nostrGeoRelayCount)
+        // Set loading state before clearing to prevent empty state flicker
-        let relayUrls: [String]? = relays.isEmpty ? nil : relays
+        state = .loading
         initialLoadComplete = false
-        NostrRelayManager.shared.subscribe(filter: filter, id: subID, relayUrls: relayUrls, handler: { [weak self] event in
+        errorMessage = nil
+        notes.removeAll()
+        noteIDs.removeAll()
+        subscribe()
+    }
+
+    func clearError() {
+        errorMessage = nil
+    }
+
+    private func subscribe() {
+        state = .loading
+        errorMessage = nil
+        if let sub = subscriptionID {
+            dependencies.unsubscribe(sub)
+            subscriptionID = nil
+        }
+        let subID = "locnotes-\(geohash)-\(UUID().uuidString.prefix(8))"
+        let relays = dependencies.relayLookup(geohash, TransportConfig.nostrGeoRelayCount)
+        guard !relays.isEmpty else {
+            subscriptionID = nil
+            initialLoadComplete = true
+            state = .noRelays
+            errorMessage = Strings.noRelays
+            SecureLogger.warning("LocationNotesManager: no geo relays for geohash=\(geohash)", category: .session)
+            return
+        }
+
+        subscriptionID = subID
+        initialLoadComplete = false
+
+        // Subscribe to center + 8 neighbors (± 1 grid)
+        let neighbors = Geohash.neighbors(of: geohash)
+        let allGeohashes = [geohash] + neighbors
+        let filter = NostrFilter.geohashNotes(allGeohashes, since: nil, limit: 200)
+
+        // Build a set of valid geohashes for tag matching (includes all 9 cells)
+        let validGeohashes = Set(allGeohashes.map { $0.lowercased() })
+
+        dependencies.subscribe(filter, subID, relays, { [weak self] event in
             guard let self = self else { return }
             guard event.kind == NostrProtocol.EventKind.textNote.rawValue else { return }
-            // Ensure matching tag
+            // Ensure matching tag - accept any of our 9 geohashes
-            guard event.tags.contains(where: { $0.count >= 2 && $0[0].lowercased() == "g" && $0[1].lowercased() == self.geohash }) else { return }
+            guard event.tags.contains(where: { tag in
-            if self.notes.contains(where: { $0.id == event.id }) { return }
+                tag.count >= 2 && tag[0].lowercased() == "g" && validGeohashes.contains(tag[1].lowercased())
+            }) else { return }
+            guard !self.noteIDs.contains(event.id) else { return }
+            self.noteIDs.insert(event.id)
             let nick = event.tags.first(where: { $0.first?.lowercased() == "n" && $0.count >= 2 })?.dropFirst().first
             let ts = Date(timeIntervalSince1970: TimeInterval(event.created_at))
             let note = Note(id: event.id, pubkey: event.pubkey, content: event.content, createdAt: ts, nickname: nick)
             self.notes.append(note)
             self.notes.sort { $0.createdAt > $1.createdAt }
-        }, onEOSE: { [weak self] in
+            self.enforceMemoryCap()
-            self?.initialLoadComplete = true
+            self.state = .ready
+        }, { [weak self] in
+            guard let self = self else { return }
+            self.initialLoadComplete = true
+            if self.state != .noRelays {
+                self.state = .ready
+            }
         })
     }
 
@@ -71,29 +201,57 @@ final class LocationNotesManager: ObservableObject {
     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 NostrIdentityBridge.deriveIdentity(forGeohash: geohash)
+            let id = try dependencies.deriveIdentity(geohash)
             let event = try NostrProtocol.createGeohashTextNote(
                 content: trimmed,
                 geohash: geohash,
                 senderIdentity: id,
                 nickname: nickname
             )
-            let relays = GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: TransportConfig.nostrGeoRelayCount)
+            dependencies.sendEvent(event, relays)
-            NostrRelayManager.shared.sendEvent(event, to: relays)
             // Optimistic local-echo
-            let echo = Note(id: event.id, pubkey: id.publicKeyHex, content: trimmed, createdAt: Date(), nickname: nickname)
+            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 {
-            NostrRelayManager.shared.unsubscribe(id: sub)
+            dependencies.unsubscribe(sub)
             subscriptionID = nil
         }
+        state = .idle
+        errorMessage = nil
     }
 }

bitchat/Services/MessageRouter.swift

@@ -6,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
@@ -21,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)
                 }
@@ -29,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)
                 }
@@ -37,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)
@@ -84,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
@@ -102,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

@@ -1,6 +1,7 @@
 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

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
@@ -116,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")
         }
     }
 }
@@ -148,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 peerFingerprints: [PeerID: String] = [:]
-    private var fingerprintToPeerID: [String: String] = [:] // fingerprint -> peerID
+    private var fingerprintToPeerID: [String: PeerID] = [:]
     
     // Thread safety
     private let serviceQueue = DispatchQueue(label: "chat.bitchat.noise.service", attributes: .concurrent)
@@ -164,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) {
@@ -258,12 +272,11 @@ final class NoiseEncryptionService {
     
     /// Get our identity fingerprint
     func getIdentityFingerprint() -> String {
-        let hash = SHA256.hash(data: staticIdentityPublicKey.rawRepresentation)
+        staticIdentityPublicKey.rawRepresentation.sha256Fingerprint()
-        return hash.map { String(format: "%02x", $0) }.joined()
     }
     
     /// Get peer's public key data
-    func getPeerPublicKeyData(_ peerID: String) -> Data? {
+    func getPeerPublicKeyData(_ peerID: PeerID) -> Data? {
         return sessionManager.getRemoteStaticKey(for: peerID)?.rawRepresentation
     }
     
@@ -391,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 {
+        guard peerID.isValid else {
-            SecureLogger.warning(.authenticationFailed(peerID: peerID))
+            SecureLogger.warning(.authenticationFailed(peerID: peerID.id))
             throw NoiseSecurityError.invalidPeerID
         }
         
@@ -405,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
@@ -414,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 {
+        guard peerID.isValid else {
-            SecureLogger.warning(.authenticationFailed(peerID: peerID))
+            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
         }
         
@@ -444,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
@@ -478,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
@@ -500,32 +513,11 @@ 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)
-        
-        serviceQueue.sync(flags: .barrier) {
-            if let fingerprint = peerFingerprints[peerID] {
-                fingerprintToPeerID.removeValue(forKey: fingerprint)
-            }
-            peerFingerprints.removeValue(forKey: peerID)
-        }
-        
-        SecureLogger.info(.sessionExpired(peerID: peerID))
-    }
 
     func clearEphemeralStateForPanic() {
         sessionManager.removeAllSessions()
@@ -538,9 +530,9 @@ final class NoiseEncryptionService {
     
     // 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) {
@@ -549,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

@@ -4,46 +4,51 @@ 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
+    private let idBridge: NostrIdentityBridge
 
-    var myPeerID: String { senderPeerID }
+    init(keychain: KeychainManagerProtocol, idBridge: NostrIdentityBridge) {
+        self.keychain = keychain
+        self.idBridge = idBridge
+    }
+
+    // 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 */ }
-    
-    init(keychain: KeychainManagerProtocol) {
-        self.keychain = keychain
-    }
 
     func startServices() { /* no-op */ }
     func stopServices() { /* no-op */ }
     func emergencyDisconnectAll() { /* no-op */ }
 
-    func isPeerConnected(_ peerID: String) -> Bool { false }
+    func isPeerConnected(_ peerID: PeerID) -> Bool { false }
-    func isPeerReachable(_ peerID: String) -> Bool { false }
+    func isPeerReachable(_ peerID: PeerID) -> Bool { false }
-    func peerNickname(peerID: String) -> String? { nil }
+    func peerNickname(peerID: PeerID) -> String? { nil }
-    func getPeerNicknames() -> [String : String] { [:] }
+    func getPeerNicknames() -> [PeerID : String] { [:] }
 
-    func getFingerprint(for peerID: String) -> String? { nil }
+    func getFingerprint(for peerID: PeerID) -> String? { nil }
-    func getNoiseSessionState(for peerID: String) -> LazyHandshakeState { .none }
+    func getNoiseSessionState(for peerID: PeerID) -> LazyHandshakeState { .none }
-    func triggerHandshake(with peerID: String) { /* no-op */ }
+    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?
@@ -59,11 +64,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 }
+            guard let senderIdentity = try? idBridge.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 {
@@ -77,7 +82,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
             }
@@ -90,12 +95,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? idBridge.getCurrentNostrIdentity() else { return }
+            let content = isFavorite ? "[FAVORITED]:\(senderIdentity.npub)" : "[UNFAVORITED]:\(senderIdentity.npub)"
+            SecureLogger.debug("NostrTransport: preparing FAVORITE(\(isFavorite)) to \(recipientNpub.prefix(16))…", category: .session)
+            // 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? idBridge.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 }
@@ -108,7 +214,7 @@ final class NostrTransport: Transport {
         let item = readQueue.removeFirst()
         Task { @MainActor in
             guard let recipientNpub = resolveRecipientNpub(for: item.peerID) else { scheduleNextReadAck(); return }
-            guard let senderIdentity = try? NostrIdentityBridge.getCurrentNostrIdentity() else { scheduleNextReadAck(); return }
+            guard let senderIdentity = try? idBridge.getCurrentNostrIdentity() else { scheduleNextReadAck(); return }
             SecureLogger.debug("NostrTransport: preparing READ ack for id=\(item.receipt.originalMessageID.prefix(8))… to \(recipientNpub.prefix(16))…", category: .session)
             // Convert recipient npub -> hex
             let recipientHex: String
@@ -117,7 +223,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
             }
@@ -139,111 +245,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? {
+    private func resolveRecipientNpub(for peerID: PeerID) -> String? {
-        if let noiseKey = Data(hexString: peerID),
+        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

@@ -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

@@ -12,9 +12,9 @@ import SwiftUI
 
 /// Manages all private chat functionality
 final class PrivateChatManager: ObservableObject {
-    @Published var privateChats: [String: [BitchatMessage]] = [:]
+    @Published var privateChats: [PeerID: [BitchatMessage]] = [:]
-    @Published var selectedPeer: String? = nil
+    @Published var selectedPeer: PeerID? = nil
-    @Published var unreadMessages: Set<String> = []
+    @Published var unreadMessages: Set<PeerID> = []
     
     private var selectedPeerFingerprint: String? = nil
     var sentReadReceipts: Set<String> = []  // Made accessible for ChatViewModel
@@ -31,7 +31,7 @@ final class PrivateChatManager: ObservableObject {
     private let privateChatCap = TransportConfig.privateChatCap
     
     /// Start a private chat with a peer
-    func startChat(with peerID: String) {
+    func startChat(with peerID: PeerID) {
         selectedPeer = peerID
         
         // Store fingerprint for persistence across reconnections
@@ -53,109 +53,33 @@ 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) {
+    func sanitizeChat(for peerID: PeerID) {
         guard let arr = privateChats[peerID] else { return }
-        var seen = Set<String>()
+        if arr.count <= 1 {
+            return
+        }
+
+        var indexByID: [String: Int] = [:]
+        indexByID.reserveCapacity(arr.count)
         var deduped: [BitchatMessage] = []
+        deduped.reserveCapacity(arr.count)
+
         for msg in arr.sorted(by: { $0.timestamp < $1.timestamp }) {
-            if !seen.contains(msg.id) {
+            if let existing = indexByID[msg.id] {
-                seen.insert(msg.id)
+                deduped[existing] = msg
-                deduped.append(msg)
             } else {
-                // Replace previous with the latest occurrence (which is later in sort)
+                indexByID[msg.id] = deduped.count
-                if let index = deduped.firstIndex(where: { $0.id == msg.id }) {
+                deduped.append(msg)
-                    deduped[index] = msg
-                }
             }
         }
+
         privateChats[peerID] = deduped
     }
     
     /// Mark messages from a peer as read
-    func markAsRead(from peerID: String) {
+    func markAsRead(from peerID: PeerID) {
         unreadMessages.remove(peerID)
         
         // Send read receipts for unread messages that haven't been sent yet
@@ -168,48 +92,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) {
@@ -223,13 +105,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
+        // - Dense graphs: keep lower but still allow multi-hop bridging
-        // - Sparse graphs: allow slightly longer reach for multi-hop discovery
+        // - Announces get a bit more headroom
-        // - Announces in sparse graphs get a bit more headroom
+        let ttlLimit: UInt8 = {
-        let ttlCap: UInt8 = {
+            if degree >= highDegreeThreshold {
-            if degree >= highDegreeThreshold { return 3 }
+                return max(UInt8(2), min(ttlCap, UInt8(5)))
-            return isAnnounce ? 7 : 6
+            }
+            let preferred = UInt8(isAnnounce ? 7 : 6)
+            return max(UInt8(2), min(ttlCap, preferred))
         }()
-        let clamped = max(1, min(ttl, ttlCap))
+        let newTTL = ttlLimit &- 1
-        let newTTL = clamped &- 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/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 isPeerConnected(_ peerID: PeerID) -> Bool
-    func isPeerReachable(_ peerID: String) -> Bool
+    func isPeerReachable(_ peerID: PeerID) -> Bool
-    func peerNickname(peerID: String) -> String?
+    func peerNickname(peerID: PeerID) -> String?
-    func getPeerNicknames() -> [String: String]
+    func getPeerNicknames() -> [PeerID: String]
 
     // Protocol utilities
-    func getFingerprint(for peerID: String) -> String?
+    func getFingerprint(for peerID: PeerID) -> String?
-    func getNoiseSessionState(for peerID: String) -> LazyHandshakeState
+    func getNoiseSessionState(for peerID: PeerID) -> LazyHandshakeState
-    func triggerHandshake(with peerID: String)
+    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 sendPrivateMessage(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String)
-    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: String)
+    func sendReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID)
-    func sendFavoriteNotification(to peerID: String, isFavorite: Bool)
+    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 sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
-    func sendVerifyResponse(to peerID: String, noiseKeyHex: String, nonceA: Data)
+    func sendVerifyResponse(to peerID: PeerID, noiseKeyHex: String, nonceA: Data)
-
-    // Peer snapshots (for non-UI services)
-    var peerSnapshotPublisher: AnyPublisher<[TransportPeerSnapshot], Never> { get }
-    func currentPeerSnapshots() -> [TransportPeerSnapshot]
 }
 
 extension Transport {
-    func sendVerifyChallenge(to peerID: String, noiseKeyHex: String, nonceA: Data) {}
+    func sendVerifyChallenge(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {}
-    func sendVerifyResponse(to peerID: String, noiseKeyHex: String, nonceA: Data) {}
+    func sendVerifyResponse(to peerID: PeerID, noiseKeyHex: String, nonceA: Data) {}
 }
 
 protocol TransportPeerEventsDelegate: AnyObject {

bitchat/Services/TransportConfig.swift

@@ -188,7 +188,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

@@ -10,7 +10,6 @@ import BitLogger
 import Foundation
 import Combine
 import SwiftUI
-import CryptoKit
 
 /// Single source of truth for peer state, combining mesh connectivity and favorites
 @MainActor
@@ -19,15 +18,16 @@ 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 peerIndex: [PeerID: BitchatPeer] = [:]
-    private var fingerprintCache: [String: String] = [:]  // peerID -> fingerprint
+    private var fingerprintCache: [PeerID: String] = [:]
     private let meshService: Transport
+    private let idBridge: NostrIdentityBridge
     private let identityManager: SecureIdentityStateManagerProtocol
     weak var messageRouter: MessageRouter?
     private let favoritesService = FavoritesPersistenceService.shared
@@ -35,8 +35,13 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     
     // MARK: - Initialization
     
-    init(meshService: Transport, identityManager: SecureIdentityStateManagerProtocol) {
+    init(
+        meshService: Transport,
+        idBridge: NostrIdentityBridge,
+        identityManager: SecureIdentityStateManagerProtocol
+    ) {
         self.meshService = meshService
+        self.idBridge = idBridge
         self.identityManager = identityManager
         
         // Subscribe to changes from both services
@@ -78,12 +83,12 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         let favorites = favoritesService.favorites
         
         var enrichedPeers: [BitchatPeer] = []
-        var connected: Set<String> = []
+        var connected: Set<PeerID> = []
-        var addedPeerIDs: Set<String> = []
+        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(
@@ -104,7 +109,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 }
@@ -138,10 +143,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)
@@ -185,7 +190,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,
@@ -205,10 +210,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,
@@ -225,27 +230,22 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     // MARK: - Public Methods
     
     /// Get peer by ID
-    func getPeer(by id: String) -> BitchatPeer? {
+    func getPeer(by peerID: PeerID) -> BitchatPeer? {
-        return peerIndex[id]
+        return peerIndex[peerID]
     }
     
     /// Get peer ID for nickname
-    func getPeerID(for nickname: String) -> String? {
+    func getPeerID(for nickname: String) -> PeerID? {
         for peer in peers {
             if peer.displayName == nickname || peer.nickname == nickname {
-                return peer.id
+                return peer.peerID
             }
         }
         return nil
     }
     
-    /// Check if peer is online
-    func isOnline(_ peerID: String) -> Bool {
-        return connectedPeerIDs.contains(peerID)
-    }
-    
     /// Check if peer is blocked
-    func isBlocked(_ peerID: String) -> Bool {
+    func isBlocked(_ peerID: PeerID) -> Bool {
         // Get fingerprint
         guard let fingerprint = getFingerprint(for: peerID) else { return false }
         
@@ -258,8 +258,8 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     }
     
     /// Toggle favorite status
-    func toggleFavorite(_ peerID: String) {
+    func toggleFavorite(_ peerID: PeerID) {
-        guard let peer = getPeer(by: peerID) else { 
+        guard let peer = getPeer(by: peerID) else {
             SecureLogger.warning("⚠️ Cannot toggle favorite - peer not found: \(peerID)", category: .session)
             return 
         }
@@ -291,7 +291,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
             var peerNostrKey = peer.nostrPublicKey
             if peerNostrKey == nil {
                 // Try to get from NostrIdentityBridge association
-                peerNostrKey = NostrIdentityBridge.getNostrPublicKey(for: peer.noisePublicKey)
+                peerNostrKey = idBridge.getNostrPublicKey(for: peer.noisePublicKey)
             }
             
             // Add favorite
@@ -322,39 +322,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         }
     }
     
-    /// Toggle blocked status
+    func getFingerprint(for peerID: PeerID) -> String? {
-    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? {
         // Check cache first
         if let cached = fingerprintCache[peerID] {
             return cached
@@ -379,23 +347,13 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     // MARK: - Compatibility Methods (for easy migration)
     
     var allPeers: [BitchatPeer] { peers }
-    var connectedPeers: [String] { Array(connectedPeerIDs) }
+    var connectedPeers: Set<PeerID> { connectedPeerIDs }
-    var favoritePeers: Set<String> { 
+    var favoritePeers: Set<String> {
-        Set(favorites.compactMap { getFingerprint(for: $0.id) })
+        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

@@ -4,7 +4,7 @@ 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 [0, M) via (h64 % M).
+//  - 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).
@@ -29,25 +29,40 @@ enum GCSFilter {
 
     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 n = min(ids.count, cap)
+        let selected = Array(ids.prefix(cap))
-        let selected = Array(ids.prefix(n))
+        let range = max(1, hashRange(count: selected.count, p: p))
-        // Map to [0, M)
+        let modulo = UInt64(range)
-        let mInit = UInt32(n << p)
+
-        var mapped = selected.map { id16 -> UInt64 in
+        var mapped = selected
-            let h = h64(id16)
+            .map { h64($0) }
-            return UInt64(h % UInt64(max(1, mInit)))
+            .map { mapHash($0, modulo: modulo) }
-        }.sorted()
+            .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 trimmedN = n
+        var trimmedCount = mapped.count
-        // Trim if over budget
+
-        while encoded.count > maxBytes && trimmedN > 0 {
+        while encoded.count > maxBytes && trimmedCount > 0 {
-            trimmedN = (trimmedN * 9) / 10 // drop ~10%
+            if trimmedCount == 1 {
-            mapped = Array(mapped.prefix(trimmedN))
+                mapped.removeAll()
+                encoded = Data()
+                break
+            }
+            trimmedCount = max(1, (trimmedCount * 9) / 10)
+            mapped = Array(mapped.prefix(trimmedCount))
             encoded = encode(sorted: mapped, p: p)
         }
-        let finalM = UInt32(max(1, trimmedN << p))
+
-        return Params(p: p, m: finalM, data: encoded)
+        return Params(p: p, m: range, data: encoded)
     }
 
     static func decodeToSortedSet(p: Int, m: UInt32, data: Data) -> [UInt64] {
@@ -77,6 +92,12 @@ enum GCSFilter {
         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)
@@ -88,6 +109,39 @@ enum GCSFilter {
         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

bitchat/Sync/GossipSyncManager.swift

@@ -1,11 +1,10 @@
 import Foundation
-import CryptoKit
 
 // Gossip-based sync manager using on-demand GCS filters
 final class GossipSyncManager {
     protocol Delegate: AnyObject {
         func sendPacket(_ packet: BitchatPacket)
-        func sendPacket(to peerID: String, packet: BitchatPacket)
+        func sendPacket(to peerID: PeerID, packet: BitchatPacket)
         func signPacketForBroadcast(_ packet: BitchatPacket) -> BitchatPacket
     }
 
@@ -13,9 +12,13 @@ final class GossipSyncManager {
         var seenCapacity: Int = 1000          // max packets per sync (cap across types)
         var gcsMaxBytes: Int = 400           // filter size budget (128..1024)
         var gcsTargetFpr: Double = 0.01      // 1%
+        var maxMessageAgeSeconds: TimeInterval = 900  // 15 min - discard older messages
+        var maintenanceIntervalSeconds: TimeInterval = 30.0
+        var stalePeerCleanupIntervalSeconds: TimeInterval = 60.0
+        var stalePeerTimeoutSeconds: TimeInterval = 60.0
     }
 
-    private let myPeerID: String
+    private let myPeerID: PeerID
     private let config: Config
     weak var delegate: Delegate?
 
@@ -27,8 +30,9 @@ final class GossipSyncManager {
     // Timer
     private var periodicTimer: DispatchSourceTimer?
     private let queue = DispatchQueue(label: "mesh.sync", qos: .utility)
+    private var lastStalePeerCleanup: Date = .distantPast
 
-    init(myPeerID: String, config: Config = Config()) {
+    init(myPeerID: PeerID, config: Config = Config()) {
         self.myPeerID = myPeerID
         self.config = config
     }
@@ -36,8 +40,11 @@ final class GossipSyncManager {
     func start() {
         stop()
         let timer = DispatchSource.makeTimerSource(queue: queue)
-        timer.schedule(deadline: .now() + 30.0, repeating: 30.0, leeway: .seconds(1))
+        let interval = max(0.1, config.maintenanceIntervalSeconds)
-        timer.setEventHandler { [weak self] in self?.sendRequestSync() }
+        timer.schedule(deadline: .now() + interval, repeating: interval, leeway: .seconds(1))
+        timer.setEventHandler { [weak self] in
+            self?.performPeriodicMaintenance()
+        }
         timer.resume()
         periodicTimer = timer
     }
@@ -46,13 +53,40 @@ final class GossipSyncManager {
         periodicTimer?.cancel(); periodicTimer = nil
     }
 
-    func scheduleInitialSyncToPeer(_ peerID: String, delaySeconds: TimeInterval = 5.0) {
+    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 isAnnouncementFresh(_ packet: BitchatPacket) -> Bool {
+        guard config.stalePeerTimeoutSeconds > 0 else { return true }
+        let nowMs = UInt64(Date().timeIntervalSince1970 * 1000)
+        let timeoutMs = UInt64(config.stalePeerTimeoutSeconds * 1000)
+        guard nowMs >= timeoutMs else { return true }
+        let cutoffMs = nowMs - timeoutMs
+        return packet.timestamp >= cutoffMs
+    }
+
+    private func _onPublicPacketSeen(_ packet: BitchatPacket) {
         let mt = MessageType(rawValue: packet.type)
         let isBroadcastRecipient: Bool = {
             guard let r = packet.recipientID else { return true }
@@ -62,6 +96,17 @@ final class GossipSyncManager {
         let isAnnounce = (mt == .announce)
         guard isBroadcastMessage || isAnnounce else { return }
 
+        // Reject expired packets to prevent ghost peers and old messages
+        guard isPacketFresh(packet) else { return }
+
+        if isAnnounce {
+            guard isAnnouncementFresh(packet) else {
+                let sender = packet.senderID.hexEncodedString().lowercased()
+                removeState(forNormalizedPeerID: sender)
+                return
+            }
+        }
+
         let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
 
         if isBroadcastMessage {
@@ -76,7 +121,7 @@ final class GossipSyncManager {
                 }
             }
         } else if isAnnounce {
-            let sender = packet.senderID.hexEncodedString()
+            let sender = packet.senderID.hexEncodedString().lowercased()
             latestAnnouncementByPeer[sender] = (id: idHex, packet: packet)
         }
     }
@@ -85,7 +130,7 @@ final class GossipSyncManager {
         let payload = buildGcsPayload()
         let pkt = BitchatPacket(
             type: MessageType.requestSync.rawValue,
-            senderID: Data(hexString: myPeerID) ?? Data(),
+            senderID: Data(hexString: myPeerID.id) ?? Data(),
             recipientID: nil, // broadcast
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -96,10 +141,10 @@ final class GossipSyncManager {
         delegate?.sendPacket(signed)
     }
 
-    private func sendRequestSync(to peerID: String) {
+    private func sendRequestSync(to peerID: PeerID) {
         let payload = buildGcsPayload()
         var recipient = Data()
-        var temp = peerID
+        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) }
@@ -107,7 +152,7 @@ final class GossipSyncManager {
         }
         let pkt = BitchatPacket(
             type: MessageType.requestSync.rawValue,
-            senderID: Data(hexString: myPeerID) ?? Data(),
+            senderID: Data(hexString: myPeerID.id) ?? Data(),
             recipientID: recipient,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -118,51 +163,60 @@ final class GossipSyncManager {
         delegate?.sendPacket(to: peerID, packet: signed)
     }
 
-    func handleRequestSync(fromPeerID: String, request: RequestSyncPacket) {
+    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 {
-            var hasher = SHA256()
+            let bucket = GCSFilter.bucket(for: id, modulus: request.m)
-            hasher.update(data: id) // 16-byte PacketId
+            return GCSFilter.contains(sortedValues: sorted, candidate: bucket)
-            let digest = hasher.finalize()
-            let db = Data(digest)
-            var x: UInt64 = 0
-            let take = min(8, db.count)
-            for i in 0..<take { x = (x << 8) | UInt64(db[i]) }
-            let v = (x & 0x7fff_ffff_ffff_ffff) % UInt64(request.m)
-            return GCSFilter.contains(sortedValues: sorted, candidate: v)
         }
 
-        // 1) Announcements: send latest per peer if requester lacks them
+        // 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: fromPeerID, packet: toSend)
+                delegate?.sendPacket(to: peerID, packet: toSend)
             }
         }
 
-        // 2) Broadcast messages: send all missing
+        // 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: fromPeerID, packet: toSend)
+                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
+        // Collect candidates: latest announce per peer + broadcast messages (only fresh)
         var candidates: [BitchatPacket] = []
         candidates.reserveCapacity(latestAnnouncementByPeer.count + messageOrder.count)
-        for (_, pair) in latestAnnouncementByPeer { candidates.append(pair.packet) }
+        for (_, pair) in latestAnnouncementByPeer {
-        for id in messageOrder { if let p = messages[id] { candidates.append(p) } }
+            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 }
 
@@ -180,11 +234,65 @@ final class GossipSyncManager {
         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 }
+        }
+    }
+
+    private func performPeriodicMaintenance(now: Date = Date()) {
+        cleanupExpiredMessages()
+        cleanupStaleAnnouncementsIfNeeded(now: now)
+        sendRequestSync()
+    }
+
+    private func cleanupStaleAnnouncementsIfNeeded(now: Date) {
+        guard now.timeIntervalSince(lastStalePeerCleanup) >= config.stalePeerCleanupIntervalSeconds else {
+            return
+        }
+        lastStalePeerCleanup = now
+        cleanupStaleAnnouncements(now: now)
+    }
+
+    private func cleanupStaleAnnouncements(now: Date) {
+        let timeoutMs = UInt64(config.stalePeerTimeoutSeconds * 1000)
+        let nowMs = UInt64(now.timeIntervalSince1970 * 1000)
+        guard nowMs >= timeoutMs else { return }
+        let cutoff = nowMs - timeoutMs
+        let stalePeerIDs = latestAnnouncementByPeer.compactMap { (peerHex, pair) -> String? in
+            pair.packet.timestamp < cutoff ? peerHex.lowercased() : nil
+        }
+        guard !stalePeerIDs.isEmpty else { return }
+        for peerKey in stalePeerIDs {
+            removeState(forNormalizedPeerID: peerKey)
+        }
+    }
+
     // Explicit removal hook for LEAVE/stale peer
-    func removeAnnouncementForPeer(_ peerID: String) {
+    func removeAnnouncementForPeer(_ peerID: PeerID) {
-        let normalizedPeerID = peerID.lowercased()
+        queue.async { [weak self] in
+            self?._removeAnnouncementForPeer(peerID)
+        }
+    }
+
+    private func _removeAnnouncementForPeer(_ peerID: PeerID) {
+        let normalizedPeerID = peerID.id.lowercased()
+        removeState(forNormalizedPeerID: normalizedPeerID)
+    }
+
+    private func removeState(forNormalizedPeerID normalizedPeerID: String) {
         _ = 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
@@ -198,3 +306,25 @@ final class GossipSyncManager {
         }
     }
 }
+
+#if DEBUG
+extension GossipSyncManager {
+    func _performMaintenanceSynchronously(now: Date = Date()) {
+        queue.sync {
+            performPeriodicMaintenance(now: now)
+        }
+    }
+
+    func _hasAnnouncement(for peerID: PeerID) -> Bool {
+        queue.sync {
+            latestAnnouncementByPeer[peerID.id.lowercased()] != nil
+        }
+    }
+
+    func _messageCount(for peerID: PeerID) -> Int {
+        queue.sync {
+            messages.values.filter { $0.senderID.hexEncodedString().lowercased() == peerID.id.lowercased() }.count
+        }
+    }
+}
+#endif

bitchat/Sync/PacketIdUtil.swift

@@ -14,8 +14,4 @@ enum PacketIdUtil {
         let digest = hasher.finalize()
         return Data(digest.prefix(16))
     }
-
-    static func computeIdHex(_ packet: BitchatPacket) -> String {
-        return computeId(packet).hexEncodedString()
-    }
 }

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
+        // BinaryProtocol caps payload length at UInt16.max (65_535). Leave headroom
-        static let maxReasonLength = 200
+        // for headers/padding by limiting user content to 60_000 bytes.
-        static let maxPeerIDLength = 64
+        static let maxMessageLength = 60_000
-        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
     }
     
     // MARK: - String Content Validation
     
-    /// Validates and sanitizes user-provided strings (nicknames, messages)
+    /// Validates and sanitizes user-provided strings used in UI
-    static func validateUserString(_ string: String, maxLength: Int, allowNewlines: Bool = false) -> String? {
+    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
+        // Remove control characters
-        var allowedControlChars = CharacterSet()
+        let controlChars = CharacterSet.controlCharacters
-        if allowNewlines {
-            allowedControlChars.insert(charactersIn: "\n\r")
-        }
-        
-        let controlChars = CharacterSet.controlCharacters.subtracting(allowedControlChars)
         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)
+        return validateUserString(nickname, maxLength: Limits.maxNicknameLength)
-    }
-    
-    /// 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)
     }
     
     // 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/Views/AppInfoView.swift

@@ -18,41 +18,77 @@ struct AppInfoView: View {
     
     // MARK: - Constants
     private enum Strings {
-        static let appName = "bitchat"
+        static let appName: LocalizedStringKey = "app_info.app_name"
-        static let tagline = "sidegroupchat"
+        static let tagline: LocalizedStringKey = "app_info.tagline"
-        
+
         enum Features {
-            static let title = "FEATURES"
+            static let title: LocalizedStringKey = "app_info.features.title"
-            static let offlineComm = ("wifi.slash", "offline communication", "works without internet using Bluetooth low energy")
+            static let offlineComm = AppInfoFeatureInfo(
-            static let encryption = ("lock.shield", "end-to-end encryption", "private messages encrypted with noise protocol")
+                icon: "wifi.slash",
-            static let extendedRange = ("antenna.radiowaves.left.and.right", "extended range", "messages relay through peers, going the distance")
+                title: "app_info.features.offline.title",
-            static let mentions = ("at", "mentions", "use @nickname to notify specific people")
+                description: "app_info.features.offline.description"
-            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 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 title: LocalizedStringKey = "app_info.privacy.title"
-            static let noTracking = ("eye.slash", "no tracking", "no servers, accounts, or data collection")
+            static let noTracking = AppInfoFeatureInfo(
-            static let ephemeral = ("shuffle", "ephemeral identity", "new peer ID generated regularly")
+                icon: "eye.slash",
-            static let panic = ("hand.raised.fill", "panic mode", "triple-tap logo to instantly clear all data")
+                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 title: LocalizedStringKey = "app_info.how_to_use.title"
-            static let instructions = [
+            static let instructions: [LocalizedStringKey] = [
-                "• set your nickname by tapping it",
+                "app_info.how_to_use.set_nickname",
-                "• tap #mesh to change channels",
+                "app_info.how_to_use.change_channels",
-                "• tap people icon for sidebar",
+                "app_info.how_to_use.open_sidebar",
-                "• tap a peer's name to start a DM",
+                "app_info.how_to_use.start_dm",
-                "• triple-tap chat to clear",
+                "app_info.how_to_use.clear_chat",
-                "• type / for commands"
+                "app_info.how_to_use.commands"
             ]
         }
-        
+
         enum Warning {
-            static let title = "WARNING"
+            static let title: LocalizedStringKey = "app_info.warning.title"
-            static let message = "private message security has not yet been fully audited. do not use for critical situations until this warning disappears."
+            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)
@@ -88,12 +124,12 @@ struct AppInfoView: View {
                 ToolbarItem(placement: .navigationBarTrailing) {
                     Button(action: { dismiss() }) {
                         Image(systemName: "xmark")
-                            .font(.system(size: 13, weight: .semibold, design: .monospaced))
+                            .font(.bitchatSystem(size: 13, weight: .semibold, design: .monospaced))
                             .foregroundColor(textColor)
                             .frame(width: 32, height: 32)
                     }
                     .buttonStyle(.plain)
-                    .accessibilityLabel("Close")
+                    .accessibilityLabel("app_info.close")
                 }
             }
         }
@@ -106,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)
             }
@@ -197,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 info: AppInfoFeatureInfo
-    let title: String
-    let description: String
     @Environment(\.colorScheme) var colorScheme
     
     private var textColor: Color {
@@ -233,18 +255,18 @@ struct FeatureRow: View {
     
     var body: some View {
         HStack(alignment: .top, spacing: 12) {
-            Image(systemName: icon)
+            Image(systemName: info.icon)
-                .font(.system(size: 20))
+                .font(.bitchatSystem(size: 20))
                 .foregroundColor(textColor)
                 .frame(width: 30)
             
             VStack(alignment: .leading, spacing: 4) {
-                Text(title)
+                Text(info.title)
-                    .font(.system(size: 14, weight: .semibold, design: .monospaced))
+                    .font(.bitchatSystem(size: 14, weight: .semibold, design: .monospaced))
                     .foregroundColor(textColor)
                 
-                Text(description)
+                Text(info.description)
-                    .font(.system(size: 12, design: .monospaced))
+                    .font(.bitchatSystem(size: 12, design: .monospaced))
                     .foregroundColor(secondaryTextColor)
                     .fixedSize(horizontal: false, vertical: true)
             }
@@ -254,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,98 @@
+//
+// 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,
+            idBridge: NostrIdentityBridge(),
+            identityManager: SecureIdentityStateManager(keychain)
+        )
+    )
+}

bitchat/Views/FingerprintView.swift

@@ -21,20 +21,43 @@ struct FingerprintView: View {
     private var backgroundColor: Color {
         colorScheme == .dark ? Color.black : Color.white
     }
+
+    private enum Strings {
+        static let title: LocalizedStringKey = "fingerprint.title"
+        static let theirFingerprint: LocalizedStringKey = "fingerprint.their_label"
+        static let handshakePending: LocalizedStringKey = "fingerprint.handshake_pending"
+        static let yourFingerprint: LocalizedStringKey = "fingerprint.your_label"
+        static let copy: LocalizedStringKey = "common.copy"
+        static let verifiedBadge: LocalizedStringKey = "fingerprint.badge.verified"
+        static let notVerifiedBadge: LocalizedStringKey = "fingerprint.badge.not_verified"
+        static let verifiedMessage: LocalizedStringKey = "fingerprint.message.verified"
+        static func verifyHint(_ nickname: String) -> String {
+            String(
+                format: String(localized: "fingerprint.message.verify_hint", comment: "Instruction to compare fingerprints with a named peer"),
+                locale: .current,
+                nickname
+            )
+        }
+        static let markVerified: LocalizedStringKey = "fingerprint.action.mark_verified"
+        static let removeVerification: LocalizedStringKey = "fingerprint.action.remove_verification"
+        static func unknownPeer() -> String {
+            String(localized: "common.unknown", comment: "Label for an unknown peer")
+        }
+    }
     
     var body: some View {
         VStack(spacing: 20) {
             // Header
             HStack {
-                Text("SECURITY VERIFICATION")
+                Text(Strings.title)
-                    .font(.system(size: 16, weight: .bold, design: .monospaced))
+                    .font(.bitchatSystem(size: 16, weight: .bold, design: .monospaced))
                     .foregroundColor(textColor)
                 
                 Spacer()
                 
                 Button(action: { dismiss() }) {
                     Image(systemName: "xmark")
-                        .font(.system(size: 14, weight: .semibold))
+                        .font(.bitchatSystem(size: 14, weight: .semibold))
                 }
                 .foregroundColor(textColor)
             }
@@ -43,13 +66,13 @@ struct FingerprintView: View {
             VStack(alignment: .leading, spacing: 16) {
                 // Prefer short mesh ID for session/encryption status
                 let statusPeerID: String = {
-                    if peerID.count == 64, let short = viewModel.getShortIDForNoiseKey(peerID) { return short }
+                    if peerID.count == 64, let short = viewModel.getShortIDForNoiseKey(peerID) { return short.id }
                     return peerID
                 }()
                 // Resolve a friendly name
                 let peerNickname: String = {
-                    if let p = viewModel.getPeer(byID: statusPeerID) { return p.displayName }
+                    if let p = viewModel.getPeer(byID: PeerID(str: statusPeerID)) { return p.displayName }
-                    if let name = viewModel.meshService.peerNickname(peerID: statusPeerID) { return name }
+                    if let name = viewModel.meshService.peerNickname(peerID: PeerID(str: statusPeerID)) { return name }
                     if peerID.count == 64, let data = Data(hexString: peerID) {
                         if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: data), !fav.peerNickname.isEmpty { return fav.peerNickname }
                         let fp = data.sha256Fingerprint()
@@ -58,25 +81,25 @@ struct FingerprintView: View {
                             if !social.claimedNickname.isEmpty { return social.claimedNickname }
                         }
                     }
-                    return "Unknown"
+                    return Strings.unknownPeer()
                 }()
                 // Accurate encryption state based on short ID session
-                let encryptionStatus = viewModel.getEncryptionStatus(for: statusPeerID)
+                let encryptionStatus = viewModel.getEncryptionStatus(for: PeerID(str: statusPeerID))
                 
                 HStack {
                     if let icon = encryptionStatus.icon {
                         Image(systemName: icon)
-                            .font(.system(size: 20))
+                            .font(.bitchatSystem(size: 20))
                             .foregroundColor(encryptionStatus == .noiseVerified ? Color.green : textColor)
                     }
                     
                     VStack(alignment: .leading, spacing: 4) {
                         Text(peerNickname)
-                            .font(.system(size: 18, weight: .semibold, design: .monospaced))
+                            .font(.bitchatSystem(size: 18, weight: .semibold, design: .monospaced))
                             .foregroundColor(textColor)
                         
                         Text(encryptionStatus.description)
-                            .font(.system(size: 12, design: .monospaced))
+                            .font(.bitchatSystem(size: 12, design: .monospaced))
                             .foregroundColor(textColor.opacity(0.7))
                     }
                     
@@ -88,13 +111,13 @@ struct FingerprintView: View {
                 
                 // Their fingerprint
                 VStack(alignment: .leading, spacing: 8) {
-                    Text("THEIR FINGERPRINT:")
+                    Text(Strings.theirFingerprint)
-                        .font(.system(size: 12, weight: .bold, design: .monospaced))
+                        .font(.bitchatSystem(size: 12, weight: .bold, design: .monospaced))
                         .foregroundColor(textColor.opacity(0.7))
                     
-                    if let fingerprint = viewModel.getFingerprint(for: statusPeerID) {
+                    if let fingerprint = viewModel.getFingerprint(for: PeerID(str: statusPeerID)) {
                         Text(formatFingerprint(fingerprint))
-                            .font(.system(size: 14, design: .monospaced))
+                            .font(.bitchatSystem(size: 14, design: .monospaced))
                             .foregroundColor(textColor)
                             .multilineTextAlignment(.leading)
                             .lineLimit(nil)
@@ -104,7 +127,7 @@ struct FingerprintView: View {
                             .background(Color.gray.opacity(0.1))
                             .cornerRadius(8)
                             .contextMenu {
-                                Button("Copy") {
+                                Button(Strings.copy) {
                                     #if os(iOS)
                                     UIPasteboard.general.string = fingerprint
                                     #else
@@ -114,22 +137,22 @@ struct FingerprintView: View {
                                 }
                             }
                     } else {
-                        Text("not available - handshake in progress")
+                        Text(Strings.handshakePending)
-                            .font(.system(size: 14, design: .monospaced))
+                            .font(.bitchatSystem(size: 14, design: .monospaced))
                             .foregroundColor(Color.orange)
                             .padding()
                     }
                 }
-                
+
                 // My fingerprint
                 VStack(alignment: .leading, spacing: 8) {
-                    Text("YOUR FINGERPRINT:")
+                    Text(Strings.yourFingerprint)
-                        .font(.system(size: 12, weight: .bold, design: .monospaced))
+                        .font(.bitchatSystem(size: 12, weight: .bold, design: .monospaced))
                         .foregroundColor(textColor.opacity(0.7))
                     
                     let myFingerprint = viewModel.getMyFingerprint()
                     Text(formatFingerprint(myFingerprint))
-                        .font(.system(size: 14, design: .monospaced))
+                        .font(.bitchatSystem(size: 14, design: .monospaced))
                         .foregroundColor(textColor)
                         .multilineTextAlignment(.leading)
                         .lineLimit(nil)
@@ -139,7 +162,7 @@ struct FingerprintView: View {
                         .background(Color.gray.opacity(0.1))
                         .cornerRadius(8)
                         .contextMenu {
-                            Button("Copy") {
+                            Button(Strings.copy) {
                                 #if os(iOS)
                                 UIPasteboard.general.string = myFingerprint
                                 #else
@@ -153,17 +176,22 @@ struct FingerprintView: View {
                 // Verification status
                 if encryptionStatus == .noiseSecured || encryptionStatus == .noiseVerified {
                     let isVerified = encryptionStatus == .noiseVerified
+                    let peerID = PeerID(str: peerID)
                     
                     VStack(spacing: 12) {
-                        Text(isVerified ? "✓ VERIFIED" : "⚠️ NOT VERIFIED")
+                        Text(isVerified ? Strings.verifiedBadge : Strings.notVerifiedBadge)
-                            .font(.system(size: 14, weight: .bold, design: .monospaced))
+                            .font(.bitchatSystem(size: 14, weight: .bold, design: .monospaced))
                             .foregroundColor(isVerified ? Color.green : Color.orange)
                             .frame(maxWidth: .infinity)
                         
-                        Text(isVerified ? 
+                        Group {
-                             "you have verified this person's identity." :
+                            if isVerified {
-                             "compare these fingerprints with \(peerNickname) using a secure channel.")
+                                Text(Strings.verifiedMessage)
-                            .font(.system(size: 12, design: .monospaced))
+                            } else {
+                                Text(Strings.verifyHint(peerNickname))
+                            }
+                        }
+                            .font(.bitchatSystem(size: 12, design: .monospaced))
                             .foregroundColor(textColor.opacity(0.7))
                             .multilineTextAlignment(.center)
                             .lineLimit(nil)
@@ -175,8 +203,8 @@ struct FingerprintView: View {
                                 viewModel.verifyFingerprint(for: peerID)
                                 dismiss()
                             }) {
-                                Text("MARK AS VERIFIED")
+                                Text(Strings.markVerified)
-                                    .font(.system(size: 14, weight: .bold, design: .monospaced))
+                                    .font(.bitchatSystem(size: 14, weight: .bold, design: .monospaced))
                                     .foregroundColor(.white)
                                     .padding(.horizontal, 20)
                                     .padding(.vertical, 10)
@@ -189,8 +217,8 @@ struct FingerprintView: View {
                                 viewModel.unverifyFingerprint(for: peerID)
                                 dismiss()
                             }) {
-                                Text("REMOVE VERIFICATION")
+                                Text(Strings.removeVerification)
-                                    .font(.system(size: 14, weight: .bold, design: .monospaced))
+                                    .font(.bitchatSystem(size: 14, weight: .bold, design: .monospaced))
                                     .foregroundColor(.white)
                                     .padding(.horizontal, 20)
                                     .padding(.vertical, 10)

bitchat/Views/GeohashPeopleList.swift

@@ -8,11 +8,19 @@ struct GeohashPeopleList: View {
     @Environment(\.colorScheme) var colorScheme
     @State private var orderedIDs: [String] = []
 
+    private enum Strings {
+        static let noneNearby: LocalizedStringKey = "geohash_people.none_nearby"
+        static let youSuffix: LocalizedStringKey = "geohash_people.you_suffix"
+        static let blockedTooltip = String(localized: "geohash_people.tooltip.blocked", comment: "Tooltip shown next to users blocked in geohash channels")
+        static let unblock: LocalizedStringKey = "geohash_people.action.unblock"
+        static let block: LocalizedStringKey = "geohash_people.action.block"
+    }
+
     var body: some View {
         if viewModel.visibleGeohashPeople().isEmpty {
             VStack(alignment: .leading, spacing: 0) {
-                Text("nobody around...")
+                Text(Strings.noneNearby)
-                    .font(.system(size: 14, design: .monospaced))
+                    .font(.bitchatSystem(size: 14, design: .monospaced))
                     .foregroundColor(secondaryTextColor)
                     .padding(.horizontal)
                     .padding(.top, 12)
@@ -20,7 +28,7 @@ struct GeohashPeopleList: View {
         } else {
             let myHex: String? = {
                 if case .location(let ch) = LocationChannelManager.shared.selectedChannel,
-                   let id = try? NostrIdentityBridge.deriveIdentity(forGeohash: ch.geohash) {
+                   let id = try? viewModel.idBridge.deriveIdentity(forGeohash: ch.geohash) {
                     return id.publicKeyHex.lowercased()
                 }
                 return nil
@@ -51,32 +59,32 @@ struct GeohashPeopleList: View {
                         let icon = teleported ? "face.dashed" : "mappin.and.ellipse"
                         let assignedColor = viewModel.colorForNostrPubkey(person.id, isDark: colorScheme == .dark)
                         let rowColor: Color = isMe ? .orange : assignedColor
-                        Image(systemName: icon).font(.system(size: 12)).foregroundColor(rowColor)
+                        Image(systemName: icon).font(.bitchatSystem(size: 12)).foregroundColor(rowColor)
 
-                        let (base, suffix) = splitSuffix(from: person.displayName)
+                        let (base, suffix) = person.displayName.splitSuffix()
                         HStack(spacing: 0) {
                             Text(base)
-                                .font(.system(size: 14, design: .monospaced))
+                                .font(.bitchatSystem(size: 14, design: .monospaced))
                                 .fontWeight(isMe ? .bold : .regular)
                                 .foregroundColor(rowColor)
                             if !suffix.isEmpty {
                                 let suffixColor = isMe ? Color.orange.opacity(0.6) : rowColor.opacity(0.6)
                                 Text(suffix)
-                                    .font(.system(size: 14, design: .monospaced))
+                                    .font(.bitchatSystem(size: 14, design: .monospaced))
                                     .foregroundColor(suffixColor)
                             }
                             if isMe {
-                                Text(" (you)")
+                                Text(Strings.youSuffix)
-                                    .font(.system(size: 14, design: .monospaced))
+                                    .font(.bitchatSystem(size: 14, design: .monospaced))
                                     .foregroundColor(rowColor)
                             }
                         }
                         if let me = myHex, person.id != me {
                             if viewModel.isGeohashUserBlocked(pubkeyHexLowercased: person.id) {
                                 Image(systemName: "nosign")
-                                    .font(.system(size: 10))
+                                    .font(.bitchatSystem(size: 10))
                                     .foregroundColor(.red)
-                                    .help("Blocked in geochash")
+                                    .help(Strings.blockedTooltip)
                             }
                         }
                         Spacer()
@@ -97,9 +105,9 @@ struct GeohashPeopleList: View {
                         } else {
                             let blocked = viewModel.isGeohashUserBlocked(pubkeyHexLowercased: person.id)
                             if blocked {
-                                Button("Unblock") { viewModel.unblockGeohashUser(pubkeyHexLowercased: person.id, displayName: person.displayName) }
+                                Button(Strings.unblock) { viewModel.unblockGeohashUser(pubkeyHexLowercased: person.id, displayName: person.displayName) }
                             } else {
-                                Button("Block") { viewModel.blockGeohashUser(pubkeyHexLowercased: person.id, displayName: person.displayName) }
+                                Button(Strings.block) { viewModel.blockGeohashUser(pubkeyHexLowercased: person.id, displayName: person.displayName) }
                             }
                         }
                     }
@@ -118,16 +126,3 @@ struct GeohashPeopleList: View {
         }
     }
 }
-
-// Helper to split a trailing #abcd suffix
-private func splitSuffix(from name: String) -> (String, String) {
-    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/LocationChannelsSheet.swift

@@ -17,21 +17,81 @@ struct LocationChannelsSheet: View {
 
     private var backgroundColor: Color { colorScheme == .dark ? .black : .white }
 
+    private enum Strings {
+        static let title: LocalizedStringKey = "location_channels.title"
+        static let description: LocalizedStringKey = "location_channels.description"
+        static let requestPermissions: LocalizedStringKey = "location_channels.action.request_permissions"
+        static let permissionDenied: LocalizedStringKey = "location_channels.permission_denied"
+        static let openSettings: LocalizedStringKey = "location_channels.action.open_settings"
+        static let loadingNearby: LocalizedStringKey = "location_channels.loading_nearby"
+        static let teleport: LocalizedStringKey = "location_channels.action.teleport"
+        static let bookmarked: LocalizedStringKey = "location_channels.bookmarked_section_title"
+        static let removeAccess: LocalizedStringKey = "location_channels.action.remove_access"
+        static let torTitle: LocalizedStringKey = "location_channels.tor.title"
+        static let torSubtitle: LocalizedStringKey = "location_channels.tor.subtitle"
+        static let toggleOn: LocalizedStringKey = "common.toggle.on"
+        static let toggleOff: LocalizedStringKey = "common.toggle.off"
+
+        static let invalidGeohash = String(localized: "location_channels.error.invalid_geohash", comment: "Error shown when a custom geohash is invalid")
+
+        static func meshTitle(_ count: Int) -> String {
+            let label = String(localized: "location_channels.mesh_label", comment: "Label for the mesh channel row")
+            return rowTitle(label: label, count: count)
+        }
+
+        static func levelTitle(for level: GeohashChannelLevel, count: Int) -> String {
+            return rowTitle(label: level.displayName, count: count)
+        }
+
+        static func bookmarkTitle(geohash: String, count: Int) -> String {
+            return rowTitle(label: "#\(geohash)", count: count)
+        }
+
+        static func subtitlePrefix(geohash: String, coverage: String) -> String {
+            String(
+                format: String(localized: "location_channels.subtitle_prefix", comment: "Subtitle prefix showing geohash and coverage"),
+                locale: .current,
+                geohash, coverage
+            )
+        }
+
+        static func subtitle(prefix: String, name: String?) -> String {
+            guard let name, !name.isEmpty else { return prefix }
+            return String(
+                format: String(localized: "location_channels.subtitle_with_name", comment: "Subtitle combining prefix and resolved location name"),
+                locale: .current,
+                prefix, name
+            )
+        }
+
+        private static func rowTitle(label: String, count: Int) -> String {
+            String(
+                format: String(localized: "location_channels.row_title", comment: "List row title with participant count"),
+                locale: .current,
+                label, count
+            )
+        }
+    }
+
     var body: some View {
         NavigationView {
             VStack(alignment: .leading, spacing: 12) {
-                Text("#location channels")
+                HStack(spacing: 12) {
-                    .font(.system(size: 18, design: .monospaced))
+                    Text(Strings.title)
-                Text("chat with people near you using geohash channels. only a coarse geohash is shared, never exact gps. your IP address is hidden by routing all traffic over tor.")
+                        .font(.bitchatSystem(size: 18, design: .monospaced))
-                    .font(.system(size: 12, design: .monospaced))
+                    Spacer()
+                    closeButton
+                }
+                Text(Strings.description)
+                    .font(.bitchatSystem(size: 12, design: .monospaced))
                     .foregroundColor(.secondary)
 
                 Group {
                     switch manager.permissionState {
                     case LocationChannelManager.PermissionState.notDetermined:
                         Button(action: { manager.enableLocationChannels() }) {
-                            Text("get location and my geohashes")
+                            Text(Strings.requestPermissions)
-                                .font(.system(size: 12, design: .monospaced))
+                                .font(.bitchatSystem(size: 12, design: .monospaced))
                                 .foregroundColor(standardGreen)
                                 .frame(maxWidth: .infinity)
                                 .padding(.vertical, 6)
@@ -41,10 +101,10 @@ struct LocationChannelsSheet: View {
                         .buttonStyle(.plain)
                     case LocationChannelManager.PermissionState.denied, LocationChannelManager.PermissionState.restricted:
                         VStack(alignment: .leading, spacing: 8) {
-                            Text("location permission denied. enable in settings to use location channels.")
+                            Text(Strings.permissionDenied)
-                                .font(.system(size: 12, design: .monospaced))
+                                .font(.bitchatSystem(size: 12, design: .monospaced))
                                 .foregroundColor(.secondary)
-                            Button("open settings") { openSystemLocationSettings() }
+                            Button(Strings.openSettings) { openSystemLocationSettings() }
                             .buttonStyle(.plain)
                         }
                     case LocationChannelManager.PermissionState.authorized:
@@ -60,29 +120,9 @@ struct LocationChannelsSheet: View {
             .background(backgroundColor)
             #if os(iOS)
             .navigationBarTitleDisplayMode(.inline)
-            .toolbar {
+            .navigationBarHidden(true)
-                ToolbarItem(placement: .navigationBarTrailing) {
-                    Button(action: { isPresented = false }) {
-                        Image(systemName: "xmark")
-                            .font(.system(size: 13, weight: .semibold, design: .monospaced))
-                            .frame(width: 32, height: 32)
-                    }
-                    .buttonStyle(.plain)
-                    .accessibilityLabel("Close")
-                }
-            }
             #else
-            .toolbar {
+            .navigationTitle("")
-                ToolbarItem(placement: .automatic) {
-                    Button(action: { isPresented = false }) {
-                        Image(systemName: "xmark")
-                            .font(.system(size: 13, weight: .semibold, design: .monospaced))
-                            .frame(width: 20, height: 20)
-                    }
-                    .buttonStyle(.plain)
-                    .accessibilityLabel("Close")
-                }
-            }
             #endif
         }
         #if os(iOS)
@@ -112,183 +152,225 @@ struct LocationChannelsSheet: View {
         .onChange(of: manager.availableChannels) { _ in }
     }
 
-    private var channelList: some View {
+    private var closeButton: some View {
-        List {
+        Button(action: { isPresented = false }) {
-            // Mesh option first (no bookmark)
+            Image(systemName: "xmark")
-            channelRow(title: meshTitleWithCount(), subtitlePrefix: "#bluetooth • \(bluetoothRangeString())", isSelected: isMeshSelected, titleColor: standardBlue, titleBold: meshCount() > 0) {
+                .font(.bitchatSystem(size: 13, weight: .semibold, design: .monospaced))
-                manager.select(ChannelID.mesh)
+                .frame(width: 32, height: 32)
-                isPresented = false
+        }
-            }
+        .buttonStyle(.plain)
+        .accessibilityLabel("Close")
+    }
 
-            // Nearby options
+    private var channelList: some View {
-            if !manager.availableChannels.isEmpty {
+        ScrollView {
-                ForEach(manager.availableChannels.filter { $0.level != .building }) { channel in
+            LazyVStack(spacing: 0) {
-                    let coverage = coverageString(forPrecision: channel.geohash.count)
+                channelRow(title: Strings.meshTitle(meshCount()), subtitlePrefix: Strings.subtitlePrefix(geohash: "bluetooth", coverage: bluetoothRangeString()), isSelected: isMeshSelected, titleColor: standardBlue, titleBold: meshCount() > 0) {
-                    let nameBase = locationName(for: channel.level)
+                    manager.select(ChannelID.mesh)
-                    let namePart = nameBase.map { formattedNamePrefix(for: channel.level) + $0 }
+                    isPresented = false
-                    let subtitlePrefix = "#\(channel.geohash) • \(coverage)"
+                }
-                    let highlight = viewModel.geohashParticipantCount(for: channel.geohash) > 0
+                .padding(.vertical, 6)
+
+                let nearby = manager.availableChannels.filter { $0.level != .building }
+                if !nearby.isEmpty {
+                    ForEach(nearby) { channel in
+                        sectionDivider
+                        let coverage = coverageString(forPrecision: channel.geohash.count)
+                        let nameBase = locationName(for: channel.level)
+                        let namePart = nameBase.map { formattedNamePrefix(for: channel.level) + $0 }
+                        let participantCount = viewModel.geohashParticipantCount(for: channel.geohash)
+                        let subtitlePrefix = Strings.subtitlePrefix(geohash: channel.geohash, coverage: coverage)
+                        let highlight = participantCount > 0
+                        channelRow(
+                            title: Strings.levelTitle(for: channel.level, count: participantCount),
+                            subtitlePrefix: subtitlePrefix,
+                            subtitleName: namePart,
+                            isSelected: isSelected(channel),
+                            titleBold: highlight,
+                            trailingAccessory: {
+                                Button(action: { bookmarks.toggle(channel.geohash) }) {
+                                    Image(systemName: bookmarks.isBookmarked(channel.geohash) ? "bookmark.fill" : "bookmark")
+                                        .font(.bitchatSystem(size: 14))
+                                }
+                                .buttonStyle(.plain)
+                                .padding(.leading, 8)
+                            }
+                        ) {
+                            manager.markTeleported(for: channel.geohash, false)
+                            manager.select(ChannelID.location(channel))
+                            isPresented = false
+                        }
+                        .padding(.vertical, 6)
+                    }
+                } else {
+                    sectionDivider
+                    HStack(spacing: 8) {
+                        ProgressView()
+                        Text(Strings.loadingNearby)
+                            .font(.bitchatSystem(size: 12, design: .monospaced))
+                    }
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .padding(.vertical, 10)
+                }
+
+                sectionDivider
+                customTeleportSection
+                    .padding(.vertical, 8)
+
+                let bookmarkedList = bookmarks.bookmarks
+                if !bookmarkedList.isEmpty {
+                    sectionDivider
+                    bookmarkedSection(bookmarkedList)
+                        .padding(.vertical, 8)
+                }
+
+                if manager.permissionState == LocationChannelManager.PermissionState.authorized {
+                    sectionDivider
+                    torToggleSection
+                        .padding(.top, 12)
+                    Button(action: {
+                        openSystemLocationSettings()
+                    }) {
+                        Text(Strings.removeAccess)
+                            .font(.bitchatSystem(size: 12, design: .monospaced))
+                            .foregroundColor(Color(red: 0.75, green: 0.1, blue: 0.1))
+                            .frame(maxWidth: .infinity)
+                            .padding(.vertical, 6)
+                            .background(Color.red.opacity(0.08))
+                            .cornerRadius(6)
+                    }
+                    .buttonStyle(.plain)
+                    .padding(.vertical, 8)
+                }
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.vertical, 6)
+            .background(backgroundColor)
+        }
+        .background(backgroundColor)
+    }
+
+    private var sectionDivider: some View {
+        Rectangle()
+            .fill(dividerColor)
+            .frame(height: 1)
+    }
+
+    private var dividerColor: Color {
+        colorScheme == .dark ? Color.white.opacity(0.12) : Color.black.opacity(0.08)
+    }
+
+    private var customTeleportSection: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            HStack(spacing: 2) {
+                Text(verbatim: "#")
+                    .font(.bitchatSystem(size: 14, design: .monospaced))
+                    .foregroundColor(.secondary)
+                TextField("geohash", text: $customGeohash)
+                    #if os(iOS)
+                    .textInputAutocapitalization(.never)
+                    .autocorrectionDisabled(true)
+                    .keyboardType(.asciiCapable)
+                    #endif
+                    .font(.bitchatSystem(size: 14, design: .monospaced))
+                    .onChange(of: customGeohash) { newValue in
+                        let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
+                        let filtered = newValue
+                            .lowercased()
+                            .replacingOccurrences(of: "#", with: "")
+                            .filter { allowed.contains($0) }
+                        if filtered.count > 12 {
+                            customGeohash = String(filtered.prefix(12))
+                        } else if filtered != newValue {
+                            customGeohash = filtered
+                        }
+                    }
+                let normalized = customGeohash
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                    .lowercased()
+                    .replacingOccurrences(of: "#", with: "")
+                let isValid = validateGeohash(normalized)
+                Button(action: {
+                    let gh = normalized
+                    guard isValid else { customError = Strings.invalidGeohash; return }
+                    let level = levelForLength(gh.count)
+                    let ch = GeohashChannel(level: level, geohash: gh)
+                    manager.markTeleported(for: ch.geohash, true)
+                    manager.select(ChannelID.location(ch))
+                    isPresented = false
+                }) {
+                    HStack(spacing: 6) {
+                        Text(Strings.teleport)
+                            .font(.bitchatSystem(size: 14, design: .monospaced))
+                        Image(systemName: "face.dashed")
+                            .font(.bitchatSystem(size: 14))
+                    }
+                }
+                .buttonStyle(.plain)
+                .font(.bitchatSystem(size: 14, design: .monospaced))
+                .padding(.vertical, 6)
+                .padding(.horizontal, 10)
+                .background(Color.secondary.opacity(0.12))
+                .cornerRadius(6)
+                .opacity(isValid ? 1.0 : 0.4)
+                .disabled(!isValid)
+            }
+            if let err = customError {
+                Text(err)
+                    .font(.bitchatSystem(size: 12, design: .monospaced))
+                    .foregroundColor(.red)
+            }
+        }
+    }
+
+    private func bookmarkedSection(_ entries: [String]) -> some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text(Strings.bookmarked)
+                .font(.bitchatSystem(size: 12, design: .monospaced))
+                .foregroundColor(.secondary)
+            LazyVStack(spacing: 0) {
+                ForEach(Array(entries.enumerated()), id: \.offset) { index, gh in
+                    let level = levelForLength(gh.count)
+                    let channel = GeohashChannel(level: level, geohash: gh)
+                    let coverage = coverageString(forPrecision: gh.count)
+                    let subtitle = Strings.subtitlePrefix(geohash: gh, coverage: coverage)
+                    let name = bookmarks.bookmarkNames[gh]
+                    let participantCount = viewModel.geohashParticipantCount(for: gh)
                     channelRow(
-                        title: geohashTitleWithCount(for: channel),
+                        title: Strings.bookmarkTitle(geohash: gh, count: participantCount),
-                        subtitlePrefix: subtitlePrefix,
+                        subtitlePrefix: subtitle,
-                        subtitleName: namePart,
+                        subtitleName: name.map { formattedNamePrefix(for: level) + $0 },
                         isSelected: isSelected(channel),
-                        titleBold: highlight,
                         trailingAccessory: {
-                            Button(action: { bookmarks.toggle(channel.geohash) }) {
+                            Button(action: { bookmarks.toggle(gh) }) {
-                                Image(systemName: bookmarks.isBookmarked(channel.geohash) ? "bookmark.fill" : "bookmark")
+                                Image(systemName: bookmarks.isBookmarked(gh) ? "bookmark.fill" : "bookmark")
-                                    .font(.system(size: 14))
+                                    .font(.bitchatSystem(size: 14))
                             }
                             .buttonStyle(.plain)
                             .padding(.leading, 8)
                         }
                     ) {
-                        // Selecting a suggested nearby channel is not a teleport. Persist this.
+                        let inRegional = manager.availableChannels.contains { $0.geohash == gh }
-                        manager.markTeleported(for: channel.geohash, false)
+                        if !inRegional && !manager.availableChannels.isEmpty {
+                            manager.markTeleported(for: gh, true)
+                        } else {
+                            manager.markTeleported(for: gh, false)
+                        }
                         manager.select(ChannelID.location(channel))
                         isPresented = false
                     }
-                }
-            } else {
-                HStack {
-                    ProgressView()
-                    Text("finding nearby channels…")
-                        .font(.system(size: 12, design: .monospaced))
-                }
-            }
-
-            // Custom geohash teleport
-            VStack(alignment: .leading, spacing: 6) {
-                HStack(spacing: 2) {
-                    Text("#")
-                        .font(.system(size: 14, design: .monospaced))
-                        .foregroundColor(.secondary)
-                    TextField("geohash", text: $customGeohash)
-                        #if os(iOS)
-                        .textInputAutocapitalization(.never)
-                        .autocorrectionDisabled(true)
-                        .keyboardType(.asciiCapable)
-                        #endif
-                        .font(.system(size: 14, design: .monospaced))
-                        .onChange(of: customGeohash) { newValue in
-                            // Allow only geohash base32 characters, strip '#', limit length
-                            let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
-                            let filtered = newValue
-                                .lowercased()
-                                .replacingOccurrences(of: "#", with: "")
-                                .filter { allowed.contains($0) }
-                            if filtered.count > 12 {
-                                customGeohash = String(filtered.prefix(12))
-                            } else if filtered != newValue {
-                                customGeohash = filtered
-                            }
-                        }
-                    let normalized = customGeohash.trimmingCharacters(in: .whitespacesAndNewlines).lowercased().replacingOccurrences(of: "#", with: "")
-                    let isValid = validateGeohash(normalized)
-                    Button(action: {
-                        let gh = normalized
-                        guard isValid else { customError = "invalid geohash"; return }
-                        let level = levelForLength(gh.count)
-                        let ch = GeohashChannel(level: level, geohash: gh)
-                        // Mark this selection as a manual teleport
-                        manager.markTeleported(for: ch.geohash, true)
-                        manager.select(ChannelID.location(ch))
-                        isPresented = false
-                    }) {
-                        HStack(spacing: 6) {
-                            Text("teleport")
-                                .font(.system(size: 14, design: .monospaced))
-                            Image(systemName: "face.dashed")
-                                .font(.system(size: 14))
-                        }
-                    }
-                    .buttonStyle(.plain)
-                    .font(.system(size: 14, design: .monospaced))
-                    .padding(.horizontal, 10)
                     .padding(.vertical, 6)
-                    .background(Color.secondary.opacity(0.12))
+                    .onAppear { bookmarks.resolveNameIfNeeded(for: gh) }
-                    .cornerRadius(6)
-                    .opacity(isValid ? 1.0 : 0.4)
-                    .disabled(!isValid)
-                }
-                if let err = customError {
-                    Text(err)
-                        .font(.system(size: 12, design: .monospaced))
-                        .foregroundColor(.red)
-                }
-            }
 
-            // Bookmarked geohashes
+                    if index < entries.count - 1 {
-            if !bookmarks.bookmarks.isEmpty {
+                        sectionDivider
-                VStack(alignment: .leading, spacing: 8) {
-                    Text("bookmarked")
-                        .font(.system(size: 12, design: .monospaced))
-                        .foregroundColor(.secondary)
-                    VStack(spacing: 6) {
-                        ForEach(bookmarks.bookmarks, id: \.self) { gh in
-                            let level = levelForLength(gh.count)
-                            let channel = GeohashChannel(level: level, geohash: gh)
-                            let coverage = coverageString(forPrecision: gh.count)
-                            let subtitle = "#\(gh) • \(coverage)"
-                            let name = bookmarks.bookmarkNames[gh]
-                            channelRow(
-                                title: geohashHashTitleWithCount(gh),
-                                subtitlePrefix: subtitle,
-                                subtitleName: name.map { formattedNamePrefix(for: level) + $0 },
-                                isSelected: isSelected(channel),
-                                trailingAccessory: {
-                                    Button(action: { bookmarks.toggle(gh) }) {
-                                        Image(systemName: bookmarks.isBookmarked(gh) ? "bookmark.fill" : "bookmark")
-                                            .font(.system(size: 14))
-                                    }
-                                    .buttonStyle(.plain)
-                                    .padding(.leading, 8)
-                                }
-                            ) {
-                                // For bookmarked selection, mark teleported based on regional membership
-                                let inRegional = manager.availableChannels.contains { $0.geohash == gh }
-                                if !inRegional && !manager.availableChannels.isEmpty {
-                                    manager.markTeleported(for: gh, true)
-                                } else {
-                                    manager.markTeleported(for: gh, false)
-                                }
-                                manager.select(ChannelID.location(channel))
-                                isPresented = false
-                            }
-                            .onAppear { bookmarks.resolveNameIfNeeded(for: gh) }
-                        }
                     }
-                    .padding(12)
-                    .background(Color.secondary.opacity(0.12))
-                    .cornerRadius(8)
                 }
-                .listRowSeparator(.hidden)
-            }
-
-            // Footer action inside the list
-            if manager.permissionState == LocationChannelManager.PermissionState.authorized {
-                torToggleSection
-                Button(action: {
-                    openSystemLocationSettings()
-                }) {
-                    Text("remove location access")
-                        .font(.system(size: 12, design: .monospaced))
-                        .foregroundColor(Color(red: 0.75, green: 0.1, blue: 0.1))
-                        .frame(maxWidth: .infinity)
-                        .padding(.vertical, 6)
-                        .background(Color.red.opacity(0.08))
-                        .cornerRadius(6)
-                }
-                .buttonStyle(.plain)
-                .listRowSeparator(.hidden)
-                .listRowBackground(Color.clear)
             }
         }
-        .listStyle(.plain)
-        .scrollContentBackground(.hidden)
-        .background(backgroundColor)
     }
 
+
     private func isSelected(_ channel: GeohashChannel) -> Bool {
         if case .location(let ch) = manager.selectedChannel {
             return ch == channel
@@ -319,31 +401,26 @@ struct LocationChannelsSheet: View {
                 let parts = splitTitleAndCount(title)
                 HStack(spacing: 4) {
                     Text(parts.base)
-                            .font(.system(size: 14, design: .monospaced))
+                            .font(.bitchatSystem(size: 14, design: .monospaced))
                             .fontWeight(titleBold ? .bold : .regular)
                             .foregroundColor(titleColor ?? Color.primary)
                         if let count = parts.countSuffix, !count.isEmpty {
                             Text(count)
-                                .font(.system(size: 11, design: .monospaced))
+                                .font(.bitchatSystem(size: 11, design: .monospaced))
                                 .foregroundColor(.secondary)
                         }
                     }
-                let subtitleFull: String = {
+                let subtitleFull = Strings.subtitle(prefix: subtitlePrefix, name: subtitleName)
-                    if let name = subtitleName, !name.isEmpty {
-                        return subtitlePrefix + " • " + name
-                    }
-                    return subtitlePrefix
-                }()
                 Text(subtitleFull)
-                    .font(.system(size: 12, design: .monospaced))
+                    .font(.bitchatSystem(size: 12, design: .monospaced))
                     .foregroundColor(.secondary)
                     .lineLimit(1)
                     .truncationMode(.tail)
                 }
                 Spacer()
                 if isSelected {
-                    Text("✔︎")
+                    Text(verbatim: "✔︎")
-                        .font(.system(size: 16, design: .monospaced))
+                        .font(.bitchatSystem(size: 16, design: .monospaced))
                         .foregroundColor(standardGreen)
                 }
                 trailingAccessory()
@@ -362,36 +439,15 @@ struct LocationChannelsSheet: View {
     }
 
     // MARK: - Helpers for counts
-    private func meshTitleWithCount() -> String {
-        // Count currently connected mesh peers (excluding self)
-        let meshCount = meshCount()
-        let noun = meshCount == 1 ? "person" : "people"
-        return "mesh [\(meshCount) \(noun)]"
-    }
-
     private func meshCount() -> Int {
         // Count mesh-connected OR mesh-reachable peers (exclude self)
         let myID = viewModel.meshService.myPeerID
         return viewModel.allPeers.reduce(0) { acc, peer in
-            if peer.id != myID && (peer.isConnected || peer.isReachable) { return acc + 1 }
+            if peer.peerID != myID && (peer.isConnected || peer.isReachable) { return acc + 1 }
             return acc
         }
     }
 
-    private func geohashTitleWithCount(for channel: GeohashChannel) -> String {
-        // Main list: keep level labels (block/neighborhood/city/province/region)
-        let count = viewModel.geohashParticipantCount(for: channel.geohash)
-        let noun = count == 1 ? "person" : "people"
-        return "\(channel.level.displayName.lowercased()) [\(count) \(noun)]"
-    }
-
-    private func geohashHashTitleWithCount(_ geohash: String) -> String {
-        // Bookmarked list: show the #geohash as the main label
-        let count = viewModel.geohashParticipantCount(for: geohash)
-        let noun = count == 1 ? "person" : "people"
-        return "#\(geohash) [\(count) \(noun)]"
-    }
-
     private func validateGeohash(_ s: String) -> Bool {
         let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
         guard !s.isEmpty, s.count <= 12 else { return false }
@@ -424,21 +480,19 @@ extension LocationChannelsSheet {
         VStack(alignment: .leading, spacing: 8) {
             Toggle(isOn: torToggleBinding) {
                 VStack(alignment: .leading, spacing: 2) {
-                    Text("tor routing")
+                    Text(Strings.torTitle)
-                        .font(.system(size: 12, weight: .semibold, design: .monospaced))
+                        .font(.bitchatSystem(size: 12, weight: .semibold, design: .monospaced))
                         .foregroundColor(.primary)
-                    Text("hides your ip for location channels. recommended: on.")
+                    Text(Strings.torSubtitle)
-                        .font(.system(size: 11, design: .monospaced))
+                        .font(.bitchatSystem(size: 11, design: .monospaced))
                         .foregroundColor(.secondary)
                 }
             }
-            .toggleStyle(IRCToggleStyle(accent: standardGreen))
+            .toggleStyle(IRCToggleStyle(accent: standardGreen, onLabel: Strings.toggleOn, offLabel: Strings.toggleOff))
         }
         .padding(12)
         .background(Color.secondary.opacity(0.12))
         .cornerRadius(8)
-        .listRowSeparator(.hidden)
-        .listRowBackground(Color.clear)
     }
 
     private var standardGreen: Color {
@@ -451,15 +505,17 @@ extension LocationChannelsSheet {
 
 private struct IRCToggleStyle: ToggleStyle {
     let accent: Color
+    let onLabel: LocalizedStringKey
+    let offLabel: LocalizedStringKey
 
     func makeBody(configuration: Configuration) -> some View {
         Button(action: { configuration.isOn.toggle() }) {
             HStack(spacing: 12) {
                 configuration.label
                 Spacer()
-                Text(configuration.isOn ? "on" : "off")
+                Text(configuration.isOn ? onLabel : offLabel)
                     .textCase(.uppercase)
-                    .font(.system(size: 12, weight: .semibold, design: .monospaced))
+                    .font(.bitchatSystem(size: 12, weight: .semibold, design: .monospaced))
                     .foregroundColor(configuration.isOn ? accent : .secondary)
                     .padding(.vertical, 4)
                     .padding(.horizontal, 10)

bitchat/Views/LocationNotesView.swift

@@ -7,6 +7,7 @@ struct LocationNotesView: View {
     let onNotesCountChanged: ((Int) -> Void)?
 
     @Environment(\.colorScheme) var colorScheme
+    @Environment(\.dynamicTypeSize) private var dynamicTypeSize
     @ObservedObject private var locationManager = LocationChannelManager.shared
     @Environment(\.dismiss) private var dismiss
     @State private var draft: String = ""
@@ -18,30 +19,39 @@ struct LocationNotesView: View {
         _manager = StateObject(wrappedValue: LocationNotesManager(geohash: gh))
     }
 
-    private var backgroundColor: Color {
+    private var backgroundColor: Color { colorScheme == .dark ? .black : .white }
-        colorScheme == .dark ? Color.black : Color.white
+    private var accentGreen: Color { colorScheme == .dark ? .green : Color(red: 0, green: 0.5, blue: 0) }
-    }
+    private var maxDraftLines: Int { dynamicTypeSize.isAccessibilitySize ? 5 : 3 }
-    private var textColor: Color {
+
-        colorScheme == .dark ? Color.green : Color(red: 0, green: 0.5, blue: 0)
+    private enum Strings {
-    }
+        static let closeAccessibility = String(localized: "common.close", comment: "Accessibility label for close buttons")
-    private var secondaryTextColor: Color {
+        static let description: LocalizedStringKey = "location_notes.description"
-        colorScheme == .dark ? Color.green.opacity(0.8) : Color(red: 0, green: 0.5, blue: 0).opacity(0.8)
+        static let loadingRecent: LocalizedStringKey = "location_notes.loading_recent"
-    }
+        static let relaysPaused: LocalizedStringKey = "location_notes.relays_paused"
-    // Slightly darker green for hash suffix emphasis
+        static let noRelaysNearby: LocalizedStringKey = "location_notes.no_relays_nearby"
-    private var darkerTextColor: Color {
+        static let retry: LocalizedStringKey = "location_notes.action.retry"
-        colorScheme == .dark ? Color.green : Color(red: 0, green: 0.4, blue: 0)
+        static let relaysRetryHint: LocalizedStringKey = "location_notes.relays_retry_hint"
+        static let loadingNotes: LocalizedStringKey = "location_notes.loading_notes"
+        static let emptyTitle: LocalizedStringKey = "location_notes.empty_title"
+        static let emptySubtitle: LocalizedStringKey = "location_notes.empty_subtitle"
+        static let dismissError: LocalizedStringKey = "location_notes.action.dismiss"
+        static let addPlaceholder: LocalizedStringKey = "location_notes.placeholder"
     }
 
     var body: some View {
+#if os(macOS)
         VStack(spacing: 0) {
-            header
+            ScrollView {
-            Divider()
+                VStack(spacing: 0) {
-            list
+                    headerSection
-            Divider()
+                    notesContent
-            input
+                }
+            }
+            .background(backgroundColor)
+            inputSection
         }
+        .frame(minWidth: 420, idealWidth: 440, minHeight: 620, idealHeight: 680)
         .background(backgroundColor)
-        .foregroundColor(textColor)
         .onDisappear { manager.cancel() }
         .onChange(of: geohash) { newValue in
             manager.setGeohash(newValue)
@@ -50,100 +60,206 @@ struct LocationNotesView: View {
         .onChange(of: manager.notes.count) { newValue in
             onNotesCountChanged?(newValue)
         }
+#else
+        NavigationView {
+            VStack(spacing: 0) {
+                headerSection
+                ScrollView {
+                    notesContent
+                }
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+                inputSection
+            }
+            .background(backgroundColor)
+            #if os(iOS)
+            .navigationBarTitleDisplayMode(.inline)
+            .navigationBarHidden(true)
+            #else
+            .navigationTitle("")
+            #endif
+        }
+       #if os(iOS)
+        .presentationDetents([.large])
+        #endif
+        .background(backgroundColor)
+        .onDisappear { manager.cancel() }
+        .onChange(of: geohash) { newValue in
+            manager.setGeohash(newValue)
+        }
+        .onAppear { onNotesCountChanged?(manager.notes.count) }
+        .onChange(of: manager.notes.count) { newValue in
+            onNotesCountChanged?(newValue)
+        }
+#endif
     }
 
-    private var header: some View {
+    private var closeButton: some View {
-        HStack {
+        Button(action: { dismiss() }) {
-            VStack(alignment: .leading, spacing: 2) {
+            Image(systemName: "xmark")
-                HStack(spacing: 4) {
+                .font(.bitchatSystem(size: 13, weight: .semibold, design: .monospaced))
-                    let c = manager.notes.count
+                .frame(width: 32, height: 32)
-                    Text("\(c) \(c == 1 ? "note" : "notes") ")
-                        .font(.system(size: 16, weight: .bold, design: .monospaced))
-                    Text("@ ")
-                        .font(.system(size: 16, weight: .bold, design: .monospaced))
-                    Text("#\(geohash)")
-                        .font(.system(size: 16, weight: .bold, design: .monospaced))
-                        .foregroundColor(textColor)
-                }
-                if let buildingName = locationManager.locationNames[.building], !buildingName.isEmpty {
-                    Text(buildingName)
-                        .font(.system(size: 12, design: .monospaced))
-                        .foregroundColor(secondaryTextColor)
-                } else if let blockName = locationManager.locationNames[.block], !blockName.isEmpty {
-                    Text(blockName)
-                        .font(.system(size: 12, design: .monospaced))
-                        .foregroundColor(secondaryTextColor)
-                }
-            }
-            Spacer()
-            Button(action: { dismiss() }) {
-                Image(systemName: "xmark")
-                    .font(.system(size: 13, weight: .semibold, design: .monospaced))
-                    .foregroundColor(textColor)
-                    .frame(width: 32, height: 32)
-                    .contentShape(Rectangle())
-            }
-            .buttonStyle(.plain)
-            .accessibilityLabel("Close")
         }
-        .frame(height: 44)
+        .buttonStyle(.plain)
-        .padding(.horizontal, 12)
+        .accessibilityLabel(Strings.closeAccessibility)
-        .background(backgroundColor.opacity(0.95))
     }
 
-    private var list: some View {
+    private var headerSection: some View {
-        ScrollView {
+        let count = manager.notes.count
-            LazyVStack(alignment: .leading, spacing: 8) {
+        return VStack(alignment: .leading, spacing: 8) {
-                ForEach(manager.notes) { note in
+            HStack(spacing: 12) {
-                    VStack(alignment: .leading, spacing: 2) {
+                Text(headerTitle(for: count))
-                        HStack(spacing: 6) {
+                    .font(.bitchatSystem(size: 18, design: .monospaced))
-                            // Show @name without the #abcd suffix; timestamp in brackets
+                Spacer()
-                            HStack(spacing: 0) {
+                closeButton
-                                Text("@")
+            }
-                                    .font(.system(size: 12, weight: .semibold, design: .monospaced))
+            if let building = locationManager.locationNames[.building], !building.isEmpty {
-                                    .foregroundColor(textColor)
+                Text(building)
-                                let parts = splitSuffix(from: note.displayName)
+                    .font(.bitchatSystem(size: 12, design: .monospaced))
-                                Text(parts.0)
+                    .foregroundColor(accentGreen)
-                                    .font(.system(size: 12, weight: .semibold, design: .monospaced))
+            } else if let block = locationManager.locationNames[.block], !block.isEmpty {
-                                    .foregroundColor(textColor)
+                Text(block)
-                            }
+                    .font(.bitchatSystem(size: 12, design: .monospaced))
-                            let ts = timestampText(for: note.createdAt)
+                    .foregroundColor(accentGreen)
-                            Text(ts.isEmpty ? "" : "[\(ts)]")
+            }
-                                .font(.system(size: 11, design: .monospaced))
+            Text(Strings.description)
-                                .foregroundColor(secondaryTextColor.opacity(0.8))
+                .font(.bitchatSystem(size: 12, design: .monospaced))
-                        }
+                .foregroundColor(.secondary)
-                        Text(note.content)
+                .fixedSize(horizontal: false, vertical: true)
-                            .font(.system(size: 14, design: .monospaced))
+            if manager.state == .noRelays {
-                            .fixedSize(horizontal: false, vertical: true)
+                Text(Strings.relaysPaused)
-                    }
+                    .font(.bitchatSystem(size: 11, design: .monospaced))
-                    .padding(.horizontal, 12)
+                    .foregroundColor(.secondary)
-                }
             }
-            .padding(.vertical, 8)
         }
+        .padding(.horizontal, 16)
+        .padding(.top, 16)
+        .padding(.bottom, 12)
         .background(backgroundColor)
     }
 
-    private var input: some View {
+    private func headerTitle(for count: Int) -> String {
-        HStack(alignment: .center, spacing: 8) {
+        String(
-            TextField("add a note for this place", text: $draft, axis: .vertical)
+            format: String(localized: "location_notes.header", comment: "Header displaying the geohash and localized note count"),
-                .textFieldStyle(.plain)
+            locale: .current,
-                .font(.system(size: 14, design: .monospaced))
+            "\(geohash) ± 1", count
-                .lineLimit(3, reservesSpace: true)
+        )
-                .padding(.horizontal, 12)
+    }
 
+    private var notesContent: some View {
+        LazyVStack(alignment: .leading, spacing: 12) {
+            if manager.state == .noRelays {
+                noRelaysRow
+            } else if manager.state == .loading && !manager.initialLoadComplete {
+                loadingRow
+            } else if manager.notes.isEmpty {
+                emptyRow
+            } else {
+                ForEach(manager.notes) { note in
+                    noteRow(note)
+                }
+            }
+
+            if let error = manager.errorMessage, manager.state != .noRelays {
+                errorRow(message: error)
+            }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 8)
+    }
+
+    private func noteRow(_ note: LocationNotesManager.Note) -> some View {
+        let baseName = note.displayName.split(separator: "#", maxSplits: 1, omittingEmptySubsequences: false).first.map(String.init) ?? note.displayName
+        let ts = timestampText(for: note.createdAt)
+        return VStack(alignment: .leading, spacing: 2) {
+            HStack(spacing: 6) {
+                Text(verbatim: "@\(baseName)")
+                    .font(.bitchatSystem(size: 12, weight: .semibold, design: .monospaced))
+                if !ts.isEmpty {
+                    Text(ts)
+                        .font(.bitchatSystem(size: 11, design: .monospaced))
+                        .foregroundColor(.secondary)
+                }
+                Spacer()
+            }
+            Text(note.content)
+                .font(.bitchatSystem(size: 14, design: .monospaced))
+                .fixedSize(horizontal: false, vertical: true)
+        }
+        .padding(.vertical, 4)
+    }
+
+    private var noRelaysRow: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            Text(Strings.noRelaysNearby)
+                .font(.bitchatSystem(size: 13, weight: .semibold, design: .monospaced))
+            Text(Strings.relaysRetryHint)
+                .font(.bitchatSystem(size: 12, design: .monospaced))
+                .foregroundColor(.secondary)
+            Button(Strings.retry) { manager.refresh() }
+                .font(.bitchatSystem(size: 12, design: .monospaced))
+                .buttonStyle(.plain)
+        }
+        .padding(.vertical, 6)
+    }
+
+    private var loadingRow: some View {
+        HStack(spacing: 10) {
+            ProgressView()
+            Text(Strings.loadingNotes)
+                .font(.bitchatSystem(size: 12, design: .monospaced))
+                .foregroundColor(.secondary)
+            Spacer()
+        }
+        .padding(.vertical, 8)
+    }
+
+    private var emptyRow: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            Text(Strings.emptyTitle)
+                .font(.bitchatSystem(size: 13, weight: .semibold, design: .monospaced))
+            Text(Strings.emptySubtitle)
+                .font(.bitchatSystem(size: 12, design: .monospaced))
+                .foregroundColor(.secondary)
+        }
+        .padding(.vertical, 6)
+    }
+
+    private func errorRow(message: String) -> some View {
+        VStack(alignment: .leading, spacing: 4) {
+            HStack(spacing: 6) {
+                Image(systemName: "exclamationmark.triangle.fill")
+                    .font(.bitchatSystem(size: 12, design: .monospaced))
+                Text(message)
+                    .font(.bitchatSystem(size: 12, design: .monospaced))
+                Spacer()
+            }
+            Button(Strings.dismissError) { manager.clearError() }
+                .font(.bitchatSystem(size: 12, design: .monospaced))
+                .buttonStyle(.plain)
+        }
+        .padding(.vertical, 6)
+    }
+
+    private var inputSection: some View {
+        HStack(alignment: .top, spacing: 10) {
+            TextField(Strings.addPlaceholder, text: $draft, axis: .vertical)
+                .textFieldStyle(.plain)
+                .font(.bitchatSystem(size: 14, design: .monospaced))
+                .lineLimit(maxDraftLines, reservesSpace: true)
+                .padding(.vertical, 6)
             Button(action: send) {
                 Image(systemName: "arrow.up.circle.fill")
-                    .font(.system(size: 20))
+                    .font(.bitchatSystem(size: 20))
-                    .foregroundColor(draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? Color.gray : textColor)
+                    .foregroundColor(sendButtonEnabled ? accentGreen : .secondary)
             }
+            .padding(.top, 2)
             .buttonStyle(.plain)
-            .disabled(draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+            .disabled(!sendButtonEnabled)
-            .padding(.trailing, 12)
         }
-        .frame(minHeight: 44)
+        .padding(.horizontal, 16)
-        .padding(.vertical, 8)
+        .padding(.vertical, 14)
-        .background(backgroundColor.opacity(0.95))
+        .background(backgroundColor)
+        .overlay(Divider(), alignment: .top)
     }
 
     private func send() {
@@ -153,15 +269,17 @@ struct LocationNotesView: View {
         draft = ""
     }
 
+    private var sendButtonEnabled: Bool {
+        !draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty && manager.state != .noRelays
+    }
+
     // MARK: - Timestamp Formatting
     private func timestampText(for date: Date) -> String {
         let now = Date()
         if let days = Calendar.current.dateComponents([.day], from: date, to: now).day, days < 7 {
-            // Relative (minute/hour/day), no seconds
             let rel = Self.relativeFormatter.string(from: date, to: now) ?? ""
             return rel.isEmpty ? "" : "\(rel) ago"
         } else {
-            // Absolute date (MMM d or MMM d, yyyy if different year)
             let sameYear = Calendar.current.isDate(date, equalTo: now, toGranularity: .year)
             let fmt = sameYear ? Self.absDateFormatter : Self.absDateYearFormatter
             return fmt.string(from: date)
@@ -189,16 +307,3 @@ struct LocationNotesView: View {
         return f
     }()
 }
-
-// Helper to split a trailing #abcd suffix
-private func splitSuffix(from name: String) -> (String, String) {
-    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/MeshPeerList.swift

@@ -11,103 +11,109 @@ struct MeshPeerList: View {
 
     @State private var orderedIDs: [String] = []
 
+    private enum Strings {
+        static let noneNearby: LocalizedStringKey = "geohash_people.none_nearby"
+        static let blockedTooltip = String(localized: "geohash_people.tooltip.blocked", comment: "Tooltip shown next to a blocked peer indicator")
+        static let newMessagesTooltip = String(localized: "mesh_peers.tooltip.new_messages", comment: "Tooltip for the unread messages indicator")
+    }
+
     var body: some View {
+        let myPeerID = viewModel.meshService.myPeerID
+        let mapped: [(peer: BitchatPeer, isMe: Bool, hasUnread: Bool, enc: EncryptionStatus)] = viewModel.allPeers.map { peer in
+            let isMe = peer.peerID == myPeerID
+            let hasUnread = viewModel.hasUnreadMessages(for: peer.peerID)
+            let enc = viewModel.getEncryptionStatus(for: peer.peerID)
+            return (peer, isMe, hasUnread, enc)
+        }
+        // Stable visual order without mutating state here
+        let currentIDs = mapped.map { $0.peer.peerID.id }
+        let displayIDs = orderedIDs.filter { currentIDs.contains($0) } + currentIDs.filter { !orderedIDs.contains($0) }
+        let peers: [(peer: BitchatPeer, isMe: Bool, hasUnread: Bool, enc: EncryptionStatus)] = displayIDs.compactMap { id in
+            mapped.first(where: { $0.peer.peerID.id == id })
+        }
+        
         if viewModel.allPeers.isEmpty {
             VStack(alignment: .leading, spacing: 0) {
-                Text("nobody around...")
+                Text(Strings.noneNearby)
-                    .font(.system(size: 14, design: .monospaced))
+                    .font(.bitchatSystem(size: 14, design: .monospaced))
                     .foregroundColor(secondaryTextColor)
                     .padding(.horizontal)
                     .padding(.top, 12)
             }
         } else {
-            let myPeerID = viewModel.meshService.myPeerID
-            let mapped: [(peer: BitchatPeer, isMe: Bool, hasUnread: Bool, enc: EncryptionStatus)] = viewModel.allPeers.map { peer in
-                let isMe = peer.id == myPeerID
-                let hasUnread = viewModel.hasUnreadMessages(for: peer.id)
-                let enc = viewModel.getEncryptionStatus(for: peer.id)
-                return (peer, isMe, hasUnread, enc)
-            }
-            // Stable visual order without mutating state here
-            let currentIDs = mapped.map { $0.peer.id }
-            let displayIDs = orderedIDs.filter { currentIDs.contains($0) } + currentIDs.filter { !orderedIDs.contains($0) }
-            let peers: [(peer: BitchatPeer, isMe: Bool, hasUnread: Bool, enc: EncryptionStatus)] = displayIDs.compactMap { id in
-                mapped.first(where: { $0.peer.id == id })
-            }
-
             VStack(alignment: .leading, spacing: 0) {
                 ForEach(0..<peers.count, id: \.self) { idx in
                     let item = peers[idx]
                     let peer = item.peer
                     let isMe = item.isMe
                     HStack(spacing: 4) {
-                        let assigned = viewModel.colorForMeshPeer(id: peer.id, isDark: colorScheme == .dark)
+                        let assigned = viewModel.colorForMeshPeer(id: peer.peerID, isDark: colorScheme == .dark)
                         let baseColor = isMe ? Color.orange : assigned
                         if isMe {
                             Image(systemName: "person.fill")
-                                .font(.system(size: 10))
+                                .font(.bitchatSystem(size: 10))
                                 .foregroundColor(baseColor)
                         } else if peer.isConnected {
                             // Mesh-connected peer: radio icon
                             Image(systemName: "antenna.radiowaves.left.and.right")
-                                .font(.system(size: 10))
+                                .font(.bitchatSystem(size: 10))
                                 .foregroundColor(baseColor)
                         } else if peer.isReachable {
                             // Mesh-reachable (relayed): point.3 icon
                             Image(systemName: "point.3.filled.connected.trianglepath.dotted")
-                                .font(.system(size: 10))
+                                .font(.bitchatSystem(size: 10))
                                 .foregroundColor(baseColor)
                         } else if peer.isMutualFavorite {
                             // Mutual favorite reachable via Nostr: globe icon (purple)
                             Image(systemName: "globe")
-                                .font(.system(size: 10))
+                                .font(.bitchatSystem(size: 10))
                                 .foregroundColor(.purple)
                         } else {
                             // Fallback icon for others (dimmed)
                             Image(systemName: "person")
-                                .font(.system(size: 10))
+                                .font(.bitchatSystem(size: 10))
                                 .foregroundColor(secondaryTextColor)
                         }
 
                         let displayName = isMe ? viewModel.nickname : peer.nickname
-                        let (base, suffix) = splitSuffix(from: displayName)
+                        let (base, suffix) = displayName.splitSuffix()
                         HStack(spacing: 0) {
                             Text(base)
-                                .font(.system(size: 14, design: .monospaced))
+                                .font(.bitchatSystem(size: 14, design: .monospaced))
                                 .foregroundColor(baseColor)
                             if !suffix.isEmpty {
                                 let suffixColor = isMe ? Color.orange.opacity(0.6) : baseColor.opacity(0.6)
                                 Text(suffix)
-                                    .font(.system(size: 14, design: .monospaced))
+                                    .font(.bitchatSystem(size: 14, design: .monospaced))
                                     .foregroundColor(suffixColor)
                             }
                         }
 
-                        if !isMe, viewModel.isPeerBlocked(peer.id) {
+                        if !isMe, viewModel.isPeerBlocked(peer.peerID) {
                             Image(systemName: "nosign")
-                                .font(.system(size: 10))
+                                .font(.bitchatSystem(size: 10))
                                 .foregroundColor(.red)
-                                .help("Blocked")
+                                .help(Strings.blockedTooltip)
                         }
 
                         if !isMe {
                             if peer.isConnected {
                                 if let icon = item.enc.icon {
                                     Image(systemName: icon)
-                                        .font(.system(size: 10))
+                                        .font(.bitchatSystem(size: 10))
                                         .foregroundColor(baseColor)
                                 }
                             } else {
                                 // Offline: prefer showing verified badge from persisted fingerprints
-                                if let fp = viewModel.getFingerprint(for: peer.id),
+                                if let fp = viewModel.getFingerprint(for: peer.peerID),
                                    viewModel.verifiedFingerprints.contains(fp) {
                                     Image(systemName: "checkmark.seal.fill")
-                                        .font(.system(size: 10))
+                                        .font(.bitchatSystem(size: 10))
                                         .foregroundColor(baseColor)
                                 } else if let icon = item.enc.icon {
                                     // Fallback to whatever status says (likely lock if we had a past session)
                                     Image(systemName: icon)
-                                        .font(.system(size: 10))
+                                        .font(.bitchatSystem(size: 10))
                                         .foregroundColor(baseColor)
                                 }
                             }
@@ -118,15 +124,15 @@ struct MeshPeerList: View {
                         // Unread message indicator for this peer
                         if !isMe, item.hasUnread {
                             Image(systemName: "envelope.fill")
-                                .font(.system(size: 10))
+                                .font(.bitchatSystem(size: 10))
                                 .foregroundColor(.orange)
-                                .help("New messages")
+                                .help(Strings.newMessagesTooltip)
                         }
 
                         if !isMe {
-                            Button(action: { onToggleFavorite(peer.id) }) {
+                            Button(action: { onToggleFavorite(peer.peerID.id) }) {
                                 Image(systemName: (peer.favoriteStatus?.isFavorite ?? false) ? "star.fill" : "star")
-                                    .font(.system(size: 12))
+                                    .font(.bitchatSystem(size: 12))
                                     .foregroundColor((peer.favoriteStatus?.isFavorite ?? false) ? .yellow : secondaryTextColor)
                             }
                             .buttonStyle(.plain)
@@ -136,16 +142,16 @@ struct MeshPeerList: View {
                     .padding(.vertical, 4)
                     .padding(.top, idx == 0 ? 10 : 0)
                     .contentShape(Rectangle())
-                    .onTapGesture { if !isMe { onTapPeer(peer.id) } }
+                    .onTapGesture { if !isMe { onTapPeer(peer.peerID.id) } }
-                    .onTapGesture(count: 2) { if !isMe { onShowFingerprint(peer.id) } }
+                    .onTapGesture(count: 2) { if !isMe { onShowFingerprint(peer.peerID.id) } }
                 }
             }
             // Seed and update order outside result builder
             .onAppear {
-                let currentIDs = mapped.map { $0.peer.id }
+                let currentIDs = mapped.map { $0.peer.peerID.id }
                 orderedIDs = currentIDs
             }
-            .onChange(of: mapped.map { $0.peer.id }) { ids in
+            .onChange(of: mapped.map { $0.peer.peerID.id }) { ids in
                 var newOrder = orderedIDs
                 newOrder.removeAll { !ids.contains($0) }
                 for id in ids where !newOrder.contains(id) { newOrder.append(id) }
@@ -154,16 +160,3 @@ struct MeshPeerList: View {
         }
     }
 }
-
-// Helper to split a trailing #abcd suffix
-private func splitSuffix(from name: String) -> (String, String) {
-    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/MessageTextHelpers.swift

@@ -37,15 +37,16 @@ extension String {
     }
 
     // Extract up to `max` Cashu tokens (cashuA/cashuB). Allow dot '.' and shorter lengths.
-    func extractCashuTokens(max: Int = 3) -> [String] {
+    func extractCashuLinks(max: Int = 3) -> [String] {
         let regex = RegexCache.cashu
         let ns = self as NSString
         let range = NSRange(location: 0, length: ns.length)
         var found: [String] = []
-        for m in regex.matches(in: self, options: [], range: range) {
+        for m in regex.matches(in: self, range: range) {
             if m.numberOfRanges > 0 {
                 let token = ns.substring(with: m.range(at: 0))
-                found.append(token)
+                let enc = token.addingPercentEncoding(withAllowedCharacters: .alphanumerics.union(CharacterSet(charactersIn: "-_"))) ?? token
+                found.append("cashu:\(enc)")
                 if found.count >= max { break }
             }
         }
@@ -58,19 +59,19 @@ extension String {
         let ns = self as NSString
         let full = NSRange(location: 0, length: ns.length)
         // lightning: scheme
-        for m in RegexCache.lightningScheme.matches(in: self, options: [], range: full) {
+        for m in RegexCache.lightningScheme.matches(in: self, range: full) {
             let s = ns.substring(with: m.range(at: 0))
             results.append(s)
             if results.count >= max { return results }
         }
         // BOLT11
-        for m in RegexCache.bolt11.matches(in: self, options: [], range: full) {
+        for m in RegexCache.bolt11.matches(in: self, range: full) {
             let s = ns.substring(with: m.range(at: 0))
             results.append("lightning:\(s)")
             if results.count >= max { return results }
         }
         // LNURL bech32
-        for m in RegexCache.lnurl.matches(in: self, options: [], range: full) {
+        for m in RegexCache.lnurl.matches(in: self, range: full) {
             let s = ns.substring(with: m.range(at: 0))
             results.append("lightning:\(s)")
             if results.count >= max { return results }

bitchat/Views/VerificationViews.swift

@@ -13,18 +13,23 @@ struct MyQRView: View {
     @Environment(\.colorScheme) var colorScheme
     private var boxColor: Color { Color.gray.opacity(0.1) }
 
+    private enum Strings {
+        static let title: LocalizedStringKey = "verification.my_qr.title"
+        static let accessibilityLabel = String(localized: "verification.my_qr.accessibility_label", comment: "Accessibility label describing the verification QR code")
+    }
+
     var body: some View {
         VStack(spacing: 12) {
-            Text("scan to verify me")
+            Text(Strings.title)
-                .font(.system(size: 16, weight: .bold, design: .monospaced))
+                .font(.bitchatSystem(size: 16, weight: .bold, design: .monospaced))
 
             VStack(spacing: 10) {
                 QRCodeImage(data: qrString, size: 240)
-                    .accessibilityLabel("verification qr code")
+                    .accessibilityLabel(Strings.accessibilityLabel)
 
                 // Non-scrolling, fully visible URL (wraps across lines)
                 Text(qrString)
-                    .font(.system(size: 11, design: .monospaced))
+                    .font(.bitchatSystem(size: 11, design: .monospaced))
                     .textSelection(.enabled)
                     .multilineTextAlignment(.leading)
                     .fixedSize(horizontal: false, vertical: true)
@@ -49,6 +54,10 @@ struct QRCodeImage: View {
     private let context = CIContext()
     private let filter = CIFilter.qrCodeGenerator()
 
+    private enum Strings {
+        static let unavailable: LocalizedStringKey = "verification.my_qr.unavailable"
+    }
+
     var body: some View {
         Group {
             if let image = generateImage() {
@@ -59,8 +68,8 @@ struct QRCodeImage: View {
                     .stroke(Color.gray.opacity(0.5), lineWidth: 1)
                     .frame(width: size, height: size)
                     .overlay(
-                        Text("qr unavailable")
+                        Text(Strings.unavailable)
-                            .font(.system(size: 12, design: .monospaced))
+                            .font(.bitchatSystem(size: 12, design: .monospaced))
                             .foregroundColor(.gray)
                     )
             }
@@ -100,17 +109,41 @@ struct ImageWrapper: View {
 struct QRScanView: View {
     @EnvironmentObject var viewModel: ChatViewModel
     var isActive: Bool = true
+    var onSuccess: (() -> Void)? = nil  // Called when verification succeeds
     @State private var input = ""
     @State private var result: String = "" // not shown for iOS scanner
     @State private var lastValid: String = ""
+
+    private enum Strings {
+        static let pastePrompt: LocalizedStringKey = "verification.scan.paste_prompt"
+        static let validate: LocalizedStringKey = "verification.scan.validate"
+        static func requested(_ nickname: String) -> String {
+            String(
+                format: String(localized: "verification.scan.status.requested", comment: "Status text when verification is requested for a nickname"),
+                locale: .current,
+                nickname
+            )
+        }
+        static let notFound = String(localized: "verification.scan.status.no_peer", comment: "Status when no matching peer is found for a verification request")
+        static let invalid = String(localized: "verification.scan.status.invalid", comment: "Status when a scanned QR payload is invalid")
+    }
+
     var body: some View {
         VStack(alignment: .leading, spacing: 12) {
             #if os(iOS)
             CameraScannerView(isActive: isActive) { code in
+                // Deduplicate: ignore if we just processed this exact QR code
+                guard code != lastValid else { return }
+
                 if let qr = VerificationService.shared.verifyScannedQR(code) {
                     let ok = viewModel.beginQRVerification(with: qr)
-                    if !ok { /* already pending; continue scanning */ }
+                    if ok {
-                    lastValid = code
+                        // Successfully initiated verification; remember this QR to prevent re-scanning
+                        lastValid = code
+                        // Close scanner and return to "My QR" view
+                        onSuccess?()
+                    }
+                    // If !ok, peer not found or already pending - don't set lastValid so user can retry
                 } else {
                     // ignore invalid reads; continue scanning
                 }
@@ -118,17 +151,30 @@ struct QRScanView: View {
             .frame(height: 260)
             .clipShape(RoundedRectangle(cornerRadius: 8))
             #else
-            Text("paste qr content to validate:")
+            Text(Strings.pastePrompt)
-                .font(.system(size: 14, weight: .medium, design: .monospaced))
+                .font(.bitchatSystem(size: 14, weight: .medium, design: .monospaced))
             TextEditor(text: $input)
                 .frame(height: 100)
                 .border(Color.gray.opacity(0.4))
-            Button("validate") {
+            Button(Strings.validate) {
+                // Deduplicate: ignore if we just processed this exact QR
+                guard input != lastValid else {
+                    result = Strings.requested("")  // Already processed
+                    return
+                }
+
                 if let qr = VerificationService.shared.verifyScannedQR(input) {
                     let ok = viewModel.beginQRVerification(with: qr)
-                    result = ok ? "verification requested for \(qr.nickname)" : "could not find matching peer"
+                    if ok {
+                        result = Strings.requested(qr.nickname)
+                        lastValid = input
+                        // Close scanner and return to "My QR" view
+                        onSuccess?()
+                    } else {
+                        result = Strings.notFound
+                    }
                 } else {
-                    result = "invalid or expired qr payload"
+                    result = Strings.invalid
                 }
             }
             .buttonStyle(.bordered)
@@ -246,7 +292,7 @@ struct VerificationSheetView: View {
     private var boxColor: Color { Color.gray.opacity(0.1) }
 
     private func myQRString() -> String {
-        let npub = try? NostrIdentityBridge.getCurrentNostrIdentity()?.npub
+        let npub = try? viewModel.idBridge.getCurrentNostrIdentity()?.npub
         return VerificationService.shared.buildMyQRString(nickname: viewModel.nickname, npub: npub) ?? ""
     }
 
@@ -254,8 +300,8 @@ struct VerificationSheetView: View {
         VStack(spacing: 0) {
             // Top header (always at top)
             HStack {
-                Text("VERIFY")
+                Text("verification.sheet.title")
-                    .font(.system(size: 14, weight: .bold, design: .monospaced))
+                    .font(.bitchatSystem(size: 14, weight: .bold, design: .monospaced))
                     .foregroundColor(accentColor)
                 Spacer()
                 Button(action: {
@@ -263,7 +309,7 @@ struct VerificationSheetView: View {
                     isPresented = false
                 }) {
                     Image(systemName: "xmark")
-                        .font(.system(size: 14, weight: .semibold))
+                        .font(.bitchatSystem(size: 14, weight: .semibold))
                         .foregroundColor(accentColor)
                 }
                 .buttonStyle(.plain)
@@ -278,18 +324,22 @@ struct VerificationSheetView: View {
             Group {
                 if showingScanner {
                     VStack(alignment: .leading, spacing: 12) {
-                        Text("scan a friend's qr")
+                        Text("verification.scan.prompt_friend")
-                            .font(.system(size: 16, weight: .bold, design: .monospaced))
+                            .font(.bitchatSystem(size: 16, weight: .bold, design: .monospaced))
                             .frame(maxWidth: .infinity)
                             .multilineTextAlignment(.center)
                             .foregroundColor(accentColor)
                         #if os(iOS)
-                        QRScanView(isActive: showingScanner)
+                        QRScanView(isActive: showingScanner, onSuccess: {
+                            showingScanner = false
+                        })
                             .environmentObject(viewModel)
                             .frame(height: 280)
                             .clipShape(RoundedRectangle(cornerRadius: 10))
                         #else
-                        QRScanView()
+                        QRScanView(onSuccess: {
+                            showingScanner = false
+                        })
                             .environmentObject(viewModel)
                         #endif
                     }
@@ -310,13 +360,13 @@ struct VerificationSheetView: View {
                 if showingScanner {
                     Button(action: { showingScanner = false }) {
                         Label("show my qr", systemImage: "qrcode")
-                            .font(.system(size: 13, design: .monospaced))
+                            .font(.bitchatSystem(size: 13, design: .monospaced))
                     }
                     .buttonStyle(.bordered)
                 } else {
                     Button(action: { showingScanner = true }) {
                         Label("scan someone else's qr", systemImage: "camera.viewfinder")
-                            .font(.system(size: 13, weight: .medium, design: .monospaced))
+                            .font(.bitchatSystem(size: 13, weight: .medium, design: .monospaced))
                     }
                     .buttonStyle(.bordered)
                     .tint(.gray)
@@ -328,7 +378,7 @@ struct VerificationSheetView: View {
                    viewModel.verifiedFingerprints.contains(fp) {
                     Button(action: { viewModel.unverifyFingerprint(for: pid) }) {
                         Label("remove verification", systemImage: "minus.circle")
-                            .font(.system(size: 12, design: .monospaced))
+                            .font(.bitchatSystem(size: 12, design: .monospaced))
                     }
                     .buttonStyle(.bordered)
                     .tint(.gray)

bitchat/_PreviewHelpers/BitchatMessage+Preview.swift

@@ -0,0 +1,27 @@
+//
+// BitchatMessage+Preview.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+extension BitchatMessage {
+    static var preview: BitchatMessage {
+        BitchatMessage(
+            id: UUID().uuidString,
+            sender: "John Doe",
+            content: "Hello",
+            timestamp: Date(),
+            isRelay: false,
+            originalSender: nil,
+            isPrivate: false,
+            recipientNickname: "Jane Doe",
+            senderPeerID: nil,
+            mentions: nil,
+            deliveryStatus: .sent
+        )
+    }
+}

bitchat/_PreviewHelpers/PreviewKeychainManager.swift

@@ -0,0 +1,41 @@
+//
+// PreviewKeychainManager.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+final class PreviewKeychainManager: KeychainManagerProtocol {
+    private var storage: [String: Data] = [:]
+    init() {}
+    
+    func saveIdentityKey(_ keyData: Data, forKey key: String) -> Bool {
+        storage[key] = keyData
+        return true
+    }
+    
+    func getIdentityKey(forKey key: String) -> Data? {
+        storage[key]
+    }
+    
+    func deleteIdentityKey(forKey key: String) -> Bool {
+        storage.removeValue(forKey: key)
+        return true
+    }
+    
+    func deleteAllKeychainData() -> Bool {
+        storage.removeAll()
+        return true
+    }
+    
+    func secureClear(_ data: inout Data) {}
+    
+    func secureClear(_ string: inout String) {}
+    
+    func verifyIdentityKeyExists() -> Bool {
+        storage["identity_noiseStaticKey"] != nil
+    }
+}

bitchatShareExtension/Localization/Localizable.xcstrings

@@ -0,0 +1,708 @@
+{
+  "sourceLanguage": "en",
+  "strings": {
+    "share.fallback.shared_link_title": {
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "shared Link",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "ar": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "رابط مشترك",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "geteilter link",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "es": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "enlace compartido",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "lien partagé",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "he": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "קישור משותף",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "id": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "tautan dibagikan",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "it": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "link condiviso",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "ja": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "共有リンク",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "ne": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "साझा गरिएको लिङ्क",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "pt-BR": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "link compartilhado",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "ru": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "поделился ссылкой",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "uk": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "спільне посилання",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "zh-Hans": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "分享的链接",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "ko": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "공유된 링크",
+            "comment": "Fallback title when saving a shared link"
+          }
+        },
+        "tr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "paylaşılan bağlantı",
+            "comment": "Fallback title when saving a shared link"
+          }
+        }
+      }
+    },
+    "share.status.failed_to_encode": {
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "failed to encode link",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "ar": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "تعذر ترميز الرابط",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "link konnte nicht codiert werden",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "es": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "no se pudo codificar el enlace",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "échec de l'encodage du lien",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "he": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "לא ניתן לקודד את הקישור",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "id": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "gagal mengodekan tautan",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "it": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "impossibile codificare il link",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "ja": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "リンクのエンコードに失敗しました",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "ne": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "लिङ्क सङ्केत गर्न सकेन",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "pt-BR": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "falha ao codificar link",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "ru": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "не удалось закодировать ссылку",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "uk": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "не вдалося закодувати посилання",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "zh-Hans": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "无法编码链接",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "ko": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "링크를 인코딩하는 데 실패했습니다",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        },
+        "tr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "bağlantı kodlanamadı",
+            "comment": "Shown when the share payload cannot be encoded"
+          }
+        }
+      }
+    },
+    "share.status.no_shareable_content": {
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "no shareable content",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "ar": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "لا محتوى قابلاً للمشاركة",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "kein teilbarer inhalt",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "es": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "sin contenido que se pueda compartir",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "aucun contenu partageable",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "he": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "אין תוכן שניתן לשתף",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "id": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "tidak ada konten yang bisa dibagikan",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "it": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "nessun contenuto condivisibile",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "ja": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "共有可能なコンテンツがありません",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "ne": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "बाँड्न मिल्ने सामग्री छैन",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "pt-BR": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "nenhum conteúdo compartilhável",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "ru": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "нет подходящего контента",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "uk": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "нема відповідного контенту",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "zh-Hans": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "没有可分享的素材",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "ko": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "공유할 수 있는 내용이 없습니다",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        },
+        "tr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "paylaşılabilir içerik yok",
+            "comment": "Shown when provided content cannot be shared"
+          }
+        }
+      }
+    },
+    "share.status.nothing_to_share": {
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "nothing to share",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "ar": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "لا شيء لمشاركته",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "nichts zum teilen",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "es": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "nada que compartir",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "rien à partager",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "he": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "אין מה לשתף",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "id": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "tidak ada yang bisa dibagikan",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "it": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "niente da condividere",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "ja": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "共有できるものがありません",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "ne": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "बाँड्ने केही छैन",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "pt-BR": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "nada para compartilhar",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "ru": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "нечем поделиться",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "uk": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "нема чим ділитися",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "zh-Hans": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "没有可分享的内容",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "ko": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "공유할 내용이 없습니다",
+            "comment": "Shown when the share extension receives no content"
+          }
+        },
+        "tr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "paylaşılacak bir şey yok",
+            "comment": "Shown when the share extension receives no content"
+          }
+        }
+      }
+    },
+    "share.status.shared_link": {
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ shared link to bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "ar": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ تم إرسال الرابط إلى bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ link zu bitchat geteilt",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "es": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ enlace compartido con bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ lien partagé vers bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "he": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ הקישור נשלח אל bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "id": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ tautan dikirim ke bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "it": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ link inviato a bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "ja": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ bitchatにリンクを共有",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "ne": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ bitchat मा लिङ्क पठाइयो",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "pt-BR": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ link enviado para bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "ru": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ ссылка отправлена в bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "uk": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ посилання надіслано в bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "zh-Hans": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ 已将链接分享至 bitchat",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "ko": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ bitchat으로 링크를 공유했습니다",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        },
+        "tr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ bitchat'e bağlantı paylaşıldı",
+            "comment": "Confirmation after successfully sharing a link"
+          }
+        }
+      }
+    },
+    "share.status.shared_text": {
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ shared text to bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "ar": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ تم إرسال النص إلى bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ text zu bitchat geteilt",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "es": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ texto compartido con bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ texte partagé vers bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "he": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ הטקסט נשלח אל bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "id": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ teks dikirim ke bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "it": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ testo inviato a bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "ja": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ bitchatにテキストを共有",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "ne": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ bitchat मा पाठ पठाइयो",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "pt-BR": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ texto enviado para bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "ru": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ текст отправлен в bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "uk": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ текст надіслано в bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "zh-Hans": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ 已将文本分享至 bitchat",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "ko": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ bitchat으로 텍스트를 공유했습니다",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        },
+        "tr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "✓ bitchat'e metin paylaşıldı",
+            "comment": "Confirmation after successfully sharing text"
+          }
+        }
+      }
+    }
+  },
+  "version": "1.0"
+}

bitchatShareExtension/ShareViewController.swift

@@ -14,6 +14,15 @@ import UniformTypeIdentifiers
 final class ShareViewController: UIViewController {
     // Bundle.main.bundleIdentifier would get the extension's bundleID
     private static let groupID = "group.chat.bitchat"
+
+    private enum Strings {
+        static let nothingToShare = String(localized: "share.status.nothing_to_share", comment: "Shown when the share extension receives no content")
+        static let noShareableContent = String(localized: "share.status.no_shareable_content", comment: "Shown when provided content cannot be shared")
+        static let sharedLinkTitleFallback = String(localized: "share.fallback.shared_link_title", comment: "Fallback title when saving a shared link")
+        static let sharedLinkConfirmation = String(localized: "share.status.shared_link", comment: "Confirmation after successfully sharing a link")
+        static let sharedTextConfirmation = String(localized: "share.status.shared_text", comment: "Confirmation after successfully sharing text")
+        static let failedToEncode = String(localized: "share.status.failed_to_encode", comment: "Shown when the share payload cannot be encoded")
+    }
     
     private let statusLabel: UILabel = {
         let l = UILabel()
@@ -35,15 +44,16 @@ final class ShareViewController: UIViewController {
             statusLabel.leadingAnchor.constraint(greaterThanOrEqualTo: view.layoutMarginsGuide.leadingAnchor),
             statusLabel.trailingAnchor.constraint(lessThanOrEqualTo: view.layoutMarginsGuide.trailingAnchor)
         ])
-
+        DispatchQueue.global().async {
-        processShare()
+            self.processShare()
+        }
     }
 
     // MARK: - Processing
     private func processShare() {
         guard let ctx = self.extensionContext,
               let item = ctx.inputItems.first as? NSExtensionItem else {
-            finishWithMessage("Nothing to share")
+            finishWithMessage(Strings.nothingToShare)
             return
         }
 
@@ -60,7 +70,7 @@ final class ShareViewController: UIViewController {
             if let title = item.attributedTitle?.string, !title.isEmpty {
                 saveAndFinish(text: title)
             } else {
-                finishWithMessage("No shareable content")
+                finishWithMessage(Strings.noShareableContent)
             }
             return
         }
@@ -80,7 +90,7 @@ final class ShareViewController: UIViewController {
                             self.saveAndFinish(text: t)
                         }
                     } else {
-                        self.finishWithMessage("No shareable content")
+                        self.finishWithMessage(Strings.noShareableContent)
                     }
                 }
             }
@@ -135,20 +145,20 @@ final class ShareViewController: UIViewController {
     private func saveAndFinish(url: URL, title: String?) {
         let payload: [String: String] = [
             "url": url.absoluteString,
-            "title": title ?? url.host ?? "Shared Link"
+            "title": title ?? url.host ?? Strings.sharedLinkTitleFallback
         ]
         if let json = try? JSONSerialization.data(withJSONObject: payload),
            let s = String(data: json, encoding: .utf8) {
             saveToSharedDefaults(content: s, type: "url")
-            finishWithMessage("✓ Shared link to bitchat")
+            finishWithMessage(Strings.sharedLinkConfirmation)
         } else {
-            finishWithMessage("Failed to encode link")
+            finishWithMessage(Strings.failedToEncode)
         }
     }
 
     private func saveAndFinish(text: String) {
         saveToSharedDefaults(content: text, type: "text")
-        finishWithMessage("✓ Shared text to bitchat")
+        finishWithMessage(Strings.sharedTextConfirmation)
     }
 
     private func saveToSharedDefaults(content: String, type: String) {
@@ -163,7 +173,7 @@ final class ShareViewController: UIViewController {
         statusLabel.text = msg
         // Complete shortly after showing status
         DispatchQueue.main.asyncAfter(deadline: .now() + TransportConfig.uiShareExtensionDismissDelaySeconds) {
-            self.extensionContext?.completeRequest(returningItems: nil, completionHandler: nil)
+            self.extensionContext?.completeRequest(returningItems: [], completionHandler: nil)
         }
     }
 }

bitchatTests/BLEServiceTests.swift

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

bitchatTests/CommandProcessorTests.swift

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

bitchatTests/EndToEnd/PrivateChatE2ETests.swift

@@ -6,115 +6,107 @@
 // For more information, see <https://unlicense.org>
 //
 
-import XCTest
+import Testing
 import CryptoKit
+import struct Foundation.UUID
 @testable import bitchat
 
-final class PrivateChatE2ETests: XCTestCase {
+struct PrivateChatE2ETests {
     
-    var alice: MockBluetoothMeshService!
+    private let alice: MockBLEService
-    var bob: MockBluetoothMeshService!
+    private let bob: MockBLEService
-    var charlie: MockBluetoothMeshService!
+    private let charlie: MockBLEService
+    private let mockKeychain = MockKeychain()
+    private let bus = MockBLEBus()
     
-    private var mockKeychain: MockKeychain!
+    init() {
-    
+        // Create services with unique peer IDs to avoid any collision
-    override func setUp() {
+        alice = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname1, bus: bus)
-        super.setUp()
+        bob = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname2, bus: bus)
-        MockBLEService.resetTestBus()
+        charlie = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname3, bus: bus)
-        
-        // Create services
-        alice = createMockService(peerID: TestConstants.testPeerID1, nickname: TestConstants.testNickname1)
-        bob = createMockService(peerID: TestConstants.testPeerID2, nickname: TestConstants.testNickname2)
-        charlie = createMockService(peerID: TestConstants.testPeerID3, nickname: TestConstants.testNickname3)
-        mockKeychain = MockKeychain()
-        
-        // Delivery tracking is now handled internally by BLEService
-    }
-    
-    override func tearDown() {
-        alice = nil
-        bob = nil
-        charlie = nil
-        mockKeychain = nil
-        super.tearDown()
     }
     
     // MARK: - Basic Private Messaging Tests
-    
+
-    func testSimplePrivateMessage() {
+    @Test func simplePrivateMessageShouldNotBeSentWithoutConnection() async {
-        simulateConnection(alice, bob)
+        // Intentionally not connecting alice and bob to test
-        
+
-        let expectation = XCTestExpectation(description: "Bob receives private message")
+        var bobReceivedMessage = false
-        
+
-        bob.messageDeliveryHandler = { message in
+        await confirmation("Bob should not receive a private message", expectedCount: 0) { bobReceivesMessage in
-            if message.content == TestConstants.testMessage1 && 
+            bob.messageDeliveryHandler = { message in
-               message.isPrivate &&
+                if message.content == TestConstants.testMessage1 &&
-               message.sender == TestConstants.testNickname1 {
+                   message.isPrivate &&
-                expectation.fulfill()
+                   message.sender == TestConstants.testNickname1 {
+                    bobReceivedMessage = true
+                    bobReceivesMessage()
+                }
             }
-        }
+
-        
+            // Alice sends private message to Bob
-        // Alice sends private message to Bob
+            alice.sendPrivateMessage(
-        alice.sendPrivateMessage(
-            TestConstants.testMessage1,
-            to: TestConstants.testPeerID2,
-            recipientNickname: TestConstants.testNickname2
-        )
-        
-        wait(for: [expectation], timeout: TestConstants.shortTimeout)
-    }
-    
-    func testPrivateMessageNotReceivedByOthers() {
-        // Connect all three
-        simulateConnection(alice, bob)
-        simulateConnection(alice, charlie)
-        
-        let bobExpectation = XCTestExpectation(description: "Bob receives private message")
-        let charlieExpectation = XCTestExpectation(description: "Charlie should not receive")
-        charlieExpectation.isInverted = true
-        
-        bob.messageDeliveryHandler = { message in
-            if message.content == TestConstants.testMessage1 && message.isPrivate {
-                bobExpectation.fulfill()
-            }
-        }
-        
-        charlie.messageDeliveryHandler = { message in
-            if message.content == TestConstants.testMessage1 {
-                charlieExpectation.fulfill() // Should not happen
-            }
-        }
-        
-        // Small delay to ensure connections are registered before send
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
-            // Alice sends private message to Bob only
-            self.alice.sendPrivateMessage(
                 TestConstants.testMessage1,
-                to: TestConstants.testPeerID2,
+                to: bob.peerID,
+                recipientNickname: TestConstants.testNickname2
+            )
+
+            // Wait a bit to ensure message would have been delivered if it was going to be
+            try? await sleep(0.1)
+        }
+
+        #expect(!bobReceivedMessage, "Bob should not have received the message")
+    }
+
+    @Test func simplePrivateMessage() async {
+        alice.simulateConnection(with: bob)
+        
+        await confirmation("Bob receives private message") { bobReceivesMessage in
+            bob.messageDeliveryHandler = { message in
+                if message.content == TestConstants.testMessage1 &&
+                   message.isPrivate &&
+                   message.sender == TestConstants.testNickname1 {
+                    bobReceivesMessage()
+                }
+            }
+            
+            // Alice sends private message to Bob
+            alice.sendPrivateMessage(
+                TestConstants.testMessage1,
+                to: bob.peerID,
                 recipientNickname: TestConstants.testNickname2
             )
         }
-        
-        wait(for: [bobExpectation, charlieExpectation], timeout: TestConstants.shortTimeout)
     }
     
-    // MARK: - Delivery Acknowledgment Tests
+    @Test func privateMessageNotReceivedByOthers() async {
-    
+        alice.simulateConnection(with: bob)
-    // NOTE: DeliveryTracker has been removed in BLEService.
+        alice.simulateConnection(with: charlie)
-    // Delivery tracking is now handled internally.
+        
-    
+        await confirmation("Bob receives private message") { bobReceivesMessage in
-    
+            bob.messageDeliveryHandler = { message in
-    // MARK: - Message Retry Tests
+                if message.content == TestConstants.testMessage1 && message.isPrivate {
-    
+                    bobReceivesMessage()
-    // NOTE: MessageRetryService has been removed in BLEService.
+                }
-    // Retry logic is now handled internally.
+            }
-    
+            
-    
+            charlie.messageDeliveryHandler = { message in
+                if message.content == TestConstants.testMessage1 {
+                    Issue.record("Charlie should not receive")
+                }
+            }
+
+            alice.sendPrivateMessage(
+                TestConstants.testMessage1,
+                to: bob.peerID,
+                recipientNickname: TestConstants.testNickname2
+            )
+        }
+    }
     
     // MARK: - End-to-End Encryption Tests
     
-    func testPrivateMessageEncryption() {
+    @Test func privateMessageEncryption() async {
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
         
         // Setup Noise sessions
         let aliceKey = Curve25519.KeyAgreement.PrivateKey()
@@ -125,175 +117,144 @@ final class PrivateChatE2ETests: XCTestCase {
         
         // Establish encrypted session
         do {
-            let handshake1 = try aliceManager.initiateHandshake(with: TestConstants.testPeerID2)
+            let handshake1 = try aliceManager.initiateHandshake(with: bob.peerID)
-            let handshake2 = try bobManager.handleIncomingHandshake(from: TestConstants.testPeerID1, message: handshake1)!
+            let handshake2 = try bobManager.handleIncomingHandshake(from: alice.peerID, message: handshake1)!
-            let handshake3 = try aliceManager.handleIncomingHandshake(from: TestConstants.testPeerID2, message: handshake2)!
+            let handshake3 = try aliceManager.handleIncomingHandshake(from: bob.peerID, message: handshake2)!
-            _ = try bobManager.handleIncomingHandshake(from: TestConstants.testPeerID1, message: handshake3)
+            _ = try bobManager.handleIncomingHandshake(from: alice.peerID, message: handshake3)
         } catch {
-            XCTFail("Failed to establish Noise session: \(error)")
+            Issue.record("Failed to establish Noise session: \(error)")
         }
         
-        let expectation = XCTestExpectation(description: "Encrypted message received")
+        await confirmation("Encrypted message received") { receiveEncryptedMessage in
-        
+            // Setup packet handlers for encryption
-        // Setup packet handlers for encryption
+            alice.packetDeliveryHandler = { packet in
-        alice.packetDeliveryHandler = { packet in
+                // Encrypt outgoing private messages
-            // Encrypt outgoing private messages
+                if packet.type == 0x01,
-            if packet.type == 0x01,
+                   let message = BitchatMessage(packet.payload),
-               let message = BitchatMessage(packet.payload),
+                   message.isPrivate {
-               message.isPrivate {
+                    do {
-                do {
+                        let encrypted = try aliceManager.encrypt(packet.payload, for: bob.peerID)
-                    let encrypted = try aliceManager.encrypt(packet.payload, for: TestConstants.testPeerID2)
+                        let encryptedPacket = BitchatPacket(
-                    let encryptedPacket = BitchatPacket(
+                            type: 0x02, // Encrypted message type
-                        type: 0x02, // Encrypted message type
+                            senderID: packet.senderID,
-                        senderID: packet.senderID,
+                            recipientID: packet.recipientID,
-                        recipientID: packet.recipientID,
+                            timestamp: packet.timestamp,
-                        timestamp: packet.timestamp,
+                            payload: encrypted,
-                        payload: encrypted,
+                            signature: packet.signature,
-                        signature: packet.signature,
+                            ttl: packet.ttl
-                        ttl: packet.ttl
+                        )
-                    )
+                        self.bob.simulateIncomingPacket(encryptedPacket)
-                    self.bob.simulateIncomingPacket(encryptedPacket)
+                    } catch {
-                } catch {
+                        Issue.record("Encryption failed: \(error)")
-                    XCTFail("Encryption failed: \(error)")
-                }
-            }
-        }
-        
-        bob.packetDeliveryHandler = { packet in
-            // Decrypt incoming encrypted messages
-            if packet.type == 0x02 {
-                do {
-                    let decrypted = try bobManager.decrypt(packet.payload, from: TestConstants.testPeerID1)
-                    if let message = BitchatMessage(decrypted) {
-                        XCTAssertEqual(message.content, TestConstants.testMessage1)
-                        XCTAssertTrue(message.isPrivate)
-                        expectation.fulfill()
                     }
-                } catch {
-                    XCTFail("Decryption failed: \(error)")
                 }
             }
+            
+            bob.packetDeliveryHandler = { packet in
+                // Decrypt incoming encrypted messages
+                if packet.type == 0x02 {
+                    do {
+                        let decrypted = try bobManager.decrypt(packet.payload, from: alice.peerID)
+                        if let message = BitchatMessage(decrypted) {
+                            #expect(message.content == TestConstants.testMessage1)
+                            #expect(message.isPrivate)
+                            receiveEncryptedMessage()
+                        }
+                    } catch {
+                        Issue.record("Decryption failed: \(error)")
+                    }
+                }
+            }
+            
+            // Send encrypted private message
+            alice.sendPrivateMessage(
+                TestConstants.testMessage1,
+                to: bob.peerID,
+                recipientNickname: TestConstants.testNickname2
+            )
         }
-        
-        // Send encrypted private message
-        alice.sendPrivateMessage(
-            TestConstants.testMessage1,
-            to: TestConstants.testPeerID2,
-            recipientNickname: TestConstants.testNickname2
-        )
-        
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
     // MARK: - Multi-hop Private Message Tests
     
-    func testPrivateMessageRelay() {
+    @Test func privateMessageRelay() async {
         // Setup: Alice -> Bob -> Charlie
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
-        simulateConnection(bob, charlie)
+        bob.simulateConnection(with: charlie)
         
-        let expectation = XCTestExpectation(description: "Private message relayed to Charlie")
+        await confirmation("Private message relayed to Charlie") { charlieReceivesMessage in
-        
+            // Bob relays private messages for Charlie
-        // Bob relays private messages for Charlie
+            bob.packetDeliveryHandler = { packet in
-        bob.packetDeliveryHandler = { packet in
+                if let recipientID = packet.recipientID,
-            if let recipientID = packet.recipientID,
+                   String(data: recipientID, encoding: .utf8) == charlie.peerID {
-               String(data: recipientID, encoding: .utf8) == TestConstants.testPeerID3 {
+                    // Relay to Charlie
-                // Relay to Charlie
+                    var relayPacket = packet
-                var relayPacket = packet
+                    relayPacket.ttl = packet.ttl - 1
-                relayPacket.ttl = packet.ttl - 1
+                    self.charlie.simulateIncomingPacket(relayPacket)
-                self.charlie.simulateIncomingPacket(relayPacket)
+                }
             }
-        }
+            
-        
+            charlie.messageDeliveryHandler = { message in
-        charlie.messageDeliveryHandler = { message in
+                if message.content == TestConstants.testMessage1 &&
-            if message.content == TestConstants.testMessage1 &&
+                    message.isPrivate &&
-               message.isPrivate &&
+                    message.recipientNickname == TestConstants.testNickname3 {
-               message.recipientNickname == TestConstants.testNickname3 {
+                    charlieReceivesMessage()
-                expectation.fulfill()
+                }
             }
+            
+            // Alice sends private message to Charlie (through Bob)
+            alice.sendPrivateMessage(
+                TestConstants.testMessage1,
+                to: charlie.peerID,
+                recipientNickname: TestConstants.testNickname3
+            )
         }
-        
-        // Alice sends private message to Charlie (through Bob)
-        alice.sendPrivateMessage(
-            TestConstants.testMessage1,
-            to: TestConstants.testPeerID3,
-            recipientNickname: TestConstants.testNickname3
-        )
-        
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
     // MARK: - Performance Tests
     
-    func testPrivateMessageThroughput() {
+    @Test func privateMessageThroughput() async {
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
         
         let messageCount = 100
         var receivedCount = 0
-        let expectation = XCTestExpectation(description: "All private messages received")
         
-        bob.messageDeliveryHandler = { message in
+        await confirmation("All private messages received") { receivePrivateMessage in
-            if message.isPrivate && message.sender == TestConstants.testNickname1 {
+            bob.messageDeliveryHandler = { message in
-                receivedCount += 1
+                if message.isPrivate && message.sender == TestConstants.testNickname1 {
-                if receivedCount == messageCount {
+                    receivedCount += 1
-                    expectation.fulfill()
+                    if receivedCount == messageCount {
+                        receivePrivateMessage()
+                    }
                 }
             }
+            
+            // Send many private messages
+            for i in 0..<messageCount {
+                alice.sendPrivateMessage(
+                    "Private message \(i)",
+                    to: bob.peerID,
+                    recipientNickname: TestConstants.testNickname2
+                )
+            }
         }
-        
+    }
-        // Send many private messages
+
-        for i in 0..<messageCount {
+    @Test func largePrivateMessage() async {
+        alice.simulateConnection(with: bob)
+
+        await confirmation("Large private message received") { receiveLargeMessage in
+            bob.messageDeliveryHandler = { message in
+                if message.content == TestConstants.testLongMessage && message.isPrivate {
+                    receiveLargeMessage()
+                }
+            }
+
             alice.sendPrivateMessage(
-                "Private message \(i)",
+                TestConstants.testLongMessage,
-                to: TestConstants.testPeerID2,
+                to: bob.peerID,
                 recipientNickname: TestConstants.testNickname2
             )
         }
-        
-        wait(for: [expectation], timeout: TestConstants.longTimeout)
-        XCTAssertEqual(receivedCount, messageCount)
-    }
-    
-    func testLargePrivateMessage() {
-        simulateConnection(alice, bob)
-        
-        let expectation = XCTestExpectation(description: "Large private message received")
-        
-        bob.messageDeliveryHandler = { message in
-            if message.content == TestConstants.testLongMessage && message.isPrivate {
-                expectation.fulfill()
-            }
-        }
-        
-        alice.sendPrivateMessage(
-            TestConstants.testLongMessage,
-            to: TestConstants.testPeerID2,
-            recipientNickname: TestConstants.testNickname2
-        )
-        
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
-    }
-    
-    // MARK: - Error Handling Tests
-    
-    // NOTE: This test relied on MessageRetryService which has been removed
-    
-    func testDuplicateAckPrevention() throws {
-        throw XCTSkip("DeliveryTracker/ACK flow removed; test not applicable")
-    }
-    
-    // MARK: - Helper Methods
-    
-    private func createMockService(peerID: String, nickname: String) -> MockBluetoothMeshService {
-        let service = MockBluetoothMeshService()
-        service.myPeerID = peerID
-        service.mockNickname = nickname
-        service._testRegister()
-        return service
-    }
-    
-    private func simulateConnection(_ peer1: MockBluetoothMeshService, _ peer2: MockBluetoothMeshService) {
-        peer1.simulateConnectedPeer(peer2.peerID)
-        peer2.simulateConnectedPeer(peer1.peerID)
     }
 }

bitchatTests/EndToEnd/PublicChatE2ETests.swift

@@ -6,440 +6,389 @@
 // For more information, see <https://unlicense.org>
 //
 
-import XCTest
+import Testing
+import struct Foundation.UUID
 @testable import bitchat
 
-final class PublicChatE2ETests: XCTestCase {
+struct PublicChatE2ETests {
     
-    var alice: MockBluetoothMeshService!
+    private let alice: MockBLEService
-    var bob: MockBluetoothMeshService!
+    private let bob: MockBLEService
-    var charlie: MockBluetoothMeshService!
+    private let charlie: MockBLEService
-    var david: MockBluetoothMeshService!
+    private let david: MockBLEService
+    private let bus = MockBLEBus()
     
-    var receivedMessages: [String: [BitchatMessage]] = [:]
+    private var receivedMessages: [String: [BitchatMessage]] = [:]
     
-    override func setUp() {
+    init() {
-        super.setUp()
+        // Create mock services with unique peer IDs to avoid any collision
-        MockBLEService.resetTestBus()
+        alice = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname1, bus: bus)
-        
+        bob = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname2, bus: bus)
-        // Create mock services
+        charlie = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname3, bus: bus)
-        alice = createMockService(peerID: TestConstants.testPeerID1, nickname: TestConstants.testNickname1)
+        david = MockBLEService(peerID: PeerID(str: UUID().uuidString), nickname: TestConstants.testNickname4, bus: bus)
-        bob = createMockService(peerID: TestConstants.testPeerID2, nickname: TestConstants.testNickname2)
-        charlie = createMockService(peerID: TestConstants.testPeerID3, nickname: TestConstants.testNickname3)
-        david = createMockService(peerID: TestConstants.testPeerID4, nickname: TestConstants.testNickname4)
-        
-        // Clear received messages
-        receivedMessages.removeAll()
-    }
-    
-    override func tearDown() {
-        alice = nil
-        bob = nil
-        charlie = nil
-        david = nil
-        super.tearDown()
     }
     
     // MARK: - Basic Broadcasting Tests
     
-    func testSimplePublicMessage() {
+    @Test func simplePublicMessage() async {
-        // Connect Alice and Bob
+        alice.simulateConnection(with: bob)
-        simulateConnection(alice, bob)
         
-        let expectation = XCTestExpectation(description: "Bob receives message")
+        await confirmation("Bob receives message") { bobReceivesMessage in
-        
+            bob.messageDeliveryHandler = { message in
-        bob.messageDeliveryHandler = { message in
+                if message.content == TestConstants.testMessage1 && message.sender == TestConstants.testNickname1 {
-            if message.content == TestConstants.testMessage1 && message.sender == TestConstants.testNickname1 {
+                    bobReceivesMessage()
-                expectation.fulfill()
+                }
             }
+            
+            alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
         }
-        
-        // Alice sends public message
-        alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
-        
-        wait(for: [expectation], timeout: TestConstants.shortTimeout)
     }
     
-    func testMultiRecipientBroadcast() {
+    @Test func multiRecipientBroadcast() async {
-        // Connect Alice to Bob and Charlie
+        alice.simulateConnection(with: bob)
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: charlie)
-        simulateConnection(alice, charlie)
         
-        let bobExpectation = XCTestExpectation(description: "Bob receives message")
+        var bobReceivedMessage = false
-        let charlieExpectation = XCTestExpectation(description: "Charlie receives message")
+        var charlieReceivedMessage = false
         
-        bob.messageDeliveryHandler = { message in
+        await confirmation("Both recieve message", expectedCount: 2) { receiveMessage in
-            if message.content == TestConstants.testMessage1 {
+            bob.messageDeliveryHandler = { message in
-                bobExpectation.fulfill()
+                if message.content == TestConstants.testMessage1 {
+                    if !bobReceivedMessage {
+                        bobReceivedMessage = true
+                        receiveMessage()
+                    } else {
+                        Issue.record("Bob received more than once")
+                    }
+                }
             }
-        }
+            
-        
+            charlie.messageDeliveryHandler = { message in
-        charlie.messageDeliveryHandler = { message in
+                if message.content == TestConstants.testMessage1 {
-            if message.content == TestConstants.testMessage1 {
+                    if !charlieReceivedMessage {
-                charlieExpectation.fulfill()
+                        charlieReceivedMessage = true
+                        receiveMessage()
+                    } else {
+                        Issue.record("Charlie received more than once")
+                    }
+                }
             }
+            
+            alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
         }
-        
-        // Alice broadcasts
-        alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
-        
-        wait(for: [bobExpectation, charlieExpectation], timeout: TestConstants.shortTimeout)
     }
     
     // MARK: - Message Routing and Relay Tests
     
-    func testMessageRelayChain() {
+    @Test func messageRelayChain() async {
         // Linear topology: Alice -> Bob -> Charlie
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
-        simulateConnection(bob, charlie)
+        bob.simulateConnection(with: charlie)
-        
+
-        let expectation = XCTestExpectation(description: "Charlie receives relayed message")
+        await confirmation("Charlie receives relayed message") { charlieReceivesMessage in
-        
+            // Set up relay in Bob
-        // Set up relay in Bob
+            bob.packetDeliveryHandler = { packet in
-        bob.packetDeliveryHandler = { packet in
+                // Bob should relay to Charlie
-            // Bob should relay to Charlie
+                if let message = BitchatMessage(packet.payload),
-            if let message = BitchatMessage(packet.payload),
+                   message.sender == TestConstants.testNickname1 {
-               message.sender == TestConstants.testNickname1 {
+
-                
+                    // Create relay message
-                // Create relay message
+                    let relayMessage = BitchatMessage(
-                let relayMessage = BitchatMessage(
+                        id: message.id,
-                    id: message.id,
+                        sender: message.sender,
-                    sender: message.sender,
+                        content: message.content,
-                    content: message.content,
+                        timestamp: message.timestamp,
-                    timestamp: message.timestamp,
+                        isRelay: true,
-                    isRelay: true,
+                        originalSender: message.sender,
-                    originalSender: message.sender,
+                        isPrivate: message.isPrivate,
-                    isPrivate: message.isPrivate,
+                        recipientNickname: message.recipientNickname,
-                    recipientNickname: message.recipientNickname,
+                        senderPeerID: message.senderPeerID,
-                    senderPeerID: message.senderPeerID,
+                        mentions: message.mentions
-                    mentions: message.mentions
-                )
-                
-                if let relayPayload = relayMessage.toBinaryPayload() {
-                    let relayPacket = BitchatPacket(
-                        type: packet.type,
-                        senderID: packet.senderID,
-                        recipientID: packet.recipientID,
-                        timestamp: packet.timestamp,
-                        payload: relayPayload,
-                        signature: packet.signature,
-                        ttl: packet.ttl - 1
                     )
-                    
+
-                    // Simulate relay to Charlie
+                    if let relayPayload = relayMessage.toBinaryPayload() {
-                    self.charlie.simulateIncomingPacket(relayPacket)
+                        let relayPacket = BitchatPacket(
+                            type: packet.type,
+                            senderID: packet.senderID,
+                            recipientID: packet.recipientID,
+                            timestamp: packet.timestamp,
+                            payload: relayPayload,
+                            signature: packet.signature,
+                            ttl: packet.ttl - 1
+                        )
+
+                        // Simulate relay to Charlie
+                        self.charlie.simulateIncomingPacket(relayPacket)
+                    }
                 }
             }
-        }
+
-        
+            charlie.messageDeliveryHandler = { message in
-        charlie.messageDeliveryHandler = { message in
+                if message.content == TestConstants.testMessage1 &&
-            if message.content == TestConstants.testMessage1 &&
+                   message.originalSender == TestConstants.testNickname1 &&
-               message.originalSender == TestConstants.testNickname1 &&
+                   message.isRelay {
-               message.isRelay {
+                    charlieReceivesMessage()
-                expectation.fulfill()
+                }
             }
+
+            alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
         }
-        
-        // Alice sends message
-        alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
-        
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
-    func testMultiHopRelay() {
+    @Test func multiHopRelay() async {
         // Topology: Alice -> Bob -> Charlie -> David
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
-        simulateConnection(bob, charlie)
+        bob.simulateConnection(with: charlie)
-        simulateConnection(charlie, david)
+        charlie.simulateConnection(with: david)
         
-        let expectation = XCTestExpectation(description: "David receives multi-hop message")
+        await confirmation("David receives multi-hop message") { davidReceivesMessage in
-        
+            // Set up relay chain
-        // Set up relay chain
+            setupRelayHandler(bob, nextHops: [charlie])
-        setupRelayHandler(bob, nextHops: [charlie])
+            setupRelayHandler(charlie, nextHops: [david])
-        setupRelayHandler(charlie, nextHops: [david])
+            
-        // Allow handlers to install
+            david.messageDeliveryHandler = { message in
-        let sendDelay = DispatchTime.now() + 0.05
+                if message.content == TestConstants.testMessage1 &&
-        
+                   message.originalSender == TestConstants.testNickname1 &&
-        david.messageDeliveryHandler = { message in
+                   message.isRelay {
-            if message.content == TestConstants.testMessage1 &&
+                    davidReceivesMessage()
-               message.originalSender == TestConstants.testNickname1 &&
+                }
-               message.isRelay {
-                expectation.fulfill()
             }
+            
+            alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
         }
-        
-        // Alice sends message
-        DispatchQueue.main.asyncAfter(deadline: sendDelay) {
-            self.alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
-        }
-        
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
     // MARK: - TTL (Time To Live) Tests
     
-    func testTTLDecrement() {
+    @Test func ttlDecrement() async {
         // Create a chain longer than TTL
-        let nodes = [alice!, bob!, charlie!, david!]
+        let nodes = [alice, bob, charlie, david]
         
         // Connect in chain
         for i in 0..<nodes.count-1 {
-            simulateConnection(nodes[i], nodes[i+1])
+            nodes[i].simulateConnection(with: nodes[i+1])
             if i > 0 && i < nodes.count-1 {
                 setupRelayHandler(nodes[i], nextHops: [nodes[i+1]])
             }
         }
         
-        let expectation = XCTestExpectation(description: "Message dropped due to TTL")
+        await confirmation("Message dropped due to TTL", expectedCount: 0) { receiveMessage in
-        expectation.isInverted = true // Should NOT be fulfilled
+            david.messageDeliveryHandler = { message in
-        
+                if message.content == TestConstants.testMessage1 {
-        david.messageDeliveryHandler = { message in
+                    receiveMessage() // This should not happen
-            if message.content == TestConstants.testMessage1 {
+                }
-                expectation.fulfill() // This should not happen
+            }
+            
+            // Inject at Bob with TTL=2 so Charlie sees it (TTL->1) and does not relay to David
+            let msg = TestHelpers.createTestMessage(
+                content: TestConstants.testMessage1,
+                sender: TestConstants.testNickname1,
+                senderPeerID: alice.peerID
+            )
+
+            if let payload = msg.toBinaryPayload() {
+                let pkt = TestHelpers.createTestPacket(senderID: alice.peerID, payload: payload, ttl: 2)
+                bob.simulateIncomingPacket(pkt)
             }
         }
-        
-        // Inject at Bob with TTL=2 so Charlie sees it (TTL->1) and does not relay to David
-        let msg = TestHelpers.createTestMessage(content: TestConstants.testMessage1, sender: TestConstants.testNickname1, senderPeerID: alice.peerID)
-        if let payload = msg.toBinaryPayload() {
-            let pkt = TestHelpers.createTestPacket(senderID: alice.peerID, payload: payload, ttl: 2)
-            bob.simulateIncomingPacket(pkt)
-        }
-        
-        wait(for: [expectation], timeout: TestConstants.shortTimeout)
     }
     
-    func testZeroTTLNotRelayed() {
+    @Test func zeroTTLNotRelayed() async {
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
-        simulateConnection(bob, charlie)
+        bob.simulateConnection(with: charlie)
         
-        let expectation = XCTestExpectation(description: "Zero TTL message not relayed")
+        await confirmation("Zero TTL message not relayed", expectedCount: 0) { receiveMessage in
-        expectation.isInverted = true
+            charlie.messageDeliveryHandler = { message in
-        
+                if message.content == "Zero TTL message" {
-        charlie.messageDeliveryHandler = { message in
+                    receiveMessage() // Should not happen
-            if message.content == "Zero TTL message" {
+                }
-                expectation.fulfill() // Should not happen
+            }
+            
+            // Create packet with TTL=0
+            let message = TestHelpers.createTestMessage(content: "Zero TTL message")
+            if let payload = message.toBinaryPayload() {
+                let packet = TestHelpers.createTestPacket(payload: payload, ttl: 0)
+                alice.simulateIncomingPacket(packet)
             }
         }
-        
-        // Create packet with TTL=0
-        let message = TestHelpers.createTestMessage(content: "Zero TTL message")
-        if let payload = message.toBinaryPayload() {
-            let packet = TestHelpers.createTestPacket(payload: payload, ttl: 0)
-            alice.simulateIncomingPacket(packet)
-        }
-        
-        wait(for: [expectation], timeout: TestConstants.shortTimeout)
     }
     
     // MARK: - Duplicate Detection Tests
     
-    func testDuplicateMessagePrevention() {
+    @Test func duplicateMessagePrevention() async {
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
         
         var messageCount = 0
-        let expectation = XCTestExpectation(description: "Only one message received")
         
-        bob.messageDeliveryHandler = { message in
+        await confirmation("Only one message received") { receiveMessage in
-            if message.content == TestConstants.testMessage1 {
+            bob.messageDeliveryHandler = { message in
-                messageCount += 1
+                if message.content == TestConstants.testMessage1 {
-                if messageCount == 1 {
+                    receiveMessage()
-                    // Send duplicate after small delay
+                    messageCount += 1
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                    if messageCount == 1 {
-                        self.alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil, messageID: message.id)
+                        // Send duplicate after small delay
+                        alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil, messageID: message.id)
+                    } else {
+                        Issue.record("Duplicate message was not filtered")
                     }
-                } else {
-                    XCTFail("Duplicate message was not filtered")
                 }
             }
+            
+            // Send original message
+            alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
         }
+    }
+    
+    @Test func duplicateContentAsNewMessageNotPrevented() async {
+        alice.simulateConnection(with: bob)
         
-        // Send original message
+        var messageCount = 0
-        alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
         
-        // Wait to ensure duplicate would have been received
+        await confirmation("Only one message received", expectedCount: 2) { receiveMessage in
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+            bob.messageDeliveryHandler = { message in
-            XCTAssertEqual(messageCount, 1)
+                if message.content == TestConstants.testMessage1 {
-            expectation.fulfill()
+                    receiveMessage()
+                    messageCount += 1
+                    if messageCount == 1 {
+                        // Send the same content as a new message
+                        alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
+                    }
+                }
+            }
+            
+            // Send original message
+            alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
         }
-        
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
     // MARK: - Mention Tests
     
-    func testMessageWithMentions() {
+    @Test func messageWithMentions() async {
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
-        simulateConnection(alice, charlie)
+        alice.simulateConnection(with: charlie)
-        
-        let expectation = XCTestExpectation(description: "Mentioned users receive notification")
         
         var mentionedUsers: Set<String> = []
         
-        bob.messageDeliveryHandler = { message in
+        await confirmation("Mentioned users receive notification", expectedCount: 2) { receiveMention in
-            if let mentions = message.mentions, mentions.contains(TestConstants.testNickname2) {
+            bob.messageDeliveryHandler = { message in
-                mentionedUsers.insert(TestConstants.testNickname2)
+                if message.mentions?.contains(TestConstants.testNickname2) == true {
+                    mentionedUsers.insert(TestConstants.testNickname2)
+                    receiveMention()
+                }
             }
-        }
+            
-        
+            charlie.messageDeliveryHandler = { message in
-        charlie.messageDeliveryHandler = { message in
+                if message.mentions?.contains(TestConstants.testNickname3) == true {
-            if let mentions = message.mentions, mentions.contains(TestConstants.testNickname3) {
+                    mentionedUsers.insert(TestConstants.testNickname3)
-                mentionedUsers.insert(TestConstants.testNickname3)
+                    receiveMention()
+                }
             }
+            
+            // Alice mentions Bob and Charlie
+            alice.sendMessage(
+                "Hey @\(TestConstants.testNickname2) and @\(TestConstants.testNickname3)!",
+                mentions: [TestConstants.testNickname2, TestConstants.testNickname3],
+                to: nil
+            )
         }
         
-        // Alice mentions Bob and Charlie
+        #expect(mentionedUsers == [TestConstants.testNickname2, TestConstants.testNickname3])
-        alice.sendMessage(
-            "Hey @\(TestConstants.testNickname2) and @\(TestConstants.testNickname3)!",
-            mentions: [TestConstants.testNickname2, TestConstants.testNickname3],
-            to: nil
-        )
-        
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-            XCTAssertEqual(mentionedUsers, [TestConstants.testNickname2, TestConstants.testNickname3])
-            expectation.fulfill()
-        }
-        
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
     // MARK: - Network Topology Tests
     
-    func testMeshTopologyBroadcast() {
+    @Test func meshTopologyBroadcast() async {
         // Create mesh: Everyone connected to everyone
-        let nodes = [alice!, bob!, charlie!, david!]
+        let nodes = [alice, bob, charlie, david]
         for i in 0..<nodes.count {
             for j in i+1..<nodes.count {
-                simulateConnection(nodes[i], nodes[j])
+                nodes[i].simulateConnection(with: nodes[j])
             }
         }
         
-        var receivedCount = 0
+        await confirmation("All nodes receive message", expectedCount: 3) { receiveMessage in
-        let expectation = XCTestExpectation(description: "All nodes receive message")
+            for (index, node) in nodes.enumerated() where index > 0 {
-        
+                node.messageDeliveryHandler = { message in
-        for (index, node) in nodes.enumerated() where index > 0 {
+                    if message.content == TestConstants.testMessage1 {
-            node.messageDeliveryHandler = { message in
+                        receiveMessage()
-                if message.content == TestConstants.testMessage1 {
-                    receivedCount += 1
-                    if receivedCount == 3 { // Bob, Charlie, David
-                        expectation.fulfill()
                     }
                 }
             }
+            
+            alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
         }
-        
-        // Alice broadcasts
-        alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
-        
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
-    func testPartialMeshRelay() {
+    @Test func partialMeshRelay() async {
         // Partial mesh: Alice -> Bob, Bob -> Charlie, Charlie -> David, David -> Alice
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
-        simulateConnection(bob, charlie)
+        bob.simulateConnection(with: charlie)
-        simulateConnection(charlie, david)
+        charlie.simulateConnection(with: david)
-        simulateConnection(david, alice)
+        david.simulateConnection(with: alice)
         
         // Setup relay handlers
         setupRelayHandler(bob, nextHops: [charlie])
         setupRelayHandler(charlie, nextHops: [david])
         setupRelayHandler(david, nextHops: [alice])
-        let sendDelay2 = DispatchTime.now() + 0.05
         
-        var receivedCount = 0
+        await confirmation("Message reaches all nodes once", expectedCount: 3) { receiveMessage in
-        let expectation = XCTestExpectation(description: "Message reaches all nodes once")
+            for node in [bob, charlie, david] {
-        
+                node.messageDeliveryHandler = { message in
-        let checkCompletion = {
+                    if message.content == TestConstants.testMessage1 {
-            if receivedCount == 3 { // Bob, Charlie, David should receive
+                        receiveMessage()
-                expectation.fulfill()
+                    }
-            }
-        }
-        
-        for node in [bob!, charlie!, david!] {
-            node.messageDeliveryHandler = { message in
-                if message.content == TestConstants.testMessage1 {
-                    receivedCount += 1
-                    checkCompletion()
                 }
             }
+            
+            alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
         }
-        
-        // Alice broadcasts
-        DispatchQueue.main.asyncAfter(deadline: sendDelay2) {
-            self.alice.sendMessage(TestConstants.testMessage1, mentions: [], to: nil)
-        }
-        
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
     }
     
     // MARK: - Performance and Stress Tests
     
-    func testHighVolumeMessaging() {
+    @Test func highVolumeMessaging() async {
-        simulateConnection(alice, bob)
+        alice.simulateConnection(with: bob)
         
         let messageCount = 100
-        var receivedCount = 0
-        let expectation = XCTestExpectation(description: "All messages received")
         
-        bob.messageDeliveryHandler = { message in
+        await confirmation("All messages received", expectedCount: messageCount) { receiveMessage in
-            if message.sender == TestConstants.testNickname1 {
+            bob.messageDeliveryHandler = { message in
-                receivedCount += 1
+                if message.sender == TestConstants.testNickname1 {
-                if receivedCount == messageCount {
+                    receiveMessage()
-                    expectation.fulfill()
                 }
             }
-        }
+            
-        
+            // Send many messages rapidly
-        // Send many messages rapidly
+            for i in 0..<messageCount {
-        for i in 0..<messageCount {
+                alice.sendMessage("Message \(i)", mentions: [], to: nil)
-            alice.sendMessage("Message \(i)", mentions: [], to: nil)
-        }
-        
-        wait(for: [expectation], timeout: TestConstants.longTimeout)
-        XCTAssertEqual(receivedCount, messageCount)
-    }
-    
-    func testLargeMessageBroadcast() {
-        simulateConnection(alice, bob)
-        
-        let expectation = XCTestExpectation(description: "Large message received")
-        
-        bob.messageDeliveryHandler = { message in
-            if message.content == TestConstants.testLongMessage {
-                expectation.fulfill()
             }
         }
+    }
+    
+    @Test func largeMessageBroadcast() async {
+        alice.simulateConnection(with: bob)
         
-        // Send large message
+        await confirmation("Large message received") { receiveLargeMessage in
-        alice.sendMessage(TestConstants.testLongMessage, mentions: [], to: nil)
+            bob.messageDeliveryHandler = { message in
-        
+                if message.content == TestConstants.testLongMessage {
-        wait(for: [expectation], timeout: TestConstants.defaultTimeout)
+                    receiveLargeMessage()
+                }
+            }
+            
+            alice.sendMessage(TestConstants.testLongMessage, mentions: [], to: nil)
+        }
     }
     
     // MARK: - Helper Methods
-    
+
-    private func createMockService(peerID: String, nickname: String) -> MockBluetoothMeshService {
+    private func setupRelayHandler(_ node: MockBLEService, nextHops: [MockBLEService]) {
-        let service = MockBluetoothMeshService()
-        service.myPeerID = peerID
-        service.mockNickname = nickname
-        service._testRegister()
-        return service
-    }
-    
-    private func simulateConnection(_ peer1: MockBluetoothMeshService, _ peer2: MockBluetoothMeshService) {
-        peer1.simulateConnectedPeer(peer2.peerID)
-        peer2.simulateConnectedPeer(peer1.peerID)
-    }
-    
-    private func setupRelayHandler(_ node: MockBluetoothMeshService, nextHops: [MockBluetoothMeshService]) {
         node.packetDeliveryHandler = { packet in
             // Check if should relay
             guard packet.ttl > 1 else { return }
-            
+
             if let message = BitchatMessage(packet.payload) {
                 // Don't relay own messages
-                guard message.senderPeerID != node.peerID else { return }
+                guard message.senderPeerID?.id != node.peerID else { return }
                 
                 // Create relay message
                 let relayMessage = BitchatMessage(
@@ -458,7 +407,7 @@ final class PublicChatE2ETests: XCTestCase {
                 if let relayPayload = relayMessage.toBinaryPayload() {
                     let relayPacket = BitchatPacket(
                         type: packet.type,
-                        senderID: node.peerID.data(using: .utf8)!,
+                        senderID: node.peerID.id.data(using: .utf8)!,
                         recipientID: packet.recipientID,
                         timestamp: packet.timestamp,
                         payload: relayPayload,

bitchatTests/FontBitchatTests.swift

@@ -0,0 +1,16 @@
+import SwiftUI
+import XCTest
+@testable import bitchat
+
+final class FontBitchatTests: XCTestCase {
+//    func testMonospacedMapping() {
+//        XCTAssertEqual(Font.bitchatSystem(size: 10, design: .monospaced), Font.system(.caption2, design: .monospaced))
+//        XCTAssertEqual(Font.bitchatSystem(size: 14, design: .monospaced), Font.system(.body, design: .monospaced))
+//        XCTAssertEqual(Font.bitchatSystem(size: 20, design: .monospaced), Font.system(.title2, design: .monospaced))
+//    }
+//
+//    func testWeightIsPreserved() {
+//        let bold = Font.bitchatSystem(size: 14, weight: .bold, design: .monospaced)
+//        XCTAssertEqual(bold, Font.system(.body, design: .monospaced).weight(.bold))
+//    }
+}

bitchatTests/Fragmentation/FragmentationTests.swift

@@ -6,48 +6,163 @@
 // For more information, see <https://unlicense.org>
 //
 
-import XCTest
+import Testing
+import Foundation
+import CoreBluetooth
 @testable import bitchat
 
-final class FragmentationTests: XCTestCase {
+struct FragmentationTests {
     
-    private var mockKeychain: MockKeychain!
+    private let mockKeychain: MockKeychain
-    private var mockIdentityManager: MockIdentityManager!
+    private let mockIdentityManager: MockIdentityManager
+    private let idBridge: NostrIdentityBridge
     
-    override func setUp() {
+    init() {
-        super.setUp()
         mockKeychain = MockKeychain()
         mockIdentityManager = MockIdentityManager(mockKeychain)
+        idBridge = NostrIdentityBridge(keychain: MockKeychainHelper())
     }
     
-    override func tearDown() {
+    @Test("Reassembly from fragments delivers a public message")
-        mockKeychain = nil
+    func reassemblyFromFragmentsDeliversPublicMessage() async throws {
-        mockIdentityManager = nil
+        let ble = BLEService(
-        super.tearDown()
+            keychain: mockKeychain,
+            idBridge: idBridge,
+            identityManager: mockIdentityManager
+        )
+        let capture = CaptureDelegate()
+        ble.delegate = capture
+        
+        // Construct a big packet (3KB) from a remote sender (not our own ID)
+        let remoteShortID = PeerID(str: "1122334455667788")
+        let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 3_000)
+        
+        // Use a small fragment size to ensure multiple pieces
+        let fragments = fragmentPacket(original, fragmentSize: 400)
+        
+        // Shuffle fragments to simulate out-of-order arrival
+        let shuffled = fragments.shuffled()
+        
+        // Inject fragments spaced out to avoid concurrent mutation inside BLEService
+        for (i, fragment) in shuffled.enumerated() {
+            let delay = 5 * Double(i) * 0.001
+            Task {
+                try await sleep(delay)
+                ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
+            }
+        }
+        
+        // Allow async processing
+        try await sleep(0.5)
+        
+        #expect(capture.publicMessages.count == 1)
+        #expect(capture.publicMessages.first?.content.count == 3_000)
     }
+    
+    @Test("Duplicate fragment does not break reassembly")
+    func duplicateFragmentDoesNotBreakReassembly() async throws {
+        let ble = BLEService(
+            keychain: mockKeychain,
+            idBridge: idBridge,
+            identityManager: mockIdentityManager
+        )
+        let capture = CaptureDelegate()
+        ble.delegate = capture
+        
+        let remoteShortID = PeerID(str: "A1B2C3D4E5F60708")
+        let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 2048)
+        var frags = fragmentPacket(original, fragmentSize: 300)
+        
+        // Duplicate one fragment
+        if let dup = frags.first {
+            frags.insert(dup, at: 1)
+        }
+        
+        for (i, fragment) in frags.enumerated() {
+            let delay = 5 * Double(i) * 0.001
+            Task {
+                try await sleep(delay)
+                ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
+            }
+        }
+        
+        // Allow async processing
+        try await sleep(0.5)
 
+        #expect(capture.publicMessages.count == 1)
+        #expect(capture.publicMessages.first?.content.count == 2048)
+    }
+    
+    @Test("Invalid fragment header is ignored")
+    func invalidFragmentHeaderIsIgnored() async throws {
+        let ble = BLEService(
+            keychain: mockKeychain,
+            idBridge: idBridge,
+            identityManager: mockIdentityManager
+        )
+        let capture = CaptureDelegate()
+        ble.delegate = capture
+        
+        let remoteShortID = PeerID(str: "0011223344556677")
+        let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 1000)
+        let fragments = fragmentPacket(original, fragmentSize: 250)
+        
+        // Corrupt one fragment: make payload too short (header incomplete)
+        var corrupted = fragments
+        if !corrupted.isEmpty {
+            var p = corrupted[0]
+            p = BitchatPacket(
+                type: p.type,
+                senderID: p.senderID,
+                recipientID: p.recipientID,
+                timestamp: p.timestamp,
+                payload: Data([0x00, 0x01, 0x02]), // invalid header
+                signature: nil,
+                ttl: p.ttl
+            )
+            corrupted[0] = p
+        }
+        
+        for (i, fragment) in corrupted.enumerated() {
+            let delay = 5 * Double(i) * 0.001
+            Task {
+                try await sleep(delay)
+                ble._test_handlePacket(fragment, fromPeerID: remoteShortID)
+            }
+        }
+        
+        // Allow async processing
+        try await sleep(0.5)
+
+        // Should not deliver since one fragment is invalid and reassembly can't complete
+        #expect(capture.publicMessages.isEmpty)
+    }
+}
+
+extension FragmentationTests {
     private final class CaptureDelegate: BitchatDelegate {
-        var publicMessages: [(peerID: String, nickname: String, content: String)] = []
+        var publicMessages: [(peerID: PeerID, nickname: String, content: String)] = []
         func didReceiveMessage(_ message: BitchatMessage) {}
-        func didConnectToPeer(_ peerID: String) {}
+        func didConnectToPeer(_ peerID: PeerID) {}
-        func didDisconnectFromPeer(_ peerID: String) {}
+        func didDisconnectFromPeer(_ peerID: PeerID) {}
-        func didUpdatePeerList(_ peers: [String]) {}
+        func didUpdatePeerList(_ peers: [PeerID]) {}
         func isFavorite(fingerprint: String) -> Bool { false }
         func didUpdateMessageDeliveryStatus(_ messageID: String, status: DeliveryStatus) {}
-        func didReceiveNoisePayload(from peerID: String, type: NoisePayloadType, payload: Data, timestamp: Date) {}
+        func didReceiveNoisePayload(from peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date) {}
-        func didReceivePublicMessage(from peerID: String, nickname: String, content: String, timestamp: Date) {
+        func didUpdateBluetoothState(_ state: CBManagerState) {}
+        func didReceivePublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date) {
             publicMessages.append((peerID, nickname, content))
         }
-        func didReceiveRegionalPublicMessage(from peerID: String, nickname: String, content: String, timestamp: Date) {}
+        func didReceiveRegionalPublicMessage(from peerID: PeerID, nickname: String, content: String, timestamp: Date) {}
     }
 
     // Helper: build a large message packet (unencrypted public message)
-    private func makeLargePublicPacket(senderShortHex: String, size: Int) -> BitchatPacket {
+    private func makeLargePublicPacket(senderShortHex: PeerID, size: Int) -> BitchatPacket {
         let content = String(repeating: "A", count: size)
         let payload = Data(content.utf8)
         let pkt = BitchatPacket(
             type: MessageType.message.rawValue,
-            senderID: Data(hexString: senderShortHex) ?? Data(),
+            senderID: Data(hexString: senderShortHex.id) ?? Data(),
             recipientID: nil,
             timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
             payload: payload,
@@ -88,101 +203,4 @@ final class FragmentationTests: XCTestCase {
         }
         return packets
     }
-
-    func test_reassembly_from_fragments_delivers_public_message() {
-        let ble = BLEService(keychain: mockKeychain, identityManager: mockIdentityManager)
-        let capture = CaptureDelegate()
-        ble.delegate = capture
-
-        // Construct a big packet (3KB) from a remote sender (not our own ID)
-        let remoteShortID = "1122334455667788"
-        let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 3_000)
-        // Use a small fragment size to ensure multiple pieces
-        let fragments = fragmentPacket(original, fragmentSize: 400)
-
-        // Shuffle fragments to simulate out-of-order arrival
-        let shuffled = fragments.shuffled()
-
-        // Inject fragments spaced out to avoid concurrent mutation inside BLEService
-        for (i, f) in shuffled.enumerated() {
-            let delay = DispatchTime.now() + .milliseconds(5 * i)
-            DispatchQueue.global().asyncAfter(deadline: delay) {
-                ble._test_handlePacket(f, fromPeerID: remoteShortID)
-            }
-        }
-
-        // Allow async processing
-        let exp = expectation(description: "reassembled")
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { exp.fulfill() }
-        wait(for: [exp], timeout: 2.0)
-
-        XCTAssertEqual(capture.publicMessages.count, 1)
-        XCTAssertEqual(capture.publicMessages.first?.content.count, 3_000)
-    }
-
-    func test_duplicate_fragment_does_not_break_reassembly() {
-        let ble = BLEService(keychain: mockKeychain, identityManager: mockIdentityManager)
-        let capture = CaptureDelegate()
-        ble.delegate = capture
-
-        let remoteShortID = "A1B2C3D4E5F60708"
-        let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 2048)
-        var frags = fragmentPacket(original, fragmentSize: 300)
-        // Duplicate one fragment
-        if let dup = frags.first { frags.insert(dup, at: 1) }
-
-        for (i, f) in frags.enumerated() {
-            let delay = DispatchTime.now() + .milliseconds(5 * i)
-            DispatchQueue.global().asyncAfter(deadline: delay) {
-                ble._test_handlePacket(f, fromPeerID: remoteShortID)
-            }
-        }
-
-        let exp = expectation(description: "reassembled2")
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { exp.fulfill() }
-        wait(for: [exp], timeout: 2.0)
-
-        XCTAssertEqual(capture.publicMessages.count, 1)
-        XCTAssertEqual(capture.publicMessages.first?.content.count, 2048)
-    }
-
-    func test_invalid_fragment_header_is_ignored() {
-        let ble = BLEService(keychain: mockKeychain, identityManager: mockIdentityManager)
-        let capture = CaptureDelegate()
-        ble.delegate = capture
-
-        let remoteShortID = "0011223344556677"
-        let original = makeLargePublicPacket(senderShortHex: remoteShortID, size: 1000)
-        let fragments = fragmentPacket(original, fragmentSize: 250)
-
-        // Corrupt one fragment: make payload too short (header incomplete)
-        var corrupted = fragments
-        if !corrupted.isEmpty {
-            var p = corrupted[0]
-            p = BitchatPacket(
-                type: p.type,
-                senderID: p.senderID,
-                recipientID: p.recipientID,
-                timestamp: p.timestamp,
-                payload: Data([0x00, 0x01, 0x02]), // invalid header
-                signature: nil,
-                ttl: p.ttl
-            )
-            corrupted[0] = p
-        }
-
-        for (i, f) in corrupted.enumerated() {
-            let delay = DispatchTime.now() + .milliseconds(5 * i)
-            DispatchQueue.global().asyncAfter(deadline: delay) {
-                ble._test_handlePacket(f, fromPeerID: remoteShortID)
-            }
-        }
-
-        let exp = expectation(description: "no reassembly")
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { exp.fulfill() }
-        wait(for: [exp], timeout: 2.0)
-
-        // Should not deliver since one fragment is invalid and reassembly can't complete
-        XCTAssertEqual(capture.publicMessages.count, 0)
-    }
 }

bitchatTests/GCSFilterTests.swift

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

bitchatTests/GeohashBookmarksStoreTests.swift

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

bitchatTests/GossipSyncManagerTests.swift

@@ -0,0 +1,149 @@
+import Foundation
+import Testing
+@testable import bitchat
+
+struct GossipSyncManagerTests {
+
+    private let myPeerID = PeerID(str: "0102030405060708")
+    
+    @Test func concurrentPacketIntakeAndSyncRequest() async throws {
+        let manager = GossipSyncManager(myPeerID: myPeerID)
+        let delegate = RecordingDelegate()
+        manager.delegate = delegate
+
+        try await confirmation("sync request sent") { sent in
+            delegate.onSend = {
+                sent()
+            }
+
+            let iterations = 200
+            let senderID = try #require(Data(hexString: "1122334455667788"))
+            
+            for i in 0..<iterations {
+                let packet = BitchatPacket(
+                    type: MessageType.message.rawValue,
+                    senderID: senderID,
+                    recipientID: nil,
+                    timestamp: 1_000_000 + UInt64(i),
+                    payload: Data([UInt8(truncatingIfNeeded: i)]),
+                    signature: nil,
+                    ttl: 1
+                )
+                manager.onPublicPacketSeen(packet)
+                try await sleep(0.001)
+            }
+
+            manager.scheduleInitialSyncToPeer(PeerID(str: "FFFFFFFFFFFFFFFF"), delaySeconds: 0.0)
+            try await sleep(0.002)
+        }
+
+        let lastPacket = try #require(delegate.lastPacket, "Expected sync packet to be sent")
+        #expect(lastPacket.type == MessageType.requestSync.rawValue)
+        #expect(RequestSyncPacket.decode(from: lastPacket.payload) != nil)
+    }
+
+    @Test func staleAnnouncementsArePurgedWithMessages() throws {
+        var config = GossipSyncManager.Config()
+        config.stalePeerCleanupIntervalSeconds = 0
+        config.stalePeerTimeoutSeconds = 5
+
+        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
+        let peerHex = "0011223344556677"
+        let senderData = try #require(Data(hexString: peerHex))
+        let initialTimestampMs = UInt64(Date().timeIntervalSince1970 * 1000)
+
+        let announcePacket = BitchatPacket(
+            type: MessageType.announce.rawValue,
+            senderID: senderData,
+            recipientID: nil,
+            timestamp: initialTimestampMs,
+            payload: Data(),
+            signature: nil,
+            ttl: 1
+        )
+
+        let messagePacket = BitchatPacket(
+            type: MessageType.message.rawValue,
+            senderID: senderData,
+            recipientID: nil,
+            timestamp: initialTimestampMs,
+            payload: Data([0x01]),
+            signature: nil,
+            ttl: 1
+        )
+
+        manager.onPublicPacketSeen(announcePacket)
+        manager.onPublicPacketSeen(messagePacket)
+
+        // Flush queue without triggering stale cleanup yet
+        manager._performMaintenanceSynchronously(now: Date())
+        #expect(manager._hasAnnouncement(for: PeerID(str: peerHex)))
+        #expect(manager._messageCount(for: PeerID(str: peerHex)) == 1)
+        
+        // Run cleanup past the timeout
+        let future = Date().addingTimeInterval(config.stalePeerTimeoutSeconds + 1)
+        manager._performMaintenanceSynchronously(now: future)
+        #expect(manager._hasAnnouncement(for: PeerID(str: peerHex)) == false)
+        #expect(manager._messageCount(for: PeerID(str: peerHex)) == 0)
+    }
+
+    @Test func ignoresAnnounceOlderThanStaleTimeout() throws {
+        var config = GossipSyncManager.Config()
+        config.stalePeerTimeoutSeconds = 5
+        config.maxMessageAgeSeconds = 100
+
+        let manager = GossipSyncManager(myPeerID: myPeerID, config: config)
+        let peerHex = "8899aabbccddeeff"
+        let senderData = try #require(Data(hexString: peerHex))
+        let staleTimestampMs = UInt64(Date().addingTimeInterval(-(config.stalePeerTimeoutSeconds + 1)).timeIntervalSince1970 * 1000)
+
+        let freshMessage = BitchatPacket(
+            type: MessageType.message.rawValue,
+            senderID: senderData,
+            recipientID: nil,
+            timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
+            payload: Data([0xAA]),
+            signature: nil,
+            ttl: 1
+        )
+        manager.onPublicPacketSeen(freshMessage)
+
+        let announcePacket = BitchatPacket(
+            type: MessageType.announce.rawValue,
+            senderID: senderData,
+            recipientID: nil,
+            timestamp: staleTimestampMs,
+            payload: Data(),
+            signature: nil,
+            ttl: 1
+        )
+
+        manager.onPublicPacketSeen(announcePacket)
+
+        manager._performMaintenanceSynchronously()
+
+        #expect(manager._hasAnnouncement(for: PeerID(str: peerHex)) == false)
+        #expect(manager._messageCount(for: PeerID(str: peerHex)) == 0)
+    }
+}
+
+private final class RecordingDelegate: GossipSyncManager.Delegate {
+    var onSend: (() -> Void)?
+    private(set) var lastPacket: BitchatPacket?
+    private let lock = NSLock()
+
+    func sendPacket(_ packet: BitchatPacket) {
+        lock.lock()
+        lastPacket = packet
+        lock.unlock()
+        onSend?()
+    }
+
+    func sendPacket(to peerID: PeerID, packet: BitchatPacket) {
+        sendPacket(packet)
+    }
+
+    func signPacketForBroadcast(_ packet: BitchatPacket) -> BitchatPacket {
+        packet
+    }
+}