Update MessageRouter to use Peer

* fix: crash on shared extension

* fix: global(qos: .default) to global()

* fix: removed weak self

.gitattributes

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

.gitignore

@@ -75,3 +75,6 @@ TestResult.xcresult/
 *.xcresult/
 build.log
 *.log
+
+# Local configs
+Local.xcconfig

Configs/Debug.xcconfig

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

Configs/Local.xcconfig.example

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

Configs/Release.xcconfig

@@ -0,0 +1,11 @@
+MARKETING_VERSION = 1.4.2
+CURRENT_PROJECT_VERSION = 1
+
+IPHONEOS_DEPLOYMENT_TARGET = 16.0
+MACOSX_DEPLOYMENT_TARGET = 13.0
+SWIFT_VERSION = 5.0
+
+DEVELOPMENT_TEAM = L3N5LHJD5Y
+CODE_SIGN_STYLE = Automatic
+
+PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat

Justfile

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

Package.swift

@@ -15,6 +15,7 @@ let package = Package(
         ),
     ],
     dependencies:[
+        .package(path: "localPackages/BitLogger"),
         .package(url: "https://github.com/21-DOT-DEV/swift-secp256k1", exact: "0.21.1")
     ],
     targets: [
@@ -22,6 +23,7 @@ let package = Package(
             name: "bitchat",
             dependencies: [
                 .product(name: "P256K", package: "swift-secp256k1"),
+                .product(name: "BitLogger", package: "BitLogger"),
                 .target(name: "TorC"),
                 .target(name: "tor-nolzma")
             ],

README.md

@@ -94,45 +94,25 @@ For detailed protocol documentation, see the [Technical Whitepaper](WHITEPAPER.m
 
 ## Setup
 
-### Option 1: Using XcodeGen (Recommended)
+### Option 1: Using Xcode
-
-1. Install XcodeGen if you haven't already:
-
-   ```bash
-   brew install xcodegen
-   ```
-
-2. Generate the Xcode project:
 
    ```bash
    cd bitchat
-   xcodegen generate
-   ```
-
-3. Open the generated project:
-   ```bash
    open bitchat.xcodeproj
    ```
 
-### Option 2: Using Swift Package Manager
+   To run on a device there're a few steps to prepare the code:
+   - Clone the local configs: `cp Configs/Local.xcconfig.example Configs/Local.xcconfig`
+   - Add your Developer Team ID into the newly created `Configs/Local.xcconfig`
+      - Bundle ID would be set to `chat.bitchat.<team_id>` (unless you set to something else)
+   - Entitlements need to be updated manually (TODO: Automate):
+      - Search and replace `group.chat.bitchat` with `group.<your_bundle_id>` (e.g. `group.chat.bitchat.ABC123`)
 
-1. Open the project in Xcode:
+### Option 2: Using `just`
 
    ```bash
-   cd bitchat
+   brew install just
-   open Package.swift
    ```
 
-2. Select your target device and run
-
-### Option 3: Manual Xcode Project
-
-1. Open Xcode and create a new iOS/macOS App
-2. Copy all Swift files from the `bitchat` directory into your project
-3. Update Info.plist with Bluetooth permissions
-4. Set deployment target to iOS 16.0 / macOS 13.0
-
-### Option 4: just
-
 Want to try this on macos: `just run` will set it up and run from source.
 Run `just clean` afterwards to restore things to original state for mobile app building and development.

bitchat.xcodeproj/project.pbxproj

@@ -14,6 +14,8 @@
 		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 */; };
 		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 */
@@ -122,12 +124,18 @@
 			path = bitchatTests;
 			sourceTree = "<group>";
 		};
+		A6E367C92E76469E0032EA8A /* Configs */ = {
+			isa = PBXFileSystemSynchronizedRootGroup;
+			path = Configs;
+			sourceTree = "<group>";
+		};
 /* End PBXFileSystemSynchronizedRootGroup section */
 
 /* Begin PBXFrameworksBuildPhase section */
 		31F6FDADA63050361C14F3A1 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			files = (
+				A6E3E5722E7703760032EA8A /* BitLogger in Frameworks */,
 				048A88812E76FD18000FBCDD /* libz.tbd in Frameworks */,
 				0481A3A02E744D6300FC845E /* tor-nolzma.xcframework in Frameworks */,
 				3EE336D150427F736F32B56C /* P256K in Frameworks */,
@@ -136,6 +144,7 @@
 		B5A5CC493FFB3D8966548140 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			files = (
+				A6E3E5702E77036A0032EA8A /* BitLogger in Frameworks */,
 				0481A35D2E6DA18600FC845E /* libz.tbd in Frameworks */,
 				0481A3A12E744D6300FC845E /* tor-nolzma.xcframework in Frameworks */,
 				885BBED78092484A5B069461 /* P256K in Frameworks */,
@@ -160,6 +169,7 @@
 				E0A1B2C3D4E5F6012345678A /* relays/online_relays_gps.csv */,
 				A6E32D212E762EAB0032EA8A /* bitchatShareExtension */,
 				A6E32D412E762EAE0032EA8A /* bitchatTests */,
+				A6E367C92E76469E0032EA8A /* Configs */,
 				0481A3542E6D877600FC845E /* Frameworks */,
 				9F37F9F2C353B58AC809E93B /* Products */,
 			);
@@ -196,6 +206,7 @@
 			name = bitchat_macOS;
 			packageProductDependencies = (
 				B1D9136AA0083366353BFA2F /* P256K */,
+				A6E3E5712E7703760032EA8A /* BitLogger */,
 			);
 			productName = bitchat_macOS;
 			productReference = 8F3A7C058C2C8E1A06C8CF8B /* bitchat.app */;
@@ -272,6 +283,7 @@
 			name = bitchat_iOS;
 			packageProductDependencies = (
 				4EB6BA1B8464F1EA38F4E286 /* P256K */,
+				A6E3E56F2E77036A0032EA8A /* BitLogger */,
 			);
 			productName = bitchat_iOS;
 			productReference = 96D0D41CA19EE5A772AA8434 /* bitchat.app */;
@@ -285,28 +297,6 @@
 			attributes = {
 				BuildIndependentTargetsInParallel = YES;
 				LastUpgradeCheck = 1640;
-				TargetAttributes = {
-					0576A29205865664C0937536 = {
-						DevelopmentTeam = L3N5LHJD5Y;
-						ProvisioningStyle = Automatic;
-					};
-					47FF23248747DD7CB666CB91 = {
-						DevelopmentTeam = L3N5LHJD5Y;
-						ProvisioningStyle = Automatic;
-					};
-					57CA17A36A2532A6CFF367BB = {
-						DevelopmentTeam = L3N5LHJD5Y;
-						ProvisioningStyle = Automatic;
-					};
-					6CB97DF2EA57234CB3E563B8 = {
-						DevelopmentTeam = L3N5LHJD5Y;
-						ProvisioningStyle = Automatic;
-					};
-					AF077EA0474EDEDE2C72716C = {
-						DevelopmentTeam = L3N5LHJD5Y;
-						ProvisioningStyle = Automatic;
-					};
-				};
 			};
 			buildConfigurationList = 3EA424CBD51200895D361189 /* Build configuration list for PBXProject "bitchat" */;
 			developmentRegion = en;
@@ -319,6 +309,7 @@
 			minimizedProjectReferenceProxies = 1;
 			packageReferences = (
 				B8C407587481BBB190741C93 /* XCRemoteSwiftPackageReference "swift-secp256k1" */,
+				A6E3E56E2E77036A0032EA8A /* XCLocalSwiftPackageReference "localPackages/BitLogger" */,
 			);
 			preferredProjectObjectVersion = 90;
 			projectDirPath = "";
@@ -397,21 +388,24 @@
 /* Begin XCBuildConfiguration section */
 		077A5203074247CF8F766E2F /* Debug configuration for PBXNativeTarget "bitchatTests_iOS" */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
+			baseConfigurationReferenceRelativePath = Debug.xcconfig;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
-				CODE_SIGN_STYLE = Automatic;
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				INFOPLIST_FILE = bitchatTests/Info.plist;
-				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
+				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 					"@loader_path/Frameworks",
 				);
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.tests;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER).tests";
 				SDKROOT = iphoneos;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 				TARGETED_DEVICE_FAMILY = "1,2";
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/bitchat.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/bitchat";
 			};
@@ -419,21 +413,24 @@
 		};
 		0DACAA261446D178EDD30ECA /* Release configuration for PBXNativeTarget "bitchatTests_iOS" */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
+			baseConfigurationReferenceRelativePath = Release.xcconfig;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
-				CODE_SIGN_STYLE = Automatic;
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				INFOPLIST_FILE = bitchatTests/Info.plist;
-				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
+				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 					"@loader_path/Frameworks",
 				);
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.tests;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER).tests";
 				SDKROOT = iphoneos;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 				TARGETED_DEVICE_FAMILY = "1,2";
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/bitchat.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/bitchat";
 			};
@@ -441,167 +438,184 @@
 		};
 		147FDAE548082D5B921C6F0B /* Release configuration for PBXNativeTarget "bitchatTests_macOS" */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
+			baseConfigurationReferenceRelativePath = Release.xcconfig;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
-				CODE_SIGN_STYLE = Automatic;
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
 				COMBINE_HIDPI_IMAGES = YES;
 				DEAD_CODE_STRIPPING = YES;
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				INFOPLIST_FILE = bitchatTests/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/../Frameworks",
 					"@loader_path/../Frameworks",
 				);
-				MACOSX_DEPLOYMENT_TARGET = 13.0;
+				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.tests;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER).tests";
 				SDKROOT = macosx;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/bitchat.app/Contents/MacOS/bitchat";
 			};
 			name = Release;
 		};
 		3DCF45111852FB2AEBE05E31 /* Release configuration for PBXNativeTarget "bitchatShareExtension" */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
+			baseConfigurationReferenceRelativePath = Release.xcconfig;
 			buildSettings = {
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
 				CODE_SIGN_ALLOW_ENTITLEMENTS_MODIFICATION = YES;
 				CODE_SIGN_ENTITLEMENTS = bitchatShareExtension/bitchatShareExtension.entitlements;
-				CODE_SIGN_STYLE = Automatic;
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				INFOPLIST_FILE = bitchatShareExtension/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = bitchat;
-				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
+				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 1.4.0;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.ShareExtension;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER).ShareExtension";
 				SDKROOT = iphoneos;
 				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
 				SUPPORTS_MACCATALYST = NO;
 				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
 				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 				TARGETED_DEVICE_FAMILY = 1;
 			};
 			name = Release;
 		};
 		702E7395723CADA4B830F4A9 /* Debug configuration for PBXNativeTarget "bitchat_iOS" */ = {
 			isa = XCBuildConfiguration;
+			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;
 				CODE_SIGN_ENTITLEMENTS = bitchat/bitchat.entitlements;
-				CODE_SIGN_IDENTITY = "iPhone Developer";
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
-				CODE_SIGN_STYLE = Automatic;
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				ENABLE_PREVIEWS = NO;
 				INFOPLIST_FILE = bitchat/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = bitchat;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
-				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
+				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.4.0;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
 				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
 				SUPPORTS_MACCATALYST = NO;
 				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
 				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 				TARGETED_DEVICE_FAMILY = 1;
 			};
 			name = Debug;
 		};
 		7FA2BADBF3B325125030CAB1 /* Debug configuration for PBXNativeTarget "bitchatTests_macOS" */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
+			baseConfigurationReferenceRelativePath = Debug.xcconfig;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
-				CODE_SIGN_STYLE = Automatic;
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
 				COMBINE_HIDPI_IMAGES = YES;
 				DEAD_CODE_STRIPPING = YES;
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				INFOPLIST_FILE = bitchatTests/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/../Frameworks",
 					"@loader_path/../Frameworks",
 				);
-				MACOSX_DEPLOYMENT_TARGET = 13.0;
+				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.tests;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER).tests";
 				SDKROOT = macosx;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/bitchat.app/Contents/MacOS/bitchat";
 			};
 			name = Debug;
 		};
 		B36671AEACCBF92BE10852E9 /* Release configuration for PBXNativeTarget "bitchat_iOS" */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
+			baseConfigurationReferenceRelativePath = Release.xcconfig;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_INCLUDE_ALL_APPICON_ASSETS = YES;
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
 				CODE_SIGN_ENTITLEMENTS = bitchat/bitchat.entitlements;
-				CODE_SIGN_IDENTITY = "iPhone Developer";
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
-				CODE_SIGN_STYLE = Automatic;
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				ENABLE_PREVIEWS = YES;
 				INFOPLIST_FILE = bitchat/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = bitchat;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
-				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
+				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.4.0;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
 				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
 				SUPPORTS_MACCATALYST = NO;
 				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
 				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 				TARGETED_DEVICE_FAMILY = 1;
 			};
 			name = Release;
 		};
 		BB044400A0F06B93F22D0D55 /* Release configuration for PBXNativeTarget "bitchat_macOS" */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
+			baseConfigurationReferenceRelativePath = Release.xcconfig;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_INCLUDE_ALL_APPICON_ASSETS = YES;
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
 				CODE_SIGN_ENTITLEMENTS = "bitchat/bitchat-macOS.entitlements";
-				CODE_SIGN_STYLE = Automatic;
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
 				COMBINE_HIDPI_IMAGES = YES;
 				DEAD_CODE_STRIPPING = YES;
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				ENABLE_PREVIEWS = YES;
 				INFOPLIST_FILE = bitchat/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = bitchat;
+				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/../Frameworks",
 				);
-				MACOSX_DEPLOYMENT_TARGET = 13.0;
+				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				MARKETING_VERSION = 1.4.0;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
 				SDKROOT = macosx;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 			};
 			name = Release;
 		};
@@ -639,10 +653,9 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = "$(CURRENT_PROJECT_VERSION)";
 				DEAD_CODE_STRIPPING = YES;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				DEVELOPMENT_TEAM = L3N5LHJD5Y;
 				ENABLE_NS_ASSERTIONS = NO;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_USER_SCRIPT_SANDBOXING = YES;
@@ -654,43 +667,47 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
+				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
-				MACOSX_DEPLOYMENT_TARGET = 13.0;
+				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				MARKETING_VERSION = 1.0.0;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_COMPILATION_MODE = wholemodule;
 				SWIFT_OPTIMIZATION_LEVEL = "-O";
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 			};
 			name = Release;
 		};
 		CC79F65842D42034ACEE79B7 /* Debug configuration for PBXNativeTarget "bitchat_macOS" */ = {
 			isa = XCBuildConfiguration;
+			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;
 				CODE_SIGN_ENTITLEMENTS = "bitchat/bitchat-macOS.entitlements";
-				CODE_SIGN_STYLE = Automatic;
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
 				COMBINE_HIDPI_IMAGES = YES;
 				DEAD_CODE_STRIPPING = YES;
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				ENABLE_PREVIEWS = NO;
 				INFOPLIST_FILE = bitchat/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = bitchat;
+				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/../Frameworks",
 				);
-				MACOSX_DEPLOYMENT_TARGET = 13.0;
+				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				MARKETING_VERSION = 1.4.0;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER)";
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
 				SDKROOT = macosx;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 			};
 			name = Debug;
 		};
@@ -728,10 +745,9 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = "$(CURRENT_PROJECT_VERSION)";
 				DEAD_CODE_STRIPPING = YES;
 				DEBUG_INFORMATION_FORMAT = dwarf;
-				DEVELOPMENT_TEAM = L3N5LHJD5Y;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
 				ENABLE_USER_SCRIPT_SANDBOXING = YES;
@@ -749,43 +765,46 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
+				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
-				MACOSX_DEPLOYMENT_TARGET = 13.0;
+				MACOSX_DEPLOYMENT_TARGET = "$(MACOSX_DEPLOYMENT_TARGET)";
-				MARKETING_VERSION = 1.0.0;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 			};
 			name = Debug;
 		};
 		DAC5E82049F8A97360BE63D6 /* Debug configuration for PBXNativeTarget "bitchatShareExtension" */ = {
 			isa = XCBuildConfiguration;
+			baseConfigurationReferenceAnchor = A6E367C92E76469E0032EA8A /* Configs */;
+			baseConfigurationReferenceRelativePath = Debug.xcconfig;
 			buildSettings = {
 				CODE_SIGNING_ALLOWED = YES;
 				CODE_SIGNING_REQUIRED = YES;
 				CODE_SIGN_ALLOW_ENTITLEMENTS_MODIFICATION = YES;
 				CODE_SIGN_ENTITLEMENTS = bitchatShareExtension/bitchatShareExtension.entitlements;
-				CODE_SIGN_STYLE = Automatic;
+				CODE_SIGN_STYLE = "$(CODE_SIGN_STYLE)";
+				DEVELOPMENT_TEAM = "$(DEVELOPMENT_TEAM)";
 				INFOPLIST_FILE = bitchatShareExtension/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = bitchat;
-				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
+				IPHONEOS_DEPLOYMENT_TARGET = "$(IPHONEOS_DEPLOYMENT_TARGET)";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 1.4.0;
+				MARKETING_VERSION = "$(MARKETING_VERSION)";
-				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.ShareExtension;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(PRODUCT_BUNDLE_IDENTIFIER).ShareExtension";
 				SDKROOT = iphoneos;
 				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
 				SUPPORTS_MACCATALYST = NO;
 				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
 				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SWIFT_VERSION = 5.0;
+				SWIFT_VERSION = "$(SWIFT_VERSION)";
 				TARGETED_DEVICE_FAMILY = 1;
 			};
 			name = Debug;
@@ -843,6 +862,13 @@
 		};
 /* End XCConfigurationList section */
 
+/* Begin XCLocalSwiftPackageReference section */
+		A6E3E56E2E77036A0032EA8A /* XCLocalSwiftPackageReference "localPackages/BitLogger" */ = {
+			isa = XCLocalSwiftPackageReference;
+			relativePath = localPackages/BitLogger;
+		};
+/* End XCLocalSwiftPackageReference section */
+
 /* Begin XCRemoteSwiftPackageReference section */
 		B8C407587481BBB190741C93 /* XCRemoteSwiftPackageReference "swift-secp256k1" */ = {
 			isa = XCRemoteSwiftPackageReference;
@@ -860,6 +886,14 @@
 			package = B8C407587481BBB190741C93 /* XCRemoteSwiftPackageReference "swift-secp256k1" */;
 			productName = P256K;
 		};
+		A6E3E56F2E77036A0032EA8A /* BitLogger */ = {
+			isa = XCSwiftPackageProductDependency;
+			productName = BitLogger;
+		};
+		A6E3E5712E7703760032EA8A /* BitLogger */ = {
+			isa = XCSwiftPackageProductDependency;
+			productName = BitLogger;
+		};
 		B1D9136AA0083366353BFA2F /* P256K */ = {
 			isa = XCSwiftPackageProductDependency;
 			package = B8C407587481BBB190741C93 /* XCRemoteSwiftPackageReference "swift-secp256k1" */;

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

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

bitchat/Assets.xcassets/Contents.json

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

bitchat/BitchatApp.swift

@@ -11,6 +11,9 @@ import UserNotifications
 
 @main
 struct BitchatApp: App {
+    static let bundleID = Bundle.main.bundleIdentifier ?? "chat.bitchat"
+    static let groupID = "group.\(bundleID)"
+    
     @StateObject private var chatViewModel: ChatViewModel
     #if os(iOS)
     @Environment(\.scenePhase) var scenePhase
@@ -54,8 +57,8 @@ struct BitchatApp: App {
                     #elseif os(macOS)
                     appDelegate.chatViewModel = chatViewModel
                     #endif
-                    // Spin up Tor early; all internet will gate on Tor 100%
+                    // Initialize network activation policy; will start Tor/Nostr only when allowed
-                    TorManager.shared.startIfNeeded()
+                    NetworkActivationService.shared.start()
                     // Check for shared content
                     checkForSharedContent()
                 }
@@ -67,7 +70,7 @@ struct BitchatApp: App {
                     switch newPhase {
                     case .background:
                         // Keep BLE mesh running in background; BLEService adapts scanning automatically
-                        // Optionally nudge Tor to dormant to save power
+                        // Always send Tor to dormant on background for a clean restart later.
                         TorManager.shared.setAppForeground(false)
                         TorManager.shared.goDormantOnBackground()
                         // Stop geohash sampling while backgrounded
@@ -84,18 +87,22 @@ struct BitchatApp: App {
                         // On initial cold launch, Tor was just started in onAppear.
                         // Skip the deterministic restart the first time we become active.
                         if didHandleInitialActive && didEnterBackground {
-                            TorManager.shared.ensureRunningOnForeground()
+                            if TorManager.shared.isAutoStartAllowed() && !TorManager.shared.isReady {
+                                TorManager.shared.ensureRunningOnForeground()
+                            }
                         } else {
                             didHandleInitialActive = true
                         }
                         didEnterBackground = false
-                        Task.detached {
+                        if TorManager.shared.isAutoStartAllowed() {
-                            let _ = await TorManager.shared.awaitReady(timeout: 60)
+                            Task.detached {
-                            await MainActor.run {
+                                let _ = await TorManager.shared.awaitReady(timeout: 60)
-                                // Rebuild proxied sessions to bind to the live Tor after readiness
+                                await MainActor.run {
-                                TorURLSession.shared.rebuild()
+                                    // Rebuild proxied sessions to bind to the live Tor after readiness
-                                // Reconnect Nostr via fresh sessions; will gate until Tor 100%
+                                    TorURLSession.shared.rebuild()
-                                NostrRelayManager.shared.resetAllConnections()
+                                    // Reconnect Nostr via fresh sessions; will gate until Tor 100%
+                                    NostrRelayManager.shared.resetAllConnections()
+                                }
                             }
                         }
                         checkForSharedContent()
@@ -130,7 +137,7 @@ struct BitchatApp: App {
     
     private func checkForSharedContent() {
         // Check app group for shared content from extension
-        guard let userDefaults = UserDefaults(suiteName: "group.chat.bitchat") else {
+        guard let userDefaults = UserDefaults(suiteName: BitchatApp.groupID) else {
             return
         }
         

bitchat/Identity/IdentityModels.swift

@@ -87,7 +87,7 @@ import Foundation
 /// Represents the ephemeral layer of identity - short-lived peer IDs that provide network privacy.
 /// These IDs rotate periodically to prevent tracking while maintaining cryptographic relationships.
 struct EphemeralIdentity {
-    let peerID: String          // 8 random bytes
+    let peer: Peer          // 8 random bytes
     let sessionStart: Date
     var handshakeState: HandshakeState
 }

bitchat/Identity/SecureIdentityStateManager.swift

@@ -90,6 +90,7 @@
 /// - Advanced conflict resolution
 ///
 
+import BitLogger
 import Foundation
 import CryptoKit
 
@@ -102,7 +103,7 @@ protocol SecureIdentityStateManagerProtocol {
     
     // MARK: Cryptographic Identities
     func upsertCryptographicIdentity(fingerprint: String, noisePublicKey: Data, signingPublicKey: Data?, claimedNickname: String?)
-    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: String) -> [CryptographicIdentity]
+    func getCryptoIdentitiesByPeerIDPrefix(_ peer: Peer) -> [CryptographicIdentity]
     func updateSocialIdentity(_ identity: SocialIdentity)
     
     // MARK: Favorites Management
@@ -120,12 +121,12 @@ protocol SecureIdentityStateManagerProtocol {
     func getBlockedNostrPubkeys() -> Set<String>
     
     // MARK: Ephemeral Session Management
-    func registerEphemeralSession(peerID: String, handshakeState: HandshakeState)
+    func registerEphemeralSession(peer: Peer, handshakeState: HandshakeState)
-    func updateHandshakeState(peerID: String, state: HandshakeState)
+    func updateHandshakeState(peer: Peer, state: HandshakeState)
     
     // MARK: Cleanup
     func clearAllIdentityData()
-    func removeEphemeralSession(peerID: String)
+    func removeEphemeralSession(peer: Peer)
     
     // MARK: Verification
     func setVerified(fingerprint: String, verified: Bool)
@@ -142,7 +143,7 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     private let encryptionKeyName = "identityCacheEncryptionKey"
     
     // In-memory state
-    private var ephemeralSessions: [String: EphemeralIdentity] = [:]
+    private var ephemeralSessions: [Peer: EphemeralIdentity] = [:]
     private var cryptographicIdentities: [String: CryptographicIdentity] = [:]
     private var cache: IdentityCache = IdentityCache()
     
@@ -320,11 +321,11 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     }
 
     /// Find cryptographic identities whose fingerprint prefix matches a peerID (16-hex) short ID
-    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: String) -> [CryptographicIdentity] {
+    func getCryptoIdentitiesByPeerIDPrefix(_ peer: Peer) -> [CryptographicIdentity] {
         queue.sync {
             // Defensive: ensure hex and correct length
-            guard peerID.count == 16, peerID.allSatisfy({ $0.isHexDigit }) else { return [] }
+            guard peer.isShort, peer.id.allSatisfy({ $0.isHexDigit }) else { return [] }
-            return cryptographicIdentities.values.filter { $0.fingerprint.hasPrefix(peerID) }
+            return cryptographicIdentities.values.filter { $0.fingerprint.hasPrefix(peer.id) }
         }
     }
     
@@ -454,19 +455,19 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
     
     // MARK: - Ephemeral Session Management
     
-    func registerEphemeralSession(peerID: String, handshakeState: HandshakeState = .none) {
+    func registerEphemeralSession(peer: Peer, handshakeState: HandshakeState = .none) {
         queue.async(flags: .barrier) {
-            self.ephemeralSessions[peerID] = EphemeralIdentity(
+            self.ephemeralSessions[peer] = EphemeralIdentity(
-                peerID: peerID,
+                peer: peer,
                 sessionStart: Date(),
                 handshakeState: handshakeState
             )
         }
     }
     
-    func updateHandshakeState(peerID: String, state: HandshakeState) {
+    func updateHandshakeState(peer: Peer, state: HandshakeState) {
         queue.async(flags: .barrier) {
-            self.ephemeralSessions[peerID]?.handshakeState = state
+            self.ephemeralSessions[peer]?.handshakeState = state
             
             // If handshake completed, update last interaction
             if case .completed(let fingerprint) = state {
@@ -492,9 +493,9 @@ final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
         }
     }
     
-    func removeEphemeralSession(peerID: String) {
+    func removeEphemeralSession(peer: Peer) {
         queue.async(flags: .barrier) {
-            self.ephemeralSessions.removeValue(forKey: peerID)
+            self.ephemeralSessions.removeValue(forKey: peer)
         }
     }
     

bitchat/Models/BitchatMessage.swift

@@ -0,0 +1,356 @@
+//
+// BitchatMessage.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+/// Represents a user-visible message in the BitChat system.
+/// Handles both broadcast messages and private encrypted messages,
+/// with support for mentions, replies, and delivery tracking.
+/// - Note: This is the primary data model for chat messages
+final class BitchatMessage: Codable {
+    let id: String
+    let sender: String
+    let content: String
+    let timestamp: Date
+    let isRelay: Bool
+    let originalSender: String?
+    let isPrivate: Bool
+    let recipientNickname: String?
+    let senderPeer: Peer?
+    let mentions: [String]?  // Array of mentioned nicknames
+    var deliveryStatus: DeliveryStatus? // Delivery tracking
+    
+    // Cached formatted text (not included in Codable)
+    private var _cachedFormattedText: [String: AttributedString] = [:]
+    
+    func getCachedFormattedText(isDark: Bool, isSelf: Bool) -> AttributedString? {
+        return _cachedFormattedText["\(isDark)-\(isSelf)"]
+    }
+    
+    func setCachedFormattedText(_ text: AttributedString, isDark: Bool, isSelf: Bool) {
+        _cachedFormattedText["\(isDark)-\(isSelf)"] = text
+    }
+    
+    // Codable implementation
+    enum CodingKeys: String, CodingKey {
+        case id, sender, content, timestamp, isRelay, originalSender
+        case isPrivate, recipientNickname, mentions, deliveryStatus
+        case senderPeer = "senderPeerID" // backwards compatibility
+    }
+    
+    init(
+        id: String? = nil,
+        sender: String,
+        content: String,
+        timestamp: Date,
+        isRelay: Bool,
+        originalSender: String? = nil,
+        isPrivate: Bool = false,
+        recipientNickname: String? = nil,
+        senderPeer: Peer? = nil,
+        mentions: [String]? = nil,
+        deliveryStatus: DeliveryStatus? = nil
+    ) {
+        self.id = id ?? UUID().uuidString
+        self.sender = sender
+        self.content = content
+        self.timestamp = timestamp
+        self.isRelay = isRelay
+        self.originalSender = originalSender
+        self.isPrivate = isPrivate
+        self.recipientNickname = recipientNickname
+        self.senderPeer = senderPeer
+        self.mentions = mentions
+        self.deliveryStatus = deliveryStatus ?? (isPrivate ? .sending : nil)
+    }
+}
+
+// MARK: - Equatable Conformance
+
+extension BitchatMessage: Equatable {
+    static func == (lhs: BitchatMessage, rhs: BitchatMessage) -> Bool {
+        return lhs.id == rhs.id &&
+               lhs.sender == rhs.sender &&
+               lhs.content == rhs.content &&
+               lhs.timestamp == rhs.timestamp &&
+               lhs.isRelay == rhs.isRelay &&
+               lhs.originalSender == rhs.originalSender &&
+               lhs.isPrivate == rhs.isPrivate &&
+               lhs.recipientNickname == rhs.recipientNickname &&
+               lhs.senderPeer == rhs.senderPeer &&
+               lhs.mentions == rhs.mentions &&
+               lhs.deliveryStatus == rhs.deliveryStatus
+    }
+}
+
+// MARK: - Binary encoding
+
+extension BitchatMessage {
+    func toBinaryPayload() -> Data? {
+        var data = Data()
+        
+        // Message format:
+        // - Flags: 1 byte (bit 0: isRelay, bit 1: isPrivate, bit 2: hasOriginalSender, bit 3: hasRecipientNickname, bit 4: hasSenderPeerID, bit 5: hasMentions)
+        // - Timestamp: 8 bytes (seconds since epoch)
+        // - ID length: 1 byte
+        // - ID: variable
+        // - Sender length: 1 byte
+        // - Sender: variable
+        // - Content length: 2 bytes
+        // - Content: variable
+        // Optional fields based on flags:
+        // - Original sender length + data
+        // - Recipient nickname length + data
+        // - Sender peer ID length + data
+        // - Mentions array
+        
+        var flags: UInt8 = 0
+        if isRelay { flags |= 0x01 }
+        if isPrivate { flags |= 0x02 }
+        if originalSender != nil { flags |= 0x04 }
+        if recipientNickname != nil { flags |= 0x08 }
+        if senderPeer != nil { flags |= 0x10 }
+        if mentions != nil && !mentions!.isEmpty { flags |= 0x20 }
+        
+        data.append(flags)
+        
+        // Timestamp (in milliseconds)
+        let timestampMillis = UInt64(timestamp.timeIntervalSince1970 * 1000)
+        // Encode as 8 bytes, big-endian
+        for i in (0..<8).reversed() {
+            data.append(UInt8((timestampMillis >> (i * 8)) & 0xFF))
+        }
+        
+        // ID
+        if let idData = id.data(using: .utf8) {
+            data.append(UInt8(min(idData.count, 255)))
+            data.append(idData.prefix(255))
+        } else {
+            data.append(0)
+        }
+        
+        // Sender
+        if let senderData = sender.data(using: .utf8) {
+            data.append(UInt8(min(senderData.count, 255)))
+            data.append(senderData.prefix(255))
+        } else {
+            data.append(0)
+        }
+        
+        // Content
+        if let contentData = content.data(using: .utf8) {
+            let length = UInt16(min(contentData.count, 65535))
+            // Encode length as 2 bytes, big-endian
+            data.append(UInt8((length >> 8) & 0xFF))
+            data.append(UInt8(length & 0xFF))
+            data.append(contentData.prefix(Int(length)))
+        } else {
+            data.append(contentsOf: [0, 0])
+        }
+        
+        // Optional fields
+        if let originalSender = originalSender, let origData = originalSender.data(using: .utf8) {
+            data.append(UInt8(min(origData.count, 255)))
+            data.append(origData.prefix(255))
+        }
+        
+        if let recipientNickname = recipientNickname, let recipData = recipientNickname.data(using: .utf8) {
+            data.append(UInt8(min(recipData.count, 255)))
+            data.append(recipData.prefix(255))
+        }
+        
+        if let peerData = senderPeer?.data {
+            data.append(UInt8(min(peerData.count, 255)))
+            data.append(peerData.prefix(255))
+        }
+        
+        // Mentions array
+        if let mentions = mentions {
+            data.append(UInt8(min(mentions.count, 255))) // Number of mentions
+            for mention in mentions.prefix(255) {
+                if let mentionData = mention.data(using: .utf8) {
+                    data.append(UInt8(min(mentionData.count, 255)))
+                    data.append(mentionData.prefix(255))
+                } else {
+                    data.append(0)
+                }
+            }
+        }
+        
+        
+        return data
+    }
+    
+    convenience init?(_ data: Data) {
+        // Create an immutable copy to prevent threading issues
+        let dataCopy = Data(data)
+        
+        
+        guard dataCopy.count >= 13 else {
+            return nil
+        }
+        
+        var offset = 0
+        
+        // Flags
+        guard offset < dataCopy.count else {
+            return nil
+        }
+        let flags = dataCopy[offset]; offset += 1
+        let isRelay = (flags & 0x01) != 0
+        let isPrivate = (flags & 0x02) != 0
+        let hasOriginalSender = (flags & 0x04) != 0
+        let hasRecipientNickname = (flags & 0x08) != 0
+        let hasSenderPeerID = (flags & 0x10) != 0
+        let hasMentions = (flags & 0x20) != 0
+        
+        // Timestamp
+        guard offset + 8 <= dataCopy.count else {
+            return nil
+        }
+        let timestampData = dataCopy[offset..<offset+8]
+        let timestampMillis = timestampData.reduce(0) { result, byte in
+            (result << 8) | UInt64(byte)
+        }
+        offset += 8
+        let timestamp = Date(timeIntervalSince1970: TimeInterval(timestampMillis) / 1000.0)
+        
+        // ID
+        guard offset < dataCopy.count else {
+            return nil
+        }
+        let idLength = Int(dataCopy[offset]); offset += 1
+        guard offset + idLength <= dataCopy.count else {
+            return nil
+        }
+        let id = String(data: dataCopy[offset..<offset+idLength], encoding: .utf8) ?? UUID().uuidString
+        offset += idLength
+        
+        // Sender
+        guard offset < dataCopy.count else {
+            return nil
+        }
+        let senderLength = Int(dataCopy[offset]); offset += 1
+        guard offset + senderLength <= dataCopy.count else {
+            return nil
+        }
+        let sender = String(data: dataCopy[offset..<offset+senderLength], encoding: .utf8) ?? "unknown"
+        offset += senderLength
+        
+        // Content
+        guard offset + 2 <= dataCopy.count else {
+            return nil
+        }
+        let contentLengthData = dataCopy[offset..<offset+2]
+        let contentLength = Int(contentLengthData.reduce(0) { result, byte in
+            (result << 8) | UInt16(byte)
+        })
+        offset += 2
+        guard offset + contentLength <= dataCopy.count else {
+            return nil
+        }
+        
+        let content = String(data: dataCopy[offset..<offset+contentLength], encoding: .utf8) ?? ""
+        offset += contentLength
+        
+        // Optional fields
+        var originalSender: String?
+        if hasOriginalSender && offset < dataCopy.count {
+            let length = Int(dataCopy[offset]); offset += 1
+            if offset + length <= dataCopy.count {
+                originalSender = String(data: dataCopy[offset..<offset+length], encoding: .utf8)
+                offset += length
+            }
+        }
+        
+        var recipientNickname: String?
+        if hasRecipientNickname && offset < dataCopy.count {
+            let length = Int(dataCopy[offset]); offset += 1
+            if offset + length <= dataCopy.count {
+                recipientNickname = String(data: dataCopy[offset..<offset+length], encoding: .utf8)
+                offset += length
+            }
+        }
+        
+        var senderPeer: Peer?
+        if hasSenderPeerID && offset < dataCopy.count {
+            let length = Int(dataCopy[offset]); offset += 1
+            if offset + length <= dataCopy.count {
+                senderPeer = Peer(data: dataCopy[offset..<offset+length])
+                offset += length
+            }
+        }
+        
+        // Mentions array
+        var mentions: [String]?
+        if hasMentions && offset < dataCopy.count {
+            let mentionCount = Int(dataCopy[offset]); offset += 1
+            if mentionCount > 0 {
+                mentions = []
+                for _ in 0..<mentionCount {
+                    if offset < dataCopy.count {
+                        let length = Int(dataCopy[offset]); offset += 1
+                        if offset + length <= dataCopy.count {
+                            if let mention = String(data: dataCopy[offset..<offset+length], encoding: .utf8) {
+                                mentions?.append(mention)
+                            }
+                            offset += length
+                        }
+                    }
+                }
+            }
+        }
+        
+        self.init(
+            id: id,
+            sender: sender,
+            content: content,
+            timestamp: timestamp,
+            isRelay: isRelay,
+            originalSender: originalSender,
+            isPrivate: isPrivate,
+            recipientNickname: recipientNickname,
+            senderPeer: senderPeer,
+            mentions: mentions
+        )
+    }
+}
+
+// MARK: - Helpers
+
+extension BitchatMessage {
+    
+    private static let timestampFormatter: DateFormatter = {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "HH:mm:ss"
+        return formatter
+    }()
+    
+    var formattedTimestamp: String {
+        Self.timestampFormatter.string(from: timestamp)
+    }
+}
+
+extension Array where Element == BitchatMessage {
+    /// Filters out empty ones and deduplicate by ID while preserving order (from oldest to newest)
+    func cleanedAndDeduped() -> [Element] {
+        let arr = filter { $0.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false }
+        guard arr.count > 1 else {
+            return arr
+        }
+        var seen = Set<String>()
+        var dedup: [BitchatMessage] = []
+        for m in arr.sorted(by: { $0.timestamp < $1.timestamp }) {
+            if !seen.contains(m.id) {
+                dedup.append(m)
+                seen.insert(m.id)
+            }
+        }
+        return dedup
+    }
+}

bitchat/Models/BitchatPacket.swift

@@ -0,0 +1,91 @@
+//
+// BitchatPacket.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+/// The core packet structure for all BitChat protocol messages.
+/// Encapsulates all data needed for routing through the mesh network,
+/// including TTL for hop limiting and optional encryption.
+/// - Note: Packets larger than BLE MTU (512 bytes) are automatically fragmented
+struct BitchatPacket: Codable {
+    let version: UInt8
+    let type: UInt8
+    let senderID: Data
+    let recipientID: Data?
+    let timestamp: UInt64
+    let payload: Data
+    var signature: Data?
+    var ttl: UInt8
+    
+    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8) {
+        self.version = 1
+        self.type = type
+        self.senderID = senderID
+        self.recipientID = recipientID
+        self.timestamp = timestamp
+        self.payload = payload
+        self.signature = signature
+        self.ttl = ttl
+    }
+    
+    // Convenience initializer for new binary format
+    init(type: UInt8, ttl: UInt8, senderID: String, payload: Data) {
+        self.version = 1
+        self.type = type
+        // Convert hex string peer ID to binary data (8 bytes)
+        var senderData = Data()
+        var tempID = senderID
+        while tempID.count >= 2 {
+            let hexByte = String(tempID.prefix(2))
+            if let byte = UInt8(hexByte, radix: 16) {
+                senderData.append(byte)
+            }
+            tempID = String(tempID.dropFirst(2))
+        }
+        self.senderID = senderData
+        self.recipientID = nil
+        self.timestamp = UInt64(Date().timeIntervalSince1970 * 1000) // milliseconds
+        self.payload = payload
+        self.signature = nil
+        self.ttl = ttl
+    }
+    
+    var data: Data? {
+        BinaryProtocol.encode(self)
+    }
+    
+    func toBinaryData(padding: Bool = true) -> Data? {
+        BinaryProtocol.encode(self, padding: padding)
+    }
+
+    // Backward-compatible helper (defaults to padded encoding)
+    func toBinaryData() -> Data? {
+        toBinaryData(padding: true)
+    }
+    
+    /// Create binary representation for signing (without signature and TTL fields)
+    /// TTL is excluded because it changes during packet relay operations
+    func toBinaryDataForSigning() -> Data? {
+        // Create a copy without signature and with fixed TTL for signing
+        // TTL must be excluded because it changes during relay
+        let unsignedPacket = BitchatPacket(
+            type: type,
+            senderID: senderID,
+            recipientID: recipientID,
+            timestamp: timestamp,
+            payload: payload,
+            signature: nil, // Remove signature for signing
+            ttl: 0 // Use fixed TTL=0 for signing to ensure relay compatibility
+        )
+        return BinaryProtocol.encode(unsignedPacket)
+    }
+    
+    static func from(_ data: Data) -> BitchatPacket? {
+        BinaryProtocol.decode(data)
+    }
+}

bitchat/Models/MessagePadding.swift

@@ -0,0 +1,61 @@
+//
+// MessagePadding.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+
+/// Provides privacy-preserving message padding to obscure actual content length.
+/// Uses PKCS#7-style padding with random bytes to prevent traffic analysis.
+struct MessagePadding {
+    // Standard block sizes for padding
+    static let blockSizes = [256, 512, 1024, 2048]
+    
+    // Add PKCS#7-style padding to reach target size
+    static func pad(_ data: Data, toSize targetSize: Int) -> Data {
+        guard data.count < targetSize else { return data }
+        
+        let paddingNeeded = targetSize - data.count
+        // Constrain to 255 to fit a single-byte pad length marker
+        guard paddingNeeded > 0 && paddingNeeded <= 255 else { return data }
+        
+        var padded = data
+        // PKCS#7: All pad bytes are equal to the pad length
+        padded.append(contentsOf: Array(repeating: UInt8(paddingNeeded), count: paddingNeeded))
+        return padded
+    }
+    
+    // Remove padding from data
+    static func unpad(_ data: Data) -> Data {
+        guard !data.isEmpty else { return data }
+        let last = data.last!
+        let paddingLength = Int(last)
+        // Must have at least 1 pad byte and not exceed data length
+        guard paddingLength > 0 && paddingLength <= data.count else { return data }
+        // Verify PKCS#7: all last N bytes equal to pad length
+        let start = data.count - paddingLength
+        let tail = data[start...]
+        for b in tail { if b != last { return data } }
+        return Data(data[..<start])
+    }
+    
+    // Find optimal block size for data
+    static func optimalBlockSize(for dataSize: Int) -> Int {
+        // Account for encryption overhead (~16 bytes for AES-GCM tag)
+        let totalSize = dataSize + 16
+        
+        // Find smallest block that fits
+        for blockSize in blockSizes {
+            if totalSize <= blockSize {
+                return blockSize
+            }
+        }
+        
+        // For very large messages, just use the original size
+        // (will be fragmented anyway)
+        return dataSize
+    }
+}

bitchat/Models/NoisePayload.swift

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

bitchat/Models/Peer.swift

@@ -0,0 +1,139 @@
+//
+// Peer.swift
+// BitLogger
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+import struct CryptoKit.SHA256
+
+struct Peer: Equatable, Hashable {
+    let id: String
+}
+
+extension Peer {
+    var data: Data? {
+        id.data(using: .utf8)
+    }
+    
+    var isNostr: Bool {
+        id.hasPrefix("nostr")
+    }
+    
+    var isNostrColon: Bool {
+        id.hasPrefix("nostr:")
+    }
+}
+
+// MARK: - Validation
+
+extension Peer {
+    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 {
+        // Accept short routing IDs (exact 16-hex) or Full Noise key hex (exact 64-hex)
+        if isShort || isNoiseKeyHex {
+            return true
+        }
+        
+        // If length equals short or full but isn't valid hex, reject
+        if id.count == Constants.hexIDLength || id.count == Constants.maxIDLength {
+            return false
+        }
+        
+        // Internal format: alphanumeric + dash/underscore up to 63 (not 16 or 64)
+        let validCharset = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-_"))
+        return !id.isEmpty &&
+                id.count < Constants.maxIDLength &&
+                id.rangeOfCharacter(from: validCharset.inverted) == nil
+    }
+    
+    /// Short routing IDs (exact 16-hex)
+    var isShort: Bool {
+        id.count == Constants.hexIDLength && Data(hexString: id) != nil
+    }
+    
+    /// Full Noise key hex (exact 64-hex)
+    var isNoiseKeyHex: Bool {
+        noiseKey != nil
+    }
+    
+    /// Full Noise key (exact 64-hex) as Data
+    var noiseKey: Data? {
+        guard id.count == Constants.maxIDLength else { return nil }
+        return Data(hexString: id)
+    }
+}
+
+// MARK: - ExpressibleByStringLiteral
+
+extension Peer: ExpressibleByStringLiteral {
+    init(stringLiteral value: String) {
+        self.init(str: value)
+    }
+}
+
+// MARK: - ExpressibleByStringInterpolation
+
+extension Peer: ExpressibleByStringInterpolation {
+    init(extendedGraphemeClusterLiteral value: String) {
+        self.init(str: value)
+    }
+}
+
+// MARK: - Codable
+
+extension Peer: Codable {
+    init(from decoder: any Decoder) throws {
+        id = try decoder.singleValueContainer().decode(String.self)
+    }
+    
+    func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(id)
+    }
+}
+
+// MARK: - Convenience Inits
+
+extension Peer {
+    init(str: String) {
+        id = str.lowercased()
+    }
+    
+    init(str: String.SubSequence) {
+        self.init(str: String(str))
+    }
+    
+    init?(data: Data) {
+        guard let str = String(data: data, encoding: .utf8) else {
+            return nil
+        }
+        self.init(str: str)
+    }
+}
+
+// MARK: - Noise Public Key Helpers
+
+extension Peer {
+    /// Derive the stable 16-hex peer ID from a Noise static public key
+    init(publicKey: Data) {
+        let digest = SHA256.hash(data: publicKey)
+        let hex = digest.map { String(format: "%02x", $0) }.joined()
+        self.init(str: hex.prefix(16))
+    }
+    
+    /// Returns a 16-hex short peer ID derived from a 64-hex Noise public key if needed
+    func toShort() -> Peer {
+        if id.count == Constants.maxIDLength, let data = Data(hexString: id) {
+            return Peer(publicKey: data)
+        }
+        return self
+    }
+}

bitchat/Models/ReadReceipt.swift

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

bitchat/Models/RequestSyncPacket.swift

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

bitchat/Noise/NoiseHandshakeCoordinator.swift

@@ -6,6 +6,7 @@
 // For more information, see <https://unlicense.org>
 //
 
+import BitLogger
 import Foundation
 
 /// Coordinates Noise handshakes to prevent race conditions and ensure reliable encryption establishment

bitchat/Noise/NoiseProtocol.swift

@@ -77,6 +77,7 @@
 /// - Noise Specification: http://www.noiseprotocol.org/noise.html
 ///
 
+import BitLogger
 import Foundation
 import CryptoKit
 

bitchat/Noise/NoiseSecurityConsiderations.swift

@@ -6,6 +6,7 @@
 // For more information, see <https://unlicense.org>
 //
 
+import BitLogger
 import Foundation
 import CryptoKit
 
@@ -52,11 +53,6 @@ struct NoiseSecurityValidator {
     static func validateHandshakeMessageSize(_ data: Data) -> Bool {
         return data.count <= NoiseSecurityConstants.maxHandshakeMessageSize
     }
-    
-    /// Validate peer ID format using unified validator
-    static func validatePeerID(_ peerID: String) -> Bool {
-        return InputValidator.validatePeerID(peerID)
-    }
 }
 
 // MARK: - Enhanced Noise Session with Security
@@ -136,8 +132,8 @@ final class SecureNoiseSession: NoiseSession {
 // MARK: - Rate Limiter
 
 final class NoiseRateLimiter {
-    private var handshakeTimestamps: [String: [Date]] = [:] // peerID -> timestamps
+    private var handshakeTimestamps: [Peer: [Date]] = [:] // Peer -> timestamps
-    private var messageTimestamps: [String: [Date]] = [:] // peerID -> timestamps
+    private var messageTimestamps: [Peer: [Date]] = [:] // Peer -> timestamps
     
     // Global rate limiting
     private var globalHandshakeTimestamps: [Date] = []
@@ -145,7 +141,7 @@ final class NoiseRateLimiter {
     
     private let queue = DispatchQueue(label: "chat.bitchat.noise.ratelimit", attributes: .concurrent)
     
-    func allowHandshake(from peerID: String) -> Bool {
+    func allowHandshake(from peer: Peer) -> Bool {
         return queue.sync(flags: .barrier) {
             let now = Date()
             let oneMinuteAgo = now.addingTimeInterval(-60)
@@ -158,23 +154,23 @@ final class NoiseRateLimiter {
             }
             
             // Check per-peer rate limit
-            var timestamps = handshakeTimestamps[peerID] ?? []
+            var timestamps = handshakeTimestamps[peer] ?? []
             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)
+                SecureLogger.warning("Per-peer handshake rate limit exceeded for \(peer.id): \(timestamps.count)/\(NoiseSecurityConstants.maxHandshakesPerMinute) per minute", category: .security)
                 return false
             }
             
             // Record new handshake
             timestamps.append(now)
-            handshakeTimestamps[peerID] = timestamps
+            handshakeTimestamps[peer] = timestamps
             globalHandshakeTimestamps.append(now)
             return true
         }
     }
     
-    func allowMessage(from peerID: String) -> Bool {
+    func allowMessage(from peer: Peer) -> Bool {
         return queue.sync(flags: .barrier) {
             let now = Date()
             let oneSecondAgo = now.addingTimeInterval(-1)
@@ -187,26 +183,35 @@ final class NoiseRateLimiter {
             }
             
             // Check per-peer rate limit
-            var timestamps = messageTimestamps[peerID] ?? []
+            var timestamps = messageTimestamps[peer] ?? []
             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)
+                SecureLogger.warning("Per-peer message rate limit exceeded for \(peer.id): \(timestamps.count)/\(NoiseSecurityConstants.maxMessagesPerSecond) per second", category: .security)
                 return false
             }
             
             // Record new message
             timestamps.append(now)
-            messageTimestamps[peerID] = timestamps
+            messageTimestamps[peer] = timestamps
             globalMessageTimestamps.append(now)
             return true
         }
     }
     
-    func reset(for peerID: String) {
+    func reset(for peer: Peer) {
         queue.async(flags: .barrier) {
-            self.handshakeTimestamps.removeValue(forKey: peerID)
+            self.handshakeTimestamps.removeValue(forKey: peer)
-            self.messageTimestamps.removeValue(forKey: peerID)
+            self.messageTimestamps.removeValue(forKey: peer)
+        }
+    }
+
+    func resetAll() {
+        queue.async(flags: .barrier) {
+            self.handshakeTimestamps.removeAll()
+            self.messageTimestamps.removeAll()
+            self.globalHandshakeTimestamps.removeAll()
+            self.globalMessageTimestamps.removeAll()
         }
     }
 }

bitchat/Noise/NoiseSession.swift

@@ -6,6 +6,7 @@
 // For more information, see <https://unlicense.org>
 //
 
+import BitLogger
 import Foundation
 import CryptoKit
 
@@ -307,6 +308,15 @@ final class NoiseSessionManager {
             _ = 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 {

bitchat/Nostr/GeoRelayDirectory.swift

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

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 Peer(publicKey: maybeData).id
             } else if maybeData.count == 8 {
                 // Already an 8-byte peer ID
                 return recipientPeerID

bitchat/Nostr/NostrIdentity.swift

@@ -150,13 +150,31 @@ struct NostrIdentityBridge {
     
     /// Clear all Nostr identity associations and current identity
     static func clearAllAssociations() {
-        // Delete current Nostr identity
+        let query: [String: Any] = [
-        KeychainHelper.delete(key: currentIdentityKey, service: keychainService)
+            kSecClass as String: kSecClassGenericPassword,
-        KeychainHelper.delete(key: deviceSeedKey, service: keychainService)
+            kSecAttrService as String: keychainService,
-        
+            kSecMatchLimit as String: kSecMatchLimitAll,
-        // Note: We can't efficiently delete all noise-nostr associations 
+            kSecReturnAttributes as String: true
-        // without tracking them, but they'll be orphaned and eventually cleaned up
+        ]
-        // The important part is deleting the current identity so a new one is generated
+
+        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)

bitchat/Nostr/NostrProtocol.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import CryptoKit
 import P256K

bitchat/Nostr/NostrRelayManager.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import Network
 import Combine
@@ -34,10 +35,12 @@ final class NostrRelayManager: ObservableObject {
         "wss://nostr21.com"
         // For local testing, you can add: "ws://localhost:8080"
     ]
+    private static let defaultRelaySet = Set(defaultRelays)
     
     @Published private(set) var relays: [Relay] = []
     @Published private(set) var isConnected = false
     
+    private var allowDefaultRelays: Bool = false
     private var 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)
@@ -64,6 +67,8 @@ final class NostrRelayManager: ObservableObject {
     private let messageQueueLock = NSLock()
     private let encoder = JSONEncoder()
     private let decoder = JSONDecoder()
+    private var networkService: NetworkActivationService { NetworkActivationService.shared }
+    private var shouldUseTor: Bool { networkService.userTorEnabled }
     
     // Exponential backoff configuration
     private let initialBackoffInterval: TimeInterval = TransportConfig.nostrRelayInitialBackoffSeconds
@@ -77,27 +82,45 @@ final class NostrRelayManager: ObservableObject {
     private var connectionGeneration: Int = 0
     
     init() {
-        // Initialize with default relays
+        let hasMutual = !FavoritesPersistenceService.shared.mutualFavorites.isEmpty
-        self.relays = Self.defaultRelays.map { Relay(url: $0) }
+        allowDefaultRelays = hasMutual
+        if hasMutual {
+            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)
+            }
+            .store(in: &cancellables)
     }
     
     /// Connect to all configured relays
     func connect() {
-        // Ensure Tor is started early and wait for readiness off-main; then hop back to connect.
+        // Global network policy gate
-        Task.detached {
+        guard networkService.activationAllowed else { return }
-            let ready = await TorManager.shared.awaitReady()
+        if shouldUseTor {
-            await MainActor.run {
+            // Ensure Tor is started early and wait for readiness off-main; then hop back to connect.
-                if !ready {
+            Task.detached {
-                    SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
+                let ready = await TorManager.shared.awaitReady()
-                    return
+                await MainActor.run {
-                }
+                    if !ready {
-                SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
+                        SecureLogger.error("❌ Tor not ready; aborting relay connections (fail-closed)", category: .session)
-                for relay in self.relays {
+                        return
-                    self.connectToRelay(relay.url)
+                    }
+                    SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (via Tor)", category: .session)
+                    for relay in self.relays {
+                        self.connectToRelay(relay.url)
+                    }
                 }
             }
+        } else {
+            SecureLogger.debug("🌐 Connecting to \(self.relays.count) Nostr relays (direct)", category: .session)
+            for relay in self.relays {
+                connectToRelay(relay.url)
+            }
         }
     }
     
@@ -116,7 +139,11 @@ final class NostrRelayManager: ObservableObject {
     
     /// Ensure connections exist to the given relay URLs (idempotent).
     func ensureConnections(to relayUrls: [String]) {
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        // Global network policy gate
+        guard networkService.activationAllowed else { return }
+        let targets = allowedRelayList(from: relayUrls)
+        guard !targets.isEmpty else { return }
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer until Tor is fully ready; avoid queuing connection attempts early
             Task.detached { [weak self] in
                 guard let self = self else { return }
@@ -125,20 +152,21 @@ final class NostrRelayManager: ObservableObject {
             }
             return
         }
-        let existing = Set(relays.map { $0.url })
+        var existing = Set(relays.map { $0.url })
-        for url in Set(relayUrls) {
+        for url in targets where !existing.contains(url) {
-            if !existing.contains(url) {
+            relays.append(Relay(url: url))
-                relays.append(Relay(url: url))
+            existing.insert(url)
-            }
+        }
-            if connections[url] == nil {
+        for url in targets where connections[url] == nil {
-                connectToRelay(url)
+            connectToRelay(url)
-            }
         }
     }
 
     /// Send an event to specified relays (or all if none specified)
     func sendEvent(_ event: NostrEvent, to relayUrls: [String]? = nil) {
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        // Global network policy gate
+        guard networkService.activationAllowed else { return }
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer sends until Tor is ready to avoid premature queueing
             Task.detached { [weak self] in
                 guard let self = self else { return }
@@ -147,7 +175,9 @@ final class NostrRelayManager: ObservableObject {
             }
             return
         }
-        let targetRelays = relayUrls ?? Self.defaultRelays
+        let requestedRelays = relayUrls ?? Self.defaultRelays
+        let targetRelays = allowedRelayList(from: requestedRelays)
+        guard !targetRelays.isEmpty else { return }
         ensureConnections(to: targetRelays)
 
         // Attempt immediate send to relays with active connections; queue the rest
@@ -212,6 +242,8 @@ final class NostrRelayManager: ObservableObject {
         handler: @escaping (NostrEvent) -> Void,
         onEOSE: (() -> Void)? = nil
     ) {
+        // Global network policy gate
+        guard networkService.activationAllowed else { return }
         // Coalesce rapid duplicate subscribe requests only if a handler already exists
         let now = Date()
         if messageHandlers[id] != nil {
@@ -220,7 +252,7 @@ final class NostrRelayManager: ObservableObject {
             }
         }
         subscribeCoalesce[id] = now
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             // Defer subscription setup until Tor is ready; avoid queuing subs early
             Task.detached { [weak self] in
                 guard let self = self else { return }
@@ -248,32 +280,37 @@ final class NostrRelayManager: ObservableObject {
             
             // Target specific relays if provided; else default. Filter permanently failed relays.
             let baseUrls = relayUrls ?? Self.defaultRelays
-            let urls = baseUrls.filter { !isPermanentlyFailed($0) }
+            let candidateUrls = baseUrls.filter { !isPermanentlyFailed($0) }
+            let urls = allowedRelayList(from: candidateUrls)
             // Always queue subscriptions; sending happens when a relay reports connected
             let existingSet = Set(relays.map { $0.url })
             for url in urls where !existingSet.contains(url) {
                 relays.append(Relay(url: url))
             }
-            for url in urls {
+            for url in candidateUrls {
                 var map = self.pendingSubscriptions[url] ?? [:]
                 map[id] = messageString
                 self.pendingSubscriptions[url] = map
             }
             // Initialize EOSE tracking if requested
             if let onEOSE = onEOSE {
-                var tracker = EOSETracker(pendingRelays: Set(urls), callback: onEOSE, timer: nil)
+                if urls.isEmpty {
-                // Fallback timeout to avoid hanging if a relay never sends EOSE
+                    onEOSE()
-                tracker.timer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
+                } else {
-                    Task { @MainActor in
+                    var tracker = EOSETracker(pendingRelays: Set(urls), callback: onEOSE, timer: nil)
-                        guard let self = self else { return }
+                    // Fallback timeout to avoid hanging if a relay never sends EOSE
-                        if let t = self.eoseTrackers[id] {
+                    tracker.timer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
-                            t.timer?.invalidate()
+                        Task { @MainActor in
-                            self.eoseTrackers.removeValue(forKey: id)
+                            guard let self = self else { return }
-                            onEOSE()
+                            if let t = self.eoseTrackers[id] {
+                                t.timer?.invalidate()
+                                self.eoseTrackers.removeValue(forKey: id)
+                                onEOSE()
+                            }
                         }
                     }
+                    eoseTrackers[id] = tracker
                 }
-                eoseTrackers[id] = tracker
             }
             SecureLogger.debug("📋 Queued subscription id=\(id) for \(urls.count) relay(s)", category: .session)
             // Ensure we actually have sockets opening to these relays so queued REQs can flush
@@ -288,6 +325,54 @@ final class NostrRelayManager: ObservableObject {
             SecureLogger.error("❌ Failed to encode subscription request: \(error)", category: .session)
         }
     }
+
+    private func updateDefaultRelayPolicy(hasMutual: Bool) {
+        guard hasMutual != allowDefaultRelays else { return }
+        allowDefaultRelays = hasMutual
+        if hasMutual {
+            var existing = Set(relays.map { $0.url })
+            for url in Self.defaultRelays where !existing.contains(url) {
+                relays.append(Relay(url: url))
+                existing.insert(url)
+            }
+            if networkService.activationAllowed {
+                ensureConnections(to: Self.defaultRelays)
+            }
+        } else {
+            for url in Self.defaultRelays {
+                if let connection = connections[url] {
+                    connection.cancel(with: .goingAway, reason: nil)
+                }
+                connections.removeValue(forKey: url)
+                subscriptions.removeValue(forKey: url)
+            }
+            messageQueueLock.lock()
+            for index in (0..<messageQueue.count).reversed() {
+                var item = messageQueue[index]
+                item.pendingRelays.subtract(Self.defaultRelaySet)
+                if item.pendingRelays.isEmpty {
+                    messageQueue.remove(at: index)
+                } else {
+                    messageQueue[index] = item
+                }
+            }
+            messageQueueLock.unlock()
+            relays.removeAll { Self.defaultRelaySet.contains($0.url) }
+            updateConnectionStatus()
+        }
+    }
+
+    private func allowedRelayList(from urls: [String]) -> [String] {
+        var seen = Set<String>()
+        var result: [String] = []
+        for url in urls {
+            if !allowDefaultRelays && Self.defaultRelaySet.contains(url) { continue }
+            if seen.insert(url).inserted {
+                result.append(url)
+            }
+        }
+        return result
+    }
     
     /// Unsubscribe from a subscription
     func unsubscribe(id: String) {
@@ -316,13 +401,15 @@ final class NostrRelayManager: ObservableObject {
     // MARK: - Private Methods
     
     private func connectToRelay(_ urlString: String) {
+        // Global network policy gate
+        guard networkService.activationAllowed else { return }
         guard let url = URL(string: urlString) else { 
             SecureLogger.warning("Invalid relay URL: \(urlString)", category: .session)
             return 
         }
 
         // Avoid initiating connections while app is backgrounded; we'll reconnect on foreground
-        if TorManager.shared.torEnforced && !TorManager.shared.isForeground() {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isForeground() {
             return
         }
         
@@ -337,7 +424,7 @@ final class NostrRelayManager: ObservableObject {
         // Attempting to connect to Nostr relay via the proxied session
         
         // If Tor is enforced but not ready, delay connection until it is.
-        if TorManager.shared.torEnforced && !TorManager.shared.isReady {
+        if shouldUseTor && TorManager.shared.torEnforced && !TorManager.shared.isReady {
             Task.detached { [weak self] in
                 guard let self = self else { return }
                 let ready = await TorManager.shared.awaitReady()
@@ -522,6 +609,13 @@ final class NostrRelayManager: ObservableObject {
     }
     
     private func handleDisconnection(relayUrl: String, error: Error) {
+        // If networking is disallowed, do not schedule reconnection
+        if !networkService.activationAllowed {
+            connections.removeValue(forKey: relayUrl)
+            subscriptions.removeValue(forKey: relayUrl)
+            updateRelayStatus(relayUrl, isConnected: false, error: error)
+            return
+        }
         connections.removeValue(forKey: relayUrl)
         subscriptions.removeValue(forKey: relayUrl)
         updateRelayStatus(relayUrl, isConnected: false, error: error)

bitchat/Protocols/BinaryProtocol.swift

@@ -328,236 +328,3 @@ struct BinaryProtocol {
         }
     }
 }
-
-// Binary encoding for BitchatMessage
-extension BitchatMessage {
-    func toBinaryPayload() -> Data? {
-        var data = Data()
-        
-        // Message format:
-        // - Flags: 1 byte (bit 0: isRelay, bit 1: isPrivate, bit 2: hasOriginalSender, bit 3: hasRecipientNickname, bit 4: hasSenderPeerID, bit 5: hasMentions)
-        // - Timestamp: 8 bytes (seconds since epoch)
-        // - ID length: 1 byte
-        // - ID: variable
-        // - Sender length: 1 byte
-        // - Sender: variable
-        // - Content length: 2 bytes
-        // - Content: variable
-        // Optional fields based on flags:
-        // - Original sender length + data
-        // - Recipient nickname length + data
-        // - Sender peer ID length + data
-        // - Mentions array
-        
-        var flags: UInt8 = 0
-        if isRelay { flags |= 0x01 }
-        if isPrivate { flags |= 0x02 }
-        if originalSender != nil { flags |= 0x04 }
-        if recipientNickname != nil { flags |= 0x08 }
-        if senderPeerID != nil { flags |= 0x10 }
-        if mentions != nil && !mentions!.isEmpty { flags |= 0x20 }
-        
-        data.append(flags)
-        
-        // Timestamp (in milliseconds)
-        let timestampMillis = UInt64(timestamp.timeIntervalSince1970 * 1000)
-        // Encode as 8 bytes, big-endian
-        for i in (0..<8).reversed() {
-            data.append(UInt8((timestampMillis >> (i * 8)) & 0xFF))
-        }
-        
-        // ID
-        if let idData = id.data(using: .utf8) {
-            data.append(UInt8(min(idData.count, 255)))
-            data.append(idData.prefix(255))
-        } else {
-            data.append(0)
-        }
-        
-        // Sender
-        if let senderData = sender.data(using: .utf8) {
-            data.append(UInt8(min(senderData.count, 255)))
-            data.append(senderData.prefix(255))
-        } else {
-            data.append(0)
-        }
-        
-        // Content
-        if let contentData = content.data(using: .utf8) {
-            let length = UInt16(min(contentData.count, 65535))
-            // Encode length as 2 bytes, big-endian
-            data.append(UInt8((length >> 8) & 0xFF))
-            data.append(UInt8(length & 0xFF))
-            data.append(contentData.prefix(Int(length)))
-        } else {
-            data.append(contentsOf: [0, 0])
-        }
-        
-        // Optional fields
-        if let originalSender = originalSender, let origData = originalSender.data(using: .utf8) {
-            data.append(UInt8(min(origData.count, 255)))
-            data.append(origData.prefix(255))
-        }
-        
-        if let recipientNickname = recipientNickname, let recipData = recipientNickname.data(using: .utf8) {
-            data.append(UInt8(min(recipData.count, 255)))
-            data.append(recipData.prefix(255))
-        }
-        
-        if let senderPeerID = senderPeerID, let peerData = senderPeerID.data(using: .utf8) {
-            data.append(UInt8(min(peerData.count, 255)))
-            data.append(peerData.prefix(255))
-        }
-        
-        // Mentions array
-        if let mentions = mentions {
-            data.append(UInt8(min(mentions.count, 255))) // Number of mentions
-            for mention in mentions.prefix(255) {
-                if let mentionData = mention.data(using: .utf8) {
-                    data.append(UInt8(min(mentionData.count, 255)))
-                    data.append(mentionData.prefix(255))
-                } else {
-                    data.append(0)
-                }
-            }
-        }
-        
-        
-        return data
-    }
-    
-    static func fromBinaryPayload(_ data: Data) -> BitchatMessage? {
-        // Create an immutable copy to prevent threading issues
-        let dataCopy = Data(data)
-        
-        
-        guard dataCopy.count >= 13 else { 
-            return nil 
-        }
-        
-        var offset = 0
-        
-        // Flags
-        guard offset < dataCopy.count else { 
-            return nil 
-        }
-        let flags = dataCopy[offset]; offset += 1
-        let isRelay = (flags & 0x01) != 0
-        let isPrivate = (flags & 0x02) != 0
-        let hasOriginalSender = (flags & 0x04) != 0
-        let hasRecipientNickname = (flags & 0x08) != 0
-        let hasSenderPeerID = (flags & 0x10) != 0
-        let hasMentions = (flags & 0x20) != 0
-        
-        // Timestamp
-        guard offset + 8 <= dataCopy.count else { 
-            return nil 
-        }
-        let timestampData = dataCopy[offset..<offset+8]
-        let timestampMillis = timestampData.reduce(0) { result, byte in
-            (result << 8) | UInt64(byte)
-        }
-        offset += 8
-        let timestamp = Date(timeIntervalSince1970: TimeInterval(timestampMillis) / 1000.0)
-        
-        // ID
-        guard offset < dataCopy.count else { 
-            return nil 
-        }
-        let idLength = Int(dataCopy[offset]); offset += 1
-        guard offset + idLength <= dataCopy.count else { 
-            return nil 
-        }
-        let id = String(data: dataCopy[offset..<offset+idLength], encoding: .utf8) ?? UUID().uuidString
-        offset += idLength
-        
-        // Sender
-        guard offset < dataCopy.count else { 
-            return nil 
-        }
-        let senderLength = Int(dataCopy[offset]); offset += 1
-        guard offset + senderLength <= dataCopy.count else { 
-            return nil 
-        }
-        let sender = String(data: dataCopy[offset..<offset+senderLength], encoding: .utf8) ?? "unknown"
-        offset += senderLength
-        
-        // Content
-        guard offset + 2 <= dataCopy.count else { 
-            return nil 
-        }
-        let contentLengthData = dataCopy[offset..<offset+2]
-        let contentLength = Int(contentLengthData.reduce(0) { result, byte in
-            (result << 8) | UInt16(byte)
-        })
-        offset += 2
-        guard offset + contentLength <= dataCopy.count else { 
-            return nil 
-        }
-        
-        let content = String(data: dataCopy[offset..<offset+contentLength], encoding: .utf8) ?? ""
-        offset += contentLength
-        
-        // Optional fields
-        var originalSender: String?
-        if hasOriginalSender && offset < dataCopy.count {
-            let length = Int(dataCopy[offset]); offset += 1
-            if offset + length <= dataCopy.count {
-                originalSender = String(data: dataCopy[offset..<offset+length], encoding: .utf8)
-                offset += length
-            }
-        }
-        
-        var recipientNickname: String?
-        if hasRecipientNickname && offset < dataCopy.count {
-            let length = Int(dataCopy[offset]); offset += 1
-            if offset + length <= dataCopy.count {
-                recipientNickname = String(data: dataCopy[offset..<offset+length], encoding: .utf8)
-                offset += length
-            }
-        }
-        
-        var senderPeerID: String?
-        if hasSenderPeerID && offset < dataCopy.count {
-            let length = Int(dataCopy[offset]); offset += 1
-            if offset + length <= dataCopy.count {
-                senderPeerID = String(data: dataCopy[offset..<offset+length], encoding: .utf8)
-                offset += length
-            }
-        }
-        
-        // Mentions array
-        var mentions: [String]?
-        if hasMentions && offset < dataCopy.count {
-            let mentionCount = Int(dataCopy[offset]); offset += 1
-            if mentionCount > 0 {
-                mentions = []
-                for _ in 0..<mentionCount {
-                    if offset < dataCopy.count {
-                        let length = Int(dataCopy[offset]); offset += 1
-                        if offset + length <= dataCopy.count {
-                            if let mention = String(data: dataCopy[offset..<offset+length], encoding: .utf8) {
-                                mentions?.append(mention)
-                            }
-                            offset += length
-                        }
-                    }
-                }
-            }
-        }
-        
-        let message = BitchatMessage(
-            id: id,
-            sender: sender,
-            content: content,
-            timestamp: timestamp,
-            isRelay: isRelay,
-            originalSender: originalSender,
-            isPrivate: isPrivate,
-            recipientNickname: recipientNickname,
-            senderPeerID: senderPeerID,
-            mentions: mentions
-        )
-        return message
-    }
-}

bitchat/Protocols/BitchatProtocol.swift

@@ -59,61 +59,6 @@
 ///
 
 import Foundation
-import CryptoKit
-
-// MARK: - Message Padding
-
-/// Provides privacy-preserving message padding to obscure actual content length.
-/// Uses PKCS#7-style padding with random bytes to prevent traffic analysis.
-struct MessagePadding {
-    // Standard block sizes for padding
-    static let blockSizes = [256, 512, 1024, 2048]
-    
-    // Add PKCS#7-style padding to reach target size
-    static func pad(_ data: Data, toSize targetSize: Int) -> Data {
-        guard data.count < targetSize else { return data }
-        
-        let paddingNeeded = targetSize - data.count
-        // Constrain to 255 to fit a single-byte pad length marker
-        guard paddingNeeded > 0 && paddingNeeded <= 255 else { return data }
-        
-        var padded = data
-        // PKCS#7: All pad bytes are equal to the pad length
-        padded.append(contentsOf: Array(repeating: UInt8(paddingNeeded), count: paddingNeeded))
-        return padded
-    }
-    
-    // Remove padding from data
-    static func unpad(_ data: Data) -> Data {
-        guard !data.isEmpty else { return data }
-        let last = data.last!
-        let paddingLength = Int(last)
-        // Must have at least 1 pad byte and not exceed data length
-        guard paddingLength > 0 && paddingLength <= data.count else { return data }
-        // Verify PKCS#7: all last N bytes equal to pad length
-        let start = data.count - paddingLength
-        let tail = data[start...]
-        for b in tail { if b != last { return data } }
-        return Data(data[..<start])
-    }
-    
-    // Find optimal block size for data
-    static func optimalBlockSize(for dataSize: Int) -> Int {
-        // Account for encryption overhead (~16 bytes for AES-GCM tag)
-        let totalSize = dataSize + 16
-        
-        // Find smallest block that fits
-        for blockSize in blockSizes {
-            if totalSize <= blockSize {
-                return blockSize
-            }
-        }
-        
-        // For very large messages, just use the original size
-        // (will be fragmented anyway)
-        return dataSize
-    }
-}
 
 // MARK: - Message Types
 
@@ -125,6 +70,7 @@ enum MessageType: UInt8 {
     case announce = 0x01        // "I'm here" with nickname
     case message = 0x02         // Public chat message  
     case leave = 0x03           // "I'm leaving"
+    case requestSync = 0x21     // GCS filter-based sync request (local-only)
     
     // Noise encryption
     case noiseHandshake = 0x10  // Handshake (init or response determined by payload)
@@ -138,6 +84,7 @@ enum MessageType: UInt8 {
         case .announce: return "announce"
         case .message: return "message"
         case .leave: return "leave"
+        case .requestSync: return "requestSync"
         case .noiseHandshake: return "noiseHandshake"
         case .noiseEncrypted: return "noiseEncrypted"
         case .fragment: return "fragment"
@@ -181,187 +128,6 @@ enum LazyHandshakeState {
     case failed(Error)         // Handshake failed
 }
 
-//
-
-// MARK: - Core Protocol Structures
-
-/// The core packet structure for all BitChat protocol messages.
-/// Encapsulates all data needed for routing through the mesh network,
-/// including TTL for hop limiting and optional encryption.
-/// - Note: Packets larger than BLE MTU (512 bytes) are automatically fragmented
-struct BitchatPacket: Codable {
-    let version: UInt8
-    let type: UInt8
-    let senderID: Data
-    let recipientID: Data?
-    let timestamp: UInt64
-    let payload: Data
-    var signature: Data?
-    var ttl: UInt8
-    
-    init(type: UInt8, senderID: Data, recipientID: Data?, timestamp: UInt64, payload: Data, signature: Data?, ttl: UInt8) {
-        self.version = 1
-        self.type = type
-        self.senderID = senderID
-        self.recipientID = recipientID
-        self.timestamp = timestamp
-        self.payload = payload
-        self.signature = signature
-        self.ttl = ttl
-    }
-    
-    // Convenience initializer for new binary format
-    init(type: UInt8, ttl: UInt8, senderID: String, payload: Data) {
-        self.version = 1
-        self.type = type
-        // Convert hex string peer ID to binary data (8 bytes)
-        var senderData = Data()
-        var tempID = senderID
-        while tempID.count >= 2 {
-            let hexByte = String(tempID.prefix(2))
-            if let byte = UInt8(hexByte, radix: 16) {
-                senderData.append(byte)
-            }
-            tempID = String(tempID.dropFirst(2))
-        }
-        self.senderID = senderData
-        self.recipientID = nil
-        self.timestamp = UInt64(Date().timeIntervalSince1970 * 1000) // milliseconds
-        self.payload = payload
-        self.signature = nil
-        self.ttl = ttl
-    }
-    
-    var data: Data? {
-        BinaryProtocol.encode(self)
-    }
-    
-    func toBinaryData(padding: Bool = true) -> Data? {
-        BinaryProtocol.encode(self, padding: padding)
-    }
-
-    // Backward-compatible helper (defaults to padded encoding)
-    func toBinaryData() -> Data? {
-        toBinaryData(padding: true)
-    }
-    
-    /// Create binary representation for signing (without signature and TTL fields)
-    /// TTL is excluded because it changes during packet relay operations
-    func toBinaryDataForSigning() -> Data? {
-        // Create a copy without signature and with fixed TTL for signing
-        // TTL must be excluded because it changes during relay
-        let unsignedPacket = BitchatPacket(
-            type: type,
-            senderID: senderID,
-            recipientID: recipientID,
-            timestamp: timestamp,
-            payload: payload,
-            signature: nil, // Remove signature for signing
-            ttl: 0 // Use fixed TTL=0 for signing to ensure relay compatibility
-        )
-        return BinaryProtocol.encode(unsignedPacket)
-    }
-    
-    static func from(_ data: Data) -> BitchatPacket? {
-        BinaryProtocol.decode(data)
-    }
-}
-
-//
-
-// MARK: - Read Receipts
-
-// Read receipt structure
-struct ReadReceipt: Codable {
-    let originalMessageID: String
-    let receiptID: String
-    var readerID: String  // Who read it
-    let readerNickname: String
-    let timestamp: Date
-    
-    init(originalMessageID: String, readerID: String, readerNickname: String) {
-        self.originalMessageID = originalMessageID
-        self.receiptID = UUID().uuidString
-        self.readerID = readerID
-        self.readerNickname = readerNickname
-        self.timestamp = Date()
-    }
-    
-    // For binary decoding
-    private init(originalMessageID: String, receiptID: String, readerID: String, readerNickname: String, timestamp: Date) {
-        self.originalMessageID = originalMessageID
-        self.receiptID = receiptID
-        self.readerID = readerID
-        self.readerNickname = readerNickname
-        self.timestamp = timestamp
-    }
-    
-    func encode() -> Data? {
-        try? JSONEncoder().encode(self)
-    }
-    
-    static func decode(from data: Data) -> ReadReceipt? {
-        try? JSONDecoder().decode(ReadReceipt.self, from: data)
-    }
-    
-    // MARK: - Binary Encoding
-    
-    func toBinaryData() -> Data {
-        var data = Data()
-        data.appendUUID(originalMessageID)
-        data.appendUUID(receiptID)
-        // ReaderID as 8-byte hex string
-        var readerData = Data()
-        var tempID = readerID
-        while tempID.count >= 2 && readerData.count < 8 {
-            let hexByte = String(tempID.prefix(2))
-            if let byte = UInt8(hexByte, radix: 16) {
-                readerData.append(byte)
-            }
-            tempID = String(tempID.dropFirst(2))
-        }
-        while readerData.count < 8 {
-            readerData.append(0)
-        }
-        data.append(readerData)
-        data.appendDate(timestamp)
-        data.appendString(readerNickname)
-        return data
-    }
-    
-    static func fromBinaryData(_ data: Data) -> ReadReceipt? {
-        // Create defensive copy
-        let dataCopy = Data(data)
-        
-        // Minimum size: 2 UUIDs (32) + readerID (8) + timestamp (8) + min nickname
-        guard dataCopy.count >= 49 else { return nil }
-        
-        var offset = 0
-        
-        guard let originalMessageID = dataCopy.readUUID(at: &offset),
-              let receiptID = dataCopy.readUUID(at: &offset) else { return nil }
-        
-        guard let readerIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
-        let readerID = readerIDData.hexEncodedString()
-        guard InputValidator.validatePeerID(readerID) else { return nil }
-        
-        guard let timestamp = dataCopy.readDate(at: &offset),
-              InputValidator.validateTimestamp(timestamp),
-              let readerNicknameRaw = dataCopy.readString(at: &offset),
-              let readerNickname = InputValidator.validateNickname(readerNicknameRaw) else { return nil }
-        
-        return ReadReceipt(originalMessageID: originalMessageID,
-                          receiptID: receiptID,
-                          readerID: readerID,
-                          readerNickname: readerNickname,
-                          timestamp: timestamp)
-    }
-}
-
-
-//
-
-
 // MARK: - Delivery Status
 
 // Delivery status for messages
@@ -391,74 +157,6 @@ enum DeliveryStatus: Codable, Equatable {
     }
 }
 
-// MARK: - Message Model
-
-/// Represents a user-visible message in the BitChat system.
-/// Handles both broadcast messages and private encrypted messages,
-/// with support for mentions, replies, and delivery tracking.
-/// - Note: This is the primary data model for chat messages
-final class BitchatMessage: Codable {
-    let id: String
-    let sender: String
-    let content: String
-    let timestamp: Date
-    let isRelay: Bool
-    let originalSender: String?
-    let isPrivate: Bool
-    let recipientNickname: String?
-    let senderPeerID: String?
-    let mentions: [String]?  // Array of mentioned nicknames
-    var deliveryStatus: DeliveryStatus? // Delivery tracking
-    
-    // Cached formatted text (not included in Codable)
-    private var _cachedFormattedText: [String: AttributedString] = [:]
-    
-    func getCachedFormattedText(isDark: Bool, isSelf: Bool) -> AttributedString? {
-        return _cachedFormattedText["\(isDark)-\(isSelf)"]
-    }
-    
-    func setCachedFormattedText(_ text: AttributedString, isDark: Bool, isSelf: Bool) {
-        _cachedFormattedText["\(isDark)-\(isSelf)"] = text
-    }
-    
-    // Codable implementation
-    enum CodingKeys: String, CodingKey {
-        case id, sender, content, timestamp, isRelay, originalSender
-        case isPrivate, recipientNickname, senderPeerID, mentions, deliveryStatus
-    }
-    
-    init(id: String? = nil, sender: String, content: String, timestamp: Date, isRelay: Bool, originalSender: String? = nil, isPrivate: Bool = false, recipientNickname: String? = nil, senderPeerID: String? = nil, mentions: [String]? = nil, deliveryStatus: DeliveryStatus? = nil) {
-        self.id = id ?? UUID().uuidString
-        self.sender = sender
-        self.content = content
-        self.timestamp = timestamp
-        self.isRelay = isRelay
-        self.originalSender = originalSender
-        self.isPrivate = isPrivate
-        self.recipientNickname = recipientNickname
-        self.senderPeerID = senderPeerID
-        self.mentions = mentions
-        self.deliveryStatus = deliveryStatus ?? (isPrivate ? .sending : nil)
-    }
-}
-
-// Equatable conformance for BitchatMessage
-extension BitchatMessage: Equatable {
-    static func == (lhs: BitchatMessage, rhs: BitchatMessage) -> Bool {
-        return lhs.id == rhs.id &&
-               lhs.sender == rhs.sender &&
-               lhs.content == rhs.content &&
-               lhs.timestamp == rhs.timestamp &&
-               lhs.isRelay == rhs.isRelay &&
-               lhs.originalSender == rhs.originalSender &&
-               lhs.isPrivate == rhs.isPrivate &&
-               lhs.recipientNickname == rhs.recipientNickname &&
-               lhs.senderPeerID == rhs.senderPeerID &&
-               lhs.mentions == rhs.mentions &&
-               lhs.deliveryStatus == rhs.deliveryStatus
-    }
-}
-
 // MARK: - Delegate Protocol
 
 protocol BitchatDelegate: AnyObject {
@@ -495,37 +193,3 @@ extension BitchatDelegate {
         // Default empty implementation
     }
 }
-
-// MARK: - Noise Payload Helpers
-
-/// Helper to create typed Noise payloads
-struct NoisePayload {
-    let type: NoisePayloadType
-    let data: Data
-    
-    /// Encode payload with type prefix
-    func encode() -> Data {
-        var encoded = Data()
-        encoded.append(type.rawValue)
-        encoded.append(data)
-        return encoded
-    }
-    
-    /// Decode payload from data
-    static func decode(_ data: Data) -> NoisePayload? {
-        // Ensure we have at least 1 byte for the type
-        guard !data.isEmpty else {
-            return nil
-        }
-        
-        // Safely get the first byte
-        let firstByte = data[data.startIndex]
-        guard let type = NoisePayloadType(rawValue: firstByte) else {
-            return nil
-        }
-        
-        // Create a proper Data copy (not a subsequence) for thread safety
-        let payloadData = data.count > 1 ? Data(data.dropFirst()) : Data()
-        return NoisePayload(type: type, data: payloadData)
-    }
-}

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

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import CoreBluetooth
 import Combine
@@ -88,8 +89,9 @@ final class BLEService: NSObject {
     
     var myPeerID: String = ""
     var myNickname: String = "anon"
-    private let noiseService: NoiseEncryptionService
+    private var noiseService: NoiseEncryptionService
     private let identityManager: SecureIdentityStateManagerProtocol
+    private let keychain: KeychainManagerProtocol
     private var myPeerIDData: Data = Data()
 
     // MARK: - Advertising Privacy
@@ -138,6 +140,9 @@ final class BLEService: NSObject {
     private var pendingDirectedRelays: [String: [String: (packet: BitchatPacket, enqueuedAt: Date)]] = [:]
     // Debounce for 'reconnected' logs
     private var lastReconnectLogAt: [String: Date] = [:]
+
+    // MARK: - Gossip Sync
+    private var gossipSyncManager: GossipSyncManager?
     
     // MARK: - Maintenance Timer
     
@@ -326,33 +331,44 @@ final class BLEService: NSObject {
         }
     }
     
-    init(keychain: KeychainManagerProtocol, identityManager: SecureIdentityStateManagerProtocol) {
+    private func configureNoiseServiceCallbacks(for service: NoiseEncryptionService) {
-        noiseService = NoiseEncryptionService(keychain: keychain)
+        service.onPeerAuthenticated = { [weak self] peerID, fingerprint in
-        self.identityManager = identityManager
-        super.init()
-        
-        // Derive stable peer ID from Noise static public key fingerprint (first 8 bytes → 16 hex chars)
-        let fingerprint = noiseService.getIdentityFingerprint() // 64 hex chars
-        self.myPeerID = String(fingerprint.prefix(16))
-        self.myPeerIDData = Data(hexString: myPeerID) ?? Data()
-        
-        // Set queue key for identification
-        messageQueue.setSpecific(key: messageQueueKey, value: ())
-        
-        // Set up Noise session establishment callback
-        // This ensures we send pending messages only when session is truly established
-        noiseService.onPeerAuthenticated = { [weak self] peerID, fingerprint in
             SecureLogger.debug("🔐 Noise session authenticated with \(peerID), fingerprint: \(fingerprint.prefix(16))...")
-            // Send any messages that were queued during handshake
             self?.messageQueue.async { [weak self] in
                 self?.sendPendingMessagesAfterHandshake(for: peerID)
                 self?.sendPendingNoisePayloadsAfterHandshake(for: peerID)
             }
-            // Proactive presence nudge: announce immediately after handshake
             self?.messageQueue.async { [weak self] in
                 self?.sendAnnounce(forceSend: true)
             }
         }
+    }
+
+    private func refreshPeerIdentity() {
+        let fingerprint = noiseService.getIdentityFingerprint()
+        myPeerID = String(fingerprint.prefix(16))
+        myPeerIDData = Data(hexString: myPeerID) ?? Data()
+    }
+
+    private func restartGossipManager() {
+        gossipSyncManager?.stop()
+        let sync = GossipSyncManager(myPeerID: myPeerID)
+        sync.delegate = self
+        sync.start()
+        gossipSyncManager = sync
+    }
+
+    init(keychain: KeychainManagerProtocol, identityManager: SecureIdentityStateManagerProtocol) {
+        self.keychain = keychain
+        noiseService = NoiseEncryptionService(keychain: keychain)
+        self.identityManager = identityManager
+        super.init()
+        
+        configureNoiseServiceCallbacks(for: noiseService)
+        refreshPeerIdentity()
+        
+        // Set queue key for identification
+        messageQueue.setSpecific(key: messageQueueKey, value: ())
         
         // Set up application state tracking (iOS only)
         #if os(iOS)
@@ -398,9 +414,12 @@ final class BLEService: NSObject {
         }
         timer.resume()
         maintenanceTimer = timer
-        
+
         // Publish initial empty state
         requestPeerDataPublish()
+
+        // Initialize gossip sync manager
+        restartGossipManager()
     }
     
     func setNickname(_ nickname: String) {
@@ -537,23 +556,13 @@ final class BLEService: NSObject {
     
     func isPeerConnected(_ peerID: String) -> Bool {
         // Accept both 16-hex short IDs and 64-hex Noise keys
-        let shortID: String = {
+        let shortID = Peer(str: peerID).toShort().id
-            if peerID.count == 64, let key = Data(hexString: peerID) {
-                return PeerIDUtils.derivePeerID(fromPublicKey: key)
-            }
-            return peerID
-        }()
         return collectionsQueue.sync { peers[shortID]?.isConnected ?? false }
     }
 
     func isPeerReachable(_ peerID: String) -> Bool {
         // Accept both 16-hex short IDs and 64-hex Noise keys
-        let shortID: String = {
+        let shortID = Peer(str: peerID).toShort().id
-            if peerID.count == 64, let key = Data(hexString: peerID) {
-                return PeerIDUtils.derivePeerID(fromPublicKey: key)
-            }
-            return peerID
-        }()
         return collectionsQueue.sync {
             // Must be mesh-attached: at least one live direct link to the mesh
             let meshAttached = peers.values.contains { $0.isConnected }
@@ -607,10 +616,11 @@ final class BLEService: NSObject {
         var payload = Data([NoisePayloadType.readReceipt.rawValue])
         payload.append(contentsOf: receipt.originalMessageID.utf8)
 
-        if noiseService.hasEstablishedSession(with: peerID) {
+        let peer = Peer(str: peerID)
+        if noiseService.hasEstablishedSession(with: peer) {
             SecureLogger.debug("📤 Sending READ receipt for message \(receipt.originalMessageID) to \(peerID)", category: .session)
             do {
-                let encrypted = try noiseService.encrypt(payload, for: peerID)
+                let encrypted = try noiseService.encrypt(payload, for: peer)
                 let packet = BitchatPacket(
                     type: MessageType.noiseEncrypted.rawValue,
                     senderID: myPeerIDData,
@@ -634,7 +644,7 @@ final class BLEService: NSObject {
                 guard let self = self else { return }
                 self.pendingNoisePayloadsAfterHandshake[peerID, default: []].append(payload)
             }
-            if !noiseService.hasSession(with: peerID) { initiateNoiseHandshake(with: peerID) }
+            if !noiseService.hasSession(with: peer) { initiateNoiseHandshake(with: peerID) }
             SecureLogger.debug("🕒 Queued READ receipt for \(peerID) until handshake completes", category: .session)
         }
     }
@@ -655,13 +665,13 @@ final class BLEService: NSObject {
     }
 
     private func sendNoisePayload(_ typedPayload: Data, to peerID: String) {
-        guard noiseService.hasSession(with: peerID) else {
+        guard noiseService.hasSession(with: Peer(str: peerID)) else {
             // Lazy-handshake path: queue? For now, initiate handshake and drop
             initiateNoiseHandshake(with: peerID)
             return
         }
         do {
-            let encrypted = try noiseService.encrypt(typedPayload, for: peerID)
+            let encrypted = try noiseService.encrypt(typedPayload, for: Peer(str: peerID))
             let packet = BitchatPacket(
                 type: MessageType.noiseEncrypted.rawValue,
                 senderID: myPeerIDData,
@@ -696,9 +706,9 @@ final class BLEService: NSObject {
     
     
     func getNoiseSessionState(for peerID: String) -> LazyHandshakeState {
-        if noiseService.hasEstablishedSession(with: peerID) {
+        if noiseService.hasEstablishedSession(with: Peer(str: peerID)) {
             return .established
-        } else if noiseService.hasSession(with: peerID) {
+        } else if noiseService.hasSession(with: Peer(str: peerID)) {
             return .handshaking
         } else {
             return .none
@@ -728,6 +738,46 @@ final class BLEService: NSObject {
         subscribedCentrals.removeAll()
         centralToPeerID.removeAll()
     }
+
+    func resetIdentityForPanic(currentNickname: String) {
+        messageQueue.sync(flags: .barrier) {
+            pendingMessagesAfterHandshake.removeAll()
+            pendingNoisePayloadsAfterHandshake.removeAll()
+        }
+
+        collectionsQueue.sync(flags: .barrier) {
+            recentAnnounceBySender.removeAll()
+            recentAnnounceOrder.removeAll()
+            pendingPeripheralWrites.removeAll()
+            pendingNotifications.removeAll()
+            pendingDirectedRelays.removeAll()
+            ingressByMessageID.removeAll()
+            recentPacketTimestamps.removeAll()
+            scheduledRelays.values.forEach { $0.cancel() }
+            scheduledRelays.removeAll()
+        }
+
+        bleQueue.sync {
+            pendingWriteBuffers.removeAll()
+            recentConnectTimeouts.removeAll()
+        }
+        recentDisconnectNotifies.removeAll()
+
+        noiseService.clearEphemeralStateForPanic()
+        noiseService.clearPersistentIdentity()
+
+        let newNoise = NoiseEncryptionService(keychain: keychain)
+        noiseService = newNoise
+        configureNoiseServiceCallbacks(for: newNoise)
+        refreshPeerIdentity()
+        restartGossipManager()
+
+        setNickname(currentNickname)
+
+        messageDeduplicator.reset()
+        requestPeerDataPublish()
+        startServices()
+    }
     
     func getNoiseService() -> NoiseEncryptionService {
         return noiseService
@@ -775,6 +825,8 @@ final class BLEService: NSObject {
                 self.messageDeduplicator.markProcessed(dedupID)
                 // Call synchronously since we're already on background queue
                 self.broadcastPacket(signedPacket)
+                // Track our own broadcast for sync
+                self.gossipSyncManager?.onPublicPacketSeen(signedPacket)
             }
         }
     }
@@ -787,7 +839,7 @@ final class BLEService: NSObject {
         SecureLogger.debug("📨 Sending PM to \(recipientID): \(content.prefix(30))...", category: .session)
         
         // Check if we have an established Noise session
-        if noiseService.hasEstablishedSession(with: recipientID) {
+        if noiseService.hasEstablishedSession(with: Peer(str: recipientID)) {
             // Encrypt and send
             do {
                 // Create TLV-encoded private message
@@ -801,7 +853,7 @@ final class BLEService: NSObject {
                 var messagePayload = Data([NoisePayloadType.privateMessage.rawValue])
                 messagePayload.append(tlvData)
                 
-                let encrypted = try noiseService.encrypt(messagePayload, for: recipientID)
+                let encrypted = try noiseService.encrypt(messagePayload, for: Peer(str: recipientID))
                 
                 // Convert recipientID to Data (assuming it's a hex string)
                 var recipientData = Data()
@@ -867,10 +919,10 @@ final class BLEService: NSObject {
     
     private func initiateNoiseHandshake(with peerID: String) {
         // Use NoiseEncryptionService for handshake
-        guard !noiseService.hasSession(with: peerID) else { return }
+        guard !noiseService.hasSession(with: Peer(str: peerID)) else { return }
         
         do {
-            let handshakeData = try noiseService.initiateHandshake(with: peerID)
+            let handshakeData = try noiseService.initiateHandshake(with: Peer(str: peerID))
             
             // Send handshake init
             let packet = BitchatPacket(
@@ -920,7 +972,7 @@ final class BLEService: NSObject {
                 var messagePayload = Data([NoisePayloadType.privateMessage.rawValue])
                 messagePayload.append(tlvData)
 
-                let encrypted = try noiseService.encrypt(messagePayload, for: peerID)
+                let encrypted = try noiseService.encrypt(messagePayload, for: Peer(str: peerID))
 
                 let packet = BitchatPacket(
                     type: MessageType.noiseEncrypted.rawValue,
@@ -1099,10 +1151,13 @@ final class BLEService: NSObject {
         }
 
         // For broadcast (no directed peer) and non-fragment, choose a subset deterministically
-        // Special-case announces: do NOT subset to maximize reach for presence
+        // Special-case control/presence messages: do NOT subset to maximize immediate coverage
         var selectedPeripheralIDs = Set(allowedPeripheralIDs)
         var selectedCentralIDs = Set(allowedCentralIDs)
-        if directedOnlyPeer == nil && packet.type != MessageType.fragment.rawValue && packet.type != MessageType.announce.rawValue {
+        if directedOnlyPeer == nil
+            && packet.type != MessageType.fragment.rawValue
+            && packet.type != MessageType.announce.rawValue
+            && packet.type != MessageType.requestSync.rawValue {
             let kp = subsetSizeForFanout(allowedPeripheralIDs.count)
             let kc = subsetSizeForFanout(allowedCentralIDs.count)
             selectedPeripheralIDs = selectDeterministicSubset(ids: allowedPeripheralIDs, k: kp, seed: messageID)
@@ -1133,6 +1188,12 @@ final class BLEService: NSObject {
         }
     }
 
+    // Directed send helper (unicast to a specific peerID) without altering packet contents
+    private func sendPacketDirected(_ packet: BitchatPacket, to peerID: String) {
+        guard let data = packet.toBinaryData(padding: false) else { return }
+        sendOnAllLinks(packet: packet, data: data, pad: false, directedOnlyPeer: peerID)
+    }
+
     // MARK: - Directed store-and-forward
     private func spoolDirectedPacket(_ packet: BitchatPacket, recipientPeerID: String) {
         let msgID = makeMessageID(for: packet)
@@ -1339,7 +1400,10 @@ final class BLEService: NSObject {
         
         // Efficient deduplication
         // Important: do not dedup fragment packets globally (each piece must pass)
-        if packet.type != MessageType.fragment.rawValue && messageDeduplicator.isDuplicate(messageID) {
+        // Special case: allow our own packets recovered via sync (TTL==0) to pass
+        // through even if we've marked them as seen at send time.
+        let allowSelfSyncReplay = (packet.ttl == 0) && (senderID == myPeerID)
+        if packet.type != MessageType.fragment.rawValue && !allowSelfSyncReplay && messageDeduplicator.isDuplicate(messageID) {
             // Announce packets (type 1) are sent every 10 seconds for peer discovery
             // It's normal to see these as duplicates - don't log them to reduce noise
             if packet.type != MessageType.announce.rawValue {
@@ -1383,6 +1447,9 @@ final class BLEService: NSObject {
         case .message:
             handleMessage(packet, from: senderID)
             
+        case .requestSync:
+            handleRequestSync(packet, from: senderID)
+            
         case .noiseHandshake:
             handleNoiseHandshake(packet, from: senderID)
             
@@ -1442,7 +1509,7 @@ final class BLEService: NSObject {
         
         // Verify that the sender's derived ID from the announced noise public key matches the packet senderID
         // This helps detect relayed or spoofed announces. Only warn in release; assert in debug.
-        let derivedFromKey = PeerIDUtils.derivePeerID(fromPublicKey: announcement.noisePublicKey)
+        let derivedFromKey = Peer(publicKey: announcement.noisePublicKey).id
         if derivedFromKey != peerID {
             SecureLogger.warning("⚠️ Announce sender mismatch: derived \(derivedFromKey.prefix(8))… vs packet \(peerID.prefix(8))…", category: .security)
 
@@ -1583,12 +1650,17 @@ final class BLEService: NSObject {
             // Only notify of connection for new or reconnected peers when it is a direct announce
             if (packet.ttl == self.messageTTL) && (isNewPeer || isReconnectedPeer) {
                 self.delegate?.didConnectToPeer(peerID)
+                // Schedule initial unicast sync to this peer
+                self.gossipSyncManager?.scheduleInitialSyncToPeer(peerID, delaySeconds: 1.0)
             }
             
             self.requestPeerDataPublish()
             self.delegate?.didUpdatePeerList(currentPeerIDs)
         }
         
+        // Track for sync (include our own and others' announces)
+        gossipSyncManager?.onPublicPacketSeen(packet)
+
         // Send announce back for bidirectional discovery (only once per peer)
         let announceBackID = "announce-back-\(peerID)"
         let shouldSendBack = !messageDeduplicator.contains(announceBackID)
@@ -1610,17 +1682,33 @@ final class BLEService: NSObject {
             }
         }
     }
+
+    // Handle REQUEST_SYNC: decode payload and respond with missing packets via sync manager
+    private func handleRequestSync(_ packet: BitchatPacket, from peerID: String) {
+        guard let req = RequestSyncPacket.decode(from: packet.payload) else {
+            SecureLogger.warning("⚠️ Malformed REQUEST_SYNC from \(peerID)", category: .session)
+            return
+        }
+        gossipSyncManager?.handleRequestSync(fromPeerID: peerID, request: req)
+    }
     
     // Mention parsing moved to ChatViewModel
     
     private func handleMessage(_ packet: BitchatPacket, from peerID: String) {
-        // Ignore self-origin public messages that may be seen again via relay
+        // Ignore self-origin public messages except when returned via sync (TTL==0).
-        if peerID == myPeerID { return }
+        // This allows our own messages to be surfaced when they come back via
+        // the sync path without re-processing regular relayed copies.
+        if peerID == myPeerID && packet.ttl != 0 { return }
 
         var accepted = false
         var senderNickname: String = ""
 
-        if let info = peers[peerID], info.isVerifiedNickname {
+        // If the packet is from ourselves (e.g., recovered via sync TTL==0), accept immediately
+        if peerID == myPeerID {
+            accepted = true
+            senderNickname = myNickname
+        }
+        else if let info = peers[peerID], info.isVerifiedNickname {
             // Known verified peer path
             accepted = true
             senderNickname = info.nickname
@@ -1633,7 +1721,7 @@ final class BLEService: NSObject {
             // Fallback: verify signature using persisted signing key for this peerID's fingerprint prefix
             if let signature = packet.signature, let packetData = packet.toBinaryDataForSigning() {
                 // Find candidate identities by peerID prefix (16 hex)
-                let candidates = identityManager.getCryptoIdentitiesByPeerIDPrefix(peerID)
+                let candidates = identityManager.getCryptoIdentitiesByPeerIDPrefix(Peer(str: peerID))
                 for candidate in candidates {
                     if let signingKey = candidate.signingPublicKey,
                        noiseService.verifySignature(signature, for: packetData, publicKey: signingKey) {
@@ -1648,6 +1736,22 @@ final class BLEService: NSObject {
                     }
                 }
             }
+            // If still not accepted and this is a sync-returned packet (TTL==0),
+            // accept with a generic nickname so history can be restored even for
+            // peers we haven't verified yet.
+            if !accepted && packet.ttl == 0 {
+                accepted = true
+                senderNickname = "anon" + String(peerID.prefix(4))
+            }
+        }
+
+        // Track broadcast messages for sync (treat nil or 0xFF..0xFF as broadcast)
+        let isBroadcastRecipient: Bool = {
+            guard let r = packet.recipientID else { return true }
+            return r.count == 8 && r.allSatisfy { $0 == 0xFF }
+        }()
+        if isBroadcastRecipient && packet.type == MessageType.message.rawValue {
+            gossipSyncManager?.onPublicPacketSeen(packet)
         }
 
         guard accepted else {
@@ -1682,7 +1786,7 @@ final class BLEService: NSObject {
            recipientID.hexEncodedString() == myPeerID {
             // Handshake is for us
             do {
-                if let response = try noiseService.processHandshakeMessage(from: peerID, message: packet.payload) {
+                if let response = try noiseService.processHandshakeMessage(from: Peer(str: peerID), message: packet.payload) {
                     // Send response
                     let responsePacket = BitchatPacket(
                         type: MessageType.noiseHandshake.rawValue,
@@ -1702,7 +1806,7 @@ final class BLEService: NSObject {
             } catch {
                 SecureLogger.error("Failed to process handshake: \(error)")
                 // Try initiating a new handshake
-                if !noiseService.hasSession(with: peerID) {
+                if !noiseService.hasSession(with: Peer(str: peerID)) {
                     initiateNoiseHandshake(with: peerID)
                 }
             }
@@ -1727,7 +1831,7 @@ final class BLEService: NSObject {
         updatePeerLastSeen(peerID)
         
         do {
-            let decrypted = try noiseService.decrypt(packet.payload, from: peerID)
+            let decrypted = try noiseService.decrypt(packet.payload, from: Peer(str: peerID))
             guard decrypted.count > 0 else { return }
             
             // First byte indicates the payload type
@@ -1767,7 +1871,7 @@ final class BLEService: NSObject {
             // We received an encrypted message before establishing a session with this peer.
             // Trigger a handshake so future messages can be decrypted.
             SecureLogger.debug("🔑 Encrypted message from \(peerID) without session; initiating handshake")
-            if !noiseService.hasSession(with: peerID) {
+            if !noiseService.hasSession(with: Peer(str: peerID)) {
                 initiateNoiseHandshake(with: peerID)
             }
         } catch {
@@ -1780,6 +1884,8 @@ final class BLEService: NSObject {
             // Remove the peer when they leave
             peers.removeValue(forKey: peerID)
         }
+        // Remove any stored announcement for sync purposes
+        gossipSyncManager?.removeAnnouncementForPeer(peerID)
         // Send on main thread
         notifyUI { [weak self] in
             guard let self = self else { return }
@@ -1861,6 +1967,8 @@ final class BLEService: NSObject {
                 self?.broadcastPacket(signedPacket)
             }
         }
+        // Ensure our own announce is included in sync state
+        gossipSyncManager?.onPublicPacketSeen(signedPacket)
     }
     
     func sendDeliveryAck(for messageID: String, to peerID: String) {
@@ -1868,9 +1976,9 @@ final class BLEService: NSObject {
         var payload = Data([NoisePayloadType.delivered.rawValue])
         payload.append(contentsOf: messageID.utf8)
 
-        if noiseService.hasEstablishedSession(with: peerID) {
+        if noiseService.hasEstablishedSession(with: Peer(str: peerID)) {
             do {
-                let encrypted = try noiseService.encrypt(payload, for: peerID)
+                let encrypted = try noiseService.encrypt(payload, for: Peer(str: peerID))
                 let packet = BitchatPacket(
                     type: MessageType.noiseEncrypted.rawValue,
                     senderID: myPeerIDData,
@@ -1890,7 +1998,7 @@ final class BLEService: NSObject {
                 guard let self = self else { return }
                 self.pendingNoisePayloadsAfterHandshake[peerID, default: []].append(payload)
             }
-            if !noiseService.hasSession(with: peerID) { initiateNoiseHandshake(with: peerID) }
+            if !noiseService.hasSession(with: Peer(str: peerID)) { initiateNoiseHandshake(with: peerID) }
             SecureLogger.debug("🕒 Queued DELIVERED ack for \(peerID) until handshake completes", category: .session)
         }
     }
@@ -1905,7 +2013,7 @@ final class BLEService: NSObject {
         SecureLogger.debug("📤 Sending \(payloads.count) pending noise payloads to \(peerID) after handshake", category: .session)
         for payload in payloads {
             do {
-                let encrypted = try noiseService.encrypt(payload, for: peerID)
+                let encrypted = try noiseService.encrypt(payload, for: Peer(str: peerID))
                 let packet = BitchatPacket(
                     type: MessageType.noiseEncrypted.rawValue,
                     senderID: myPeerIDData,
@@ -2088,6 +2196,8 @@ final class BLEService: NSObject {
                 if !peer.isConnected {
                     if age > retention {
                         SecureLogger.debug("🗑️ Removing stale peer after reachability window: \(peerID) (\(peer.nickname))", category: .session)
+                        // Also remove any stored announcement from sync candidates
+                        gossipSyncManager?.removeAnnouncementForPeer(peerID)
                         peers.removeValue(forKey: peerID)
                         removedOfflineCount += 1
                     }
@@ -2249,6 +2359,29 @@ final class BLEService: NSObject {
     }
 }
 
+// MARK: - GossipSyncManager Delegate
+extension BLEService: GossipSyncManager.Delegate {
+    func sendPacket(_ packet: BitchatPacket) {
+        if DispatchQueue.getSpecific(key: messageQueueKey) != nil {
+            broadcastPacket(packet)
+        } else {
+            messageQueue.async { [weak self] in self?.broadcastPacket(packet) }
+        }
+    }
+
+    func sendPacket(to peerID: String, packet: BitchatPacket) {
+        if DispatchQueue.getSpecific(key: messageQueueKey) != nil {
+            sendPacketDirected(packet, to: peerID)
+        } else {
+            messageQueue.async { [weak self] in self?.sendPacketDirected(packet, to: peerID) }
+        }
+    }
+
+    func signPacketForBroadcast(_ packet: BitchatPacket) -> BitchatPacket {
+        return noiseService.signPacket(packet) ?? packet
+    }
+}
+
 // MARK: - CBCentralManagerDelegate
 
 extension BLEService: CBCentralManagerDelegate {

bitchat/Services/FavoritesPersistenceService.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import Combine
 
@@ -178,12 +179,11 @@ 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(for peer: Peer) -> FavoriteRelationship? {
-        // Quick sanity: peerID should be 16 hex chars (8 bytes)
+        // Quick sanity: peer.id should be 16 hex chars (8 bytes)
-        guard peerID.count == 16 else { return nil }
+        guard peer.isShort else { return nil }
-        for (pubkey, rel) in favorites {
+        for (pubkey, rel) in favorites where Peer(publicKey: pubkey) == peer {
-            let derived = PeerIDUtils.derivePeerID(fromPublicKey: pubkey)
+            return rel
-            if derived == peerID { return rel }
         }
         return nil
     }

bitchat/Services/KeychainManager.swift

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

bitchat/Services/LocationChannelManager.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import Combine
 

bitchat/Services/LocationNotesManager.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 
 /// Persistent location notes (Nostr kind 1) scoped to a street-level geohash (precision 7).

bitchat/Services/MessageRouter.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 
 /// Routes messages between BLE and Nostr transports
@@ -5,7 +6,7 @@ import Foundation
 final class MessageRouter {
     private let mesh: Transport
     private let nostr: NostrTransport
-    private var outbox: [String: [(content: String, nickname: String, messageID: String)]] = [:] // peerID -> queued messages
+    private var outbox: [Peer: [(content: String, nickname: String, messageID: String)]] = [:] // Peer -> queued messages
 
     init(mesh: Transport, nostr: NostrTransport) {
         self.mesh = mesh
@@ -20,80 +21,80 @@ 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 peer = Peer(publicKey: data)
                 Task { @MainActor in
-                    self.flushOutbox(for: peerID)
+                    self.flushOutbox(for: peer)
                 }
             }
             // Handle key updates
             if let newKey = note.userInfo?["peerPublicKey"] as? Data,
                let _ = note.userInfo?["isKeyUpdate"] as? Bool {
-                let peerID = PeerIDUtils.derivePeerID(fromPublicKey: newKey)
+                let peer = Peer(publicKey: newKey)
                 Task { @MainActor in
-                    self.flushOutbox(for: peerID)
+                    self.flushOutbox(for: peer)
                 }
             }
         }
     }
 
-    func sendPrivate(_ content: String, to peerID: String, recipientNickname: String, messageID: String) {
+    func sendPrivate(_ content: String, to peer: Peer, recipientNickname: String, messageID: String) {
-        let reachableMesh = mesh.isPeerReachable(peerID)
+        let reachableMesh = mesh.isPeerReachable(peer.id)
         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 \(peer.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)
+            mesh.sendPrivateMessage(content, to: peer.id, recipientNickname: recipientNickname, messageID: messageID)
-        } else if canSendViaNostr(peerID: peerID) {
+        } else if canSendViaNostr(peer: peer) {
-            SecureLogger.debug("Routing PM via Nostr to \(peerID.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+            SecureLogger.debug("Routing PM via Nostr to \(peer.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
-            nostr.sendPrivateMessage(content, to: peerID, recipientNickname: recipientNickname, messageID: messageID)
+            nostr.sendPrivateMessage(content, to: peer.id, recipientNickname: recipientNickname, messageID: messageID)
         } else {
             // Queue for later (when mesh connects or Nostr mapping appears)
-            if outbox[peerID] == nil { outbox[peerID] = [] }
+            if outbox[peer] == nil { outbox[peer] = [] }
-            outbox[peerID]?.append((content, recipientNickname, messageID))
+            outbox[peer]?.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 \(peer.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 peer: Peer) {
         // Prefer mesh for reachable peers; BLE will queue if handshake is needed
-        if mesh.isPeerReachable(peerID) {
+        if mesh.isPeerReachable(peer.id) {
-            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 \(peer.id.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…", category: .session)
-            mesh.sendReadReceipt(receipt, to: peerID)
+            mesh.sendReadReceipt(receipt, to: peer.id)
         } 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 \(peer.id.prefix(8))… id=\(receipt.originalMessageID.prefix(8))…", category: .session)
-            nostr.sendReadReceipt(receipt, to: peerID)
+            nostr.sendReadReceipt(receipt, to: peer.id)
         }
     }
 
-    func sendDeliveryAck(_ messageID: String, to peerID: String) {
+    func sendDeliveryAck(_ messageID: String, to peer: Peer) {
-        if mesh.isPeerReachable(peerID) {
+        if mesh.isPeerReachable(peer.id) {
-            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 \(peer.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
-            mesh.sendDeliveryAck(for: messageID, to: peerID)
+            mesh.sendDeliveryAck(for: messageID, to: peer.id)
         } else {
-            nostr.sendDeliveryAck(for: messageID, to: peerID)
+            nostr.sendDeliveryAck(for: messageID, to: peer.id)
         }
     }
 
-    func sendFavoriteNotification(to peerID: String, isFavorite: Bool) {
+    func sendFavoriteNotification(to peer: Peer, isFavorite: Bool) {
         // Route via mesh when connected; else use Nostr
-        if mesh.isPeerConnected(peerID) {
+        if mesh.isPeerConnected(peer.id) {
-            mesh.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
+            mesh.sendFavoriteNotification(to: peer.id, isFavorite: isFavorite)
         } else {
-            nostr.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
+            nostr.sendFavoriteNotification(to: peer.id, isFavorite: isFavorite)
         }
     }
 
     // MARK: - Outbox Management
-    private func canSendViaNostr(peerID: String) -> Bool {
+    private func canSendViaNostr(peer: Peer) -> 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 = peer.noiseKey {
             if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: noiseKey),
                fav.peerNostrPublicKey != nil {
                 return true
             }
-        } else if peerID.count == 16 {
+        } else if peer.isShort {
-            if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID),
+            if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: peer),
                fav.peerNostrPublicKey != nil {
                 return true
             }
@@ -101,18 +102,18 @@ final class MessageRouter {
         return false
     }
 
-    func flushOutbox(for peerID: String) {
+    func flushOutbox(for peer: Peer) {
-        guard let queued = outbox[peerID], !queued.isEmpty else { return }
+        guard let queued = outbox[peer], !queued.isEmpty else { return }
-        SecureLogger.debug("Flushing outbox for \(peerID.prefix(8))… count=\(queued.count)", category: .session)
+        SecureLogger.debug("Flushing outbox for \(peer.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) {
+            if mesh.isPeerReachable(peer.id) {
-                SecureLogger.debug("Outbox -> mesh for \(peerID.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+                SecureLogger.debug("Outbox -> mesh for \(peer.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
-                mesh.sendPrivateMessage(content, to: peerID, recipientNickname: nickname, messageID: messageID)
+                mesh.sendPrivateMessage(content, to: peer.id, recipientNickname: nickname, messageID: messageID)
-            } else if canSendViaNostr(peerID: peerID) {
+            } else if canSendViaNostr(peer: peer) {
-                SecureLogger.debug("Outbox -> Nostr for \(peerID.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
+                SecureLogger.debug("Outbox -> Nostr for \(peer.id.prefix(8))… id=\(messageID.prefix(8))…", category: .session)
-                nostr.sendPrivateMessage(content, to: peerID, recipientNickname: nickname, messageID: messageID)
+                nostr.sendPrivateMessage(content, to: peer.id, recipientNickname: nickname, messageID: messageID)
             } else {
                 // Keep unsent items queued
                 remaining.append((content, nickname, messageID))
@@ -120,9 +121,9 @@ final class MessageRouter {
         }
         // Persist only items we could not send
         if remaining.isEmpty {
-            outbox.removeValue(forKey: peerID)
+            outbox.removeValue(forKey: peer)
         } else {
-            outbox[peerID] = remaining
+            outbox[peer] = remaining
         }
     }
 

bitchat/Services/NetworkActivationService.swift

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

bitchat/Services/NoiseEncryptionService.swift

@@ -83,6 +83,7 @@
 /// - Background queue for CPU-intensive operations
 ///
 
+import BitLogger
 import Foundation
 import CryptoKit
 
@@ -147,8 +148,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: [Peer: String] = [:] // Peer -> fingerprint
-    private var fingerprintToPeerID: [String: String] = [:] // fingerprint -> peerID
+    private var fingerprintToPeer: [String: Peer] = [:] // fingerprint -> Peer
     
     // Thread safety
     private let serviceQueue = DispatchQueue(label: "chat.bitchat.noise.service", attributes: .concurrent)
@@ -236,7 +237,7 @@ final class NoiseEncryptionService {
         
         // Set up session callbacks
         sessionManager.onSessionEstablished = { [weak self] peerID, remoteStaticKey in
-            self?.handleSessionEstablished(peerID: peerID, remoteStaticKey: remoteStaticKey)
+            self?.handleSessionEstablished(peer: Peer(str: peerID), remoteStaticKey: remoteStaticKey)
         }
         
         // Start session maintenance timer
@@ -262,8 +263,8 @@ final class NoiseEncryptionService {
     }
     
     /// Get peer's public key data
-    func getPeerPublicKeyData(_ peerID: String) -> Data? {
+    func getPeerPublicKeyData(_ peer: Peer) -> Data? {
-        return sessionManager.getRemoteStaticKey(for: peerID)?.rawRepresentation
+        return sessionManager.getRemoteStaticKey(for: peer.id)?.rawRepresentation
     }
     
     /// Clear persistent identity (for panic mode)
@@ -390,52 +391,52 @@ final class NoiseEncryptionService {
     // MARK: - Handshake Management
     
     /// Initiate a Noise handshake with a peer
-    func initiateHandshake(with peerID: String) throws -> Data {
+    func initiateHandshake(with peer: Peer) throws -> Data {
         
         // Validate peer ID
-        guard NoiseSecurityValidator.validatePeerID(peerID) else {
+        guard peer.isValid else {
-            SecureLogger.warning(.authenticationFailed(peerID: peerID))
+            SecureLogger.warning(.authenticationFailed(peerID: peer.id))
             throw NoiseSecurityError.invalidPeerID
         }
         
         // Check rate limit
-        guard rateLimiter.allowHandshake(from: peerID) else {
+        guard rateLimiter.allowHandshake(from: peer) else {
-            SecureLogger.warning(.authenticationFailed(peerID: "Rate limited: \(peerID)"))
+            SecureLogger.warning(.authenticationFailed(peerID: "Rate limited: \(peer.id)"))
             throw NoiseSecurityError.rateLimitExceeded
         }
         
-        SecureLogger.info(.handshakeStarted(peerID: peerID))
+        SecureLogger.info(.handshakeStarted(peerID: peer.id))
         
         // Return raw handshake data without wrapper
         // The Noise protocol handles its own message format
-        let handshakeData = try sessionManager.initiateHandshake(with: peerID)
+        let handshakeData = try sessionManager.initiateHandshake(with: peer.id)
         return handshakeData
     }
     
     /// Process an incoming handshake message
-    func processHandshakeMessage(from peerID: String, message: Data) throws -> Data? {
+    func processHandshakeMessage(from peer: Peer, message: Data) throws -> Data? {
         
         // Validate peer ID
-        guard NoiseSecurityValidator.validatePeerID(peerID) else {
+        guard peer.isValid else {
-            SecureLogger.warning(.authenticationFailed(peerID: peerID))
+            SecureLogger.warning(.authenticationFailed(peerID: peer.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: peer.id, error: "Message too large"))
             throw NoiseSecurityError.messageTooLarge
         }
         
         // Check rate limit
-        guard rateLimiter.allowHandshake(from: peerID) else {
+        guard rateLimiter.allowHandshake(from: peer) else {
-            SecureLogger.warning(.authenticationFailed(peerID: "Rate limited: \(peerID)"))
+            SecureLogger.warning(.authenticationFailed(peerID: "Rate limited: \(peer.id)"))
             throw NoiseSecurityError.rateLimitExceeded
         }
         
         // For handshakes, we process the raw data directly without NoiseMessage wrapper
         // The Noise protocol handles its own message format
-        let responsePayload = try sessionManager.handleIncomingHandshake(from: peerID, message: message)
+        let responsePayload = try sessionManager.handleIncomingHandshake(from: peer.id, message: message)
         
         
         // Return raw response without wrapper
@@ -443,108 +444,117 @@ final class NoiseEncryptionService {
     }
     
     /// Check if we have an established session with a peer
-    func hasEstablishedSession(with peerID: String) -> Bool {
+    func hasEstablishedSession(with peer: Peer) -> Bool {
-        return sessionManager.getSession(for: peerID)?.isEstablished() ?? false
+        return sessionManager.getSession(for: peer.id)?.isEstablished() ?? false
     }
     
     /// Check if we have a session (established or handshaking) with a peer
-    func hasSession(with peerID: String) -> Bool {
+    func hasSession(with peer: Peer) -> Bool {
-        return sessionManager.getSession(for: peerID) != nil
+        return sessionManager.getSession(for: peer.id) != nil
     }
     
     // MARK: - Encryption/Decryption
     
     /// Encrypt data for a specific peer
-    func encrypt(_ data: Data, for peerID: String) throws -> Data {
+    func encrypt(_ data: Data, for peer: Peer) throws -> Data {
         // Validate message size
         guard NoiseSecurityValidator.validateMessageSize(data) else {
             throw NoiseSecurityError.messageTooLarge
         }
         
         // Check rate limit
-        guard rateLimiter.allowMessage(from: peerID) else {
+        guard rateLimiter.allowMessage(from: peer) else {
             throw NoiseSecurityError.rateLimitExceeded
         }
         
         // Check if we have an established session
-        guard hasEstablishedSession(with: peerID) else {
+        guard hasEstablishedSession(with: peer) else {
             // Signal that handshake is needed
-            onHandshakeRequired?(peerID)
+            onHandshakeRequired?(peer.id)
             throw NoiseEncryptionError.handshakeRequired
         }
         
-        return try sessionManager.encrypt(data, for: peerID)
+        return try sessionManager.encrypt(data, for: peer.id)
     }
     
     /// Decrypt data from a specific peer
-    func decrypt(_ data: Data, from peerID: String) throws -> Data {
+    func decrypt(_ data: Data, from peer: Peer) throws -> Data {
         // Validate message size
         guard NoiseSecurityValidator.validateMessageSize(data) else {
             throw NoiseSecurityError.messageTooLarge
         }
         
         // Check rate limit
-        guard rateLimiter.allowMessage(from: peerID) else {
+        guard rateLimiter.allowMessage(from: peer) else {
             throw NoiseSecurityError.rateLimitExceeded
         }
         
         // Check if we have an established session
-        guard hasEstablishedSession(with: peerID) else {
+        guard hasEstablishedSession(with: peer) else {
             throw NoiseEncryptionError.sessionNotEstablished
         }
         
-        return try sessionManager.decrypt(data, from: peerID)
+        return try sessionManager.decrypt(data, from: peer.id)
     }
     
     // MARK: - Peer Management
     
     /// Get fingerprint for a peer
-    func getPeerFingerprint(_ peerID: String) -> String? {
+    func getPeerFingerprint(_ peer: Peer) -> String? {
         return serviceQueue.sync {
-            return peerFingerprints[peerID]
+            return peerFingerprints[peer]
         }
     }
     
     /// Get peer ID for a fingerprint
-    func getPeerID(for fingerprint: String) -> String? {
+    func getPeer(for fingerprint: String) -> Peer? {
         return serviceQueue.sync {
-            return fingerprintToPeerID[fingerprint]
+            return fingerprintToPeer[fingerprint]
         }
     }
     
     /// Remove a peer session
-    func removePeer(_ peerID: String) {
+    func removePeer(_ peer: Peer) {
-        sessionManager.removeSession(for: peerID)
+        sessionManager.removeSession(for: peer.id)
         
         serviceQueue.sync(flags: .barrier) {
-            if let fingerprint = peerFingerprints[peerID] {
+            if let fingerprint = peerFingerprints[peer] {
-                fingerprintToPeerID.removeValue(forKey: fingerprint)
+                fingerprintToPeer.removeValue(forKey: fingerprint)
             }
-            peerFingerprints.removeValue(forKey: peerID)
+            peerFingerprints.removeValue(forKey: peer)
         }
         
-        SecureLogger.info(.sessionExpired(peerID: peerID))
+        SecureLogger.info(.sessionExpired(peerID: peer.id))
+    }
+
+    func clearEphemeralStateForPanic() {
+        sessionManager.removeAllSessions()
+        serviceQueue.sync(flags: .barrier) {
+            peerFingerprints.removeAll()
+            fingerprintToPeer.removeAll()
+        }
+        rateLimiter.resetAll()
     }
     
     // MARK: - Private Helpers
     
-    private func handleSessionEstablished(peerID: String, remoteStaticKey: Curve25519.KeyAgreement.PublicKey) {
+    private func handleSessionEstablished(peer: Peer, remoteStaticKey: Curve25519.KeyAgreement.PublicKey) {
         // Calculate fingerprint
         let fingerprint = calculateFingerprint(for: remoteStaticKey)
         
         // Store fingerprint mapping
         serviceQueue.sync(flags: .barrier) {
-            peerFingerprints[peerID] = fingerprint
+            peerFingerprints[peer] = fingerprint
-            fingerprintToPeerID[fingerprint] = peerID
+            fingerprintToPeer[fingerprint] = peer
         }
         
         // Log security event
-        SecureLogger.info(.handshakeCompleted(peerID: peerID))
+        SecureLogger.info(.handshakeCompleted(peerID: peer.id))
         
         // Notify all handlers about authentication
         serviceQueue.async { [weak self] in
             self?.onPeerAuthenticatedHandlers.forEach { handler in
-                handler(peerID, fingerprint)
+                handler(peer.id, fingerprint)
             }
         }
     }

bitchat/Services/NostrTransport.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import Combine
 
@@ -173,7 +174,7 @@ final class NostrTransport: Transport {
             return npub
         }
         if peerID.count == 16,
-           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(forPeerID: peerID),
+           let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: Peer(str: peerID)),
            let npub = fav.peerNostrPublicKey {
             return npub
         }

bitchat/Services/NotificationService.swift

@@ -61,11 +61,11 @@ final class NotificationService {
         sendLocalNotification(title: title, body: body, identifier: identifier)
     }
     
-    func sendPrivateMessageNotification(from sender: String, message: String, peerID: String) {
+    func sendPrivateMessageNotification(from sender: String, message: String, peer: Peer) {
         let title = "🔒 DM from \(sender)"
         let body = message
         let identifier = "private-\(UUID().uuidString)"
-        let userInfo = ["peerID": peerID, "senderName": sender]
+        let userInfo = ["peerID": peer.id, "senderName": sender]
         
         sendLocalNotification(title: title, body: body, identifier: identifier, userInfo: userInfo)
     }

bitchat/Services/PrivateChatManager.swift

@@ -6,6 +6,7 @@
 // This is free and unencumbered software released into the public domain.
 //
 
+import BitLogger
 import Foundation
 import SwiftUI
 
@@ -72,7 +73,7 @@ final class PrivateChatManager: ObservableObject {
             originalSender: nil,
             isPrivate: true,
             recipientNickname: peerNickname,
-            senderPeerID: meshService.myPeerID,
+            senderPeer: Peer(str: meshService.myPeerID),
             mentions: nil,
             deliveryStatus: .sending
         )
@@ -93,7 +94,7 @@ final class PrivateChatManager: ObservableObject {
     
     /// Handle incoming private message
     func handleIncomingMessage(_ message: BitchatMessage) {
-        guard let senderPeerID = message.senderPeerID else { return }
+        guard let senderPeerID = message.senderPeer?.id else { return }
         
         // Initialize chat if needed
         if privateChats[senderPeerID] == nil {
@@ -125,7 +126,7 @@ final class PrivateChatManager: ObservableObject {
                 NotificationService.shared.sendPrivateMessageNotification(
                     from: message.sender,
                     message: message.content,
-                    peerID: senderPeerID
+                    peer: Peer(str: senderPeerID)
                 )
             }
         } else {
@@ -160,7 +161,7 @@ final class PrivateChatManager: ObservableObject {
         // Send read receipts for unread messages that haven't been sent yet
         if let messages = privateChats[peerID] {
             for message in messages {
-                if message.senderPeerID == peerID && !message.isRelay && !sentReadReceipts.contains(message.id) {
+                if message.senderPeer?.id == peerID && !message.isRelay && !sentReadReceipts.contains(message.id) {
                     sendReadReceipt(for: message)
                 }
             }
@@ -213,7 +214,7 @@ final class PrivateChatManager: ObservableObject {
     
     private func sendReadReceipt(for message: BitchatMessage) {
         guard !sentReadReceipts.contains(message.id),
-              let senderPeerID = message.senderPeerID else {
+              let senderPeerID = message.senderPeer?.id else {
             return
         }
         
@@ -230,7 +231,7 @@ final class PrivateChatManager: ObservableObject {
         if let router = messageRouter {
             SecureLogger.debug("PrivateChatManager: sending READ ack for \(message.id.prefix(8))… to \(senderPeerID.prefix(8))… via router", category: .session)
             Task { @MainActor in
-                router.sendReadReceipt(receipt, to: senderPeerID)
+                router.sendReadReceipt(receipt, to: Peer(str: senderPeerID))
             }
         } else {
             // Fallback: preserve previous behavior

bitchat/Services/Tor/TorManager.swift

@@ -1,3 +1,4 @@
+import BitLogger
 import Foundation
 import Network
 import Darwin
@@ -67,19 +68,27 @@ final class TorManager: ObservableObject {
     private var controlMonitorStarted = false
     private var pathMonitor: NWPathMonitor?
     private var isAppForeground: Bool = true
+    private var isDormant: Bool = false
     private var lastRestartAt: Date? = nil
+    // Global policy gate: only allow Tor to start when true
+    private(set) var allowAutoStart: Bool = false
 
     private init() {}
 
     // MARK: - Public API
 
     func startIfNeeded() {
+        // Respect global start policy
+        guard allowAutoStart else { return }
         // Do not start in background; caller should wait for foreground
         guard isAppForeground else { return }
         guard !didStart else { return }
         didStart = true
+        isDormant = false
         isStarting = true
         lastError = nil
+        // Announce initial start so UI can show a status message
+        NotificationCenter.default.post(name: .TorWillStart, object: nil)
         ensureFilesystemLayout()
         startTor()
         startPathMonitorIfNeeded()
@@ -472,6 +481,8 @@ final class TorManager: ObservableObject {
     // MARK: - Foreground recovery and control helpers
 
     func ensureRunningOnForeground() {
+        // Respect global start policy
+        if !allowAutoStart { return }
         // iOS can suspend Tor harshly; the most reliable approach for
         // embedding is to restart Tor every time we become active.
         Task.detached(priority: .userInitiated) { [weak self] in
@@ -483,18 +494,39 @@ final class TorManager: ObservableObject {
                 return true
             }
             if !claimed { return }
+            if await self.resumeTorIfPossible() {
+                await MainActor.run {
+                    self.restarting = false
+                    self.isStarting = false
+                }
+                return
+            }
             await self.restartTor()
             await MainActor.run { self.restarting = false }
         }
     }
 
     func goDormantOnBackground() {
-        // Stricter model: fully stop Tor when app backgrounds to save power
+        // Prefer Tor's DORMANT mode so we can resume on foreground without a full restart.
-        // and avoid half-suspended states. We'll restart cleanly on .active.
+        // If the control port is unreachable, fall back to a hard shutdown.
         Task.detached { [weak self] in
             guard let self = self else { return }
+            let signaled = await self.controlSendSignal("DORMANT")
+            if signaled {
+                SecureLogger.info("TorManager: signalled DORMANT", category: .session)
+                await MainActor.run {
+                    self.isDormant = true
+                    self.isReady = false
+                    self.socksReady = false
+                    self.isStarting = false
+                }
+                return
+            }
+
+            SecureLogger.warning("TorManager: DORMANT signal failed; shutting down", category: .session)
             _ = tor_host_shutdown()
             await MainActor.run {
+                self.isDormant = false
                 self.isReady = false
                 self.socksReady = false
                 self.bootstrapProgress = 0
@@ -507,6 +539,24 @@ final class TorManager: ObservableObject {
         }
     }
 
+    func shutdownCompletely() {
+        Task.detached { [weak self] in
+            guard let self = self else { return }
+            _ = tor_host_shutdown()
+            await MainActor.run {
+                self.isDormant = false
+                self.isReady = false
+                self.socksReady = false
+                self.bootstrapProgress = 0
+                self.bootstrapSummary = ""
+                self.isStarting = false
+                self.didStart = false
+                self.restarting = false
+                self.controlMonitorStarted = false
+            }
+        }
+    }
+
     private func restartTor() async {
         await MainActor.run {
             // Announce restart so UI can notify the user
@@ -516,14 +566,28 @@ final class TorManager: ObservableObject {
             self.bootstrapProgress = 0
             self.bootstrapSummary = ""
             self.isStarting = true
+            self.isDormant = false
             self.lastRestartAt = Date()
         }
         // Prefer clean shutdown via owning controller FD; join the tor thread
         _ = tor_host_shutdown()
         // As a fallback, try control signal if needed (harmless if tor already down)
         _ = await controlSendSignal("SHUTDOWN")
+        // Allow Tor thread to fully terminate before re-starting.
+        var waited = 0
+        while tor_host_is_running() != 0 && waited < 40 {
+            try? await Task.sleep(nanoseconds: 100_000_000) // 100ms
+            waited += 1
+        }
+        if waited >= 40 {
+            SecureLogger.warning("TorManager: tor_host_is_running still true before restart", category: .session)
+        }
+        // Allow control monitor and start logic to reinitialize cleanly
+        await MainActor.run {
+            self.controlMonitorStarted = false
+            self.didStart = false
+        }
         // Now start fresh
-        await MainActor.run { self.didStart = false }
         await MainActor.run { self.startIfNeeded() }
     }
 
@@ -589,6 +653,62 @@ final class TorManager: ObservableObject {
         return (text?.contains("250")) == true
     }
 
+    private func resumeTorIfPossible() async -> Bool {
+        let wasDormant = await MainActor.run { self.isDormant }
+        let pendingReady = await MainActor.run { self.socksReady && !self.isReady }
+        let needsWake = wasDormant || pendingReady
+        if !needsWake {
+            return false
+        }
+
+        let activated = await controlSendSignal("ACTIVE")
+        let pinged = await controlPingBootstrap(timeout: 3.0)
+        if !activated && !pinged {
+            SecureLogger.warning("TorManager: ACTIVE signal failed", category: .session)
+            return false
+        }
+
+        if let info = await controlGetBootstrapInfo() {
+            await MainActor.run {
+                self.bootstrapProgress = info.progress
+                self.bootstrapSummary = info.summary
+            }
+        }
+
+        await MainActor.run {
+            self.isDormant = false
+            self.isStarting = true
+            self.socksReady = false
+        }
+
+        let firstReady = await waitForSocksReady(timeout: 12.0)
+        if firstReady {
+            await MainActor.run {
+                self.socksReady = true
+                self.isStarting = false
+            }
+            SecureLogger.info("TorManager: resumed Tor via ACTIVE signal", category: .session)
+            return true
+        }
+
+        if pinged {
+            let secondReady = await waitForSocksReady(timeout: 20.0)
+            await MainActor.run {
+                self.socksReady = secondReady
+                self.isStarting = !secondReady
+            }
+            if secondReady {
+                SecureLogger.info("TorManager: resumed Tor after extended wait", category: .session)
+                return true
+            }
+        } else {
+            await MainActor.run { self.isStarting = false }
+        }
+
+        SecureLogger.warning("TorManager: ACTIVE resume failed; will restart", category: .session)
+        return false
+    }
+
     private func controlExchange(lines: [String], timeout: TimeInterval) async -> String? {
         guard let cookiePath = dataDirectoryURL()?.appendingPathComponent("control_auth_cookie"),
               let cookie = try? Data(contentsOf: cookiePath) else { return nil }
@@ -635,3 +755,14 @@ final class TorManager: ObservableObject {
         return resultText
     }
 }
+
+// MARK: - Start policy configuration
+extension TorManager {
+    @MainActor
+    func setAutoStartAllowed(_ allow: Bool) {
+        allowAutoStart = allow
+    }
+
+    @MainActor
+    func isAutoStartAllowed() -> Bool { allowAutoStart }
+}

bitchat/Services/Tor/TorNotifications.swift

@@ -3,4 +3,6 @@ import Foundation
 extension Notification.Name {
     static let TorDidBecomeReady = Notification.Name("TorDidBecomeReady")
     static let TorWillRestart = Notification.Name("TorWillRestart")
+    static let TorWillStart = Notification.Name("TorWillStart")
+    static let TorUserPreferenceChanged = Notification.Name("TorUserPreferenceChanged")
 }

bitchat/Services/Tor/TorURLSession.swift

@@ -4,43 +4,34 @@ import CFNetwork
 #endif
 
 /// Provides a shared URLSession that routes traffic via Tor's SOCKS5 proxy
-/// when Tor is enforced/ready. Falls back to a default session only when
+/// when Tor is enforced/ready. Allows swapping between proxied and direct
-/// compiled with the `BITCHAT_DEV_ALLOW_CLEARNET` flag.
+/// sessions so UI can toggle Tor usage at runtime.
 final class TorURLSession {
     static let shared = TorURLSession()
 
-    // Default (no proxy) session for local development when dev bypass is enabled.
+    // Default (no proxy) session for direct Nostr access when Tor is disabled.
-    private var defaultSession: URLSession = {
+    private var defaultSession: URLSession = TorURLSession.makeDefaultSession()
-        let cfg = URLSessionConfiguration.default
-        cfg.waitsForConnectivity = true
-        return URLSession(configuration: cfg)
-    }()
 
     // Proxied (SOCKS5) session that routes through Tor.
     private var torSession: URLSession = TorURLSession.makeTorSession()
+    private var useTorProxy: Bool = true
 
     var session: URLSession {
-        #if BITCHAT_DEV_ALLOW_CLEARNET
+        useTorProxy ? torSession : defaultSession
-        // Dev bypass: use direct session. Call sites may still await Tor if desired.
-        return defaultSession
-        #else
-        // Production: always use the Tor-proxied session. Call sites ensure readiness.
-        return torSession
-        #endif
     }
 
     // Recreate sessions so new clients bind to the fresh SOCKS/control ports after a Tor restart.
     func rebuild() {
-        #if BITCHAT_DEV_ALLOW_CLEARNET
+        defaultSession = TorURLSession.makeDefaultSession()
-        defaultSession = {
-            let cfg = URLSessionConfiguration.default
-            cfg.waitsForConnectivity = true
-            return URLSession(configuration: cfg)
-        }()
-        #endif
         torSession = TorURLSession.makeTorSession()
     }
 
+    func setProxyMode(useTor: Bool) {
+        guard useTorProxy != useTor else { return }
+        useTorProxy = useTor
+        rebuild()
+    }
+
     private static func makeTorSession() -> URLSession {
         let cfg = URLSessionConfiguration.ephemeral
         cfg.waitsForConnectivity = true
@@ -63,4 +54,10 @@ final class TorURLSession {
         #endif
         return URLSession(configuration: cfg)
     }
+
+    private static func makeDefaultSession() -> URLSession {
+        let cfg = URLSessionConfiguration.default
+        cfg.waitsForConnectivity = true
+        return URLSession(configuration: cfg)
+    }
 }

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

@@ -6,6 +6,7 @@
 //  This is free and unencumbered software released into the public domain.
 //
 
+import BitLogger
 import Foundation
 import Combine
 import SwiftUI
@@ -306,7 +307,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         
         // Send favorite notification to the peer via router (mesh or Nostr)
         if let router = messageRouter {
-            router.sendFavoriteNotification(to: peerID, isFavorite: !wasFavorite)
+            router.sendFavoriteNotification(to: Peer(str: peerID), isFavorite: !wasFavorite)
         } else {
             // Fallback to mesh-only if router not yet wired
             meshService.sendFavoriteNotification(to: peerID, isFavorite: !wasFavorite)

bitchat/Sync/GCSFilter.swift

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

bitchat/Sync/GossipSyncManager.swift

@@ -0,0 +1,200 @@
+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 signPacketForBroadcast(_ packet: BitchatPacket) -> BitchatPacket
+    }
+
+    struct Config {
+        var seenCapacity: Int = 1000          // max packets per sync (cap across types)
+        var gcsMaxBytes: Int = 400           // filter size budget (128..1024)
+        var gcsTargetFpr: Double = 0.01      // 1%
+    }
+
+    private let myPeerID: String
+    private let config: Config
+    weak var delegate: Delegate?
+
+    // Storage: broadcast messages (ordered by insert), and latest announce per sender
+    private var messages: [String: BitchatPacket] = [:] // idHex -> packet
+    private var messageOrder: [String] = []
+    private var latestAnnouncementByPeer: [String: (id: String, packet: BitchatPacket)] = [:]
+
+    // Timer
+    private var periodicTimer: DispatchSourceTimer?
+    private let queue = DispatchQueue(label: "mesh.sync", qos: .utility)
+
+    init(myPeerID: String, config: Config = Config()) {
+        self.myPeerID = myPeerID
+        self.config = config
+    }
+
+    func start() {
+        stop()
+        let timer = DispatchSource.makeTimerSource(queue: queue)
+        timer.schedule(deadline: .now() + 30.0, repeating: 30.0, leeway: .seconds(1))
+        timer.setEventHandler { [weak self] in self?.sendRequestSync() }
+        timer.resume()
+        periodicTimer = timer
+    }
+
+    func stop() {
+        periodicTimer?.cancel(); periodicTimer = nil
+    }
+
+    func scheduleInitialSyncToPeer(_ peerID: String, delaySeconds: TimeInterval = 5.0) {
+        queue.asyncAfter(deadline: .now() + delaySeconds) { [weak self] in
+            self?.sendRequestSync(to: peerID)
+        }
+    }
+
+    func onPublicPacketSeen(_ packet: BitchatPacket) {
+        let mt = MessageType(rawValue: packet.type)
+        let isBroadcastRecipient: Bool = {
+            guard let r = packet.recipientID else { return true }
+            return r.count == 8 && r.allSatisfy { $0 == 0xFF }
+        }()
+        let isBroadcastMessage = (mt == .message && isBroadcastRecipient)
+        let isAnnounce = (mt == .announce)
+        guard isBroadcastMessage || isAnnounce else { return }
+
+        let idHex = PacketIdUtil.computeId(packet).hexEncodedString()
+
+        if isBroadcastMessage {
+            if messages[idHex] == nil {
+                messages[idHex] = packet
+                messageOrder.append(idHex)
+                // Enforce capacity
+                let cap = max(1, config.seenCapacity)
+                while messageOrder.count > cap {
+                    let victim = messageOrder.removeFirst()
+                    messages.removeValue(forKey: victim)
+                }
+            }
+        } else if isAnnounce {
+            let sender = packet.senderID.hexEncodedString()
+            latestAnnouncementByPeer[sender] = (id: idHex, packet: packet)
+        }
+    }
+
+    private func sendRequestSync() {
+        let payload = buildGcsPayload()
+        let pkt = BitchatPacket(
+            type: MessageType.requestSync.rawValue,
+            senderID: Data(hexString: myPeerID) ?? Data(),
+            recipientID: nil, // broadcast
+            timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
+            payload: payload,
+            signature: nil,
+            ttl: 0 // local-only
+        )
+        let signed = delegate?.signPacketForBroadcast(pkt) ?? pkt
+        delegate?.sendPacket(signed)
+    }
+
+    private func sendRequestSync(to peerID: String) {
+        let payload = buildGcsPayload()
+        var recipient = Data()
+        var temp = peerID
+        while temp.count >= 2 && recipient.count < 8 {
+            let hexByte = String(temp.prefix(2))
+            if let b = UInt8(hexByte, radix: 16) { recipient.append(b) }
+            temp = String(temp.dropFirst(2))
+        }
+        let pkt = BitchatPacket(
+            type: MessageType.requestSync.rawValue,
+            senderID: Data(hexString: myPeerID) ?? Data(),
+            recipientID: recipient,
+            timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
+            payload: payload,
+            signature: nil,
+            ttl: 0 // local-only
+        )
+        let signed = delegate?.signPacketForBroadcast(pkt) ?? pkt
+        delegate?.sendPacket(to: peerID, packet: signed)
+    }
+
+    func handleRequestSync(fromPeerID: String, 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()
+            hasher.update(data: id) // 16-byte PacketId
+            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
+        for (_, pair) in latestAnnouncementByPeer {
+            let (idHex, pkt) = pair
+            let idBytes = Data(hexString: idHex) ?? Data()
+            if !mightContain(idBytes) {
+                var toSend = pkt
+                toSend.ttl = 0
+                delegate?.sendPacket(to: fromPeerID, packet: toSend)
+            }
+        }
+
+        // 2) Broadcast messages: send all missing
+        let toSendMsgs = messageOrder.compactMap { messages[$0] }
+        for pkt in toSendMsgs {
+            let idBytes = PacketIdUtil.computeId(pkt)
+            if !mightContain(idBytes) {
+                var toSend = pkt
+                toSend.ttl = 0
+                delegate?.sendPacket(to: fromPeerID, packet: toSend)
+            }
+        }
+    }
+
+    // Build REQUEST_SYNC payload using current candidates and GCS params
+    private func buildGcsPayload() -> Data {
+        // Collect candidates: latest announce per peer + broadcast messages
+        var candidates: [BitchatPacket] = []
+        candidates.reserveCapacity(latestAnnouncementByPeer.count + messageOrder.count)
+        for (_, pair) in latestAnnouncementByPeer { candidates.append(pair.packet) }
+        for id in messageOrder { if let p = messages[id] { candidates.append(p) } }
+        // Sort by timestamp desc
+        candidates.sort { $0.timestamp > $1.timestamp }
+
+        let p = GCSFilter.deriveP(targetFpr: config.gcsTargetFpr)
+        let nMax = GCSFilter.estimateMaxElements(sizeBytes: config.gcsMaxBytes, p: p)
+        let cap = max(1, config.seenCapacity)
+        let takeN = min(candidates.count, min(nMax, cap))
+        if takeN <= 0 {
+            let req = RequestSyncPacket(p: p, m: 1, data: Data())
+            return req.encode()
+        }
+        let ids: [Data] = candidates.prefix(takeN).map { PacketIdUtil.computeId($0) }
+        let params = GCSFilter.buildFilter(ids: ids, maxBytes: config.gcsMaxBytes, targetFpr: config.gcsTargetFpr)
+        let req = RequestSyncPacket(p: params.p, m: params.m, data: params.data)
+        return req.encode()
+    }
+
+    // Explicit removal hook for LEAVE/stale peer
+    func removeAnnouncementForPeer(_ peerID: String) {
+        let normalizedPeerID = peerID.lowercased()
+        _ = latestAnnouncementByPeer.removeValue(forKey: normalizedPeerID)
+        
+        // Remove messages from this peer
+        // Collect IDs to remove first to avoid concurrent modification
+        let messageIdsToRemove = messages.compactMap { (id, message) -> String? in
+            message.senderID.hexEncodedString().lowercased() == normalizedPeerID ? id : nil
+        }
+        
+        // Remove messages and update messageOrder
+        for id in messageIdsToRemove {
+            messages.removeValue(forKey: id)
+            messageOrder.removeAll { $0 == id }
+        }
+    }
+}

bitchat/Sync/PacketIdUtil.swift

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

bitchat/Utils/Color+Peer.swift

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

bitchat/Utils/InputValidator.swift

@@ -10,27 +10,6 @@ struct InputValidator {
         static let maxNicknameLength = 50
         static let maxMessageLength = 10_000
         static let maxReasonLength = 200
-        static let maxPeerIDLength = 64
-        static let hexPeerIDLength = 16 // 8 bytes = 16 hex chars
-    }
-    
-    // MARK: - Peer ID Validation
-    
-    /// Validates a peer ID from any source (short 16-hex, full 64-hex, or internal alnum/-/_ up to 64)
-    static func validatePeerID(_ peerID: String) -> Bool {
-        // Accept short routing IDs (exact 16-hex)
-        if PeerIDResolver.isShortID(peerID) { return true }
-        // If length equals short-hex length but isn't valid hex, reject
-        if peerID.count == Limits.hexPeerIDLength { return false }
-        // Accept full Noise key hex (exact 64-hex)
-        if PeerIDResolver.isNoiseKeyHex(peerID) { return true }
-        // If length equals full key length but isn't valid hex, reject
-        if peerID.count == Limits.maxPeerIDLength { return false }
-        // Internal format: alphanumeric + dash/underscore up to 63 (not 16 or 64)
-        let validCharset = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-_"))
-        return !peerID.isEmpty &&
-               peerID.count < Limits.maxPeerIDLength &&
-               peerID.rangeOfCharacter(from: validCharset.inverted) == nil
     }
     
     // MARK: - String Content Validation

bitchat/Utils/PeerIDResolver.swift

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

bitchat/Utils/String+DJB2.swift

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

bitchat/Utils/String+Nickname.swift

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

bitchat/Views/ContentView.swift

@@ -459,10 +459,15 @@ struct ContentView: View {
                     if let name = viewModel.meshService.peerNickname(peerID: peerID) {
                         selectedMessageSender = name
                     } else {
-                        selectedMessageSender = viewModel.messages.last(where: { $0.senderPeerID == peerID && $0.sender != "system" })?.sender
+                        selectedMessageSender = viewModel.messages.last(where: { $0.senderPeer?.id == peerID && $0.sender != "system" })?.sender
                     }
                 }
-                showMessageActions = true
+                if viewModel.isSelfSender(peerID: selectedMessageSenderID, displayName: selectedMessageSender) {
+                    selectedMessageSender = nil
+                    selectedMessageSenderID = nil
+                } else {
+                    showMessageActions = true
+                }
             }
             .onOpenURL { url in
                 guard url.scheme == "bitchat", url.host == "geohash" else { return }
@@ -1367,7 +1372,7 @@ struct ContentView: View {
                !fav.peerNickname.isEmpty { return fav.peerNickname }
             // Fallback: resolve from persisted social identity via fingerprint mapping
             if headerPeerID.count == 16 {
-                let candidates = viewModel.identityManager.getCryptoIdentitiesByPeerIDPrefix(headerPeerID)
+                let candidates = viewModel.identityManager.getCryptoIdentitiesByPeerIDPrefix(Peer(str: headerPeerID))
                 if let id = candidates.first,
                    let social = viewModel.identityManager.getSocialIdentity(for: id.fingerprint) {
                     if let pet = social.localPetname, !pet.isEmpty { return pet }

bitchat/Views/LocationChannelsSheet.swift

@@ -9,6 +9,7 @@ struct LocationChannelsSheet: View {
     @Binding var isPresented: Bool
     @ObservedObject private var manager = LocationChannelManager.shared
     @ObservedObject private var bookmarks = GeohashBookmarksStore.shared
+    @ObservedObject private var network = NetworkActivationService.shared
     @EnvironmentObject var viewModel: ChatViewModel
     @Environment(\.colorScheme) var colorScheme
     @State private var customGeohash: String = ""
@@ -266,6 +267,7 @@ struct LocationChannelsSheet: View {
 
             // Footer action inside the list
             if manager.permissionState == LocationChannelManager.PermissionState.authorized {
+                torToggleSection
                 Button(action: {
                     openSystemLocationSettings()
                 }) {
@@ -409,8 +411,36 @@ struct LocationChannelsSheet: View {
     }
 }
 
-// MARK: - Standardized Colors
+// MARK: - TOR Toggle & Standardized Colors
 extension LocationChannelsSheet {
+    private var torToggleBinding: Binding<Bool> {
+        Binding(
+            get: { network.userTorEnabled },
+            set: { network.setUserTorEnabled($0) }
+        )
+    }
+
+    private var torToggleSection: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Toggle(isOn: torToggleBinding) {
+                VStack(alignment: .leading, spacing: 2) {
+                    Text("tor routing")
+                        .font(.system(size: 12, weight: .semibold, design: .monospaced))
+                        .foregroundColor(.primary)
+                    Text("hides your ip for location channels. recommended: on.")
+                        .font(.system(size: 11, design: .monospaced))
+                        .foregroundColor(.secondary)
+                }
+            }
+            .toggleStyle(IRCToggleStyle(accent: standardGreen))
+        }
+        .padding(12)
+        .background(Color.secondary.opacity(0.12))
+        .cornerRadius(8)
+        .listRowSeparator(.hidden)
+        .listRowBackground(Color.clear)
+    }
+
     private var standardGreen: Color {
         (colorScheme == .dark) ? Color.green : Color(red: 0, green: 0.5, blue: 0)
     }
@@ -419,6 +449,34 @@ extension LocationChannelsSheet {
     }
 }
 
+private struct IRCToggleStyle: ToggleStyle {
+    let accent: Color
+
+    func makeBody(configuration: Configuration) -> some View {
+        Button(action: { configuration.isOn.toggle() }) {
+            HStack(spacing: 12) {
+                configuration.label
+                Spacer()
+                Text(configuration.isOn ? "on" : "off")
+                    .textCase(.uppercase)
+                    .font(.system(size: 12, weight: .semibold, design: .monospaced))
+                    .foregroundColor(configuration.isOn ? accent : .secondary)
+                    .padding(.vertical, 4)
+                    .padding(.horizontal, 10)
+                    .background(
+                        RoundedRectangle(cornerRadius: 6)
+                            .fill(accent.opacity(configuration.isOn ? 0.18 : 0.08))
+                    )
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 6)
+                            .stroke(accent.opacity(configuration.isOn ? 0.35 : 0.15), lineWidth: 1)
+                    )
+            }
+        }
+        .buttonStyle(.plain)
+    }
+}
+
 // MARK: - Coverage helpers
 extension LocationChannelsSheet {
     private func coverageString(forPrecision len: Int) -> String {

bitchatShareExtension/ShareViewController.swift

@@ -12,6 +12,9 @@ import UniformTypeIdentifiers
 /// Modern share extension using UIKit + UTTypes.
 /// Avoids deprecated Social framework and SLComposeServiceViewController.
 final class ShareViewController: UIViewController {
+    // Bundle.main.bundleIdentifier would get the extension's bundleID
+    private static let groupID = "group.chat.bitchat"
+    
     private let statusLabel: UILabel = {
         let l = UILabel()
         l.translatesAutoresizingMaskIntoConstraints = false
@@ -32,8 +35,9 @@ 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
@@ -149,7 +153,7 @@ final class ShareViewController: UIViewController {
     }
 
     private func saveToSharedDefaults(content: String, type: String) {
-        guard let userDefaults = UserDefaults(suiteName: "group.chat.bitchat") else { return }
+        guard let userDefaults = UserDefaults(suiteName: Self.groupID) else { return }
         userDefaults.set(content, forKey: "sharedContent")
         userDefaults.set(type, forKey: "sharedContentType")
         userDefaults.set(Date(), forKey: "sharedContentDate")
@@ -160,7 +164,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

@@ -134,7 +134,7 @@ final class BLEServiceTests: XCTestCase {
             originalSender: nil,
             isPrivate: false,
             recipientNickname: nil,
-            senderPeerID: "REMOTE123",
+            senderPeer: "REMOTE123",
             mentions: nil
         )
         
@@ -161,7 +161,7 @@ final class BLEServiceTests: XCTestCase {
             originalSender: nil,
             isPrivate: false,
             recipientNickname: nil,
-            senderPeerID: "PACKET123",
+            senderPeer: "PACKET123",
             mentions: nil
         )
         
@@ -215,7 +215,7 @@ final class BLEServiceTests: XCTestCase {
         let expectation = XCTestExpectation(description: "Delivery handler called")
         
         service.packetDeliveryHandler = { packet in
-            if let msg = BitchatMessage.fromBinaryPayload(packet.payload) {
+            if let msg = BitchatMessage(packet.payload) {
                 XCTAssertEqual(msg.content, "Test delivery")
                 expectation.fulfill()
             }
@@ -243,7 +243,7 @@ final class BLEServiceTests: XCTestCase {
             originalSender: nil,
             isPrivate: false,
             recipientNickname: nil,
-            senderPeerID: "TEST123",
+            senderPeer: "TEST123",
             mentions: nil
         )
         

bitchatTests/EndToEnd/PrivateChatE2ETests.swift

@@ -139,7 +139,7 @@ final class PrivateChatE2ETests: XCTestCase {
         alice.packetDeliveryHandler = { packet in
             // Encrypt outgoing private messages
             if packet.type == 0x01,
-               let message = BitchatMessage.fromBinaryPayload(packet.payload),
+               let message = BitchatMessage(packet.payload),
                message.isPrivate {
                 do {
                     let encrypted = try aliceManager.encrypt(packet.payload, for: TestConstants.testPeerID2)
@@ -164,7 +164,7 @@ final class PrivateChatE2ETests: XCTestCase {
             if packet.type == 0x02 {
                 do {
                     let decrypted = try bobManager.decrypt(packet.payload, from: TestConstants.testPeerID1)
-                    if let message = BitchatMessage.fromBinaryPayload(decrypted) {
+                    if let message = BitchatMessage(decrypted) {
                         XCTAssertEqual(message.content, TestConstants.testMessage1)
                         XCTAssertTrue(message.isPrivate)
                         expectation.fulfill()

bitchatTests/EndToEnd/PublicChatE2ETests.swift

@@ -98,7 +98,7 @@ final class PublicChatE2ETests: XCTestCase {
         // Set up relay in Bob
         bob.packetDeliveryHandler = { packet in
             // Bob should relay to Charlie
-            if let message = BitchatMessage.fromBinaryPayload(packet.payload),
+            if let message = BitchatMessage(packet.payload),
                message.sender == TestConstants.testNickname1 {
                 
                 // Create relay message
@@ -111,7 +111,7 @@ final class PublicChatE2ETests: XCTestCase {
                     originalSender: message.sender,
                     isPrivate: message.isPrivate,
                     recipientNickname: message.recipientNickname,
-                    senderPeerID: message.senderPeerID,
+                    senderPeerID: message.senderPeer?.id,
                     mentions: message.mentions
                 )
                 
@@ -437,9 +437,9 @@ final class PublicChatE2ETests: XCTestCase {
             // Check if should relay
             guard packet.ttl > 1 else { return }
             
-            if let message = BitchatMessage.fromBinaryPayload(packet.payload) {
+            if let message = BitchatMessage(packet.payload) {
                 // Don't relay own messages
-                guard message.senderPeerID != node.peerID else { return }
+                guard message.senderPeer?.id != node.peerID else { return }
                 
                 // Create relay message
                 let relayMessage = BitchatMessage(
@@ -451,7 +451,7 @@ final class PublicChatE2ETests: XCTestCase {
                     originalSender: message.isRelay ? message.originalSender : message.sender,
                     isPrivate: message.isPrivate,
                     recipientNickname: message.recipientNickname,
-                    senderPeerID: message.senderPeerID,
+                    senderPeerID: message.senderPeer?.id,
                     mentions: message.mentions
                 )
                 

bitchatTests/Integration/IntegrationTests.swift

@@ -531,7 +531,7 @@ final class IntegrationTests: XCTestCase {
         // Setup encryption at Alice
         nodes["Alice"]!.packetDeliveryHandler = { packet in
             if packet.type == 0x01,
-               let message = BitchatMessage.fromBinaryPayload(packet.payload),
+               let message = BitchatMessage(packet.payload),
                message.isPrivate && packet.recipientID != nil {
                 // Encrypt private messages
                 if let encrypted = try? self.noiseManagers["Alice"]!.encrypt(packet.payload, for: TestConstants.testPeerID2) {
@@ -553,7 +553,7 @@ final class IntegrationTests: XCTestCase {
         nodes["Bob"]!.packetDeliveryHandler = { packet in
             if packet.type == 0x02 {
                 if let decrypted = try? self.noiseManagers["Bob"]!.decrypt(packet.payload, from: TestConstants.testPeerID1),
-                   let message = BitchatMessage.fromBinaryPayload(decrypted) {
+                   let message = BitchatMessage(decrypted) {
                     bobDecrypted = message.content == "Secret message"
                     expectation.fulfill()
                 }
@@ -626,8 +626,8 @@ final class IntegrationTests: XCTestCase {
         node.packetDeliveryHandler = { packet in
             guard packet.ttl > 1 else { return }
             
-            if let message = BitchatMessage.fromBinaryPayload(packet.payload) {
+            if let message = BitchatMessage(packet.payload) {
-                guard message.senderPeerID != node.peerID else { return }
+                guard message.senderPeer?.id != node.peerID else { return }
                 
                 let relayMessage = BitchatMessage(
                     id: message.id,
@@ -638,7 +638,7 @@ final class IntegrationTests: XCTestCase {
                     originalSender: message.isRelay ? message.originalSender : message.sender,
                     isPrivate: message.isPrivate,
                     recipientNickname: message.recipientNickname,
-                    senderPeerID: message.senderPeerID,
+                    senderPeerID: message.senderPeer?.id,
                     mentions: message.mentions
                 )
                 

bitchatTests/Mocks/MockBLEService.swift

@@ -309,7 +309,7 @@ final class MockBLEService: NSObject {
 
     func simulateIncomingPacket(_ packet: BitchatPacket) {
         // Process through the actual handling logic
-        if let message = BitchatMessage.fromBinaryPayload(packet.payload) {
+        if let message = BitchatMessage(packet.payload) {
             var shouldDeliver = false
             seenLock.lock()
             if !seenMessageIDs.contains(message.id) {
@@ -331,7 +331,7 @@ final class MockBLEService: NSObject {
                     let nextTTL = packet.ttl > 0 ? packet.ttl - 1 : 0
                     for neighbor in neighbors() {
                         // Avoid immediate echo loopback to sender if known
-                        if let sender = message.senderPeerID, sender == neighbor.peerID { continue }
+                        if let sender = message.senderPeer?.id, sender == neighbor.peerID { continue }
                         var relay = packet
                         relay.ttl = nextTTL
                         neighbor.simulateIncomingPacket(relay)

bitchatTests/Protocol/BinaryProtocolTests.swift

@@ -197,14 +197,14 @@ final class BinaryProtocolTests: XCTestCase {
             return
         }
         
-        guard let decodedMessage = BitchatMessage.fromBinaryPayload(payload) else {
+        guard let decodedMessage = BitchatMessage(payload) else {
             XCTFail("Failed to decode message from binary")
             return
         }
         
         XCTAssertEqual(decodedMessage.content, message.content)
         XCTAssertEqual(decodedMessage.sender, message.sender)
-        XCTAssertEqual(decodedMessage.senderPeerID, message.senderPeerID)
+        XCTAssertEqual(decodedMessage.senderPeerID, message.senderPeer?.id)
         XCTAssertEqual(decodedMessage.isPrivate, message.isPrivate)
         
         // Timestamp should be close (within 1 second due to conversion)
@@ -219,7 +219,7 @@ final class BinaryProtocolTests: XCTestCase {
         )
         
         guard let payload = message.toBinaryPayload(),
-              let decodedMessage = BitchatMessage.fromBinaryPayload(payload) else {
+              let decodedMessage = BitchatMessage(payload) else {
             XCTFail("Failed to encode/decode private message")
             return
         }
@@ -233,7 +233,7 @@ final class BinaryProtocolTests: XCTestCase {
         let message = TestHelpers.createTestMessage(mentions: mentions)
         
         guard let payload = message.toBinaryPayload(),
-              let decodedMessage = BitchatMessage.fromBinaryPayload(payload) else {
+              let decodedMessage = BitchatMessage(payload) else {
             XCTFail("Failed to encode/decode message with mentions")
             return
         }
@@ -256,7 +256,7 @@ final class BinaryProtocolTests: XCTestCase {
         )
         
         guard let payload = message.toBinaryPayload(),
-              let decodedMessage = BitchatMessage.fromBinaryPayload(payload) else {
+              let decodedMessage = BitchatMessage(payload) else {
             XCTFail("Failed to encode/decode relay message")
             return
         }
@@ -294,7 +294,7 @@ final class BinaryProtocolTests: XCTestCase {
         let message = TestHelpers.createTestMessage(content: largeContent)
         
         guard let payload = message.toBinaryPayload(),
-              let decodedMessage = BitchatMessage.fromBinaryPayload(payload) else {
+              let decodedMessage = BitchatMessage(payload) else {
             XCTFail("Failed to handle large message")
             return
         }
@@ -307,7 +307,7 @@ final class BinaryProtocolTests: XCTestCase {
         let emptyMessage = TestHelpers.createTestMessage(content: "")
         
         guard let payload = emptyMessage.toBinaryPayload(),
-              let decodedMessage = BitchatMessage.fromBinaryPayload(payload) else {
+              let decodedMessage = BitchatMessage(payload) else {
             XCTFail("Failed to handle empty message")
             return
         }

bitchatTests/TestUtilities/TestHelpers.swift

@@ -44,7 +44,7 @@ final class TestHelpers {
             originalSender: nil,
             isPrivate: isPrivate,
             recipientNickname: recipientNickname,
-            senderPeerID: senderPeerID,
+            senderPeer: senderPeerID,
             mentions: mentions
         )
     }

localPackages/BitLogger/Package.swift

@@ -0,0 +1,23 @@
+// swift-tools-version: 5.9
+
+import PackageDescription
+
+let package = Package(
+    name: "BitLogger",
+    platforms: [
+        .iOS(.v16),
+        .macOS(.v13)
+    ],
+    products: [
+        .library(
+            name: "BitLogger",
+            targets: ["BitLogger"]
+        )
+    ],
+    targets: [
+        .target(
+            name: "BitLogger",
+            path: "Sources"
+        )
+    ]
+)

localPackages/BitLogger/Sources/OSLog+Categories.swift

@@ -1,6 +1,6 @@
 //
 // OSLog+Categories.swift
-// bitchat
+// BitLogger
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
@@ -8,7 +8,7 @@
 
 import os.log
 
-extension OSLog {
+public extension OSLog {
     private static let subsystem = "chat.bitchat"
     
     static let noise        = OSLog(subsystem: subsystem, category: "noise")

localPackages/BitLogger/Sources/SecureLogger.swift

@@ -1,6 +1,6 @@
 //
 // SecureLogger.swift
-// bitchat
+// BitLogger
 //
 // This is free and unencumbered software released into the public domain.
 // For more information, see <https://unlicense.org>
@@ -11,7 +11,7 @@ import os.log
 
 /// Centralized security-aware logging framework
 /// Provides safe logging that filters sensitive data and security events
-final class SecureLogger {
+public final class SecureLogger {
     
     // MARK: - Timestamp Formatter
     
@@ -85,8 +85,50 @@ final class SecureLogger {
     private static func shouldLog(_ level: LogLevel) -> Bool {
         return level.order >= minimumLevel.order
     }
+}
+
+// MARK: - Public Logging Methods
+
+public extension SecureLogger {
     
-    // MARK: - Security Event Types
+    static func debug(_ message: @autoclosure () -> String, category: OSLog = .noise,
+                      file: String = #file, line: Int = #line, function: String = #function) {
+        log(message(), category: category, level: .debug, file: file, line: line, function: function)
+    }
+    
+    static func info(_ message: @autoclosure () -> String, category: OSLog = .noise,
+                     file: String = #file, line: Int = #line, function: String = #function) {
+        log(message(), category: category, level: .info, file: file, line: line, function: function)
+    }
+    
+    static func warning(_ message: @autoclosure () -> String, category: OSLog = .noise,
+                        file: String = #file, line: Int = #line, function: String = #function) {
+        log(message(), category: category, level: .warning, file: file, line: line, function: function)
+    }
+    
+    static func error(_ message: @autoclosure () -> String, category: OSLog = .noise,
+                      file: String = #file, line: Int = #line, function: String = #function) {
+        log(message(), category: category, level: .error, file: file, line: line, function: function)
+    }
+    
+    /// Log errors with context
+    static func error(_ error: Error, context: @autoclosure () -> String, category: OSLog = .noise,
+                      file: String = #file, line: Int = #line, function: String = #function) {
+        let location = formatLocation(file: file, line: line, function: function)
+        let sanitized = sanitize(context())
+        let errorDesc = sanitize(error.localizedDescription)
+        
+        #if DEBUG
+        os_log("%{public}@ Error in %{public}@: %{public}@", log: category, type: .error, location, sanitized, errorDesc)
+        #else
+        os_log("%{private}@ Error in %{private}@: %{private}@", log: category, type: .error, location, sanitized, errorDesc)
+        #endif
+    }
+}
+
+// MARK: Security Event Logging
+
+public extension SecureLogger {
     
     enum SecurityEvent {
         case handshakeStarted(peerID: String)
@@ -111,30 +153,6 @@ final class SecureLogger {
         }
     }
     
-    // MARK: - Public Logging Methods
-    
-    static func debug(_ message: @autoclosure () -> String, category: OSLog = .noise,
-                      file: String = #file, line: Int = #line, function: String = #function) {
-        log(message(), category: category, level: .debug, file: file, line: line, function: function)
-    }
-    
-    static func info(_ message: @autoclosure () -> String, category: OSLog = .noise,
-                     file: String = #file, line: Int = #line, function: String = #function) {
-        log(message(), category: category, level: .info, file: file, line: line, function: function)
-    }
-    
-    static func warning(_ message: @autoclosure () -> String, category: OSLog = .noise,
-                        file: String = #file, line: Int = #line, function: String = #function) {
-        log(message(), category: category, level: .warning, file: file, line: line, function: function)
-    }
-    
-    static func error(_ message: @autoclosure () -> String, category: OSLog = .noise,
-                      file: String = #file, line: Int = #line, function: String = #function) {
-        log(message(), category: category, level: .error, file: file, line: line, function: function)
-    }
-    
-    // MARK: Security Event Logging
-    
     static func debug(_ event: SecurityEvent, file: String = #file, line: Int = #line, function: String = #function) {
         logSecurityEvent(event, level: .debug, file: file, line: line, function: function)
     }
@@ -150,25 +168,11 @@ final class SecureLogger {
     static func error(_ event: SecurityEvent, file: String = #file, line: Int = #line, function: String = #function) {
         logSecurityEvent(event, level: .error, file: file, line: line, function: function)
     }
-    
-    /// Log errors with context
-    static func error(_ error: Error, context: @autoclosure () -> String, category: OSLog = .noise,
-                      file: String = #file, line: Int = #line, function: String = #function) {
-        let location = formatLocation(file: file, line: line, function: function)
-        let sanitized = sanitize(context())
-        let errorDesc = sanitize(error.localizedDescription)
-        
-        #if DEBUG
-        os_log("%{public}@ Error in %{public}@: %{public}@", log: category, type: .error, location, sanitized, errorDesc)
-        #else
-        os_log("%{private}@ Error in %{private}@: %{private}@", log: category, type: .error, location, sanitized, errorDesc)
-        #endif
-    }
 }
 
 // MARK: - Convenience Extensions
 
-extension SecureLogger {
+public extension SecureLogger {
     
     enum KeyOperation: String, CustomStringConvertible {
         case load
@@ -177,7 +181,7 @@ extension SecureLogger {
         case delete
         case save
         
-        var description: String { rawValue }
+        public var description: String { rawValue }
     }
     
     /// Log key management operations
@@ -290,8 +294,8 @@ private extension SecureLogger {
 
 /// Helper to migrate from print statements to SecureLogger
 /// Usage: Replace print(...) with secureLog(...)
-func secureLog(_ items: Any..., separator: String = " ", terminator: String = "\n",
+public func secureLog(_ items: Any..., separator: String = " ", terminator: String = "\n",
-               file: String = #file, line: Int = #line, function: String = #function) {
+                      file: String = #file, line: Int = #line, function: String = #function) {
     #if DEBUG
     let message = items.map { String(describing: $0) }.joined(separator: separator)
     SecureLogger.debug(message, file: file, line: line, function: function)

project.yml

@@ -1,236 +0,0 @@
-name: bitchat
-options:
-  bundleIdPrefix: chat.bitchat
-  deploymentTarget:
-    iOS: 16.0
-    macOS: 13.0
-  createIntermediateGroups: true
-  
-settings:
-  MARKETING_VERSION: 1.0.0
-  CURRENT_PROJECT_VERSION: 1
-
-packages:
-  P256K:
-    url: https://github.com/21-DOT-DEV/swift-secp256k1
-    majorVersion: 0.21.1
-  
-targets:
-  bitchat_iOS:
-    type: application
-    platform: iOS
-    sources: 
-      - bitchat
-    resources:
-      - bitchat/Assets.xcassets
-      - bitchat/LaunchScreen.storyboard
-    info:
-      path: bitchat/Info.plist
-      properties:
-        CFBundleDisplayName: bitchat
-        CFBundleShortVersionString: $(MARKETING_VERSION)
-        CFBundleVersion: $(CURRENT_PROJECT_VERSION)
-        NSBluetoothAlwaysUsageDescription: bitchat uses Bluetooth to create a secure mesh network for chatting with nearby users.
-        NSBluetoothPeripheralUsageDescription: bitchat uses Bluetooth to discover and connect with other bitchat users nearby.
-        NSCameraUsageDescription: bitchat uses the camera to scan QR codes to verify peers.
-        NSLocationWhenInUseUsageDescription: bitchat uses your approximate location to compute local geohash channels for optional public chats. Exact GPS is never shared.
-        UIBackgroundModes:
-          - bluetooth-central
-          - bluetooth-peripheral
-        UILaunchStoryboardName: LaunchScreen
-        UISupportedInterfaceOrientations:
-          - UIInterfaceOrientationPortrait
-        UISupportedInterfaceOrientations~ipad:
-          - UIInterfaceOrientationPortrait
-          - UIInterfaceOrientationPortraitUpsideDown
-          - UIInterfaceOrientationLandscapeLeft
-          - UIInterfaceOrientationLandscapeRight
-        UIRequiresFullScreen: false
-        CFBundleURLTypes:
-          - CFBundleURLSchemes:
-              - bitchat
-        # xcodegen quirk: include some macOS properties in iOS target
-        LSMinimumSystemVersion: $(MACOSX_DEPLOYMENT_TARGET)
-    settings:
-      PRODUCT_BUNDLE_IDENTIFIER: chat.bitchat
-      PRODUCT_NAME: bitchat
-      INFOPLIST_FILE: bitchat/Info.plist
-      ENABLE_PREVIEWS: YES
-      SWIFT_VERSION: 5.0
-      IPHONEOS_DEPLOYMENT_TARGET: 16.0
-      SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD: YES
-      CODE_SIGN_STYLE: Automatic
-      CODE_SIGNING_REQUIRED: YES
-      CODE_SIGNING_ALLOWED: YES
-      DEVELOPMENT_TEAM: L3N5LHJD5Y
-      ASSETCATALOG_COMPILER_APPICON_NAME: AppIcon
-      ASSETCATALOG_COMPILER_INCLUDE_ALL_APPICON_ASSETS: YES
-      CODE_SIGN_ENTITLEMENTS: bitchat/bitchat.entitlements
-    dependencies:
-      - target: bitchatShareExtension
-        embed: true
-      - package: P256K
-      - framework: Frameworks/tor-nolzma.xcframework
-        embed: true
-        codeSign: true
-      - sdk: libz.tbd
-        
-  bitchat_macOS:
-    type: application
-    platform: macOS
-    sources: 
-      - bitchat
-    resources:
-      - bitchat/Assets.xcassets
-    info:
-      path: bitchat/Info.plist
-      properties:
-        CFBundleDisplayName: bitchat
-        CFBundleShortVersionString: $(MARKETING_VERSION)
-        CFBundleVersion: $(CURRENT_PROJECT_VERSION)
-        LSMinimumSystemVersion: $(MACOSX_DEPLOYMENT_TARGET)
-        NSBluetoothAlwaysUsageDescription: bitchat uses Bluetooth to create a secure mesh network for chatting with nearby users.
-        NSBluetoothPeripheralUsageDescription: bitchat uses Bluetooth to discover and connect with other bitchat users nearby.
-        NSCameraUsageDescription: bitchat uses the camera to scan QR codes to verify peers.
-        NSLocationWhenInUseUsageDescription: bitchat uses your approximate location to compute local geohash channels for optional public chats. Exact GPS is never shared.
-        CFBundleURLTypes:
-          - CFBundleURLSchemes:
-              - bitchat
-        # xcodegen quirk: include some iOS properties in macOS target
-        UIBackgroundModes:
-          - bluetooth-central
-          - bluetooth-peripheral
-        UILaunchStoryboardName: LaunchScreen
-        UISupportedInterfaceOrientations:
-          - UIInterfaceOrientationPortrait
-        UIRequiresFullScreen: true
-    settings:
-      PRODUCT_BUNDLE_IDENTIFIER: chat.bitchat
-      PRODUCT_NAME: bitchat
-      INFOPLIST_FILE: bitchat/Info.plist
-      ENABLE_PREVIEWS: NO
-      SWIFT_VERSION: 5.0
-      MACOSX_DEPLOYMENT_TARGET: 13.0
-      CODE_SIGN_STYLE: Automatic
-      CODE_SIGNING_REQUIRED: YES
-      CODE_SIGNING_ALLOWED: YES
-      DEVELOPMENT_TEAM: L3N5LHJD5Y
-      ASSETCATALOG_COMPILER_APPICON_NAME: AppIcon
-      ASSETCATALOG_COMPILER_INCLUDE_ALL_APPICON_ASSETS: YES
-      CODE_SIGN_ENTITLEMENTS: bitchat/bitchat-macOS.entitlements
-    dependencies:
-      - package: P256K
-      - framework: Frameworks/tor-nolzma.xcframework
-        embed: true
-        codeSign: true
-      - sdk: libz.tbd
-
-  bitchatShareExtension:
-    type: app-extension
-    platform: iOS
-    sources:
-      - bitchatShareExtension
-      - bitchat/Services/TransportConfig.swift
-    info:
-      path: bitchatShareExtension/Info.plist
-      properties:
-        CFBundleDisplayName: bitchat
-        CFBundleShortVersionString: $(MARKETING_VERSION)
-        CFBundleVersion: $(CURRENT_PROJECT_VERSION)
-        NSExtension:
-          NSExtensionPointIdentifier: com.apple.share-services
-          NSExtensionPrincipalClass: $(PRODUCT_MODULE_NAME).ShareViewController
-          NSExtensionAttributes:
-            NSExtensionActivationRule:
-              NSExtensionActivationSupportsText: true
-              NSExtensionActivationSupportsWebURLWithMaxCount: 1
-              NSExtensionActivationSupportsImageWithMaxCount: 1
-    settings:
-      PRODUCT_BUNDLE_IDENTIFIER: chat.bitchat.ShareExtension
-      INFOPLIST_FILE: bitchatShareExtension/Info.plist
-      SWIFT_VERSION: 5.0
-      IPHONEOS_DEPLOYMENT_TARGET: 16.0
-      CODE_SIGN_STYLE: Automatic
-      CODE_SIGNING_REQUIRED: YES
-      CODE_SIGNING_ALLOWED: YES
-      DEVELOPMENT_TEAM: L3N5LHJD5Y
-      CODE_SIGN_ENTITLEMENTS: bitchatShareExtension/bitchatShareExtension.entitlements
-      CODE_SIGN_ALLOW_ENTITLEMENTS_MODIFICATION: YES
-
-  bitchatTests_iOS:
-    type: bundle.unit-test
-    platform: iOS
-    sources: 
-      - bitchatTests
-    dependencies:
-      - target: bitchat_iOS
-    settings:
-      PRODUCT_BUNDLE_IDENTIFIER: chat.bitchat.tests
-      INFOPLIST_FILE: bitchatTests/Info.plist
-      SWIFT_VERSION: 5.0
-      IPHONEOS_DEPLOYMENT_TARGET: 16.0
-      TEST_HOST: $(BUILT_PRODUCTS_DIR)/bitchat.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/bitchat
-      BUNDLE_LOADER: $(TEST_HOST)
-      CODE_SIGN_STYLE: Automatic
-      CODE_SIGNING_REQUIRED: YES
-      CODE_SIGNING_ALLOWED: YES
-      DEVELOPMENT_TEAM: L3N5LHJD5Y
-      
-  bitchatTests_macOS:
-    type: bundle.unit-test
-    platform: macOS
-    sources: 
-      - bitchatTests
-    dependencies:
-      - target: bitchat_macOS
-    settings:
-      PRODUCT_BUNDLE_IDENTIFIER: chat.bitchat.tests
-      INFOPLIST_FILE: bitchatTests/Info.plist
-      SWIFT_VERSION: 5.0
-      MACOSX_DEPLOYMENT_TARGET: 13.0
-      TEST_HOST: $(BUILT_PRODUCTS_DIR)/bitchat.app/Contents/MacOS/bitchat
-      BUNDLE_LOADER: $(TEST_HOST)
-      CODE_SIGN_STYLE: Automatic
-      CODE_SIGNING_REQUIRED: YES
-      CODE_SIGNING_ALLOWED: YES
-      DEVELOPMENT_TEAM: L3N5LHJD5Y
-
-schemes:
-  bitchat (iOS):
-    build:
-      targets:
-        bitchat_iOS: all
-        bitchatShareExtension: all
-    run:
-      config: Debug
-      executable: bitchat_iOS
-    test:
-      config: Debug
-      targets:
-        - bitchatTests_iOS
-    profile:
-      config: Release
-      executable: bitchat_iOS
-    analyze:
-      config: Debug
-    archive:
-      config: Release
-      
-  bitchat (macOS):
-    build:
-      targets:
-        bitchat_macOS: all
-    run:
-      config: Debug
-      executable: bitchat_macOS
-    test:
-      config: Debug
-      targets:
-        - bitchatTests_macOS
-    profile:
-      config: Release
-      executable: bitchat_macOS
-    analyze:
-      config: Debug
-    archive:
-      config: Release

setup.sh

@@ -1,40 +0,0 @@
-#!/bin/bash
-
-echo "bitchat Setup Script"
-echo "==================="
-
-# Check if XcodeGen is installed
-if command -v xcodegen &> /dev/null; then
-    echo "✓ XcodeGen found"
-    echo "Generating Xcode project..."
-    xcodegen generate
-    echo "✓ Project generated successfully"
-    echo ""
-    echo "To open the project, run:"
-    echo "  open bitchat.xcodeproj"
-else
-    echo "⚠️  XcodeGen not found"
-    echo ""
-    echo "You have several options:"
-    echo "1. Install XcodeGen:"
-    echo "   brew install xcodegen"
-    echo ""
-    echo "2. Open with Swift Package Manager:"
-    echo "   open Package.swift"
-    echo ""
-    echo "3. Create a new Xcode project manually and add the source files"
-fi
-
-echo ""
-echo "Project Structure:"
-echo "- bitchat/           Main source files"
-echo "  - BitchatApp.swift    App entry point"
-echo "  - Views/              SwiftUI views"
-echo "  - ViewModels/         View models"
-echo "  - Services/           Bluetooth and encryption"
-echo "  - Protocols/          Protocol definitions"
-echo ""
-echo "Remember to:"
-echo "1. Enable Bluetooth in device settings"
-echo "2. Run on physical devices (Bluetooth doesn't work in simulator)"
-echo "3. Test with multiple devices for mesh functionality"