Notes icon: turn blue immediately when sheet shows notes by passing count up from sheet (closure) and OR-ing with counter; reset on sheet close

* Make static functions instance functions to be testable

* Injectable KeychainManager + Mock + updated tests

* Remove `pendingActions` from identity manager (dead code)

* Remove `getHandshakeState` from identity manager (dead code)

* Remove `getAllSocialIdentities` from identity manager (dead code)

* Remove `getCryptographicIdentity` from identity manager (dead code)

* Remove `resolveIdentity` from identity manager (dead code)

* Identity Manager: minor clean up

* Put Identity Manager behind a protocol

* Remove Keychain and Identity Manager singletons

* Tests: include MockKeychain/MockIdentityManager in project; init identityManager in CommandProcessorTests

---------

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

Frameworks/README.md

@@ -1,12 +0,0 @@
-Place Tor.xcframework here
-
-Instructions
-- Obtain a prebuilt Tor Apple xcframework (iCepa/Onion Browser lineage) or build your own minimal client-only Tor.
-- Rename it (if needed) to `Tor.xcframework` and drop it in this `Frameworks/` directory.
-- Regenerate the Xcode project if you use XcodeGen (`project.yml` already references `Frameworks/Tor.xcframework`).
-- Build the app; `TorManager` will automatically bootstrap Tor and route all networking through it.
-
-Notes
-- For iOS, the framework will be embedded and code-signed automatically.
-- For macOS, it will be linked and embedded as well (you may prefer a system tor for smaller bundles).
-

bitchat.xcodeproj/project.pbxproj

@@ -33,14 +33,18 @@
 		0481A3472E6D869F00FC845E /* TorURLSession.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A3442E6D869F00FC845E /* TorURLSession.swift */; };
 		0481A3482E6D869F00FC845E /* TorManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A3432E6D869F00FC845E /* TorManager.swift */; };
 		0481A3492E6D869F00FC845E /* TorURLSession.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A3442E6D869F00FC845E /* TorURLSession.swift */; };
-		0481A3552E6D877600FC845E /* README.md in Resources */ = {isa = PBXBuildFile; fileRef = 0481A3532E6D877600FC845E /* README.md */; };
-		0481A3562E6D877600FC845E /* README.md in Resources */ = {isa = PBXBuildFile; fileRef = 0481A3532E6D877600FC845E /* README.md */; };
 		0481A3582E6D929E00FC845E /* tor-nolzma.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0481A3572E6D929E00FC845E /* tor-nolzma.xcframework */; };
 		0481A3592E6D929E00FC845E /* tor-nolzma.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0481A3572E6D929E00FC845E /* tor-nolzma.xcframework */; };
 		0481A35B2E6D9BEF00FC845E /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 0481A35A2E6D9BEF00FC845E /* libz.tbd */; };
 		0481A35D2E6DA18600FC845E /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 0481A35C2E6DA18600FC845E /* libz.tbd */; };
 		0481A3902E734CAE00FC845E /* CommandProcessorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A38F2E734CAE00FC845E /* CommandProcessorTests.swift */; };
 		0481A3912E734CAE00FC845E /* CommandProcessorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A38F2E734CAE00FC845E /* CommandProcessorTests.swift */; };
+		0481A3A92E74D28800FC845E /* LocationNotesView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A3A82E74D28800FC845E /* LocationNotesView.swift */; };
+		0481A3AA2E74D28800FC845E /* LocationNotesView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A3A82E74D28800FC845E /* LocationNotesView.swift */; };
+		0481A3AC2E74D29400FC845E /* LocationNotesManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A3AB2E74D29400FC845E /* LocationNotesManager.swift */; };
+		0481A3AD2E74D29400FC845E /* LocationNotesManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A3AB2E74D29400FC845E /* LocationNotesManager.swift */; };
+		0481A3AF2E74E06300FC845E /* LocationNotesCounter.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A3AE2E74E06300FC845E /* LocationNotesCounter.swift */; };
+		0481A3B02E74E06300FC845E /* LocationNotesCounter.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0481A3AE2E74E06300FC845E /* LocationNotesCounter.swift */; };
 		048A4BE72E5CCCC300162C4A /* TransportConfig.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4BE62E5CCCC300162C4A /* TransportConfig.swift */; };
 		048A4BE82E5CCCC300162C4A /* TransportConfig.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4BE62E5CCCC300162C4A /* TransportConfig.swift */; };
 		048A4BE92E5CCCC300162C4B /* TransportConfig.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4BE62E5CCCC300162C4A /* TransportConfig.swift */; };
@@ -128,6 +132,10 @@
 		9CCF09F7527EC681A13FC246 /* NoiseSecurityConsiderations.swift in Sources */ = {isa = PBXBuildFile; fileRef = 43B4548DAFC9F7AA8873DA53 /* NoiseSecurityConsiderations.swift */; };
 		A0A1C26EFBFDD5B8EFEEDE57 /* PublicChatE2ETests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D22BF09A49010947CEFE45E2 /* PublicChatE2ETests.swift */; };
 		A1B2C3D44E5F60718293A4B5 /* XChaCha20Poly1305Compat.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */; };
+		A1B2C3D4E5F60123456789BA /* MockKeychain.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D4E5F60123456789AA /* MockKeychain.swift */; };
+		A1B2C3D4E5F60123456789BB /* MockKeychain.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D4E5F60123456789AA /* MockKeychain.swift */; };
+		A1B2C3D4E5F60123456789BC /* MockIdentityManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D4E5F60123456789AB /* MockIdentityManager.swift */; };
+		A1B2C3D4E5F60123456789BD /* MockIdentityManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D4E5F60123456789AB /* MockIdentityManager.swift */; };
 		A1B2C3D54E5F60718293A4B6 /* XChaCha20Poly1305Compat.swift in Sources */ = {isa = PBXBuildFile; fileRef = A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */; };
 		A2977428C1D9EF9944C4BFAF /* BLEServiceTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 980B109CBA72BC996455C62B /* BLEServiceTests.swift */; };
 		A7187D48B07C6857DE01D0ED /* NoiseProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = 43613045E63D21D429396805 /* NoiseProtocol.swift */; };
@@ -228,11 +236,13 @@
 		047502B82E560F690083520F /* RelayController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RelayController.swift; sourceTree = "<group>"; };
 		0481A3432E6D869F00FC845E /* TorManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TorManager.swift; sourceTree = "<group>"; };
 		0481A3442E6D869F00FC845E /* TorURLSession.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TorURLSession.swift; sourceTree = "<group>"; };
-		0481A3532E6D877600FC845E /* README.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = README.md; sourceTree = "<group>"; };
 		0481A3572E6D929E00FC845E /* tor-nolzma.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; path = "tor-nolzma.xcframework"; sourceTree = "<group>"; };
 		0481A35A2E6D9BEF00FC845E /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; };
 		0481A35C2E6DA18600FC845E /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; };
 		0481A38F2E734CAE00FC845E /* CommandProcessorTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CommandProcessorTests.swift; sourceTree = "<group>"; };
+		0481A3A82E74D28800FC845E /* LocationNotesView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LocationNotesView.swift; sourceTree = "<group>"; };
+		0481A3AB2E74D29400FC845E /* LocationNotesManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LocationNotesManager.swift; sourceTree = "<group>"; };
+		0481A3AE2E74E06300FC845E /* LocationNotesCounter.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LocationNotesCounter.swift; sourceTree = "<group>"; };
 		048A4BE62E5CCCC300162C4A /* TransportConfig.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TransportConfig.swift; sourceTree = "<group>"; };
 		048A4C272E5FCD6600162C4A /* GeohashBookmarksStore.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GeohashBookmarksStore.swift; sourceTree = "<group>"; };
 		048A4C2A2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GeohashBookmarksStoreTests.swift; sourceTree = "<group>"; };
@@ -285,6 +295,8 @@
 		9AB6BE4ABD7F5088E9865E56 /* NoiseSession.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NoiseSession.swift; sourceTree = "<group>"; };
 		A08E03AA0C63E97C91749AEC /* ContentView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ContentView.swift; sourceTree = "<group>"; };
 		A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = XChaCha20Poly1305Compat.swift; sourceTree = "<group>"; };
+		A1B2C3D4E5F60123456789AA /* MockKeychain.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MockKeychain.swift; sourceTree = "<group>"; };
+		A1B2C3D4E5F60123456789AB /* MockIdentityManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MockIdentityManager.swift; sourceTree = "<group>"; };
 		A2136C3E22D02D4A8DBE7EAB /* BinaryProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BinaryProtocol.swift; sourceTree = "<group>"; };
 		AA11BB22CC33DD44EE55FF68 /* MessageTextHelpers.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MessageTextHelpers.swift; sourceTree = "<group>"; };
 		AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VerificationService.swift; sourceTree = "<group>"; };
@@ -366,7 +378,6 @@
 			children = (
 				0481A35A2E6D9BEF00FC845E /* libz.tbd */,
 				0481A35C2E6DA18600FC845E /* libz.tbd */,
-				0481A3532E6D877600FC845E /* README.md */,
 				0481A3572E6D929E00FC845E /* tor-nolzma.xcframework */,
 			);
 			path = Frameworks;
@@ -464,6 +475,8 @@
 			children = (
 				C27328EE574221395B2B8E87 /* MockBluetoothMeshService.swift */,
 				FE7CCF2BD78A3F3DAE6DA145 /* MockBLEService.swift */,
+				A1B2C3D4E5F60123456789AA /* MockKeychain.swift */,
+				A1B2C3D4E5F60123456789AB /* MockIdentityManager.swift */,
 			);
 			path = Mocks;
 			sourceTree = "<group>";
@@ -507,6 +520,7 @@
 		A55126E93155456CAA8D6656 /* Views */ = {
 			isa = PBXGroup;
 			children = (
+				0481A3A82E74D28800FC845E /* LocationNotesView.swift */,
 				AA77BB13CC22DD33EE44FF57 /* VerificationViews.swift */,
 				047502B22E55FED60083520F /* GeohashPeopleList.swift */,
 				047502B32E55FED60083520F /* MeshPeerList.swift */,
@@ -584,6 +598,8 @@
 			isa = PBXGroup;
 			children = (
 				0481A3452E6D869F00FC845E /* Tor */,
+				0481A3AE2E74E06300FC845E /* LocationNotesCounter.swift */,
+				0481A3AB2E74D29400FC845E /* LocationNotesManager.swift */,
 				048A4C272E5FCD6600162C4A /* GeohashBookmarksStore.swift */,
 				048A4BE62E5CCCC300162C4A /* TransportConfig.swift */,
 				AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */,
@@ -777,7 +793,6 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				0481A3552E6D877600FC845E /* README.md in Resources */,
 				7DD72D928FF9DD3CA81B46B0 /* Assets.xcassets in Resources */,
 				E0A1B2C3D4E5F6012345678D /* relays/online_relays_gps.csv in Resources */,
 			);
@@ -789,7 +804,6 @@
 			files = (
 				BCCFEDC1EBE59323C3C470BF /* Assets.xcassets in Resources */,
 				E65BBB6544FE0159F3C6C3A8 /* LaunchScreen.storyboard in Resources */,
-				0481A3562E6D877600FC845E /* README.md in Resources */,
 				E0A1B2C3D4E5F6012345678E /* relays/online_relays_gps.csv in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -826,6 +840,7 @@
 				047502B92E560F690083520F /* RelayController.swift in Sources */,
 				6E7761E21C99F28AE2F9BE5F /* BitchatApp.swift in Sources */,
 				84E3F9B64FB7FB4A140BD0A8 /* BitchatPeer.swift in Sources */,
+				0481A3B02E74E06300FC845E /* LocationNotesCounter.swift in Sources */,
 				923027D6F2F417AFA2488127 /* BitchatProtocol.swift in Sources */,
 				D450CF41F207BDE1A1AAA56E /* ChatViewModel.swift in Sources */,
 				B0CA7796B2B2AC2B33F84548 /* CompressionUtil.swift in Sources */,
@@ -856,6 +871,8 @@
 				049BD3AF2E51ED60001A566B /* Transport.swift in Sources */,
 				E2DCF7817344F1CCDB8B7B2F /* SecureIdentityStateManager.swift in Sources */,
 				049BD3A02E51DBF4001A566B /* Packets.swift in Sources */,
+				0481A3AD2E74D29400FC845E /* LocationNotesManager.swift in Sources */,
+				0481A3AA2E74D28800FC845E /* LocationNotesView.swift in Sources */,
 				047502892E5416250083520F /* Geohash.swift in Sources */,
 				0475028A2E5416250083520F /* LocationChannel.swift in Sources */,
 				049BD3A12E51DBF4001A566B /* PeerID.swift in Sources */,
@@ -891,6 +908,7 @@
 				047502BA2E560F690083520F /* RelayController.swift in Sources */,
 				10E68BB889356219189E38EC /* BitchatApp.swift in Sources */,
 				84D13329AB7EE1D65A37438A /* BitchatPeer.swift in Sources */,
+				0481A3AF2E74E06300FC845E /* LocationNotesCounter.swift in Sources */,
 				6DE056E1EE9850E9FBF50157 /* BitchatProtocol.swift in Sources */,
 				7576A357B278E5733E9D9F33 /* ChatViewModel.swift in Sources */,
 				7DCA0DBCB8884E3B31C7BCE3 /* CompressionUtil.swift in Sources */,
@@ -921,6 +939,8 @@
 				049BD3AE2E51ED60001A566B /* Transport.swift in Sources */,
 				68C4BE564735F6E7915274A2 /* SecureIdentityStateManager.swift in Sources */,
 				049BD3A22E51DBF4001A566B /* Packets.swift in Sources */,
+				0481A3AC2E74D29400FC845E /* LocationNotesManager.swift in Sources */,
+				0481A3A92E74D28800FC845E /* LocationNotesView.swift in Sources */,
 				047502872E5416250083520F /* Geohash.swift in Sources */,
 				047502882E5416250083520F /* LocationChannel.swift in Sources */,
 				049BD3A32E51DBF4001A566B /* PeerID.swift in Sources */,
@@ -949,6 +969,8 @@
 				047502932E547ACC0083520F /* LocationChannelsTests.swift in Sources */,
 				048A4C2B2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */,
 				6C803BF930E7E19BE6E99EAA /* MockBLEService.swift in Sources */,
+				A1B2C3D4E5F60123456789BB /* MockKeychain.swift in Sources */,
+				A1B2C3D4E5F60123456789BD /* MockIdentityManager.swift in Sources */,
 				765254F56997F01054699AC0 /* NoiseProtocolTests.swift in Sources */,
 				968181D255CA7A804340B4DA /* NostrProtocolTests.swift in Sources */,
 				ED83C7AC1E6BEF15389C0132 /* PrivateChatE2ETests.swift in Sources */,
@@ -973,6 +995,8 @@
 				047502922E547ACC0083520F /* LocationChannelsTests.swift in Sources */,
 				048A4C2C2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */,
 				3849CA6D99B2D536636DF4A6 /* MockBLEService.swift in Sources */,
+				A1B2C3D4E5F60123456789BA /* MockKeychain.swift in Sources */,
+				A1B2C3D4E5F60123456789BC /* MockIdentityManager.swift in Sources */,
 				BC4DC75F4FB823FF40569676 /* NoiseProtocolTests.swift in Sources */,
 				EE8C3ECADAB3083A2687D50B /* NostrProtocolTests.swift in Sources */,
 				0AE840940F21AFC07C226636 /* PrivateChatE2ETests.swift in Sources */,
@@ -1088,7 +1112,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 1.3.4;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.ShareExtension;
 				SDKROOT = iphoneos;
 				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -1119,7 +1143,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.3.4;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat;
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
@@ -1174,7 +1198,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.3.4;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat;
 				PRODUCT_NAME = bitchat;
 				SDKROOT = iphoneos;
@@ -1206,7 +1230,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 13.0;
-				MARKETING_VERSION = 1.3.4;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat;
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
@@ -1295,7 +1319,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 13.0;
-				MARKETING_VERSION = 1.3.4;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat;
 				PRODUCT_NAME = bitchat;
 				REGISTER_APP_GROUPS = YES;
@@ -1388,7 +1412,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 1.3.4;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.bitchat.ShareExtension;
 				SDKROOT = iphoneos;
 				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

bitchat/BitchatApp.swift

@@ -11,7 +11,7 @@ import UserNotifications
 
 @main
 struct BitchatApp: App {
-    @StateObject private var chatViewModel = ChatViewModel()
+    @StateObject private var chatViewModel: ChatViewModel
     #if os(iOS)
     @Environment(\.scenePhase) var scenePhase
     @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
@@ -23,6 +23,14 @@ struct BitchatApp: App {
     #endif
     
     init() {
+        let keychain = KeychainManager()
+        _chatViewModel = StateObject(
+            wrappedValue: ChatViewModel(
+                keychain: keychain,
+                identityManager: SecureIdentityStateManager(keychain)
+            )
+        )
+        
         UNUserNotificationCenter.current().delegate = NotificationDelegate.shared
         // Warm up georelay directory and refresh if stale (once/day)
         GeoRelayDirectory.shared.prefetchIfNeeded()

bitchat/Identity/SecureIdentityStateManager.swift

@@ -93,13 +93,51 @@
 import Foundation
 import CryptoKit
 
+protocol SecureIdentityStateManagerProtocol {
+    // MARK: Secure Loading/Saving
+    func forceSave()
+    
+    // MARK: Social Identity Management
+    func getSocialIdentity(for fingerprint: String) -> SocialIdentity?
+    
+    // MARK: Cryptographic Identities
+    func upsertCryptographicIdentity(fingerprint: String, noisePublicKey: Data, signingPublicKey: Data?, claimedNickname: String?)
+    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: String) -> [CryptographicIdentity]
+    func updateSocialIdentity(_ identity: SocialIdentity)
+    
+    // MARK: Favorites Management
+    func getFavorites() -> Set<String>
+    func setFavorite(_ fingerprint: String, isFavorite: Bool)
+    func isFavorite(fingerprint: String) -> Bool
+    
+    // MARK: Blocked Users Management
+    func isBlocked(fingerprint: String) -> Bool
+    func setBlocked(_ fingerprint: String, isBlocked: Bool)
+    
+    // MARK: Geohash (Nostr) Blocking
+    func isNostrBlocked(pubkeyHexLowercased: String) -> Bool
+    func setNostrBlocked(_ pubkeyHexLowercased: String, isBlocked: Bool)
+    func getBlockedNostrPubkeys() -> Set<String>
+    
+    // MARK: Ephemeral Session Management
+    func registerEphemeralSession(peerID: String, handshakeState: HandshakeState)
+    func updateHandshakeState(peerID: String, state: HandshakeState)
+    
+    // MARK: Cleanup
+    func clearAllIdentityData()
+    func removeEphemeralSession(peerID: String)
+    
+    // MARK: Verification
+    func setVerified(fingerprint: String, verified: Bool)
+    func isVerified(fingerprint: String) -> Bool
+    func getVerifiedFingerprints() -> Set<String>
+}
+
 /// Singleton manager for secure identity state persistence and retrieval.
 /// Provides thread-safe access to identity mappings with encryption at rest.
 /// All identity data is stored encrypted in the device Keychain for security.
-final class SecureIdentityStateManager {
-    static let shared = SecureIdentityStateManager()
-    
-    private let keychain = KeychainManager.shared
+final class SecureIdentityStateManager: SecureIdentityStateManagerProtocol {
+    private let keychain: KeychainManagerProtocol
     private let cacheKey = "bitchat.identityCache.v2"
     private let encryptionKeyName = "identityCacheEncryptionKey"
     
@@ -108,9 +146,6 @@ final class SecureIdentityStateManager {
     private var cryptographicIdentities: [String: CryptographicIdentity] = [:]
     private var cache: IdentityCache = IdentityCache()
     
-    // Pending actions before handshake
-    private var pendingActions: [String: PendingActions] = [:]
-    
     // Thread safety
     private let queue = DispatchQueue(label: "bitchat.identity.state", attributes: .concurrent)
     
@@ -122,7 +157,9 @@ final class SecureIdentityStateManager {
     // Encryption key
     private let encryptionKey: SymmetricKey
     
-    private init() {
+    init(_ keychain: KeychainManagerProtocol) {
+        self.keychain = keychain
+        
         // Generate or retrieve encryption key from keychain
         let loadedKey: SymmetricKey
         
@@ -146,9 +183,13 @@ final class SecureIdentityStateManager {
         loadIdentityCache()
     }
     
+    deinit {
+        forceSave()
+    }
+    
     // MARK: - Secure Loading/Saving
     
-    func loadIdentityCache() {
+    private func loadIdentityCache() {
         guard let encryptedData = keychain.getIdentityKey(forKey: cacheKey) else {
             // No existing cache, start fresh
             return
@@ -164,12 +205,7 @@ final class SecureIdentityStateManager {
         }
     }
     
-    deinit {
-        // Force save any pending changes
-        forceSave()
-    }
-    
-    func saveIdentityCache() {
+    private func saveIdentityCache() {
         // Mark that we need to save
         pendingSave = true
         
@@ -201,26 +237,8 @@ final class SecureIdentityStateManager {
     // Force immediate save (for app termination)
     func forceSave() {
         saveTimer?.invalidate()
-        if pendingSave {
         performSave()
     }
-    }
-    
-    // MARK: - Identity Resolution
-    
-    func resolveIdentity(peerID: String, claimedNickname: String) -> IdentityHint {
-        queue.sync {
-            // Check if we have candidates based on nickname
-            if let fingerprints = cache.nicknameIndex[claimedNickname] {
-                if fingerprints.count == 1 {
-                    return .likelyKnown(fingerprint: fingerprints.first!)
-                } else {
-                    return .ambiguous(candidates: fingerprints)
-                }
-            }
-            return .unknown
-        }
-    }
     
     // MARK: - Social Identity Management
     
@@ -301,11 +319,6 @@ final class SecureIdentityStateManager {
         }
     }
 
-    /// Retrieve cryptographic identity by fingerprint
-    func getCryptographicIdentity(for fingerprint: String) -> CryptographicIdentity? {
-        queue.sync { cryptographicIdentities[fingerprint] }
-    }
-
     /// Find cryptographic identities whose fingerprint prefix matches a peerID (16-hex) short ID
     func getCryptoIdentitiesByPeerIDPrefix(_ peerID: String) -> [CryptographicIdentity] {
         queue.sync {
@@ -315,12 +328,6 @@ final class SecureIdentityStateManager {
         }
     }
     
-    func getAllSocialIdentities() -> [SocialIdentity] {
-        queue.sync {
-            return Array(cache.socialIdentities.values)
-        }
-    }
-    
     func updateSocialIdentity(_ identity: SocialIdentity) {
         queue.async(flags: .barrier) {
             self.cache.socialIdentities[identity.fingerprint] = identity
@@ -469,53 +476,6 @@ final class SecureIdentityStateManager {
         }
     }
     
-    func getHandshakeState(peerID: String) -> HandshakeState? {
-        queue.sync {
-            return ephemeralSessions[peerID]?.handshakeState
-        }
-    }
-    
-    // MARK: - Pending Actions
-    
-    func setPendingAction(peerID: String, action: PendingActions) {
-        queue.async(flags: .barrier) {
-            self.pendingActions[peerID] = action
-        }
-    }
-    
-    func applyPendingActions(peerID: String, fingerprint: String) {
-        queue.async(flags: .barrier) {
-            guard let actions = self.pendingActions[peerID] else { return }
-            
-            // Get or create social identity
-            var identity = self.cache.socialIdentities[fingerprint] ?? SocialIdentity(
-                fingerprint: fingerprint,
-                localPetname: nil,
-                claimedNickname: "Unknown",
-                trustLevel: .unknown,
-                isFavorite: false,
-                isBlocked: false,
-                notes: nil
-            )
-            
-            // Apply pending actions
-            if let toggleFavorite = actions.toggleFavorite {
-                identity.isFavorite = toggleFavorite
-            }
-            if let trustLevel = actions.setTrustLevel {
-                identity.trustLevel = trustLevel
-            }
-            if let petname = actions.setPetname {
-                identity.localPetname = petname
-            }
-            
-            // Save updated identity
-            self.cache.socialIdentities[fingerprint] = identity
-            self.pendingActions.removeValue(forKey: peerID)
-            self.saveIdentityCache()
-        }
-    }
-    
     // MARK: - Cleanup
     
     func clearAllIdentityData() {
@@ -525,7 +485,6 @@ final class SecureIdentityStateManager {
             self.cache = IdentityCache()
             self.ephemeralSessions.removeAll()
             self.cryptographicIdentities.removeAll()
-            self.pendingActions.removeAll()
             
             // Delete from keychain
             let deleted = self.keychain.deleteIdentityKey(forKey: self.cacheKey)
@@ -536,7 +495,6 @@ final class SecureIdentityStateManager {
     func removeEphemeralSession(peerID: String) {
         queue.async(flags: .barrier) {
             self.ephemeralSessions.removeValue(forKey: peerID)
-            self.pendingActions.removeValue(forKey: peerID)
         }
     }
     

bitchat/Noise/NoiseProtocol.swift

@@ -490,6 +490,7 @@ final class NoiseSymmetricState {
 final class NoiseHandshakeState {
     private let role: NoiseRole
     private let pattern: NoisePattern
+    private let keychain: KeychainManagerProtocol
     private var symmetricState: NoiseSymmetricState
     
     // Keys
@@ -505,9 +506,16 @@ final class NoiseHandshakeState {
     private var messagePatterns: [[NoiseMessagePattern]] = []
     private var currentPattern = 0
     
-    init(role: NoiseRole, pattern: NoisePattern, localStaticKey: Curve25519.KeyAgreement.PrivateKey? = nil, remoteStaticKey: Curve25519.KeyAgreement.PublicKey? = nil) {
+    init(
+        role: NoiseRole,
+        pattern: NoisePattern,
+        keychain: KeychainManagerProtocol,
+        localStaticKey: Curve25519.KeyAgreement.PrivateKey? = nil,
+        remoteStaticKey: Curve25519.KeyAgreement.PublicKey? = nil
+    ) {
         self.role = role
         self.pattern = pattern
+        self.keychain = keychain
         
         // Initialize static keys
         if let localKey = localStaticKey {
@@ -578,7 +586,7 @@ final class NoiseHandshakeState {
                 var sharedData = shared.withUnsafeBytes { Data($0) }
                 symmetricState.mixKey(sharedData)
                 // Clear sensitive shared secret
-                KeychainManager.secureClear(&sharedData)
+                keychain.secureClear(&sharedData)
                 
             case .es:
                 // DH(ephemeral, static) - direction depends on role
@@ -626,7 +634,7 @@ final class NoiseHandshakeState {
                 var sharedData = shared.withUnsafeBytes { Data($0) }
                 symmetricState.mixKey(sharedData)
                 // Clear sensitive shared secret
-                KeychainManager.secureClear(&sharedData)
+                keychain.secureClear(&sharedData)
             }
         }
         
@@ -714,7 +722,7 @@ final class NoiseHandshakeState {
                 var sharedData = shared.withUnsafeBytes { Data($0) }
                 symmetricState.mixKey(sharedData)
                 // Clear sensitive shared secret
-                KeychainManager.secureClear(&sharedData)
+                keychain.secureClear(&sharedData)
             } else {
                 guard let localStatic = localStaticPrivate,
                       let remoteEphemeral = remoteEphemeralPublic else {
@@ -724,7 +732,7 @@ final class NoiseHandshakeState {
                 var sharedData = shared.withUnsafeBytes { Data($0) }
                 symmetricState.mixKey(sharedData)
                 // Clear sensitive shared secret
-                KeychainManager.secureClear(&sharedData)
+                keychain.secureClear(&sharedData)
             }
             
         case .se:
@@ -737,7 +745,7 @@ final class NoiseHandshakeState {
                 var sharedData = shared.withUnsafeBytes { Data($0) }
                 symmetricState.mixKey(sharedData)
                 // Clear sensitive shared secret
-                KeychainManager.secureClear(&sharedData)
+                keychain.secureClear(&sharedData)
             } else {
                 guard let localEphemeral = localEphemeralPrivate,
                       let remoteStatic = remoteStaticPublic else {
@@ -747,7 +755,7 @@ final class NoiseHandshakeState {
                 var sharedData = shared.withUnsafeBytes { Data($0) }
                 symmetricState.mixKey(sharedData)
                 // Clear sensitive shared secret
-                KeychainManager.secureClear(&sharedData)
+                keychain.secureClear(&sharedData)
             }
             
         case .ss:

bitchat/Noise/NoiseSession.swift

@@ -36,6 +36,7 @@ enum NoiseSessionState: Equatable {
 class NoiseSession {
     let peerID: String
     let role: NoiseRole
+    private let keychain: KeychainManagerProtocol
     private var state: NoiseSessionState = .uninitialized
     private var handshakeState: NoiseHandshakeState?
     private var sendCipher: NoiseCipherState?
@@ -52,9 +53,16 @@ class NoiseSession {
     // Thread safety
     private let sessionQueue = DispatchQueue(label: "chat.bitchat.noise.session", attributes: .concurrent)
     
-    init(peerID: String, role: NoiseRole, localStaticKey: Curve25519.KeyAgreement.PrivateKey, remoteStaticKey: Curve25519.KeyAgreement.PublicKey? = nil) {
+    init(
+        peerID: String,
+        role: NoiseRole,
+        keychain: KeychainManagerProtocol,
+        localStaticKey: Curve25519.KeyAgreement.PrivateKey,
+        remoteStaticKey: Curve25519.KeyAgreement.PublicKey? = nil
+    ) {
         self.peerID = peerID
         self.role = role
+        self.keychain = keychain
         self.localStaticKey = localStaticKey
         self.remoteStaticPublicKey = remoteStaticKey
     }
@@ -71,6 +79,7 @@ class NoiseSession {
             handshakeState = NoiseHandshakeState(
                 role: role,
                 pattern: .XX,
+                keychain: keychain,
                 localStaticKey: localStaticKey,
                 remoteStaticKey: nil
             )
@@ -98,6 +107,7 @@ class NoiseSession {
                 handshakeState = NoiseHandshakeState(
                     role: role,
                     pattern: .XX,
+                    keychain: keychain,
                     localStaticKey: localStaticKey,
                     remoteStaticKey: nil
                 )
@@ -230,13 +240,13 @@ class NoiseSession {
             // Clear sent handshake messages
             for i in 0..<sentHandshakeMessages.count {
                 var message = sentHandshakeMessages[i]
-                KeychainManager.secureClear(&message)
+                keychain.secureClear(&message)
             }
             sentHandshakeMessages.removeAll()
             
             // Clear handshake hash
             if var hash = handshakeHash {
-                KeychainManager.secureClear(&hash)
+                keychain.secureClear(&hash)
             }
             handshakeHash = nil
             
@@ -252,14 +262,16 @@ class NoiseSession {
 final class NoiseSessionManager {
     private var sessions: [String: NoiseSession] = [:]
     private let localStaticKey: Curve25519.KeyAgreement.PrivateKey
+    private let keychain: KeychainManagerProtocol
     private let managerQueue = DispatchQueue(label: "chat.bitchat.noise.manager", attributes: .concurrent)
     
     // Callbacks
     var onSessionEstablished: ((String, Curve25519.KeyAgreement.PublicKey) -> Void)?
     var onSessionFailed: ((String, Error) -> Void)?
     
-    init(localStaticKey: Curve25519.KeyAgreement.PrivateKey) {
+    init(localStaticKey: Curve25519.KeyAgreement.PrivateKey, keychain: KeychainManagerProtocol) {
         self.localStaticKey = localStaticKey
+        self.keychain = keychain
     }
     
     // MARK: - Session Management
@@ -269,6 +281,7 @@ final class NoiseSessionManager {
             let session = SecureNoiseSession(
                 peerID: peerID,
                 role: role,
+                keychain: keychain,
                 localStaticKey: localStaticKey
             )
             sessions[peerID] = session
@@ -320,6 +333,7 @@ final class NoiseSessionManager {
             let session = SecureNoiseSession(
                 peerID: peerID,
                 role: .initiator,
+                keychain: keychain,
                 localStaticKey: localStaticKey
             )
             sessions[peerID] = session
@@ -370,6 +384,7 @@ final class NoiseSessionManager {
                 let newSession = SecureNoiseSession(
                     peerID: peerID,
                     role: .responder,
+                    keychain: keychain,
                     localStaticKey: localStaticKey
                 )
                 sessions[peerID] = newSession

bitchat/Nostr/NostrProtocol.swift

@@ -124,6 +124,28 @@ struct NostrProtocol {
         return try event.sign(with: schnorrKey)
     }
 
+    /// Create a persistent location note (kind 1: text note) tagged to a street-level geohash.
+    static func createGeohashTextNote(
+        content: String,
+        geohash: String,
+        senderIdentity: NostrIdentity,
+        nickname: String? = nil
+    ) throws -> NostrEvent {
+        var tags = [["g", geohash]]
+        if let nickname = nickname?.trimmingCharacters(in: .whitespacesAndNewlines), !nickname.isEmpty {
+            tags.append(["n", nickname])
+        }
+        let event = NostrEvent(
+            pubkey: senderIdentity.publicKeyHex,
+            createdAt: Date(),
+            kind: .textNote,
+            tags: tags,
+            content: content
+        )
+        let schnorrKey = try senderIdentity.schnorrSigningKey()
+        return try event.sign(with: schnorrKey)
+    }
+    
     // MARK: - Private Methods
     
     private static func createSeal(

bitchat/Nostr/NostrRelayManager.swift

@@ -46,6 +46,14 @@ final class NostrRelayManager: ObservableObject {
     private var subscribeCoalesce: [String: Date] = [:]
     private var cancellables = Set<AnyCancellable>()
 
+    // Track EOSE per subscription to signal when initial stored events are done
+    private struct EOSETracker {
+        var pendingRelays: Set<String>
+        var callback: () -> Void
+        var timer: Timer?
+    }
+    private var eoseTrackers: [String: EOSETracker] = [:]
+    
     // Message queue for reliability
     // Pending sends held only for relays that are not yet connected.
     private struct PendingSend {
@@ -201,7 +209,8 @@ final class NostrRelayManager: ObservableObject {
         filter: NostrFilter,
         id: String = UUID().uuidString,
         relayUrls: [String]? = nil,
-        handler: @escaping (NostrEvent) -> Void
+        handler: @escaping (NostrEvent) -> Void,
+        onEOSE: (() -> Void)? = nil
     ) {
         // Coalesce rapid duplicate subscribe requests only if a handler already exists
         let now = Date()
@@ -250,6 +259,22 @@ final class NostrRelayManager: ObservableObject {
                 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)
+                // Fallback timeout to avoid hanging if a relay never sends EOSE
+                tracker.timer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
+                    Task { @MainActor in
+                        guard let self = self else { return }
+                        if let t = self.eoseTrackers[id] {
+                            t.timer?.invalidate()
+                            self.eoseTrackers.removeValue(forKey: id)
+                            onEOSE()
+                        }
+                    }
+                }
+                eoseTrackers[id] = tracker
+            }
             SecureLogger.debug("📋 Queued subscription id=\(id) for \(urls.count) relay(s)", category: .session)
             // Ensure we actually have sockets opening to these relays so queued REQs can flush
             ensureConnections(to: urls)
@@ -418,9 +443,17 @@ final class NostrRelayManager: ObservableObject {
             } else {
                 SecureLogger.warning("⚠️ No handler for subscription \(subId)", category: .session)
             }
-        case .eose:
-            // No-op for now
-            break
+        case .eose(let subId):
+            if var tracker = eoseTrackers[subId] {
+                tracker.pendingRelays.remove(relayUrl)
+                if tracker.pendingRelays.isEmpty {
+                    tracker.timer?.invalidate()
+                    eoseTrackers.removeValue(forKey: subId)
+                    tracker.callback()
+                } else {
+                    eoseTrackers[subId] = tracker
+                }
+            }
         case .ok(let eventId, let success, let reason):
             if success {
                 _ = Self.pendingGiftWrapIDs.remove(eventId)
@@ -755,6 +788,16 @@ struct NostrFilter: Encodable {
         filter.limit = limit
         return filter
     }
+
+    // For location notes: persistent text notes (kind 1) tagged with geohash
+    static func geohashNotes(_ geohash: String, since: Date? = nil, limit: Int = 200) -> NostrFilter {
+        var filter = NostrFilter()
+        filter.kinds = [1]
+        filter.since = since?.timeIntervalSince1970.toInt()
+        filter.tagFilters = ["g": [geohash]]
+        filter.limit = limit
+        return filter
+    }
 }
 
 // Dynamic coding key for tag filters

bitchat/Protocols/LocationChannel.swift

@@ -2,6 +2,7 @@ import Foundation
 
 /// Levels of location channels mapped to geohash precisions.
 enum GeohashChannelLevel: CaseIterable, Codable, Equatable {
+    case building
     case block
     case neighborhood
     case city
@@ -11,6 +12,7 @@ enum GeohashChannelLevel: CaseIterable, Codable, Equatable {
     /// Geohash length used for this level.
     var precision: Int {
         switch self {
+        case .building: return 8
         case .block: return 7
         case .neighborhood: return 6
         case .city: return 5
@@ -21,6 +23,7 @@ enum GeohashChannelLevel: CaseIterable, Codable, Equatable {
 
     var displayName: String {
         switch self {
+        case .building: return "Building"
         case .block: return "Block"
         case .neighborhood: return "Neighborhood"
         case .city: return "City"
@@ -35,6 +38,7 @@ extension GeohashChannelLevel {
         let container = try decoder.singleValueContainer()
         if let raw = try? container.decode(String.self) {
             switch raw {
+            case "building": self = .building
             case "block": self = .block
             case "neighborhood": self = .neighborhood
             case "city": self = .city
@@ -46,6 +50,7 @@ extension GeohashChannelLevel {
             }
         } else if let precision = try? container.decode(Int.self) {
             switch precision {
+            case 8: self = .building
             case 7: self = .block
             case 6: self = .neighborhood
             case 5: self = .city
@@ -61,6 +66,7 @@ extension GeohashChannelLevel {
     func encode(to encoder: Encoder) throws {
         var container = encoder.singleValueContainer()
         switch self {
+        case .building: try container.encode("building")
         case .block: try container.encode("block")
         case .neighborhood: try container.encode("neighborhood")
         case .city: try container.encode("city")

bitchat/Services/BLEService.swift

@@ -88,7 +88,8 @@ final class BLEService: NSObject {
     
     var myPeerID: String = ""
     var myNickname: String = "anon"
-    private let noiseService = NoiseEncryptionService()
+    private let noiseService: NoiseEncryptionService
+    private let identityManager: SecureIdentityStateManagerProtocol
     private var myPeerIDData: Data = Data()
 
     // MARK: - Advertising Privacy
@@ -325,7 +326,9 @@ final class BLEService: NSObject {
         }
     }
     
-    override init() {
+    init(keychain: KeychainManagerProtocol, identityManager: SecureIdentityStateManagerProtocol) {
+        noiseService = NoiseEncryptionService(keychain: keychain)
+        self.identityManager = identityManager
         super.init()
         
         // Derive stable peer ID from Noise static public key fingerprint (first 8 bytes → 16 hex chars)
@@ -1548,7 +1551,7 @@ final class BLEService: NSObject {
             // Derive fingerprint from Noise public key
             let hash = SHA256.hash(data: announcement.noisePublicKey)
             let fingerprint = hash.map { String(format: "%02x", $0) }.joined()
-            SecureIdentityStateManager.shared.upsertCryptographicIdentity(
+            identityManager.upsertCryptographicIdentity(
                 fingerprint: fingerprint,
                 noisePublicKey: announcement.noisePublicKey,
                 signingPublicKey: announcement.signingPublicKey,
@@ -1630,13 +1633,13 @@ 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 = SecureIdentityStateManager.shared.getCryptoIdentitiesByPeerIDPrefix(peerID)
+                let candidates = identityManager.getCryptoIdentitiesByPeerIDPrefix(peerID)
                 for candidate in candidates {
                     if let signingKey = candidate.signingPublicKey,
                        noiseService.verifySignature(signature, for: packetData, publicKey: signingKey) {
                         accepted = true
                         // Prefer persisted social petname or claimed nickname
-                        if let social = SecureIdentityStateManager.shared.getSocialIdentity(for: candidate.fingerprint) {
+                        if let social = identityManager.getSocialIdentity(for: candidate.fingerprint) {
                             senderNickname = social.localPetname ?? social.claimedNickname
                         } else {
                             senderNickname = "anon" + String(peerID.prefix(4))

bitchat/Services/CommandProcessor.swift

@@ -20,10 +20,12 @@ enum CommandResult {
 final class CommandProcessor {
     weak var chatViewModel: ChatViewModel?
     weak var meshService: Transport?
+    private let identityManager: SecureIdentityStateManagerProtocol
     
-    init(chatViewModel: ChatViewModel? = nil, meshService: Transport? = nil) {
+    init(chatViewModel: ChatViewModel? = nil, meshService: Transport? = nil, identityManager: SecureIdentityStateManagerProtocol) {
         self.chatViewModel = chatViewModel
         self.meshService = meshService
+        self.identityManager = identityManager
     }
     
     /// Process a command string
@@ -189,7 +191,7 @@ final class CommandProcessor {
             }
 
             // Geohash blocked names (prefer visible display names; fallback to #suffix)
-            let geoBlocked = Array(SecureIdentityStateManager.shared.getBlockedNostrPubkeys())
+            let geoBlocked = Array(identityManager.getBlockedNostrPubkeys())
             var geoNames: [String] = []
             if let vm = chatViewModel {
                 let visible = vm.visibleGeohashPeople()
@@ -213,14 +215,14 @@ final class CommandProcessor {
         
         if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
            let fingerprint = meshService?.getFingerprint(for: peerID) {
-            if SecureIdentityStateManager.shared.isBlocked(fingerprint: fingerprint) {
+            if identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is already blocked")
             }
             // Block the user (mesh/noise identity)
-            if var identity = SecureIdentityStateManager.shared.getSocialIdentity(for: fingerprint) {
+            if var identity = identityManager.getSocialIdentity(for: fingerprint) {
                 identity.isBlocked = true
                 identity.isFavorite = false
-                SecureIdentityStateManager.shared.updateSocialIdentity(identity)
+                identityManager.updateSocialIdentity(identity)
             } else {
                 let blockedIdentity = SocialIdentity(
                     fingerprint: fingerprint,
@@ -231,16 +233,16 @@ final class CommandProcessor {
                     isBlocked: true,
                     notes: nil
                 )
-                SecureIdentityStateManager.shared.updateSocialIdentity(blockedIdentity)
+                identityManager.updateSocialIdentity(blockedIdentity)
             }
             return .success(message: "blocked \(nickname). you will no longer receive messages from them")
         }
         // Mesh lookup failed; try geohash (Nostr) participant by display name
         if let pub = chatViewModel?.nostrPubkeyForDisplayName(nickname) {
-            if SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: pub) {
+            if identityManager.isNostrBlocked(pubkeyHexLowercased: pub) {
                 return .success(message: "\(nickname) is already blocked")
             }
-            SecureIdentityStateManager.shared.setNostrBlocked(pub, isBlocked: true)
+            identityManager.setNostrBlocked(pub, isBlocked: true)
             return .success(message: "blocked \(nickname) in geohash chats")
         }
         
@@ -257,18 +259,18 @@ final class CommandProcessor {
         
         if let peerID = chatViewModel?.getPeerIDForNickname(nickname),
            let fingerprint = meshService?.getFingerprint(for: peerID) {
-            if !SecureIdentityStateManager.shared.isBlocked(fingerprint: fingerprint) {
+            if !identityManager.isBlocked(fingerprint: fingerprint) {
                 return .success(message: "\(nickname) is not blocked")
             }
-            SecureIdentityStateManager.shared.setBlocked(fingerprint, isBlocked: false)
+            identityManager.setBlocked(fingerprint, isBlocked: false)
             return .success(message: "unblocked \(nickname)")
         }
         // Try geohash unblock
         if let pub = chatViewModel?.nostrPubkeyForDisplayName(nickname) {
-            if !SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: pub) {
+            if !identityManager.isNostrBlocked(pubkeyHexLowercased: pub) {
                 return .success(message: "\(nickname) is not blocked")
             }
-            SecureIdentityStateManager.shared.setNostrBlocked(pub, isBlocked: false)
+            identityManager.setNostrBlocked(pub, isBlocked: false)
             return .success(message: "unblocked \(nickname) in geohash chats")
         }
         return .error(message: "cannot unblock \(nickname): not found")

bitchat/Services/FavoritesPersistenceService.swift

@@ -13,12 +13,16 @@ final class FavoritesPersistenceService: ObservableObject {
         let theyFavoritedUs: Bool
         let favoritedAt: Date
         let lastUpdated: Date
+        // Track what we last sent as OUR npub to this peer, to avoid resending unless it changes
+        // Note: we do not track which npub we last sent to them; sending happens only on favorite toggle
         
         var isMutual: Bool {
             isFavorite && theyFavoritedUs
         }
     }
     
+    // We intentionally do not track when we last sent our npub; sending happens only on favorite toggle.
+
     private static let storageKey = "chat.bitchat.favorites"
     private static let keychainService = "chat.bitchat.favorites"
     

bitchat/Services/KeychainManager.swift

@@ -9,16 +9,23 @@
 import Foundation
 import Security
 
-final class KeychainManager {
-    static let shared = KeychainManager()
+protocol KeychainManagerProtocol {
+    func saveIdentityKey(_ keyData: Data, forKey key: String) -> Bool
+    func getIdentityKey(forKey key: String) -> Data?
+    func deleteIdentityKey(forKey key: String) -> Bool
+    func deleteAllKeychainData() -> Bool
     
+    func secureClear(_ data: inout Data)
+    func secureClear(_ string: inout String)
+    
+    func verifyIdentityKeyExists() -> Bool
+}
+
+final class KeychainManager: KeychainManagerProtocol {
     // Use consistent service name for all keychain items
     private let service = "chat.bitchat"
     private let appGroup = "group.chat.bitchat"
     
-    private init() {}
-    
-    
     private func isSandboxed() -> Bool {
         #if os(macOS)
         // More robust sandbox detection using multiple methods
@@ -310,7 +317,7 @@ final class KeychainManager {
     // MARK: - Security Utilities
     
     /// Securely clear sensitive data from memory
-    static func secureClear(_ data: inout Data) {
+    func secureClear(_ data: inout Data) {
         _ = data.withUnsafeMutableBytes { bytes in
             // Use volatile memset to prevent compiler optimization
             memset_s(bytes.baseAddress, bytes.count, 0, bytes.count)
@@ -319,7 +326,7 @@ final class KeychainManager {
     }
     
     /// Securely clear sensitive string from memory
-    static func secureClear(_ string: inout String) {
+    func secureClear(_ string: inout String) {
         // Convert to mutable data and clear
         if var data = string.data(using: .utf8) {
             secureClear(&data)

bitchat/Services/LocationChannelManager.swift

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

bitchat/Services/LocationNotesCounter.swift

@@ -0,0 +1,52 @@
+import Foundation
+
+/// Lightweight background counter for location notes (kind 1) at block-level geohash.
+@MainActor
+final class LocationNotesCounter: ObservableObject {
+    static let shared = LocationNotesCounter()
+
+    @Published private(set) var geohash: String? = nil
+    @Published private(set) var count: Int? = 0
+    @Published private(set) var initialLoadComplete: Bool = false
+
+    private var subscriptionID: String? = nil
+    private var noteIDs = Set<String>()
+
+    private init() {}
+
+    func subscribe(geohash gh: String) {
+        let norm = gh.lowercased()
+        if geohash == norm { return }
+        cancel()
+        geohash = norm
+        count = 0
+        noteIDs.removeAll()
+        initialLoadComplete = false
+
+        // Subscribe only to the building geohash (precision 8)
+        let subID = "locnotes-count-\(norm)-\(UUID().uuidString.prefix(6))"
+        subscriptionID = subID
+        let filter = NostrFilter.geohashNotes(norm, since: nil, limit: 500)
+        let relays = GeoRelayDirectory.shared.closestRelays(toGeohash: norm, count: TransportConfig.nostrGeoRelayCount)
+        let relayUrls: [String]? = relays.isEmpty ? nil : relays
+        NostrRelayManager.shared.subscribe(filter: filter, id: subID, relayUrls: relayUrls, handler: { [weak self] event in
+            guard let self = self else { return }
+            guard event.kind == NostrProtocol.EventKind.textNote.rawValue else { return }
+            guard event.tags.contains(where: { $0.count >= 2 && $0[0].lowercased() == "g" && $0[1].lowercased() == norm }) else { return }
+            if !self.noteIDs.contains(event.id) {
+                self.noteIDs.insert(event.id)
+                self.count = self.noteIDs.count
+            }
+        }, onEOSE: { [weak self] in
+            self?.initialLoadComplete = true
+        })
+    }
+
+    func cancel() {
+        if let sub = subscriptionID { NostrRelayManager.shared.unsubscribe(id: sub) }
+        subscriptionID = nil
+        geohash = nil
+        count = 0
+        noteIDs.removeAll()
+    }
+}

bitchat/Services/LocationNotesManager.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+/// Persistent location notes (Nostr kind 1) scoped to a street-level geohash (precision 7).
+/// Subscribes to and publishes notes for a given geohash and provides a send API.
+@MainActor
+final class LocationNotesManager: ObservableObject {
+    struct Note: Identifiable, Equatable {
+        let id: String
+        let pubkey: String
+        let content: String
+        let createdAt: Date
+        let nickname: String?
+
+        var displayName: String {
+            let suffix = String(pubkey.suffix(4))
+            if let nick = nickname, !nick.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+                return "\(nick)#\(suffix)"
+            }
+            return "anon#\(suffix)"
+        }
+    }
+
+    @Published private(set) var notes: [Note] = [] // reverse-chron sorted
+    @Published private(set) var geohash: String
+    @Published private(set) var initialLoadComplete: Bool = false
+    private var subscriptionID: String?
+
+    init(geohash: String) {
+        self.geohash = geohash.lowercased()
+        subscribe()
+    }
+
+    func setGeohash(_ newGeohash: String) {
+        let norm = newGeohash.lowercased()
+        guard norm != geohash else { return }
+        if let sub = subscriptionID {
+            NostrRelayManager.shared.unsubscribe(id: sub)
+            subscriptionID = nil
+        }
+        geohash = norm
+        notes.removeAll()
+        subscribe()
+    }
+
+    private func subscribe() {
+        let subID = "locnotes-\(geohash)-\(UUID().uuidString.prefix(8))"
+        subscriptionID = subID
+        // For persistent notes, allow relays to return recent history without an aggressive time cutoff
+        let filter = NostrFilter.geohashNotes(geohash, since: nil, limit: 200)
+        let relays = GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: TransportConfig.nostrGeoRelayCount)
+        let relayUrls: [String]? = relays.isEmpty ? nil : relays
+        initialLoadComplete = false
+        NostrRelayManager.shared.subscribe(filter: filter, id: subID, relayUrls: relayUrls, handler: { [weak self] event in
+            guard let self = self else { return }
+            guard event.kind == NostrProtocol.EventKind.textNote.rawValue else { return }
+            // Ensure matching tag
+            guard event.tags.contains(where: { $0.count >= 2 && $0[0].lowercased() == "g" && $0[1].lowercased() == self.geohash }) else { return }
+            if self.notes.contains(where: { $0.id == event.id }) { return }
+            let nick = event.tags.first(where: { $0.first?.lowercased() == "n" && $0.count >= 2 })?.dropFirst().first
+            let ts = Date(timeIntervalSince1970: TimeInterval(event.created_at))
+            let note = Note(id: event.id, pubkey: event.pubkey, content: event.content, createdAt: ts, nickname: nick)
+            self.notes.append(note)
+            self.notes.sort { $0.createdAt > $1.createdAt }
+        }, onEOSE: { [weak self] in
+            self?.initialLoadComplete = true
+        })
+    }
+
+    /// Send a location note for the current geohash using the per-geohash identity.
+    func send(content: String, nickname: String) {
+        let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return }
+        do {
+            let id = try NostrIdentityBridge.deriveIdentity(forGeohash: geohash)
+            let event = try NostrProtocol.createGeohashTextNote(
+                content: trimmed,
+                geohash: geohash,
+                senderIdentity: id,
+                nickname: nickname
+            )
+            let relays = GeoRelayDirectory.shared.closestRelays(toGeohash: geohash, count: TransportConfig.nostrGeoRelayCount)
+            NostrRelayManager.shared.sendEvent(event, to: relays)
+            // Optimistic local-echo
+            let echo = Note(id: event.id, pubkey: id.publicKeyHex, content: trimmed, createdAt: Date(), nickname: nickname)
+            self.notes.insert(echo, at: 0)
+        } catch {
+            SecureLogger.error("LocationNotesManager: failed to send note: \(error)", category: .session)
+        }
+    }
+
+    /// Explicitly cancel subscription and release resources.
+    func cancel() {
+        if let sub = subscriptionID {
+            NostrRelayManager.shared.unsubscribe(id: sub)
+            subscriptionID = nil
+        }
+    }
+}

bitchat/Services/MessageRouter.swift

@@ -74,6 +74,7 @@ final class MessageRouter {
     }
 
     func sendFavoriteNotification(to peerID: String, isFavorite: Bool) {
+        // Route via mesh when connected; else use Nostr
         if mesh.isPeerConnected(peerID) {
             mesh.sendFavoriteNotification(to: peerID, isFavorite: isFavorite)
         } else {

bitchat/Services/NoiseEncryptionService.swift

@@ -155,6 +155,7 @@ final class NoiseEncryptionService {
     
     // Security components
     private let rateLimiter = NoiseRateLimiter()
+    private let keychain: KeychainManagerProtocol
     
     // Session maintenance
     private var rekeyTimer: Timer?
@@ -181,12 +182,14 @@ final class NoiseEncryptionService {
         }
     }
     
-    init() {
+    init(keychain: KeychainManagerProtocol) {
+        self.keychain = keychain
+        
         // Load or create static identity key (ONLY from keychain)
         let loadedKey: Curve25519.KeyAgreement.PrivateKey
         
         // Try to load from keychain
-        if let identityData = KeychainManager.shared.getIdentityKey(forKey: "noiseStaticKey"),
+        if let identityData = keychain.getIdentityKey(forKey: "noiseStaticKey"),
            let key = try? Curve25519.KeyAgreement.PrivateKey(rawRepresentation: identityData) {
             loadedKey = key
             SecureLogger.logKeyOperation(.load, keyType: "noiseStaticKey", success: true)
@@ -197,7 +200,7 @@ final class NoiseEncryptionService {
             let keyData = loadedKey.rawRepresentation
             
             // Save to keychain
-            let saved = KeychainManager.shared.saveIdentityKey(keyData, forKey: "noiseStaticKey")
+            let saved = keychain.saveIdentityKey(keyData, forKey: "noiseStaticKey")
             SecureLogger.logKeyOperation(.create, keyType: "noiseStaticKey", success: saved)
         }
         
@@ -209,7 +212,7 @@ final class NoiseEncryptionService {
         let loadedSigningKey: Curve25519.Signing.PrivateKey
         
         // Try to load from keychain
-        if let signingData = KeychainManager.shared.getIdentityKey(forKey: "ed25519SigningKey"),
+        if let signingData = keychain.getIdentityKey(forKey: "ed25519SigningKey"),
            let key = try? Curve25519.Signing.PrivateKey(rawRepresentation: signingData) {
             loadedSigningKey = key
             SecureLogger.logKeyOperation(.load, keyType: "ed25519SigningKey", success: true)
@@ -220,7 +223,7 @@ final class NoiseEncryptionService {
             let keyData = loadedSigningKey.rawRepresentation
             
             // Save to keychain
-            let saved = KeychainManager.shared.saveIdentityKey(keyData, forKey: "ed25519SigningKey")
+            let saved = keychain.saveIdentityKey(keyData, forKey: "ed25519SigningKey")
             SecureLogger.logKeyOperation(.create, keyType: "ed25519SigningKey", success: saved)
         }
         
@@ -229,7 +232,7 @@ final class NoiseEncryptionService {
         self.signingPublicKey = signingKey.publicKey
         
         // Initialize session manager
-        self.sessionManager = NoiseSessionManager(localStaticKey: staticIdentityKey)
+        self.sessionManager = NoiseSessionManager(localStaticKey: staticIdentityKey, keychain: keychain)
         
         // Set up session callbacks
         sessionManager.onSessionEstablished = { [weak self] peerID, remoteStaticKey in
@@ -266,8 +269,8 @@ final class NoiseEncryptionService {
     /// Clear persistent identity (for panic mode)
     func clearPersistentIdentity() {
         // Clear from keychain
-        let deletedStatic = KeychainManager.shared.deleteIdentityKey(forKey: "noiseStaticKey")
-        let deletedSigning = KeychainManager.shared.deleteIdentityKey(forKey: "ed25519SigningKey")
+        let deletedStatic = keychain.deleteIdentityKey(forKey: "noiseStaticKey")
+        let deletedSigning = keychain.deleteIdentityKey(forKey: "ed25519SigningKey")
         SecureLogger.logKeyOperation(.delete, keyType: "identity keys", success: deletedStatic && deletedSigning)
         SecureLogger.warning("Panic mode activated - identity cleared", category: .security)
         // Stop rekey timer

bitchat/Services/NostrTransport.swift

@@ -21,11 +21,16 @@ final class NostrTransport: Transport {
     private var readQueue: [QueuedRead] = []
     private var isSendingReadAcks = false
     private let readAckInterval: TimeInterval = TransportConfig.nostrReadAckInterval
+    private let keychain: KeychainManagerProtocol
 
     var myPeerID: String { senderPeerID }
     var myNickname: String { "" }
     func setNickname(_ nickname: String) { /* not used for Nostr */ }
     
+    init(keychain: KeychainManagerProtocol) {
+        self.keychain = keychain
+    }
+
     func startServices() { /* no-op */ }
     func stopServices() { /* no-op */ }
     func emergencyDisconnectAll() { /* no-op */ }
@@ -38,11 +43,17 @@ final class NostrTransport: Transport {
     func getFingerprint(for peerID: String) -> String? { nil }
     func getNoiseSessionState(for peerID: String) -> LazyHandshakeState { .none }
     func triggerHandshake(with peerID: String) { /* no-op */ }
+    
     // Nostr does not use Noise sessions here; return a cached placeholder to avoid reallocation
-    private static var cachedNoiseService: NoiseEncryptionService = {
-        NoiseEncryptionService()
-    }()
-    func getNoiseService() -> NoiseEncryptionService { Self.cachedNoiseService }
+    private static var cachedNoiseService: NoiseEncryptionService?
+    func getNoiseService() -> NoiseEncryptionService {
+        if let noiseService = Self.cachedNoiseService {
+            return noiseService
+        }
+        let noiseService = NoiseEncryptionService(keychain: keychain)
+        Self.cachedNoiseService = noiseService
+        return noiseService
+    }
 
     // Public broadcast not supported over Nostr here
     func sendMessage(_ content: String, mentions: [String]) { /* no-op */ }

bitchat/Services/TransportConfig.swift

@@ -103,7 +103,7 @@ enum TransportConfig {
     // Location
     static let locationDistanceFilterMeters: Double = 1000
     // Live (channel sheet open) distance threshold for meaningful updates
-    static let locationDistanceFilterLiveMeters: Double = 21.0
+    static let locationDistanceFilterLiveMeters: Double = 10.0
     static let locationLiveRefreshInterval: TimeInterval = 5.0
 
     // Notifications (geohash)

bitchat/Services/UnifiedPeerService.swift

@@ -27,14 +27,16 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
     private var peerIndex: [String: BitchatPeer] = [:]
     private var fingerprintCache: [String: String] = [:]  // peerID -> fingerprint
     private let meshService: Transport
+    private let identityManager: SecureIdentityStateManagerProtocol
     weak var messageRouter: MessageRouter?
     private let favoritesService = FavoritesPersistenceService.shared
     private var cancellables = Set<AnyCancellable>()
     
     // MARK: - Initialization
     
-    init(meshService: Transport) {
+    init(meshService: Transport, identityManager: SecureIdentityStateManagerProtocol) {
         self.meshService = meshService
+        self.identityManager = identityManager
         
         // Subscribe to changes from both services
         setupSubscriptions()
@@ -174,7 +176,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         // Determine reachability based on lastSeen and identity trust
         let now = Date()
         let fingerprint = peerInfo.noisePublicKey?.sha256Fingerprint()
-        let isVerified = fingerprint.map { SecureIdentityStateManager.shared.isVerified(fingerprint: $0) } ?? false
+        let isVerified = fingerprint.map { identityManager.isVerified(fingerprint: $0) } ?? false
         let isFav = peerInfo.noisePublicKey.flatMap { favorites[$0]?.isFavorite } ?? false
         let retention: TimeInterval = (isVerified || isFav) ? TransportConfig.bleReachabilityRetentionVerifiedSeconds : TransportConfig.bleReachabilityRetentionUnverifiedSeconds
         // A peer is reachable if we recently saw them AND we are attached to the mesh
@@ -195,27 +197,6 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
            let favoriteStatus = favorites[noiseKey] {
             peer.favoriteStatus = favoriteStatus
             peer.nostrPublicKey = favoriteStatus.peerNostrPublicKey
-        } else {
-            // Check by nickname for reconnected peers
-            let favoriteByNickname = favorites.values.first { 
-                $0.peerNickname == peerInfo.nickname 
-            }
-            
-            if let favorite = favoriteByNickname,
-               let noiseKey = peerInfo.noisePublicKey {
-                SecureLogger.debug("🔄 Found favorite for '\(peerInfo.nickname)' by nickname, updating noise key", category: .session)
-                
-                // Update the favorite's key in persistence
-                favoritesService.updateNoisePublicKey(
-                    from: favorite.peerNoisePublicKey,
-                    to: noiseKey,
-                    peerNickname: peerInfo.nickname
-                )
-                
-                // Get updated favorite
-                peer.favoriteStatus = favoritesService.getFavoriteStatus(for: noiseKey)
-                peer.nostrPublicKey = peer.favoriteStatus?.peerNostrPublicKey ?? favorite.peerNostrPublicKey
-            }
         }
         
         return peer
@@ -268,7 +249,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         guard let fingerprint = getFingerprint(for: peerID) else { return false }
         
         // Check SecureIdentityStateManager for block status
-        if let identity = SecureIdentityStateManager.shared.getSocialIdentity(for: fingerprint) {
+        if let identity = identityManager.getSocialIdentity(for: fingerprint) {
             return identity.isBlocked
         }
         
@@ -345,7 +326,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
         guard let fingerprint = getFingerprint(for: peerID) else { return }
         
         // Get or create social identity
-        var identity = SecureIdentityStateManager.shared.getSocialIdentity(for: fingerprint)
+        var identity = identityManager.getSocialIdentity(for: fingerprint)
             ?? SocialIdentity(
                 fingerprint: fingerprint,
                 localPetname: nil,
@@ -368,7 +349,7 @@ final class UnifiedPeerService: ObservableObject, TransportPeerEventsDelegate {
             }
         }
         
-        SecureIdentityStateManager.shared.updateSocialIdentity(identity)
+        identityManager.updateSocialIdentity(identity)
     }
     
     /// Get fingerprint for peer ID

bitchat/ViewModels/ChatViewModel.swift

@@ -344,13 +344,16 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
     
     // MARK: - Services and Storage
     
-    var meshService: Transport = BLEService()
+    let meshService: Transport
+    let identityManager: SecureIdentityStateManagerProtocol
+    
     private var nostrRelayManager: NostrRelayManager?
     // PeerManager replaced by UnifiedPeerService
     private var processedNostrEvents = Set<String>()  // Simple deduplication
     private var processedNostrEventOrder: [String] = []
     private let maxProcessedNostrEvents = TransportConfig.uiProcessedNostrEventsCap
     private let userDefaults = UserDefaults.standard
+    private let keychain: KeychainManagerProtocol
     private let nicknameKey = "bitchat.nickname"
     // Location channel state (macOS supports manual geohash selection)
     @Published private var activeChannel: ChannelID = .mesh
@@ -420,6 +423,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
     private var geoSamplingSubs: [String: String] = [:] // subID -> geohash
     private var lastGeoNotificationAt: [String: Date] = [:] // geohash -> last notify time
     
+    
     // MARK: - Message Delivery Tracking
     
     // Delivery tracking
@@ -484,7 +488,14 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
     // MARK: - Initialization
     
     @MainActor
-    init() {
+    init(
+        keychain: KeychainManagerProtocol,
+        identityManager: SecureIdentityStateManagerProtocol
+    ) {
+        self.keychain = keychain
+        self.identityManager = identityManager
+        self.meshService = BLEService(keychain: keychain, identityManager: identityManager)
+        
         // Load persisted read receipts
         if let data = UserDefaults.standard.data(forKey: "sentReadReceipts"),
            let receipts = try? JSONDecoder().decode([String].self, from: data) {
@@ -495,10 +506,10 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         }
         
         // Initialize services
-        self.commandProcessor = CommandProcessor()
+        self.commandProcessor = CommandProcessor(identityManager: identityManager)
         self.privateChatManager = PrivateChatManager(meshService: meshService)
-        self.unifiedPeerService = UnifiedPeerService(meshService: meshService)
-        let nostrTransport = NostrTransport()
+        self.unifiedPeerService = UnifiedPeerService(meshService: meshService, identityManager: identityManager)
+        let nostrTransport = NostrTransport(keychain: keychain)
         self.messageRouter = MessageRouter(mesh: meshService, nostr: nostrTransport)
         // Route receipts from PrivateChatManager through MessageRouter
         self.privateChatManager.messageRouter = self.messageRouter
@@ -847,7 +858,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         Task { @MainActor in
             self.torRestartPending = true
             // Post only in geohash channels (queue if not active)
-            self.addGeohashOnlySystemMessage("tor restarting to recover connectivity…")
+            self.addGeohashOnlySystemMessage("tor restarting to recover connectivity...")
         }
     }
 
@@ -976,7 +987,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                     let messageId = pm.messageID
                     // Send delivery ACK immediately (once per message ID)
                     if !self.sentGeoDeliveryAcks.contains(messageId) {
-                        let nt = NostrTransport()
+                        let nt = NostrTransport(keychain: keychain)
                         nt.senderPeerID = self.meshService.myPeerID
                         nt.sendDeliveryAckGeohash(for: messageId, toRecipientHex: senderPubkey, from: id)
                         self.sentGeoDeliveryAcks.insert(messageId)
@@ -1004,7 +1015,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                     deliveryStatus: .delivered(to: self.nickname, at: Date())
                 )
                     // Respect geohash blocks
-                    if SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: senderPubkey) {
+                    if identityManager.isNostrBlocked(pubkeyHexLowercased: senderPubkey) {
                         return
                     }
                     if self.privateChats[convKey] == nil { self.privateChats[convKey] = [] }
@@ -1014,7 +1025,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                     if isViewing {
                         // pared back: omit pre-send READ log
                         if !wasReadBefore {
-                            let nt = NostrTransport()
+                            let nt = NostrTransport(keychain: keychain)
                             nt.senderPeerID = self.meshService.myPeerID
                             nt.sendReadReceiptGeohash(messageId, toRecipientHex: senderPubkey, from: id)
                             self.sentReadReceipts.insert(messageId)
@@ -1237,7 +1248,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         }
         
         // Update identity state manager with handshake completion
-        SecureIdentityStateManager.shared.updateHandshakeState(peerID: peerID, state: .completed(fingerprint: fingerprintStr))
+        identityManager.updateHandshakeState(peerID: peerID, state: .completed(fingerprint: fingerprintStr))
         
         // Update encryption status now that we have the fingerprint
         updateEncryptionStatus(for: peerID)
@@ -1246,9 +1257,9 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         let peerNicknames = meshService.getPeerNicknames()
         if let nickname = peerNicknames[peerID], nickname != "Unknown" && nickname != "anon\(peerID.prefix(4))" {
             // Update or create social identity with the claimed nickname
-            if var identity = SecureIdentityStateManager.shared.getSocialIdentity(for: fingerprintStr) {
+            if var identity = identityManager.getSocialIdentity(for: fingerprintStr) {
                 identity.claimedNickname = nickname
-                SecureIdentityStateManager.shared.updateSocialIdentity(identity)
+                identityManager.updateSocialIdentity(identity)
             } else {
                 let newIdentity = SocialIdentity(
                     fingerprint: fingerprintStr,
@@ -1259,7 +1270,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                     isBlocked: false,
                     notes: nil
                 )
-                SecureIdentityStateManager.shared.updateSocialIdentity(newIdentity)
+                identityManager.updateSocialIdentity(newIdentity)
             }
         }
         
@@ -1620,7 +1631,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                 self.geoNicknames[event.pubkey.lowercased()] = nick
             }
             // If this pubkey is blocked, skip mapping, participants, and timeline
-            if SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: event.pubkey) {
+            if identityManager.isNostrBlocked(pubkeyHexLowercased: event.pubkey) {
                 return
             }
             // Store mapping for geohash DM initiation
@@ -1698,7 +1709,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                     SecureLogger.info("GeoDM: recv PM <- sender=\(senderPubkey.prefix(8))… mid=\(messageId.prefix(8))…", category: .session)
                     // Send delivery ACK immediately (even if duplicate), once per messageID
                     if !self.sentGeoDeliveryAcks.contains(messageId) {
-                        let nostrTransport = NostrTransport()
+                        let nostrTransport = NostrTransport(keychain: keychain)
                         nostrTransport.senderPeerID = self.meshService.myPeerID
                     // pared back: omit pre-send log
                         nostrTransport.sendDeliveryAckGeohash(for: messageId, toRecipientHex: senderPubkey, from: id)
@@ -1733,7 +1744,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                     if isViewing {
                         // pared back: omit pre-send READ log
                         if !wasReadBefore {
-                            let nostrTransport = NostrTransport()
+                            let nostrTransport = NostrTransport(keychain: keychain)
                             nostrTransport.senderPeerID = self.meshService.myPeerID
                             nostrTransport.sendReadReceiptGeohash(messageId, toRecipientHex: senderPubkey, from: id)
                             self.sentReadReceipts.insert(messageId)
@@ -1818,7 +1829,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         // Prune expired entries
         map = map.filter { $0.value >= cutoff }
         // Remove blocked Nostr pubkeys
-        map = map.filter { !SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: $0.key) }
+        map = map.filter { !identityManager.isNostrBlocked(pubkeyHexLowercased: $0.key) }
         geoParticipants[gh] = map
         // Build display list
         let people = map
@@ -1851,7 +1862,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         let cutoff = Date().addingTimeInterval(-TransportConfig.uiRecentCutoffFiveMinutesSeconds)
         let map = (geoParticipants[gh] ?? [:])
             .filter { $0.value >= cutoff }
-            .filter { !SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: $0.key) }
+            .filter { !identityManager.isNostrBlocked(pubkeyHexLowercased: $0.key) }
         let people = map
             .map { (pub, seen) in GeoPerson(id: pub, displayName: displayNameForNostrPubkey(pub), lastSeen: seen) }
             .sorted { $0.lastSeen > $1.lastSeen }
@@ -1868,12 +1879,12 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
     // Geohash block helpers
     @MainActor
     func isGeohashUserBlocked(pubkeyHexLowercased: String) -> Bool {
-        return SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: pubkeyHexLowercased)
+        return identityManager.isNostrBlocked(pubkeyHexLowercased: pubkeyHexLowercased)
     }
     @MainActor
     func blockGeohashUser(pubkeyHexLowercased: String, displayName: String) {
         let hex = pubkeyHexLowercased.lowercased()
-        SecureIdentityStateManager.shared.setNostrBlocked(hex, isBlocked: true)
+        identityManager.setNostrBlocked(hex, isBlocked: true)
         
         // Remove from participants for all geohashes
         for (gh, var map) in geoParticipants {
@@ -1921,7 +1932,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
     }
     @MainActor
     func unblockGeohashUser(pubkeyHexLowercased: String, displayName: String) {
-        SecureIdentityStateManager.shared.setNostrBlocked(pubkeyHexLowercased, isBlocked: false)
+        identityManager.setNostrBlocked(pubkeyHexLowercased, isBlocked: false)
         addSystemMessage("unblocked \(displayName) in geohash chats")
     }
 
@@ -1970,7 +1981,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                 let content = event.content.trimmingCharacters(in: .whitespacesAndNewlines)
                 guard !content.isEmpty else { return }
                 // Respect geohash blocks
-                if SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: event.pubkey.lowercased()) { return }
+                if identityManager.isNostrBlocked(pubkeyHexLowercased: event.pubkey.lowercased()) { return }
                 // Skip self identity for this geohash
                 if let my = try? NostrIdentityBridge.deriveIdentity(forGeohash: gh), my.publicKeyHex.lowercased() == event.pubkey.lowercased() { return }
                 // Only trigger when there were zero participants in this geohash recently
@@ -2122,7 +2133,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                 return
             }
             // Respect geohash blocks
-            if SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: recipientHex) {
+            if identityManager.isNostrBlocked(pubkeyHexLowercased: recipientHex) {
                 if let msgIdx = privateChats[peerID]?.firstIndex(where: { $0.id == messageID }) {
                     privateChats[peerID]?[msgIdx].deliveryStatus = .failed(reason: "user is blocked")
                 }
@@ -2140,7 +2151,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                     return
                 }
                 SecureLogger.debug("GeoDM: local send mid=\(messageID.prefix(8))… to=\(recipientHex.prefix(8))… conv=\(peerID)", category: .session)
-                let nostrTransport = NostrTransport()
+                let nostrTransport = NostrTransport(keychain: keychain)
                 nostrTransport.senderPeerID = meshService.myPeerID
                 nostrTransport.sendPrivateMessageGeohash(content: content, toRecipientHex: recipientHex, from: id, messageID: messageID)
                 if let msgIdx = privateChats[peerID]?.firstIndex(where: { $0.id == messageID }) {
@@ -2798,15 +2809,15 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         meshService.stopServices()
         
         // Force save any pending identity changes (verifications, favorites, etc)
-        SecureIdentityStateManager.shared.forceSave()
+        identityManager.forceSave()
         
         // Verify identity key is still there
-        _ = KeychainManager.shared.verifyIdentityKeyExists()
+        _ = keychain.verifyIdentityKeyExists()
         
         // No need to force synchronize here
         
         // Verify identity key after save
-        _ = KeychainManager.shared.verifyIdentityKeyExists()
+        _ = keychain.verifyIdentityKeyExists()
     }
     
     @objc private func appWillTerminate() {
@@ -2857,7 +2868,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             for message in messages where message.senderPeerID == peerID && !message.isRelay {
                 if !sentReadReceipts.contains(message.id) {
                     SecureLogger.debug("GeoDM: sending READ for mid=\(message.id.prefix(8))… to=\(recipientHex.prefix(8))…", category: .session)
-                    let nostrTransport = NostrTransport()
+                    let nostrTransport = NostrTransport(keychain: keychain)
                     nostrTransport.senderPeerID = meshService.myPeerID
                     nostrTransport.sendReadReceiptGeohash(message.id, toRecipientHex: recipientHex, from: id)
                     sentReadReceipts.insert(message.id)
@@ -3003,7 +3014,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         privateChatManager.unreadMessages.removeAll()
         
         // Delete all keychain data (including Noise and Nostr keys)
-        _ = KeychainManager.shared.deleteAllKeychainData()
+        _ = keychain.deleteAllKeychainData()
         
         // Clear UserDefaults identity data
         userDefaults.removeObject(forKey: "bitchat.noiseIdentityKey")
@@ -3019,14 +3030,14 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         
         // Clear favorites and peer mappings
         // Clear through SecureIdentityStateManager instead of directly
-        SecureIdentityStateManager.shared.clearAllIdentityData()
+        identityManager.clearAllIdentityData()
         peerIDToPublicKeyFingerprint.removeAll()
         
         // Clear persistent favorites from keychain
         FavoritesPersistenceService.shared.clearAllFavorites()
         
         // Clear identity data from secure storage
-        SecureIdentityStateManager.shared.clearAllIdentityData()
+        identityManager.clearAllIdentityData()
         
         // Clear autocomplete state
         autocompleteSuggestions.removeAll()
@@ -4252,7 +4263,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         
         // Try to resolve through fingerprint and social identity
         if let fingerprint = getFingerprint(for: peerID) {
-            if let identity = SecureIdentityStateManager.shared.getSocialIdentity(for: fingerprint) {
+            if let identity = identityManager.getSocialIdentity(for: fingerprint) {
                 // Prefer local petname if set
                 if let petname = identity.localPetname {
                     return petname
@@ -4284,7 +4295,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         guard let fingerprint = getFingerprint(for: peerID) else { return }
         
         // Update secure storage with verified status
-        SecureIdentityStateManager.shared.setVerified(fingerprint: fingerprint, verified: true)
+        identityManager.setVerified(fingerprint: fingerprint, verified: true)
         
         // Update local set for UI
         verifiedFingerprints.insert(fingerprint)
@@ -4296,8 +4307,8 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
     @MainActor
     func unverifyFingerprint(for peerID: String) {
         guard let fingerprint = getFingerprint(for: peerID) else { return }
-        SecureIdentityStateManager.shared.setVerified(fingerprint: fingerprint, verified: false)
-        SecureIdentityStateManager.shared.forceSave()
+        identityManager.setVerified(fingerprint: fingerprint, verified: false)
+        identityManager.forceSave()
         verifiedFingerprints.remove(fingerprint)
         updateEncryptionStatus(for: peerID)
     }
@@ -4305,7 +4316,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
     @MainActor
     func loadVerifiedFingerprints() {
         // Load verified fingerprints directly from secure storage
-        verifiedFingerprints = SecureIdentityStateManager.shared.getVerifiedFingerprints()
+        verifiedFingerprints = identityManager.getVerifiedFingerprints()
         // Log snapshot for debugging persistence
         let sample = Array(verifiedFingerprints.prefix(TransportConfig.uiFingerprintSampleCount)).map { $0.prefix(8) }.joined(separator: ", ")
         SecureLogger.info("🔐 Verified loaded: \(verifiedFingerprints.count) [\(sample)]", category: .security)
@@ -4505,8 +4516,8 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                     if let fp = getFingerprint(for: peerID) {
                         let short = fp.prefix(8)
                         SecureLogger.info("🔐 Marking verified fingerprint: \(short)", category: .security)
-                        SecureIdentityStateManager.shared.setVerified(fingerprint: fp, verified: true)
-                        SecureIdentityStateManager.shared.forceSave()
+                        identityManager.setVerified(fingerprint: fp, verified: true)
+                        identityManager.forceSave()
                         verifiedFingerprints.insert(fp)
                         let name = unifiedPeerService.getPeer(by: peerID)?.nickname ?? resolveNickname(for: peerID)
                         NotificationService.shared.sendLocalNotification(
@@ -4597,18 +4608,10 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             isConnected = true
             
             // Register ephemeral session with identity manager
-            SecureIdentityStateManager.shared.registerEphemeralSession(peerID: peerID)
+            identityManager.registerEphemeralSession(peerID: peerID, handshakeState: .none)
             
-            // Check if we favorite this peer and resend notification on reconnect
-            // This ensures Nostr key mapping is maintained across reconnections
-            if let peer = unifiedPeerService.getPeer(by: peerID),
-               let favoriteStatus = FavoritesPersistenceService.shared.getFavoriteStatus(for: peer.noisePublicKey),
-               favoriteStatus.isFavorite {
-                // Resend favorite notification with our Nostr key after a short delay
-                try? await Task.sleep(nanoseconds: TransportConfig.uiAsyncMediumSleepNs) // 0.5 seconds
-                meshService.sendFavoriteNotification(to: peerID, isFavorite: true)
-                SecureLogger.debug("📤 Resent favorite notification to reconnected peer \(peerID)", category: .session)
-            }
+            // Intentionally do not resend favorites on reconnect.
+            // We only send our npub when a favorite is toggled on, or if our npub changes.
             
             // Force UI refresh
             objectWillChange.send()
@@ -4630,7 +4633,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         SecureLogger.debug("👋 Peer disconnected: \(peerID)", category: .session)
         
         // Remove ephemeral session from identity manager
-        SecureIdentityStateManager.shared.removeEphemeralSession(peerID: peerID)
+        identityManager.removeEphemeralSession(peerID: peerID)
 
         // If the open PM is tied to this short peer ID, switch UI context to the full Noise key (offline favorite)
         var derivedStableKeyHex: String? = shortIDToNoiseKey[peerID]
@@ -4737,7 +4740,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             
             // Register ephemeral sessions for all connected peers
             for peerID in peers {
-                SecureIdentityStateManager.shared.registerEphemeralSession(peerID: peerID)
+                self.identityManager.registerEphemeralSession(peerID: peerID, handshakeState: .none)
             }
             
             // Schedule UI refresh to ensure offline favorites are shown
@@ -4889,7 +4892,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
     }
     
     func isFavorite(fingerprint: String) -> Bool {
-        return SecureIdentityStateManager.shared.isFavorite(fingerprint: fingerprint)
+        return identityManager.isFavorite(fingerprint: fingerprint)
     }
     
     // MARK: - Delivery Tracking
@@ -4957,6 +4960,26 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
         messages.append(systemMessage)
     }
 
+    /// Add a system message to the mesh timeline only (never geohash).
+    /// If mesh is currently active, also append to the visible `messages`.
+    @MainActor
+    private func addMeshOnlySystemMessage(_ content: String) {
+        let systemMessage = BitchatMessage(
+            sender: "system",
+            content: content,
+            timestamp: Date(),
+            isRelay: false
+        )
+        // Persist to mesh timeline
+        meshTimeline.append(systemMessage)
+        trimMeshTimelineIfNeeded()
+        // Only show inline if mesh is the active channel
+        if case .mesh = activeChannel {
+            messages.append(systemMessage)
+        }
+        objectWillChange.send()
+    }
+
     /// Public helper to add a system message to the public chat timeline.
     /// Also persists the message into the active channel's backing store so it survives timeline rebinds.
     @MainActor
@@ -5199,7 +5222,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                         messageRouter.sendDeliveryAck(messageId, to: key.hexEncodedString())
                     } else if let id = try? NostrIdentityBridge.getCurrentNostrIdentity() {
                         // Fallback: no Noise mapping yet — send directly to sender's Nostr pubkey
-                        let nt = NostrTransport()
+                        let nt = NostrTransport(keychain: keychain)
                         nt.senderPeerID = meshService.myPeerID
                         nt.sendDeliveryAckGeohash(for: messageId, toRecipientHex: senderPubkey, from: id)
                         SecureLogger.debug("Sent DELIVERED ack directly to Nostr pub=\(senderPubkey.prefix(8))… for mid=\(messageId.prefix(8))…", category: .session)
@@ -5221,7 +5244,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
                             messageRouter.sendReadReceipt(receipt, to: key.hexEncodedString())
                             sentReadReceipts.insert(messageId)
                         } else if let id = try? NostrIdentityBridge.getCurrentNostrIdentity() {
-                            let nt = NostrTransport()
+                            let nt = NostrTransport(keychain: keychain)
                             nt.senderPeerID = meshService.myPeerID
                             nt.sendReadReceiptGeohash(messageId, toRecipientHex: senderPubkey, from: id)
                             sentReadReceipts.insert(messageId)
@@ -5384,8 +5407,10 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             SecureLogger.warning("⚠️ Cannot get Noise key for peer \(peerID)", category: .session)
             return
         }
+        // Determine prior state to avoid duplicate system messages on repeated notifications
+        let prior = FavoritesPersistenceService.shared.getFavoriteStatus(for: finalNoiseKey)?.theyFavoritedUs ?? false
 
-        // Update the favorite relationship
+        // Update the favorite relationship (idempotent storage)
         FavoritesPersistenceService.shared.updatePeerFavoritedUs(
             peerNoisePublicKey: finalNoiseKey,
             favorited: isFavorite,
@@ -5393,14 +5418,16 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             peerNostrPublicKey: nostrPubkey
         )
 
-        // If they favorited us and provided their Nostr key, ensure it's stored
+        // If they favorited us and provided their Nostr key, ensure it's stored (log only)
         if isFavorite && nostrPubkey != nil {
             SecureLogger.info("💾 Storing Nostr key association for \(senderNickname): \(nostrPubkey!.prefix(16))...", category: .session)
         }
 
-        // Show system message
+        // Only show a system message when the state changes, and only in mesh
+        if prior != isFavorite {
             let action = isFavorite ? "favorited" : "unfavorited"
-        addSystemMessage("\(senderNickname) \(action) you")
+            addMeshOnlySystemMessage("\(senderNickname) \(action) you")
+        }
     }
     
     @MainActor
@@ -5596,7 +5623,7 @@ final class ChatViewModel: ObservableObject, BitchatDelegate {
             // Check geohash (Nostr) blocks using mapping to full pubkey
             if peerID.hasPrefix("nostr") {
                 if let full = nostrKeyMapping[peerID]?.lowercased() {
-                    if SecureIdentityStateManager.shared.isNostrBlocked(pubkeyHexLowercased: full) { return true }
+                    if identityManager.isNostrBlocked(pubkeyHexLowercased: full) { return true }
                 }
             }
             return false

bitchat/Views/ContentView.swift

@@ -25,6 +25,7 @@ struct ContentView: View {
     @EnvironmentObject var viewModel: ChatViewModel
     @ObservedObject private var locationManager = LocationChannelManager.shared
     @ObservedObject private var bookmarks = GeohashBookmarksStore.shared
+    @ObservedObject private var notesCounter = LocationNotesCounter.shared
     @State private var messageText = ""
     @State private var textFieldSelection: NSRange? = nil
     @FocusState private var isTextFieldFocused: Bool
@@ -49,6 +50,10 @@ struct ContentView: View {
     @State private var showLocationChannelsSheet = false
     @State private var showVerifySheet = false
     @State private var expandedMessageIDs: Set<String> = []
+    @State private var showLocationNotes = false
+    @State private var notesGeohash: String? = nil
+    @State private var sheetNotesCount: Int = 0
+    // Timer-based refresh removed; use LocationChannelManager live updates instead
     // Window sizes for rendering (infinite scroll up)
     @State private var windowCountPublic: Int = 300
     @State private var windowCountPrivate: [String: Int] = [:]
@@ -1091,7 +1096,7 @@ struct ContentView: View {
                 TextField("nickname", text: $viewModel.nickname)
                     .textFieldStyle(.plain)
                     .font(.system(size: 14, design: .monospaced))
-                    .frame(maxWidth: 100)
+                    .frame(maxWidth: 80)
                     .foregroundColor(textColor)
                     .focused($isNicknameFieldFocused)
                     .autocorrectionDisabled(true)
@@ -1170,6 +1175,29 @@ struct ContentView: View {
                 }
                 .buttonStyle(.plain)
 
+                // Notes icon (mesh only and when location is authorized), to the right of #mesh
+                if case .mesh = locationManager.selectedChannel, locationManager.permissionState == .authorized {
+                    Button(action: {
+                        // Kick a one-shot refresh and show the sheet immediately.
+                        LocationChannelManager.shared.enableLocationChannels()
+                        LocationChannelManager.shared.refreshChannels()
+                        // If we already have a block geohash, pass it; otherwise wait in the sheet.
+                        notesGeohash = LocationChannelManager.shared.availableChannels.first(where: { $0.level == .building })?.geohash
+                        showLocationNotes = true
+                    }) {
+                        HStack(alignment: .center, spacing: 4) {
+                            let hasNotes = ((notesCounter.count ?? 0) > 0) || (sheetNotesCount > 0)
+                            Image(systemName: "long.text.page.and.pencil")
+                                .font(.system(size: 12))
+                                .foregroundColor(hasNotes ? Color(hue: 0.60, saturation: 0.85, brightness: 0.82) : Color.gray)
+                                .padding(.top, 1)
+                        }
+                        .fixedSize(horizontal: true, vertical: false)
+                    }
+                    .buttonStyle(.plain)
+                    .accessibilityLabel("Location notes for this place")
+                }
+
                 HStack(spacing: 4) {
                     // People icon with count
                     Image(systemName: "person.2.fill")
@@ -1180,9 +1208,12 @@ struct ContentView: View {
                         .accessibilityHidden(true)
                 }
                 .foregroundColor(headerCountColor)
+                .lineLimit(1)
+                .fixedSize(horizontal: true, vertical: false)
 
                 // QR moved to the PEOPLE header in the sidebar when on mesh channel
             }
+            .layoutPriority(3)
             .onTapGesture {
                 withAnimation(.easeInOut(duration: TransportConfig.uiAnimationMediumSeconds)) {
                     showSidebar.toggle()
@@ -1201,6 +1232,91 @@ struct ContentView: View {
                 .onAppear { viewModel.isLocationChannelsSheetPresented = true }
                 .onDisappear { viewModel.isLocationChannelsSheetPresented = false }
         }
+        .sheet(isPresented: $showLocationNotes) {
+            Group {
+                if let gh = notesGeohash ?? LocationChannelManager.shared.availableChannels.first(where: { $0.level == .building })?.geohash {
+                    LocationNotesView(geohash: gh, onNotesCountChanged: { cnt in sheetNotesCount = cnt })
+                        .environmentObject(viewModel)
+                } else {
+                    VStack(spacing: 12) {
+                        HStack {
+                            Text("notes")
+                                .font(.system(size: 16, weight: .bold, design: .monospaced))
+                            Spacer()
+                            Button(action: { showLocationNotes = false }) {
+                                Image(systemName: "xmark")
+                                    .font(.system(size: 13, weight: .semibold, design: .monospaced))
+                                    .foregroundColor(textColor)
+                                    .frame(width: 32, height: 32)
+                            }
+                            .buttonStyle(.plain)
+                            .accessibilityLabel("Close")
+                        }
+                        .frame(height: 44)
+                        .padding(.horizontal, 12)
+                        .background(backgroundColor.opacity(0.95))
+                        Text("location unavailable")
+                            .font(.system(size: 14, design: .monospaced))
+                            .foregroundColor(secondaryTextColor)
+                        Button("enable location") {
+                            LocationChannelManager.shared.enableLocationChannels()
+                            LocationChannelManager.shared.refreshChannels()
+                        }
+                        .buttonStyle(.bordered)
+                        Spacer()
+                    }
+                    .background(backgroundColor)
+                    .foregroundColor(textColor)
+                    // per-sheet global onChange added below
+                }
+            }
+            .onAppear {
+                // Ensure we are authorized and start live location updates (distance-filtered)
+                LocationChannelManager.shared.enableLocationChannels()
+                LocationChannelManager.shared.beginLiveRefresh()
+            }
+            .onDisappear {
+                LocationChannelManager.shared.endLiveRefresh()
+                sheetNotesCount = 0
+            }
+            .onChange(of: locationManager.availableChannels) { channels in
+                if let current = channels.first(where: { $0.level == .building })?.geohash,
+                   notesGeohash != current {
+                    notesGeohash = current
+                    #if os(iOS)
+                    // Light taptic when geohash changes while the sheet is open
+                    let generator = UIImpactFeedbackGenerator(style: .light)
+                    generator.prepare()
+                    generator.impactOccurred()
+                    #endif
+                }
+            }
+        }
+        .onAppear {
+            updateNotesCounterSubscription()
+            if case .mesh = locationManager.selectedChannel,
+               locationManager.permissionState == .authorized,
+               LocationChannelManager.shared.availableChannels.isEmpty {
+                LocationChannelManager.shared.refreshChannels()
+            }
+        }
+        .onChange(of: locationManager.selectedChannel) { _ in
+            updateNotesCounterSubscription()
+            if case .mesh = locationManager.selectedChannel,
+               locationManager.permissionState == .authorized,
+               LocationChannelManager.shared.availableChannels.isEmpty {
+                LocationChannelManager.shared.refreshChannels()
+            }
+        }
+        .onChange(of: locationManager.availableChannels) { _ in updateNotesCounterSubscription() }
+        .onChange(of: locationManager.permissionState) { _ in
+            updateNotesCounterSubscription()
+            if case .mesh = locationManager.selectedChannel,
+               locationManager.permissionState == .authorized,
+               LocationChannelManager.shared.availableChannels.isEmpty {
+                LocationChannelManager.shared.refreshChannels()
+            }
+        }
         .alert("heads up", isPresented: $viewModel.showScreenshotPrivacyWarning) {
             Button("ok", role: .cancel) {}
         } message: {
@@ -1247,15 +1363,15 @@ struct ContentView: View {
                !fav.peerNickname.isEmpty { return fav.peerNickname }
             // Fallback: resolve from persisted social identity via fingerprint mapping
             if headerPeerID.count == 16 {
-                let candidates = SecureIdentityStateManager.shared.getCryptoIdentitiesByPeerIDPrefix(headerPeerID)
+                let candidates = viewModel.identityManager.getCryptoIdentitiesByPeerIDPrefix(headerPeerID)
                 if let id = candidates.first,
-                   let social = SecureIdentityStateManager.shared.getSocialIdentity(for: id.fingerprint) {
+                   let social = viewModel.identityManager.getSocialIdentity(for: id.fingerprint) {
                     if let pet = social.localPetname, !pet.isEmpty { return pet }
                     if !social.claimedNickname.isEmpty { return social.claimedNickname }
                 }
             } else if headerPeerID.count == 64, let keyData = Data(hexString: headerPeerID) {
                 let fp = keyData.sha256Fingerprint()
-                if let social = SecureIdentityStateManager.shared.getSocialIdentity(for: fp) {
+                if let social = viewModel.identityManager.getSocialIdentity(for: fp) {
                     if let pet = social.localPetname, !pet.isEmpty { return pet }
                     if !social.claimedNickname.isEmpty { return social.claimedNickname }
                 }
@@ -1399,6 +1515,26 @@ struct ContentView: View {
     
 }
 
+// MARK: - Notes Counter Subscription Helper
+extension ContentView {
+    private func updateNotesCounterSubscription() {
+        switch locationManager.selectedChannel {
+        case .mesh:
+            // Ensure we have a fresh one-shot location fix so building geohash is current
+            if locationManager.permissionState == .authorized {
+                LocationChannelManager.shared.refreshChannels()
+            }
+            if let building = LocationChannelManager.shared.availableChannels.first(where: { $0.level == .building })?.geohash {
+                LocationNotesCounter.shared.subscribe(geohash: building)
+            } else {
+                LocationNotesCounter.shared.cancel()
+            }
+        case .location:
+            LocationNotesCounter.shared.cancel()
+        }
+    }
+}
+
 // MARK: - Helper Views
 
 // Rounded payment chip button

bitchat/Views/FingerprintView.swift

@@ -53,7 +53,7 @@ struct FingerprintView: View {
                     if peerID.count == 64, let data = Data(hexString: peerID) {
                         if let fav = FavoritesPersistenceService.shared.getFavoriteStatus(for: data), !fav.peerNickname.isEmpty { return fav.peerNickname }
                         let fp = data.sha256Fingerprint()
-                        if let social = SecureIdentityStateManager.shared.getSocialIdentity(for: fp) {
+                        if let social = viewModel.identityManager.getSocialIdentity(for: fp) {
                             if let pet = social.localPetname, !pet.isEmpty { return pet }
                             if !social.claimedNickname.isEmpty { return social.claimedNickname }
                         }

bitchat/Views/LocationChannelsSheet.swift

@@ -107,7 +107,7 @@ struct LocationChannelsSheet: View {
 
             // Nearby options
             if !manager.availableChannels.isEmpty {
-                ForEach(manager.availableChannels) { channel in
+                ForEach(manager.availableChannels.filter { $0.level != .building }) { channel in
                     let coverage = coverageString(forPrecision: channel.geohash.count)
                     let nameBase = locationName(for: channel.level)
                     let namePart = nameBase.map { formattedNamePrefix(for: channel.level) + $0 }
@@ -381,6 +381,7 @@ struct LocationChannelsSheet: View {
         case 5: return .city
         case 6: return .neighborhood
         case 7: return .block
+        case 8: return .building
         default: return .block
         }
     }

bitchat/Views/LocationNotesSheet.swift

@@ -0,0 +1,65 @@
+import SwiftUI
+
+struct LocationNotesSheet: View {
+    @EnvironmentObject var viewModel: ChatViewModel
+    @ObservedObject private var locationManager = LocationChannelManager.shared
+    @Binding var notesGeohash: String?
+    @Environment(\.dismiss) private var dismiss
+    @Environment(\.colorScheme) private var colorScheme
+
+    private var backgroundColor: Color { colorScheme == .dark ? .black : .white }
+    private var textColor: Color { colorScheme == .dark ? .green : Color(red: 0, green: 0.5, blue: 0) }
+    private var secondaryTextColor: Color { textColor.opacity(0.8) }
+
+    var body: some View {
+        Group {
+            if let gh = notesGeohash ?? locationManager.availableChannels.first(where: { $0.level == .block })?.geohash {
+                // Found block geohash: show notes view
+                LocationNotesView(geohash: gh)
+                    .environmentObject(viewModel)
+            } else {
+                // Acquire location: keep a loading overlay (Matrix) until we either get a block geohash
+                ZStack {
+                    VStack(spacing: 0) {
+                        HStack {
+                            VStack(alignment: .leading, spacing: 2) {
+                                Text("notes")
+                                    .font(.system(size: 16, weight: .bold, design: .monospaced))
+                                Text("acquiring location…")
+                                    .font(.system(size: 12, design: .monospaced))
+                                    .foregroundColor(secondaryTextColor)
+                            }
+                            Spacer()
+                            Button(action: { dismiss() }) {
+                                Image(systemName: "xmark")
+                                    .font(.system(size: 13, weight: .semibold, design: .monospaced))
+                                    .foregroundColor(textColor)
+                                    .frame(width: 32, height: 32)
+                            }
+                            .buttonStyle(.plain)
+                            .accessibilityLabel("Close")
+                        }
+                        .frame(height: 44)
+                        .padding(.horizontal, 12)
+                        .background(backgroundColor.opacity(0.95))
+                        Spacer()
+                    }
+                    MatrixRainView()
+                        .transition(.opacity)
+                }
+                .background(backgroundColor)
+                .foregroundColor(textColor)
+                .onAppear {
+                    LocationChannelManager.shared.enableLocationChannels()
+                    // Nudge a fresh fix
+                    LocationChannelManager.shared.refreshChannels()
+                }
+                .onChange(of: locationManager.availableChannels) { channels in
+                    if notesGeohash == nil, let block = channels.first(where: { $0.level == .block }) {
+                        notesGeohash = block.geohash
+                    }
+                }
+            }
+        }
+    }
+}

bitchat/Views/LocationNotesView.swift

@@ -0,0 +1,176 @@
+import SwiftUI
+
+struct LocationNotesView: View {
+    @EnvironmentObject var viewModel: ChatViewModel
+    @StateObject private var manager: LocationNotesManager
+    let geohash: String
+    let onNotesCountChanged: ((Int) -> Void)?
+
+    @Environment(\.colorScheme) var colorScheme
+    @ObservedObject private var locationManager = LocationChannelManager.shared
+    @Environment(\.dismiss) private var dismiss
+    @State private var draft: String = ""
+
+    init(geohash: String, onNotesCountChanged: ((Int) -> Void)? = nil) {
+        let gh = geohash.lowercased()
+        self.geohash = gh
+        self.onNotesCountChanged = onNotesCountChanged
+        _manager = StateObject(wrappedValue: LocationNotesManager(geohash: gh))
+    }
+
+    private var backgroundColor: Color {
+        colorScheme == .dark ? Color.black : Color.white
+    }
+    private var textColor: Color {
+        colorScheme == .dark ? Color.green : Color(red: 0, green: 0.5, blue: 0)
+    }
+    private var secondaryTextColor: Color {
+        colorScheme == .dark ? Color.green.opacity(0.8) : Color(red: 0, green: 0.5, blue: 0).opacity(0.8)
+    }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            header
+            Divider()
+            list
+            Divider()
+            input
+        }
+        .background(backgroundColor)
+        .foregroundColor(textColor)
+        .onDisappear { manager.cancel() }
+        .onChange(of: geohash) { newValue in
+            manager.setGeohash(newValue)
+        }
+        .onAppear { onNotesCountChanged?(manager.notes.count) }
+        .onChange(of: manager.notes.count) { newValue in
+            onNotesCountChanged?(newValue)
+        }
+    }
+
+    private var header: some View {
+        HStack {
+            VStack(alignment: .leading, spacing: 2) {
+                HStack(spacing: 4) {
+                    let c = manager.notes.count
+                    Text("\(c) \(c == 1 ? "note" : "notes") ")
+                        .font(.system(size: 16, weight: .bold, design: .monospaced))
+                    Text("@ #\(geohash)")
+                        .font(.system(size: 16, weight: .bold, design: .monospaced))
+                }
+                if let buildingName = locationManager.locationNames[.building], !buildingName.isEmpty {
+                    Text(buildingName)
+                        .font(.system(size: 12, design: .monospaced))
+                        .foregroundColor(secondaryTextColor)
+                } else if let blockName = locationManager.locationNames[.block], !blockName.isEmpty {
+                    Text(blockName)
+                        .font(.system(size: 12, design: .monospaced))
+                        .foregroundColor(secondaryTextColor)
+                }
+            }
+            Spacer()
+            Button(action: { dismiss() }) {
+                Image(systemName: "xmark")
+                    .font(.system(size: 13, weight: .semibold, design: .monospaced))
+                    .foregroundColor(textColor)
+                    .frame(width: 32, height: 32)
+                    .contentShape(Rectangle())
+            }
+            .buttonStyle(.plain)
+            .accessibilityLabel("Close")
+        }
+        .frame(height: 44)
+        .padding(.horizontal, 12)
+        .background(backgroundColor.opacity(0.95))
+    }
+
+    private var list: some View {
+        ScrollView {
+            LazyVStack(alignment: .leading, spacing: 8) {
+                ForEach(manager.notes) { note in
+                    VStack(alignment: .leading, spacing: 2) {
+                        HStack(spacing: 6) {
+                            Text(note.displayName)
+                                .font(.system(size: 12, weight: .semibold, design: .monospaced))
+                                .foregroundColor(secondaryTextColor)
+                            Text(timestampText(for: note.createdAt))
+                                .font(.system(size: 11, design: .monospaced))
+                                .foregroundColor(secondaryTextColor.opacity(0.8))
+                        }
+                        Text(note.content)
+                            .font(.system(size: 14, design: .monospaced))
+                            .fixedSize(horizontal: false, vertical: true)
+                    }
+                    .padding(.horizontal, 12)
+                }
+            }
+            .padding(.vertical, 8)
+        }
+        .background(backgroundColor)
+    }
+
+    private var input: some View {
+        HStack(alignment: .center, spacing: 8) {
+            TextField("add a note for this place", text: $draft, axis: .vertical)
+                .textFieldStyle(.plain)
+                .font(.system(size: 14, design: .monospaced))
+                .lineLimit(3, reservesSpace: true)
+                .padding(.horizontal, 12)
+
+            Button(action: send) {
+                Image(systemName: "arrow.up.circle.fill")
+                    .font(.system(size: 20))
+                    .foregroundColor(draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? Color.gray : textColor)
+            }
+            .buttonStyle(.plain)
+            .disabled(draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+            .padding(.trailing, 12)
+        }
+        .frame(minHeight: 44)
+        .padding(.vertical, 8)
+        .background(backgroundColor.opacity(0.95))
+    }
+
+    private func send() {
+        let content = draft.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !content.isEmpty else { return }
+        manager.send(content: content, nickname: viewModel.nickname)
+        draft = ""
+    }
+
+    // MARK: - Timestamp Formatting
+    private func timestampText(for date: Date) -> String {
+        let now = Date()
+        if let days = Calendar.current.dateComponents([.day], from: date, to: now).day, days < 7 {
+            // Relative (minute/hour/day), no seconds
+            let rel = Self.relativeFormatter.string(from: date, to: now) ?? ""
+            return rel.isEmpty ? "" : "\(rel) ago"
+        } else {
+            // Absolute date (MMM d or MMM d, yyyy if different year)
+            let sameYear = Calendar.current.isDate(date, equalTo: now, toGranularity: .year)
+            let fmt = sameYear ? Self.absDateFormatter : Self.absDateYearFormatter
+            return fmt.string(from: date)
+        }
+    }
+
+    private static let relativeFormatter: DateComponentsFormatter = {
+        let f = DateComponentsFormatter()
+        f.allowedUnits = [.day, .hour, .minute]
+        f.maximumUnitCount = 1
+        f.unitsStyle = .abbreviated
+        f.collapsesLargestUnit = true
+        return f
+    }()
+
+    private static let absDateFormatter: DateFormatter = {
+        let f = DateFormatter()
+        f.setLocalizedDateFormatFromTemplate("MMM d")
+        return f
+    }()
+
+    private static let absDateYearFormatter: DateFormatter = {
+        let f = DateFormatter()
+        f.setLocalizedDateFormatFromTemplate("MMM d, y")
+        return f
+    }()
+}

bitchatTests/CommandProcessorTests.swift

@@ -3,9 +3,22 @@ import XCTest
 
 final class CommandProcessorTests: XCTestCase {
     
+    var identityManager: MockIdentityManager!
+    
+    override func setUp() {
+        super.setUp()
+        // Provide a minimal identity manager for commands that query identity/block lists
+        identityManager = MockIdentityManager(MockKeychain())
+    }
+    
+    override func tearDown() {
+        identityManager = nil
+        super.tearDown()
+    }
+
     @MainActor
     func test_slap_notFoundGrammar() {
-        let processor = CommandProcessor(chatViewModel: nil, meshService: nil)
+        let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/slap @system")
         switch result {
         case .error(let message):
@@ -17,7 +30,7 @@ final class CommandProcessorTests: XCTestCase {
 
     @MainActor
     func test_hug_notFoundGrammar() {
-        let processor = CommandProcessor(chatViewModel: nil, meshService: nil)
+        let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/hug @system")
         switch result {
         case .error(let message):
@@ -29,7 +42,7 @@ final class CommandProcessorTests: XCTestCase {
 
     @MainActor
     func test_slap_usageMessage() {
-        let processor = CommandProcessor(chatViewModel: nil, meshService: nil)
+        let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/slap")
         switch result {
         case .error(let message):
@@ -39,4 +52,3 @@ final class CommandProcessorTests: XCTestCase {
         }
     }
 }
-

bitchatTests/EndToEnd/PrivateChatE2ETests.swift

@@ -16,6 +16,8 @@ final class PrivateChatE2ETests: XCTestCase {
     var bob: MockBluetoothMeshService!
     var charlie: MockBluetoothMeshService!
     
+    private var mockKeychain: MockKeychain!
+    
     override func setUp() {
         super.setUp()
         MockBLEService.resetTestBus()
@@ -24,6 +26,7 @@ final class PrivateChatE2ETests: XCTestCase {
         alice = createMockService(peerID: TestConstants.testPeerID1, nickname: TestConstants.testNickname1)
         bob = createMockService(peerID: TestConstants.testPeerID2, nickname: TestConstants.testNickname2)
         charlie = createMockService(peerID: TestConstants.testPeerID3, nickname: TestConstants.testNickname3)
+        mockKeychain = MockKeychain()
         
         // Delivery tracking is now handled internally by BLEService
     }
@@ -32,6 +35,7 @@ final class PrivateChatE2ETests: XCTestCase {
         alice = nil
         bob = nil
         charlie = nil
+        mockKeychain = nil
         super.tearDown()
     }
     
@@ -116,8 +120,8 @@ final class PrivateChatE2ETests: XCTestCase {
         let aliceKey = Curve25519.KeyAgreement.PrivateKey()
         let bobKey = Curve25519.KeyAgreement.PrivateKey()
         
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish encrypted session
         do {

bitchatTests/Fragmentation/FragmentationTests.swift

@@ -11,6 +11,21 @@ import XCTest
 
 final class FragmentationTests: XCTestCase {
     
+    private var mockKeychain: MockKeychain!
+    private var mockIdentityManager: MockIdentityManager!
+    
+    override func setUp() {
+        super.setUp()
+        mockKeychain = MockKeychain()
+        mockIdentityManager = MockIdentityManager(mockKeychain)
+    }
+    
+    override func tearDown() {
+        mockKeychain = nil
+        mockIdentityManager = nil
+        super.tearDown()
+    }
+
     private final class CaptureDelegate: BitchatDelegate {
         var publicMessages: [(peerID: String, nickname: String, content: String)] = []
         func didReceiveMessage(_ message: BitchatMessage) {}
@@ -75,7 +90,7 @@ final class FragmentationTests: XCTestCase {
     }
 
     func test_reassembly_from_fragments_delivers_public_message() {
-        let ble = BLEService()
+        let ble = BLEService(keychain: mockKeychain, identityManager: mockIdentityManager)
         let capture = CaptureDelegate()
         ble.delegate = capture
 
@@ -106,7 +121,7 @@ final class FragmentationTests: XCTestCase {
     }
 
     func test_duplicate_fragment_does_not_break_reassembly() {
-        let ble = BLEService()
+        let ble = BLEService(keychain: mockKeychain, identityManager: mockIdentityManager)
         let capture = CaptureDelegate()
         ble.delegate = capture
 
@@ -132,7 +147,7 @@ final class FragmentationTests: XCTestCase {
     }
 
     func test_invalid_fragment_header_is_ignored() {
-        let ble = BLEService()
+        let ble = BLEService(keychain: mockKeychain, identityManager: mockIdentityManager)
         let capture = CaptureDelegate()
         ble.delegate = capture
 

bitchatTests/Integration/IntegrationTests.swift

@@ -14,6 +14,7 @@ final class IntegrationTests: XCTestCase {
     
     var nodes: [String: MockBluetoothMeshService] = [:]
     var noiseManagers: [String: NoiseSessionManager] = [:]
+    private var mockKeychain: MockKeychain!
     
     override func setUp() {
         super.setUp()
@@ -21,6 +22,7 @@ final class IntegrationTests: XCTestCase {
         // broadcast propagation across a larger mesh. Integration-only.
         MockBLEService.resetTestBus()
         MockBLEService.autoFloodEnabled = true
+        mockKeychain = MockKeychain()
         
         // Create a network of nodes
         createNode("Alice", peerID: TestConstants.testPeerID1)
@@ -34,6 +36,7 @@ final class IntegrationTests: XCTestCase {
         MockBLEService.autoFloodEnabled = false
         nodes.removeAll()
         noiseManagers.removeAll()
+        mockKeychain = nil
         super.tearDown()
     }
     
@@ -307,7 +310,7 @@ final class IntegrationTests: XCTestCase {
         
         // Simulate Bob restart by recreating his Noise manager
         let bobKey = Curve25519.KeyAgreement.PrivateKey()
-        noiseManagers["Bob"] = NoiseSessionManager(localStaticKey: bobKey)
+        noiseManagers["Bob"] = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Re-establish Noise handshake explicitly via managers
         do {
@@ -593,7 +596,7 @@ final class IntegrationTests: XCTestCase {
         
         // Create Noise manager
         let key = Curve25519.KeyAgreement.PrivateKey()
-        noiseManagers[name] = NoiseSessionManager(localStaticKey: key)
+        noiseManagers[name] = NoiseSessionManager(localStaticKey: key, keychain: mockKeychain)
     }
     
     private func connect(_ node1: String, _ node2: String) {

bitchatTests/Mocks/MockBLEService.swift

@@ -36,6 +36,8 @@ final class MockBLEService: NSObject {
     var myPeerID: String = "MOCK1234"
     var myNickname: String = "MockUser"
     
+    private let mockKeychain = MockKeychain()
+    
     // Test-specific properties
     var sentMessages: [(message: BitchatMessage, packet: BitchatPacket)] = []
     var sentPackets: [BitchatPacket] = []
@@ -272,7 +274,7 @@ final class MockBLEService: NSObject {
     }
     
     func getNoiseService() -> NoiseEncryptionService {
-        return NoiseEncryptionService()
+        return NoiseEncryptionService(keychain: mockKeychain)
     }
     
     func getFingerprint(for peerID: String) -> String? {

bitchatTests/Mocks/MockIdentityManager.swift

@@ -0,0 +1,80 @@
+//
+// MockIdentityManager.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+@testable import bitchat
+
+final class MockIdentityManager: SecureIdentityStateManagerProtocol {
+    private let keychain: KeychainManagerProtocol
+    
+    init(_ keychain: KeychainManagerProtocol) {
+        self.keychain = keychain
+    }
+    
+    func loadIdentityCache() {}
+    
+    func saveIdentityCache() {}
+    
+    func forceSave() {}
+    
+    func getSocialIdentity(for fingerprint: String) -> SocialIdentity? {
+        nil
+    }
+    
+    func upsertCryptographicIdentity(fingerprint: String, noisePublicKey: Data, signingPublicKey: Data?, claimedNickname: String?) {}
+    
+    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: String) -> [CryptographicIdentity] {
+        []
+    }
+    
+    func updateSocialIdentity(_ identity: SocialIdentity) {}
+    
+    func getFavorites() -> Set<String> {
+        Set()
+    }
+    
+    func setFavorite(_ fingerprint: String, isFavorite: Bool) {}
+    
+    func isFavorite(fingerprint: String) -> Bool {
+        false
+    }
+    
+    func isBlocked(fingerprint: String) -> Bool {
+        false
+    }
+    
+    func setBlocked(_ fingerprint: String, isBlocked: Bool) {}
+    
+    func isNostrBlocked(pubkeyHexLowercased: String) -> Bool {
+        true
+    }
+    
+    func setNostrBlocked(_ pubkeyHexLowercased: String, isBlocked: Bool) {}
+    
+    func getBlockedNostrPubkeys() -> Set<String> {
+        Set()
+    }
+    
+    func registerEphemeralSession(peerID: String, handshakeState: HandshakeState) {}
+    
+    func updateHandshakeState(peerID: String, state: HandshakeState) {}
+    
+    func clearAllIdentityData() {}
+    
+    func removeEphemeralSession(peerID: String) {}
+    
+    func setVerified(fingerprint: String, verified: Bool) {}
+    
+    func isVerified(fingerprint: String) -> Bool {
+        true
+    }
+    
+    func getVerifiedFingerprints() -> Set<String> {
+        Set()
+    }
+}

bitchatTests/Mocks/MockKeychain.swift

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

bitchatTests/Noise/NoiseProtocolTests.swift

@@ -16,16 +16,19 @@ final class NoiseProtocolTests: XCTestCase {
     var bobKey: Curve25519.KeyAgreement.PrivateKey!
     var aliceSession: NoiseSession!
     var bobSession: NoiseSession!
+    private var mockKeychain: MockKeychain!
     
     override func setUp() {
         super.setUp()
         aliceKey = Curve25519.KeyAgreement.PrivateKey()
         bobKey = Curve25519.KeyAgreement.PrivateKey()
+        mockKeychain = MockKeychain()
     }
     
     override func tearDown() {
         aliceSession = nil
         bobSession = nil
+        mockKeychain = nil
         super.tearDown()
     }
     
@@ -36,12 +39,14 @@ final class NoiseProtocolTests: XCTestCase {
         aliceSession = NoiseSession(
             peerID: TestConstants.testPeerID2,
             role: .initiator,
+            keychain: mockKeychain,
             localStaticKey: aliceKey
         )
         
         bobSession = NoiseSession(
             peerID: TestConstants.testPeerID1,
             role: .responder,
+            keychain: mockKeychain,
             localStaticKey: bobKey
         )
         
@@ -80,6 +85,7 @@ final class NoiseProtocolTests: XCTestCase {
         aliceSession = NoiseSession(
             peerID: TestConstants.testPeerID2,
             role: .initiator,
+            keychain: mockKeychain,
             localStaticKey: aliceKey
         )
         
@@ -144,6 +150,7 @@ final class NoiseProtocolTests: XCTestCase {
         aliceSession = NoiseSession(
             peerID: TestConstants.testPeerID2,
             role: .initiator,
+            keychain: mockKeychain,
             localStaticKey: aliceKey
         )
         
@@ -157,7 +164,7 @@ final class NoiseProtocolTests: XCTestCase {
     // MARK: - Session Manager Tests
     
     func testSessionManagerBasicOperations() throws {
-        let manager = NoiseSessionManager(localStaticKey: aliceKey)
+        let manager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         
         // Create session
         let session = manager.createSession(for: TestConstants.testPeerID2, role: .initiator)
@@ -174,7 +181,7 @@ final class NoiseProtocolTests: XCTestCase {
     }
     
     func testSessionManagerHandshakeInitiation() throws {
-        let manager = NoiseSessionManager(localStaticKey: aliceKey)
+        let manager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         
         // Initiate handshake
         let handshakeData = try manager.initiateHandshake(with: TestConstants.testPeerID2)
@@ -187,8 +194,8 @@ final class NoiseProtocolTests: XCTestCase {
     }
     
     func testSessionManagerIncomingHandshake() throws {
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Alice initiates
         let message1 = try aliceManager.initiateHandshake(with: TestConstants.testPeerID2)
@@ -211,8 +218,8 @@ final class NoiseProtocolTests: XCTestCase {
     }
     
     func testSessionManagerEncryptionDecryption() throws {
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -256,11 +263,11 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testSessionIsolation() throws {
         // Create two separate session pairs
-        let aliceSession1 = NoiseSession(peerID: "peer1", role: .initiator, localStaticKey: aliceKey)
-        let bobSession1 = NoiseSession(peerID: "alice1", role: .responder, localStaticKey: bobKey)
+        let aliceSession1 = NoiseSession(peerID: "peer1", role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+        let bobSession1 = NoiseSession(peerID: "alice1", role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
         
-        let aliceSession2 = NoiseSession(peerID: "peer2", role: .initiator, localStaticKey: aliceKey)
-        let bobSession2 = NoiseSession(peerID: "alice2", role: .responder, localStaticKey: bobKey)
+        let aliceSession2 = NoiseSession(peerID: "peer2", role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+        let bobSession2 = NoiseSession(peerID: "alice2", role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
         
         // Establish both pairs
         try performHandshake(initiator: aliceSession1, responder: bobSession1)
@@ -282,8 +289,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testPeerRestartDetection() throws {
         // Establish initial sessions
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
@@ -295,7 +302,7 @@ final class NoiseProtocolTests: XCTestCase {
         _ = try aliceManager.decrypt(message2, from: TestConstants.testPeerID2)
         
         // Simulate Bob restart by creating new manager with same key
-        let bobManagerRestarted = NoiseSessionManager(localStaticKey: bobKey)
+        let bobManagerRestarted = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Bob initiates new handshake after restart
         let newHandshake1 = try bobManagerRestarted.initiateHandshake(with: TestConstants.testPeerID1)
@@ -318,8 +325,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testNonceDesynchronizationRecovery() throws {
         // Create two sessions
-        aliceSession = NoiseSession(peerID: TestConstants.testPeerID2, role: .initiator, localStaticKey: aliceKey)
-        bobSession = NoiseSession(peerID: TestConstants.testPeerID1, role: .responder, localStaticKey: bobKey)
+        aliceSession = NoiseSession(peerID: TestConstants.testPeerID2, role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+        bobSession = NoiseSession(peerID: TestConstants.testPeerID1, role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
         
         // Establish sessions
         try performHandshake(initiator: aliceSession, responder: bobSession)
@@ -342,8 +349,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testConcurrentEncryption() throws {
         // Test thread safety of encryption operations
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
@@ -380,8 +387,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testSessionStaleDetection() throws {
         // Test that sessions are properly marked as stale
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
@@ -394,8 +401,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testHandshakeAfterDecryptionFailure() throws {
         // Test that handshake is properly initiated after decryption failure
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -413,8 +420,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testHandshakeAlwaysAcceptedWithExistingSession() throws {
         // Test that handshake is always accepted even with existing valid session
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -453,8 +460,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testNonceDesynchronizationCausesRehandshake() throws {
         // Test that nonce desynchronization leads to proper re-handshake
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -499,8 +506,8 @@ final class NoiseProtocolTests: XCTestCase {
     func testHandshakePerformance() throws {
         measure {
             do {
-                let alice = NoiseSession(peerID: "bob", role: .initiator, localStaticKey: aliceKey)
-                let bob = NoiseSession(peerID: "alice", role: .responder, localStaticKey: bobKey)
+                let alice = NoiseSession(peerID: "bob", role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+                let bob = NoiseSession(peerID: "alice", role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
                 try performHandshake(initiator: alice, responder: bob)
             } catch {
                 XCTFail("Handshake failed: \(error)")
@@ -530,12 +537,14 @@ final class NoiseProtocolTests: XCTestCase {
         aliceSession = NoiseSession(
             peerID: TestConstants.testPeerID2,
             role: .initiator,
+            keychain: mockKeychain,
             localStaticKey: aliceKey
         )
         
         bobSession = NoiseSession(
             peerID: TestConstants.testPeerID1,
             role: .responder,
+            keychain: mockKeychain,
             localStaticKey: bobKey
         )